f088ea2f6ac9f27991d605b4093666d1a3d0843c
[linux-2.6.git] / drivers / staging / smbfs / dir.c
1 /*
2  *  dir.c
3  *
4  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5  *  Copyright (C) 1997 by Volker Lendecke
6  *
7  *  Please add a note about your changes to smbfs in the ChangeLog file.
8  */
9
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>
17
18 #include "smb_fs.h"
19 #include "smb_mount.h"
20 #include "smbno.h"
21
22 #include "smb_debug.h"
23 #include "proto.h"
24
25 static int smb_readdir(struct file *, void *, filldir_t);
26 static int smb_dir_open(struct inode *, struct file *);
27
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 *);
37
38 const struct file_operations smb_dir_operations =
39 {
40         .llseek         = generic_file_llseek,
41         .read           = generic_read_dir,
42         .readdir        = smb_readdir,
43         .unlocked_ioctl = smb_ioctl,
44         .open           = smb_dir_open,
45 };
46
47 const struct inode_operations smb_dir_inode_operations =
48 {
49         .create         = smb_create,
50         .lookup         = smb_lookup,
51         .unlink         = smb_unlink,
52         .mkdir          = smb_mkdir,
53         .rmdir          = smb_rmdir,
54         .rename         = smb_rename,
55         .getattr        = smb_getattr,
56         .setattr        = smb_notify_change,
57 };
58
59 const struct inode_operations smb_dir_inode_operations_unix =
60 {
61         .create         = smb_create,
62         .lookup         = smb_lookup,
63         .unlink         = smb_unlink,
64         .mkdir          = smb_mkdir,
65         .rmdir          = smb_rmdir,
66         .rename         = smb_rename,
67         .getattr        = smb_getattr,
68         .setattr        = smb_notify_change,
69         .symlink        = smb_symlink,
70         .mknod          = smb_make_node,
71         .link           = smb_link,
72 };
73
74 /*
75  * Read a directory, using filldir to fill the dirent memory.
76  * smb_proc_readdir does the actual reading from the smb server.
77  *
78  * The cache code is almost directly taken from ncpfs
79  */
80 static int 
81 smb_readdir(struct file *filp, void *dirent, filldir_t filldir)
82 {
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;
89         int result;
90
91         ctl.page  = NULL;
92         ctl.cache = NULL;
93
94         VERBOSE("reading %s/%s, f_pos=%d\n",
95                 DENTRY_PATH(dentry),  (int) filp->f_pos);
96
97         result = 0;
98
99         lock_kernel();
100
101         switch ((unsigned int) filp->f_pos) {
102         case 0:
103                 if (filldir(dirent, ".", 1, 0, dir->i_ino, DT_DIR) < 0)
104                         goto out;
105                 filp->f_pos = 1;
106                 /* fallthrough */
107         case 1:
108                 if (filldir(dirent, "..", 2, 1, parent_ino(dentry), DT_DIR) < 0)
109                         goto out;
110                 filp->f_pos = 2;
111         }
112
113         /*
114          * Make sure our inode is up-to-date.
115          */
116         result = smb_revalidate_inode(dentry);
117         if (result)
118                 goto out;
119
120
121         page = grab_cache_page(&dir->i_data, 0);
122         if (!page)
123                 goto read_really;
124
125         ctl.cache = cache = kmap(page);
126         ctl.head  = cache->head;
127
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);
131                 goto init_cache;
132         }
133
134         if (filp->f_pos == 2) {
135                 if (jiffies - ctl.head.time >= SMB_MAX_AGE(server))
136                         goto init_cache;
137
138                 /*
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)
143                  *
144                  * Instead smbfs invalidates its own cache on local changes
145                  * and remote changes are not seen until timeout.
146                  */
147         }
148
149         if (filp->f_pos > ctl.head.end)
150                 goto finished;
151
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;
155
156         for (;;) {
157                 if (ctl.ofs != 0) {
158                         ctl.page = find_lock_page(&dir->i_data, ctl.ofs);
159                         if (!ctl.page)
160                                 goto invalid_cache;
161                         ctl.cache = kmap(ctl.page);
162                         if (!PageUptodate(ctl.page))
163                                 goto invalid_cache;
164                 }
165                 while (ctl.idx < SMB_DIRCACHE_SIZE) {
166                         struct dentry *dent;
167                         int res;
168
169                         dent = smb_dget_fpos(ctl.cache->dentry[ctl.idx],
170                                              dentry, filp->f_pos);
171                         if (!dent)
172                                 goto invalid_cache;
173
174                         res = filldir(dirent, dent->d_name.name,
175                                       dent->d_name.len, filp->f_pos,
176                                       dent->d_inode->i_ino, DT_UNKNOWN);
177                         dput(dent);
178                         if (res)
179                                 goto finished;
180                         filp->f_pos += 1;
181                         ctl.idx += 1;
182                         if (filp->f_pos > ctl.head.end)
183                                 goto finished;
184                 }
185                 if (ctl.page) {
186                         kunmap(ctl.page);
187                         SetPageUptodate(ctl.page);
188                         unlock_page(ctl.page);
189                         page_cache_release(ctl.page);
190                         ctl.page = NULL;
191                 }
192                 ctl.idx  = 0;
193                 ctl.ofs += 1;
194         }
195 invalid_cache:
196         if (ctl.page) {
197                 kunmap(ctl.page);
198                 unlock_page(ctl.page);
199                 page_cache_release(ctl.page);
200                 ctl.page = NULL;
201         }
202         ctl.cache = cache;
203 init_cache:
204         smb_invalidate_dircache_entries(dentry);
205         ctl.head.time = jiffies;
206         ctl.head.eof = 0;
207         ctl.fpos = 2;
208         ctl.ofs = 0;
209         ctl.idx = SMB_DIRCACHE_START;
210         ctl.filled = 0;
211         ctl.valid  = 1;
212 read_really:
213         result = server->ops->readdir(filp, dirent, filldir, &ctl);
214         if (result == -ERESTARTSYS && page)
215                 ClearPageUptodate(page);
216         if (ctl.idx == -1)
217                 goto invalid_cache;     /* retry */
218         ctl.head.end = ctl.fpos - 1;
219         ctl.head.eof = ctl.valid;
220 finished:
221         if (page) {
222                 cache->head = ctl.head;
223                 kunmap(page);
224                 if (result != -ERESTARTSYS)
225                         SetPageUptodate(page);
226                 unlock_page(page);
227                 page_cache_release(page);
228         }
229         if (ctl.page) {
230                 kunmap(ctl.page);
231                 SetPageUptodate(ctl.page);
232                 unlock_page(ctl.page);
233                 page_cache_release(ctl.page);
234         }
235 out:
236         unlock_kernel();
237         return result;
238 }
239
240 static int
241 smb_dir_open(struct inode *dir, struct file *file)
242 {
243         struct dentry *dentry = file->f_path.dentry;
244         struct smb_sb_info *server;
245         int error = 0;
246
247         VERBOSE("(%s/%s)\n", dentry->d_parent->d_name.name,
248                 file->f_path.dentry->d_name.name);
249
250         /*
251          * Directory timestamps in the core protocol aren't updated
252          * when a file is added, so we give them a very short TTL.
253          */
254         lock_kernel();
255         server = server_from_dentry(dentry);
256         if (server->opt.protocol < SMB_PROTOCOL_LANMAN2) {
257                 unsigned long age = jiffies - SMB_I(dir)->oldmtime;
258                 if (age > 2*HZ)
259                         smb_invalid_dir_cache(dir);
260         }
261
262         /*
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.
266          */
267         if (server->state == CONN_VALID || !IS_ROOT(dentry))
268                 error = smb_revalidate_inode(dentry);
269         unlock_kernel();
270         return error;
271 }
272
273 /*
274  * Dentry operations routines
275  */
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 *);
280
281 static const struct dentry_operations smbfs_dentry_operations =
282 {
283         .d_revalidate   = smb_lookup_validate,
284         .d_hash         = smb_hash_dentry,
285         .d_compare      = smb_compare_dentry,
286         .d_delete       = smb_delete_dentry,
287 };
288
289 static const struct dentry_operations smbfs_dentry_operations_case =
290 {
291         .d_revalidate   = smb_lookup_validate,
292         .d_delete       = smb_delete_dentry,
293 };
294
295
296 /*
297  * This is the callback when the dcache has a lookup hit.
298  */
299 static int
300 smb_lookup_validate(struct dentry * dentry, struct nameidata *nd)
301 {
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;
305         int valid;
306
307         /*
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.)
311          */
312         valid = (age <= SMB_MAX_AGE(server));
313 #ifdef SMBFS_DEBUG_VERBOSE
314         if (!valid)
315                 VERBOSE("%s/%s not valid, age=%lu\n", 
316                         DENTRY_PATH(dentry), age);
317 #endif
318
319         if (inode) {
320                 lock_kernel();
321                 if (is_bad_inode(inode)) {
322                         PARANOIA("%s/%s has dud inode\n", DENTRY_PATH(dentry));
323                         valid = 0;
324                 } else if (!valid)
325                         valid = (smb_revalidate_inode(dentry) == 0);
326                 unlock_kernel();
327         } else {
328                 /*
329                  * What should we do for negative dentries?
330                  */
331         }
332         return valid;
333 }
334
335 static int 
336 smb_hash_dentry(struct dentry *dir, struct qstr *this)
337 {
338         unsigned long hash;
339         int i;
340
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);
345   
346         return 0;
347 }
348
349 static int
350 smb_compare_dentry(struct dentry *dir, struct qstr *a, struct qstr *b)
351 {
352         int i, result = 1;
353
354         if (a->len != b->len)
355                 goto out;
356         for (i=0; i < a->len; i++) {
357                 if (tolower(a->name[i]) != tolower(b->name[i]))
358                         goto out;
359         }
360         result = 0;
361 out:
362         return result;
363 }
364
365 /*
366  * This is the callback from dput() when d_count is going to 0.
367  * We use this to unhash dentries with bad inodes.
368  */
369 static int
370 smb_delete_dentry(struct dentry * dentry)
371 {
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));
376                         return 1;
377                 }
378         } else {
379                 /* N.B. Unhash negative dentries? */
380         }
381         return 0;
382 }
383
384 /*
385  * Initialize a new dentry
386  */
387 void
388 smb_new_dentry(struct dentry *dentry)
389 {
390         struct smb_sb_info *server = server_from_dentry(dentry);
391
392         if (server->mnt->flags & SMB_MOUNT_CASE)
393                 dentry->d_op = &smbfs_dentry_operations_case;
394         else
395                 dentry->d_op = &smbfs_dentry_operations;
396         dentry->d_time = jiffies;
397 }
398
399
400 /*
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?
404  */
405 void
406 smb_renew_times(struct dentry * dentry)
407 {
408         dget(dentry);
409         dentry->d_time = jiffies;
410
411         while (!IS_ROOT(dentry)) {
412                 struct dentry *parent = dget_parent(dentry);
413                 dput(dentry);
414                 dentry = parent;
415
416                 dentry->d_time = jiffies;
417         }
418         dput(dentry);
419 }
420
421 static struct dentry *
422 smb_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
423 {
424         struct smb_fattr finfo;
425         struct inode *inode;
426         int error;
427         struct smb_sb_info *server;
428
429         error = -ENAMETOOLONG;
430         if (dentry->d_name.len > SMB_MAXNAMELEN)
431                 goto out;
432
433         /* Do not allow lookup of names with backslashes in */
434         error = -EINVAL;
435         if (memchr(dentry->d_name.name, '\\', dentry->d_name.len))
436                 goto out;
437
438         lock_kernel();
439         error = smb_proc_getattr(dentry, &finfo);
440 #ifdef SMBFS_PARANOIA
441         if (error && error != -ENOENT)
442                 PARANOIA("find %s/%s failed, error=%d\n",
443                          DENTRY_PATH(dentry), error);
444 #endif
445
446         inode = NULL;
447         if (error == -ENOENT)
448                 goto add_entry;
449         if (!error) {
450                 error = -EACCES;
451                 finfo.f_ino = iunique(dentry->d_sb, 2);
452                 inode = smb_iget(dir->i_sb, &finfo);
453                 if (inode) {
454         add_entry:
455                         server = server_from_dentry(dentry);
456                         if (server->mnt->flags & SMB_MOUNT_CASE)
457                                 dentry->d_op = &smbfs_dentry_operations_case;
458                         else
459                                 dentry->d_op = &smbfs_dentry_operations;
460
461                         d_add(dentry, inode);
462                         smb_renew_times(dentry);
463                         error = 0;
464                 }
465         }
466         unlock_kernel();
467 out:
468         return ERR_PTR(error);
469 }
470
471 /*
472  * This code is common to all routines creating a new inode.
473  */
474 static int
475 smb_instantiate(struct dentry *dentry, __u16 fileid, int have_id)
476 {
477         struct smb_sb_info *server = server_from_dentry(dentry);
478         struct inode *inode;
479         int error;
480         struct smb_fattr fattr;
481
482         VERBOSE("file %s/%s, fileid=%u\n", DENTRY_PATH(dentry), fileid);
483
484         error = smb_proc_getattr(dentry, &fattr);
485         if (error)
486                 goto out_close;
487
488         smb_renew_times(dentry);
489         fattr.f_ino = iunique(dentry->d_sb, 2);
490         inode = smb_iget(dentry->d_sb, &fattr);
491         if (!inode)
492                 goto out_no_inode;
493
494         if (have_id) {
495                 struct smb_inode_info *ei = SMB_I(inode);
496                 ei->fileid = fileid;
497                 ei->access = SMB_O_RDWR;
498                 ei->open = server->generation;
499         }
500         d_instantiate(dentry, inode);
501 out:
502         return error;
503
504 out_no_inode:
505         error = -EACCES;
506 out_close:
507         if (have_id) {
508                 PARANOIA("%s/%s failed, error=%d, closing %u\n",
509                          DENTRY_PATH(dentry), error, fileid);
510                 smb_close_fileid(dentry, fileid);
511         }
512         goto out;
513 }
514
515 /* N.B. How should the mode argument be used? */
516 static int
517 smb_create(struct inode *dir, struct dentry *dentry, int mode,
518                 struct nameidata *nd)
519 {
520         struct smb_sb_info *server = server_from_dentry(dentry);
521         __u16 fileid;
522         int error;
523         struct iattr attr;
524
525         VERBOSE("creating %s/%s, mode=%d\n", DENTRY_PATH(dentry), mode);
526
527         lock_kernel();
528         smb_invalid_dir_cache(dir);
529         error = smb_proc_create(dentry, 0, get_seconds(), &fileid);
530         if (!error) {
531                 if (server->opt.capabilities & SMB_CAP_UNIX) {
532                         /* Set attributes for new file */
533                         attr.ia_valid = ATTR_MODE;
534                         attr.ia_mode = mode;
535                         error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
536                 }
537                 error = smb_instantiate(dentry, fileid, 1);
538         } else {
539                 PARANOIA("%s/%s failed, error=%d\n",
540                          DENTRY_PATH(dentry), error);
541         }
542         unlock_kernel();
543         return error;
544 }
545
546 /* N.B. How should the mode argument be used? */
547 static int
548 smb_mkdir(struct inode *dir, struct dentry *dentry, int mode)
549 {
550         struct smb_sb_info *server = server_from_dentry(dentry);
551         int error;
552         struct iattr attr;
553
554         lock_kernel();
555         smb_invalid_dir_cache(dir);
556         error = smb_proc_mkdir(dentry);
557         if (!error) {
558                 if (server->opt.capabilities & SMB_CAP_UNIX) {
559                         /* Set attributes for new directory */
560                         attr.ia_valid = ATTR_MODE;
561                         attr.ia_mode = mode;
562                         error = smb_proc_setattr_unix(dentry, &attr, 0, 0);
563                 }
564                 error = smb_instantiate(dentry, 0, 0);
565         }
566         unlock_kernel();
567         return error;
568 }
569
570 static int
571 smb_rmdir(struct inode *dir, struct dentry *dentry)
572 {
573         struct inode *inode = dentry->d_inode;
574         int error;
575
576         /*
577          * Close the directory if it's open.
578          */
579         lock_kernel();
580         smb_close(inode);
581
582         /*
583          * Check that nobody else is using the directory..
584          */
585         error = -EBUSY;
586         if (!d_unhashed(dentry))
587                 goto out;
588
589         smb_invalid_dir_cache(dir);
590         error = smb_proc_rmdir(dentry);
591
592 out:
593         unlock_kernel();
594         return error;
595 }
596
597 static int
598 smb_unlink(struct inode *dir, struct dentry *dentry)
599 {
600         int error;
601
602         /*
603          * Close the file if it's open.
604          */
605         lock_kernel();
606         smb_close(dentry->d_inode);
607
608         smb_invalid_dir_cache(dir);
609         error = smb_proc_unlink(dentry);
610         if (!error)
611                 smb_renew_times(dentry);
612         unlock_kernel();
613         return error;
614 }
615
616 static int
617 smb_rename(struct inode *old_dir, struct dentry *old_dentry,
618            struct inode *new_dir, struct dentry *new_dentry)
619 {
620         int error;
621
622         /*
623          * Close any open files, and check whether to delete the
624          * target before attempting the rename.
625          */
626         lock_kernel();
627         if (old_dentry->d_inode)
628                 smb_close(old_dentry->d_inode);
629         if (new_dentry->d_inode) {
630                 smb_close(new_dentry->d_inode);
631                 error = smb_proc_unlink(new_dentry);
632                 if (error) {
633                         VERBOSE("unlink %s/%s, error=%d\n",
634                                 DENTRY_PATH(new_dentry), error);
635                         goto out;
636                 }
637                 /* FIXME */
638                 d_delete(new_dentry);
639         }
640
641         smb_invalid_dir_cache(old_dir);
642         smb_invalid_dir_cache(new_dir);
643         error = smb_proc_mv(old_dentry, new_dentry);
644         if (!error) {
645                 smb_renew_times(old_dentry);
646                 smb_renew_times(new_dentry);
647         }
648 out:
649         unlock_kernel();
650         return error;
651 }
652
653 /*
654  * FIXME: samba servers won't let you create device nodes unless uid/gid
655  * matches the connection credentials (and we don't know which those are ...)
656  */
657 static int
658 smb_make_node(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
659 {
660         int error;
661         struct iattr attr;
662
663         attr.ia_valid = ATTR_MODE | ATTR_UID | ATTR_GID;
664         attr.ia_mode = mode;
665         current_euid_egid(&attr.ia_uid, &attr.ia_gid);
666
667         if (!new_valid_dev(dev))
668                 return -EINVAL;
669
670         smb_invalid_dir_cache(dir);
671         error = smb_proc_setattr_unix(dentry, &attr, MAJOR(dev), MINOR(dev));
672         if (!error) {
673                 error = smb_instantiate(dentry, 0, 0);
674         }
675         return error;
676 }
677
678 /*
679  * dentry = existing file
680  * new_dentry = new file
681  */
682 static int
683 smb_link(struct dentry *dentry, struct inode *dir, struct dentry *new_dentry)
684 {
685         int error;
686
687         DEBUG1("smb_link old=%s/%s new=%s/%s\n",
688                DENTRY_PATH(dentry), DENTRY_PATH(new_dentry));
689         smb_invalid_dir_cache(dir);
690         error = smb_proc_link(server_from_dentry(dentry), dentry, new_dentry);
691         if (!error) {
692                 smb_renew_times(dentry);
693                 error = smb_instantiate(new_dentry, 0, 0);
694         }
695         return error;
696 }