4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5 * Copyright (C) 1997 by Volker Lendecke
7 * Please add a note about your changes to smbfs in the ChangeLog file.
10 #include <linux/time.h>
11 #include <linux/errno.h>
12 #include <linux/kernel.h>
13 #include <linux/smp_lock.h>
14 #include <linux/ctype.h>
15 #include <linux/net.h>
16 #include <linux/sched.h>
18 #include <linux/smb_fs.h>
19 #include <linux/smb_mount.h>
20 #include <linux/smbno.h>
22 #include "smb_debug.h"
25 static int smb_readdir(struct file *, void *, filldir_t);
26 static int smb_dir_open(struct inode *, struct file *);
28 static struct dentry *smb_lookup(struct inode *, struct dentry *, struct nameidata *);
29 static int smb_create(struct inode *, struct dentry *, int, struct nameidata *);
30 static int smb_mkdir(struct inode *, struct dentry *, int);
31 static int smb_rmdir(struct inode *, struct dentry *);
32 static int smb_unlink(struct inode *, struct dentry *);
33 static int smb_rename(struct inode *, struct dentry *,
34 struct inode *, struct dentry *);
35 static int smb_make_node(struct inode *,struct dentry *,int,dev_t);
36 static int smb_link(struct dentry *, struct inode *, struct dentry *);
38 const struct file_operations smb_dir_operations =
40 .llseek = generic_file_llseek,
41 .read = generic_read_dir,
42 .readdir = smb_readdir,
43 .unlocked_ioctl = smb_ioctl,
47 const struct inode_operations smb_dir_inode_operations =
55 .getattr = smb_getattr,
56 .setattr = smb_notify_change,
59 const struct inode_operations smb_dir_inode_operations_unix =
67 .getattr = smb_getattr,
68 .setattr = smb_notify_change,
69 .symlink = smb_symlink,
70 .mknod = smb_make_node,
75 * Read a directory, using filldir to fill the dirent memory.
76 * smb_proc_readdir does the actual reading from the smb server.
78 * The cache code is almost directly taken from ncpfs
81 smb_readdir(struct file *filp, void *dirent, filldir_t filldir)
83 struct dentry *dentry = filp->f_path.dentry;
84 struct inode *dir = dentry->d_inode;
85 struct smb_sb_info *server = server_from_dentry(dentry);
86 union smb_dir_cache *cache = NULL;
87 struct smb_cache_control ctl;
88 struct page *page = NULL;
94 VERBOSE("reading %s/%s, f_pos=%d\n",
95 DENTRY_PATH(dentry), (int) filp->f_pos);
101 switch ((unsigned int) filp->f_pos) {
103 if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
108 if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0)
114 * Make sure our inode is up-to-date.
116 result = smb_revalidate_inode(dentry);
121 page = grab_cache_page(&dir->i_data, 0);
125 ctl.cache = cache = kmap(page);
126 ctl.head = cache->head;
128 if (!PageUptodate(page) || !ctl.head.eof) {
129 VERBOSE("%s/%s, page uptodate=%d, eof=%d\n",
130 DENTRY_PATH(dentry), PageUptodate(page),ctl.head.eof);
134 if (filp->f_pos == 2) {
135 if (jiffies - ctl.head.time >= SMB_MAX_AGE(server))
139 * N.B. ncpfs checks mtime of dentry too here, we don't.
140 * 1. common smb servers do not update mtime on dir changes
141 * 2. it requires an extra smb request
142 * (revalidate has the same timeout as ctl.head.time)
144 * Instead smbfs invalidates its own cache on local changes
145 * and remote changes are not seen until timeout.
149 if (filp->f_pos > ctl.head.end)
152 ctl.fpos = filp->f_pos + (SMB_DIRCACHE_START - 2);
153 ctl.ofs = ctl.fpos / SMB_DIRCACHE_SIZE;
154 ctl.idx = ctl.fpos % SMB_DIRCACHE_SIZE;
158 ctl.page = find_lock_page(&dir->i_data, ctl.ofs);
161 ctl.cache = kmap(ctl.page);
162 if (!PageUptodate(ctl.page))
165 while (ctl.idx < SMB_DIRCACHE_SIZE) {
169 dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx],
170 dentry, filp->f_pos);
174 res = filldir(dirent, dent->d_name.name,
175 dent->d_name.len, filp->f_pos,
176 dent->d_inode->i_ino, DT_UNKNOWN);
182 if (filp->f_pos > ctl.head.end)
187 SetPageUptodate(ctl.page);
188 unlock_page(ctl.page);
189 page_cache_release(ctl.page);
198 unlock_page(ctl.page);
199 page_cache_release(ctl.page);
204 smb_invalidate_dircache_entries(dentry);
205 ctl.head.time = jiffies;
209 ctl.idx = SMB_DIRCACHE_START;
213 result = server->ops->readdir(filp, dirent, filldir, &ctl);
214 if (result == -ERESTARTSYS && page)
215 ClearPageUptodate(page);
217 goto invalid_cache; /* retry */
218 ctl.head.end = ctl.fpos - 1;
219 ctl.head.eof = ctl.valid;
222 cache->head = ctl.head;
224 if (result != -ERESTARTSYS)
225 SetPageUptodate(page);
227 page_cache_release(page);
231 SetPageUptodate(ctl.page);
232 unlock_page(ctl.page);
233 page_cache_release(ctl.page);
241 smb_dir_open(struct inode *dir, struct file *file)
243 struct dentry *dentry = file->f_path.dentry;
244 struct smb_sb_info *server;
247 VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
248 file->f_path.dentry->d_name.name);
251 * Directory timestamps in the core protocol aren't updated
252 * when a file is added, so we give them a very short TTL.
255 server = server_from_dentry(dentry);
256 if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) {
257 unsigned long age = jiffies - SMB_I(dir)->oldmtime;
259 smb_invalid_dir_cache(dir);
263 * Note: in order to allow the smbmount process to open the
264 * mount point, we only revalidate if the connection is valid or
265 * if the process is trying to access something other than the root.
267 if (server->state == CONN_VALID || !IS_ROOT(dentry))
268 error = smb_revalidate_inode(dentry);
274 * Dentry operations routines
276 static int smb_lookup_validate(struct dentry *, struct nameidata *);
277 static int smb_hash_dentry(struct dentry *, struct qstr *);
278 static int smb_compare_dentry(struct dentry *, struct qstr *, struct qstr *);
279 static int smb_delete_dentry(struct dentry *);
281 static const struct dentry_operations smbfs_dentry_operations =
283 .d_revalidate = smb_lookup_validate,
284 .d_hash = smb_hash_dentry,
285 .d_compare = smb_compare_dentry,
286 .d_delete = smb_delete_dentry,
289 static const struct dentry_operations smbfs_dentry_operations_case =
291 .d_revalidate = smb_lookup_validate,
292 .d_delete = smb_delete_dentry,
297 * This is the callback when the dcache has a lookup hit.
300 smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
302 struct smb_sb_info *server = server_from_dentry(dentry);
303 struct inode * inode = dentry->d_inode;
304 unsigned long age = jiffies - dentry->d_time;
308 * The default validation is based on dentry age:
309 * we believe in dentries for a few seconds. (But each
310 * successful server lookup renews the timestamp.)
312 valid = (age <= SMB_MAX_AGE(server));
313 #ifdef SMBFS_DEBUG_VERBOSE
315 VERBOSE("%s/%s not valid, age=%lu\n",
316 DENTRY_PATH(dentry), age);
321 if (is_bad_inode(inode)) {
322 PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry));
325 valid = (smb_revalidate_inode(dentry) == 0);
329 * What should we do for negative dentries?
336 smb_hash_dentry(struct dentry *dir, struct qstr *this)
341 hash = init_name_hash();
342 for (i=0; i < this->len ; i++)
343 hash = partial_name_hash(tolower(this->name[i]), hash);
344 this->hash = end_name_hash(hash);
350 smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b)
354 if (a->len != b->len)
356 for (i=0; i < a->len; i++) {
357 if (tolower(a->name[i]) != tolower(b->name[i]))
366 * This is the callback from dput() when d_count is going to 0.
367 * We use this to unhash dentries with bad inodes.
370 smb_delete_dentry(struct dentry * dentry)
372 if (dentry->d_inode) {
373 if (is_bad_inode(dentry->d_inode)) {
374 PARANOIA("bad inode, unhashing %s/%s\n",
375 DENTRY_PATH(dentry));
379 /* N.B. Unhash negative dentries? */
385 * Initialize a new dentry
388 smb_new_dentry(struct dentry *dentry)
390 struct smb_sb_info *server = server_from_dentry(dentry);
392 if (server->mnt->flags & SMB_MOUNT_CASE)
393 dentry->d_op = &smbfs_dentry_operations_case;
395 dentry->d_op = &smbfs_dentry_operations;
396 dentry->d_time = jiffies;
401 * Whenever a lookup succeeds, we know the parent directories
402 * are all valid, so we want to update the dentry timestamps.
403 * N.B. Move this to dcache?
406 smb_renew_times(struct dentry * dentry)
409 spin_lock(&dentry->d_lock);
411 struct dentry *parent;
413 dentry->d_time = jiffies;
416 parent = dentry->d_parent;
418 spin_unlock(&dentry->d_lock);
421 spin_lock(&dentry->d_lock);
423 spin_unlock(&dentry->d_lock);
427 static struct dentry *
428 smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
430 struct smb_fattr finfo;
433 struct smb_sb_info *server;
435 error = -ENAMETOOLONG;
436 if (dentry->d_name.len > SMB_MAXNAMELEN)
439 /* Do not allow lookup of names with backslashes in */
441 if (memchr(dentry->d_name.name, '\\', dentry->d_name.len))
445 error = smb_proc_getattr(dentry, &finfo);
446 #ifdef SMBFS_PARANOIA
447 if (error && error != -ENOENT)
448 PARANOIA("find %s/%s failed, error=%d\n",
449 DENTRY_PATH(dentry), error);
453 if (error == -ENOENT)
457 finfo.f_ino = iunique(dentry->d_sb, 2);
458 inode = smb_iget(dir->i_sb, &finfo);
461 server = server_from_dentry(dentry);
462 if (server->mnt->flags & SMB_MOUNT_CASE)
463 dentry->d_op = &smbfs_dentry_operations_case;
465 dentry->d_op = &smbfs_dentry_operations;
467 d_add(dentry, inode);
468 smb_renew_times(dentry);
474 return ERR_PTR(error);
478 * This code is common to all routines creating a new inode.
481 smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id)
483 struct smb_sb_info *server = server_from_dentry(dentry);
486 struct smb_fattr fattr;
488 VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid);
490 error = smb_proc_getattr(dentry, &fattr);
494 smb_renew_times(dentry);
495 fattr.f_ino = iunique(dentry->d_sb, 2);
496 inode = smb_iget(dentry->d_sb, &fattr);
501 struct smb_inode_info *ei = SMB_I(inode);
503 ei->access = SMB_O_RDWR;
504 ei->open = server->generation;
506 d_instantiate(dentry, inode);
514 PARANOIA("%s/%s failed, error=%d, closing %u\n",
515 DENTRY_PATH(dentry), error, fileid);
516 smb_close_fileid(dentry, fileid);
521 /* N.B. How should the mode argument be used? */
523 smb_create(struct inode *dir, struct dentry *dentry, int mode,
524 struct nameidata *nd)
526 struct smb_sb_info *server = server_from_dentry(dentry);
531 VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode);
534 smb_invalid_dir_cache(dir);
535 error = smb_proc_create(dentry, 0, get_seconds(), &fileid);
537 if (server->opt.capabilities & SMB_CAP_UNIX) {
538 /* Set attributes for new file */
539 attr.ia_valid = ATTR_MODE;
541 error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
543 error = smb_instantiate(dentry, fileid, 1);
545 PARANOIA("%s/%s failed, error=%d\n",
546 DENTRY_PATH(dentry), error);
552 /* N.B. How should the mode argument be used? */
554 smb_mkdir(struct inode *dir, struct dentry *dentry, int mode)
556 struct smb_sb_info *server = server_from_dentry(dentry);
561 smb_invalid_dir_cache(dir);
562 error = smb_proc_mkdir(dentry);
564 if (server->opt.capabilities & SMB_CAP_UNIX) {
565 /* Set attributes for new directory */
566 attr.ia_valid = ATTR_MODE;
568 error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
570 error = smb_instantiate(dentry, 0, 0);
577 smb_rmdir(struct inode *dir, struct dentry *dentry)
579 struct inode *inode = dentry->d_inode;
583 * Close the directory if it's open.
589 * Check that nobody else is using the directory..
592 if (!d_unhashed(dentry))
595 smb_invalid_dir_cache(dir);
596 error = smb_proc_rmdir(dentry);
604 smb_unlink(struct inode *dir, struct dentry *dentry)
609 * Close the file if it's open.
612 smb_close(dentry->d_inode);
614 smb_invalid_dir_cache(dir);
615 error = smb_proc_unlink(dentry);
617 smb_renew_times(dentry);
623 smb_rename(struct inode *old_dir, struct dentry *old_dentry,
624 struct inode *new_dir, struct dentry *new_dentry)
629 * Close any open files, and check whether to delete the
630 * target before attempting the rename.
633 if (old_dentry->d_inode)
634 smb_close(old_dentry->d_inode);
635 if (new_dentry->d_inode) {
636 smb_close(new_dentry->d_inode);
637 error = smb_proc_unlink(new_dentry);
639 VERBOSE("unlink %s/%s, error=%d\n",
640 DENTRY_PATH(new_dentry), error);
644 d_delete(new_dentry);
647 smb_invalid_dir_cache(old_dir);
648 smb_invalid_dir_cache(new_dir);
649 error = smb_proc_mv(old_dentry, new_dentry);
651 smb_renew_times(old_dentry);
652 smb_renew_times(new_dentry);
660 * FIXME: samba servers won't let you create device nodes unless uid/gid
661 * matches the connection credentials (and we don't know which those are ...)
664 smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
669 attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID;
671 current_euid_egid(&attr.ia_uid, &attr.ia_gid);
673 if (!new_valid_dev(dev))
676 smb_invalid_dir_cache(dir);
677 error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev));
679 error = smb_instantiate(dentry, 0, 0);
685 * dentry = existing file
686 * new_dentry = new file
689 smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry)
693 DEBUG1("smb_link old=%s/%s new=%s/%s\n",
694 DENTRY_PATH(dentry), DENTRY_PATH(new_dentry));
695 smb_invalid_dir_cache(dir);
696 error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry);
698 smb_renew_times(dentry);
699 error = smb_instantiate(new_dentry, 0, 0);