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