Merge Btrfs into fs/btrfs
[linux-2.6] / fs / coda / dir.c
1
2 /*
3  * Directory operations for Coda filesystem
4  * Original version: (C) 1996 P. Braam and M. Callahan
5  * Rewritten for Linux 2.1. (C) 1997 Carnegie Mellon University
6  * 
7  * Carnegie Mellon encourages users to contribute improvements to
8  * the Coda project. Contact Peter Braam (coda@cs.cmu.edu).
9  */
10
11 #include <linux/types.h>
12 #include <linux/kernel.h>
13 #include <linux/time.h>
14 #include <linux/fs.h>
15 #include <linux/file.h>
16 #include <linux/stat.h>
17 #include <linux/errno.h>
18 #include <linux/string.h>
19 #include <linux/smp_lock.h>
20
21 #include <asm/uaccess.h>
22
23 #include <linux/coda.h>
24 #include <linux/coda_linux.h>
25 #include <linux/coda_psdev.h>
26 #include <linux/coda_fs_i.h>
27 #include <linux/coda_cache.h>
28
29 #include "coda_int.h"
30
31 /* dir inode-ops */
32 static int coda_create(struct inode *dir, struct dentry *new, int mode, struct nameidata *nd);
33 static struct dentry *coda_lookup(struct inode *dir, struct dentry *target, struct nameidata *nd);
34 static int coda_link(struct dentry *old_dentry, struct inode *dir_inode, 
35                      struct dentry *entry);
36 static int coda_unlink(struct inode *dir_inode, struct dentry *entry);
37 static int coda_symlink(struct inode *dir_inode, struct dentry *entry,
38                         const char *symname);
39 static int coda_mkdir(struct inode *dir_inode, struct dentry *entry, int mode);
40 static int coda_rmdir(struct inode *dir_inode, struct dentry *entry);
41 static int coda_rename(struct inode *old_inode, struct dentry *old_dentry, 
42                        struct inode *new_inode, struct dentry *new_dentry);
43
44 /* dir file-ops */
45 static int coda_readdir(struct file *file, void *buf, filldir_t filldir);
46
47 /* dentry ops */
48 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd);
49 static int coda_dentry_delete(struct dentry *);
50
51 /* support routines */
52 static int coda_venus_readdir(struct file *coda_file, void *buf,
53                               filldir_t filldir);
54
55 /* same as fs/bad_inode.c */
56 static int coda_return_EIO(void)
57 {
58         return -EIO;
59 }
60 #define CODA_EIO_ERROR ((void *) (coda_return_EIO))
61
62 static struct dentry_operations coda_dentry_operations =
63 {
64         .d_revalidate   = coda_dentry_revalidate,
65         .d_delete       = coda_dentry_delete,
66 };
67
68 const struct inode_operations coda_dir_inode_operations =
69 {
70         .create         = coda_create,
71         .lookup         = coda_lookup,
72         .link           = coda_link,
73         .unlink         = coda_unlink,
74         .symlink        = coda_symlink,
75         .mkdir          = coda_mkdir,
76         .rmdir          = coda_rmdir,
77         .mknod          = CODA_EIO_ERROR,
78         .rename         = coda_rename,
79         .permission     = coda_permission,
80         .getattr        = coda_getattr,
81         .setattr        = coda_setattr,
82 };
83
84 const struct file_operations coda_dir_operations = {
85         .llseek         = generic_file_llseek,
86         .read           = generic_read_dir,
87         .readdir        = coda_readdir,
88         .open           = coda_open,
89         .release        = coda_release,
90         .fsync          = coda_fsync,
91 };
92
93
94 /* inode operations for directories */
95 /* access routines: lookup, readlink, permission */
96 static struct dentry *coda_lookup(struct inode *dir, struct dentry *entry, struct nameidata *nd)
97 {
98         struct inode *inode = NULL;
99         struct CodaFid resfid = { { 0, } };
100         int type = 0;
101         int error = 0;
102         const char *name = entry->d_name.name;
103         size_t length = entry->d_name.len;
104
105         if (length > CODA_MAXNAMLEN) {
106                 printk(KERN_ERR "name too long: lookup, %s (%*s)\n",
107                        coda_i2s(dir), (int)length, name);
108                 return ERR_PTR(-ENAMETOOLONG);
109         }
110
111         /* control object, create inode on the fly */
112         if (coda_isroot(dir) && coda_iscontrol(name, length)) {
113                 error = coda_cnode_makectl(&inode, dir->i_sb);
114                 type = CODA_NOCACHE;
115                 goto exit;
116         }
117
118         lock_kernel();
119
120         error = venus_lookup(dir->i_sb, coda_i2f(dir), name, length,
121                              &type, &resfid);
122         if (!error)
123                 error = coda_cnode_make(&inode, &resfid, dir->i_sb);
124
125         unlock_kernel();
126
127         if (error && error != -ENOENT)
128                 return ERR_PTR(error);
129
130 exit:
131         entry->d_op = &coda_dentry_operations;
132
133         if (inode && (type & CODA_NOCACHE))
134                 coda_flag_inode(inode, C_VATTR | C_PURGE);
135
136         return d_splice_alias(inode, entry);
137 }
138
139
140 int coda_permission(struct inode *inode, int mask)
141 {
142         int error = 0;
143
144         mask &= MAY_READ | MAY_WRITE | MAY_EXEC;
145  
146         if (!mask)
147                 return 0; 
148
149         lock_kernel();
150
151         if (coda_cache_check(inode, mask))
152                 goto out; 
153
154         error = venus_access(inode->i_sb, coda_i2f(inode), mask);
155     
156         if (!error)
157                 coda_cache_enter(inode, mask);
158
159  out:
160         unlock_kernel();
161         return error;
162 }
163
164
165 static inline void coda_dir_update_mtime(struct inode *dir)
166 {
167 #ifdef REQUERY_VENUS_FOR_MTIME
168         /* invalidate the directory cnode's attributes so we refetch the
169          * attributes from venus next time the inode is referenced */
170         coda_flag_inode(dir, C_VATTR);
171 #else
172         /* optimistically we can also act as if our nose bleeds. The
173          * granularity of the mtime is coarse anyways so we might actually be
174          * right most of the time. Note: we only do this for directories. */
175         dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
176 #endif
177 }
178
179 /* we have to wrap inc_nlink/drop_nlink because sometimes userspace uses a
180  * trick to fool GNU find's optimizations. If we can't be sure of the link
181  * (because of volume mount points) we set i_nlink to 1 which forces find
182  * to consider every child as a possible directory. We should also never
183  * see an increment or decrement for deleted directories where i_nlink == 0 */
184 static inline void coda_dir_inc_nlink(struct inode *dir)
185 {
186         if (dir->i_nlink >= 2)
187                 inc_nlink(dir);
188 }
189
190 static inline void coda_dir_drop_nlink(struct inode *dir)
191 {
192         if (dir->i_nlink > 2)
193                 drop_nlink(dir);
194 }
195
196 /* creation routines: create, mknod, mkdir, link, symlink */
197 static int coda_create(struct inode *dir, struct dentry *de, int mode, struct nameidata *nd)
198 {
199         int error=0;
200         const char *name=de->d_name.name;
201         int length=de->d_name.len;
202         struct inode *inode;
203         struct CodaFid newfid;
204         struct coda_vattr attrs;
205
206         lock_kernel();
207
208         if (coda_isroot(dir) && coda_iscontrol(name, length)) {
209                 unlock_kernel();
210                 return -EPERM;
211         }
212
213         error = venus_create(dir->i_sb, coda_i2f(dir), name, length, 
214                                 0, mode, &newfid, &attrs);
215
216         if ( error ) {
217                 unlock_kernel();
218                 d_drop(de);
219                 return error;
220         }
221
222         inode = coda_iget(dir->i_sb, &newfid, &attrs);
223         if ( IS_ERR(inode) ) {
224                 unlock_kernel();
225                 d_drop(de);
226                 return PTR_ERR(inode);
227         }
228
229         /* invalidate the directory cnode's attributes */
230         coda_dir_update_mtime(dir);
231         unlock_kernel();
232         d_instantiate(de, inode);
233         return 0;
234 }
235
236 static int coda_mkdir(struct inode *dir, struct dentry *de, int mode)
237 {
238         struct inode *inode;
239         struct coda_vattr attrs;
240         const char *name = de->d_name.name;
241         int len = de->d_name.len;
242         int error;
243         struct CodaFid newfid;
244
245         lock_kernel();
246
247         if (coda_isroot(dir) && coda_iscontrol(name, len)) {
248                 unlock_kernel();
249                 return -EPERM;
250         }
251
252         attrs.va_mode = mode;
253         error = venus_mkdir(dir->i_sb, coda_i2f(dir), 
254                                name, len, &newfid, &attrs);
255         
256         if ( error ) {
257                 unlock_kernel();
258                 d_drop(de);
259                 return error;
260         }
261          
262         inode = coda_iget(dir->i_sb, &newfid, &attrs);
263         if ( IS_ERR(inode) ) {
264                 unlock_kernel();
265                 d_drop(de);
266                 return PTR_ERR(inode);
267         }
268
269         /* invalidate the directory cnode's attributes */
270         coda_dir_inc_nlink(dir);
271         coda_dir_update_mtime(dir);
272         unlock_kernel();
273         d_instantiate(de, inode);
274         return 0;
275 }
276
277 /* try to make de an entry in dir_inodde linked to source_de */ 
278 static int coda_link(struct dentry *source_de, struct inode *dir_inode, 
279           struct dentry *de)
280 {
281         struct inode *inode = source_de->d_inode;
282         const char * name = de->d_name.name;
283         int len = de->d_name.len;
284         int error;
285
286         lock_kernel();
287
288         if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) {
289                 unlock_kernel();
290                 return -EPERM;
291         }
292
293         error = venus_link(dir_inode->i_sb, coda_i2f(inode),
294                            coda_i2f(dir_inode), (const char *)name, len);
295
296         if (error) {
297                 d_drop(de);
298                 goto out;
299         }
300
301         coda_dir_update_mtime(dir_inode);
302         atomic_inc(&inode->i_count);
303         d_instantiate(de, inode);
304         inc_nlink(inode);
305
306 out:
307         unlock_kernel();
308         return(error);
309 }
310
311
312 static int coda_symlink(struct inode *dir_inode, struct dentry *de,
313                         const char *symname)
314 {
315         const char *name = de->d_name.name;
316         int len = de->d_name.len;
317         int symlen;
318         int error = 0;
319
320         lock_kernel();
321
322         if (coda_isroot(dir_inode) && coda_iscontrol(name, len)) {
323                 unlock_kernel();
324                 return -EPERM;
325         }
326
327         symlen = strlen(symname);
328         if ( symlen > CODA_MAXPATHLEN ) {
329                 unlock_kernel();
330                 return -ENAMETOOLONG;
331         }
332
333         /*
334          * This entry is now negative. Since we do not create
335          * an inode for the entry we have to drop it.
336          */
337         d_drop(de);
338         error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len,
339                               symname, symlen);
340
341         /* mtime is no good anymore */
342         if ( !error )
343                 coda_dir_update_mtime(dir_inode);
344
345         unlock_kernel();
346         return error;
347 }
348
349 /* destruction routines: unlink, rmdir */
350 static int coda_unlink(struct inode *dir, struct dentry *de)
351 {
352         int error;
353         const char *name = de->d_name.name;
354         int len = de->d_name.len;
355
356         lock_kernel();
357
358         error = venus_remove(dir->i_sb, coda_i2f(dir), name, len);
359         if ( error ) {
360                 unlock_kernel();
361                 return error;
362         }
363
364         coda_dir_update_mtime(dir);
365         drop_nlink(de->d_inode);
366         unlock_kernel();
367         return 0;
368 }
369
370 static int coda_rmdir(struct inode *dir, struct dentry *de)
371 {
372         const char *name = de->d_name.name;
373         int len = de->d_name.len;
374         int error;
375
376         lock_kernel();
377
378         error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len);
379         if (!error) {
380                 /* VFS may delete the child */
381                 if (de->d_inode)
382                     de->d_inode->i_nlink = 0;
383
384                 /* fix the link count of the parent */
385                 coda_dir_drop_nlink(dir);
386                 coda_dir_update_mtime(dir);
387         }
388         unlock_kernel();
389         return error;
390 }
391
392 /* rename */
393 static int coda_rename(struct inode *old_dir, struct dentry *old_dentry,
394                        struct inode *new_dir, struct dentry *new_dentry)
395 {
396         const char *old_name = old_dentry->d_name.name;
397         const char *new_name = new_dentry->d_name.name;
398         int old_length = old_dentry->d_name.len;
399         int new_length = new_dentry->d_name.len;
400         int error;
401
402         lock_kernel();
403
404         error = venus_rename(old_dir->i_sb, coda_i2f(old_dir),
405                              coda_i2f(new_dir), old_length, new_length,
406                              (const char *) old_name, (const char *)new_name);
407
408         if ( !error ) {
409                 if ( new_dentry->d_inode ) {
410                         if ( S_ISDIR(new_dentry->d_inode->i_mode) ) {
411                                 coda_dir_drop_nlink(old_dir);
412                                 coda_dir_inc_nlink(new_dir);
413                         }
414                         coda_dir_update_mtime(old_dir);
415                         coda_dir_update_mtime(new_dir);
416                         coda_flag_inode(new_dentry->d_inode, C_VATTR);
417                 } else {
418                         coda_flag_inode(old_dir, C_VATTR);
419                         coda_flag_inode(new_dir, C_VATTR);
420                 }
421         }
422         unlock_kernel();
423
424         return error;
425 }
426
427
428 /* file operations for directories */
429 static int coda_readdir(struct file *coda_file, void *buf, filldir_t filldir)
430 {
431         struct coda_file_info *cfi;
432         struct file *host_file;
433         int ret;
434
435         cfi = CODA_FTOC(coda_file);
436         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
437         host_file = cfi->cfi_container;
438
439         if (!host_file->f_op)
440                 return -ENOTDIR;
441
442         if (host_file->f_op->readdir)
443         {
444                 /* potemkin case: we were handed a directory inode.
445                  * We can't use vfs_readdir because we have to keep the file
446                  * position in sync between the coda_file and the host_file.
447                  * and as such we need grab the inode mutex. */
448                 struct inode *host_inode = host_file->f_path.dentry->d_inode;
449
450                 mutex_lock(&host_inode->i_mutex);
451                 host_file->f_pos = coda_file->f_pos;
452
453                 ret = -ENOENT;
454                 if (!IS_DEADDIR(host_inode)) {
455                         ret = host_file->f_op->readdir(host_file, buf, filldir);
456                         file_accessed(host_file);
457                 }
458
459                 coda_file->f_pos = host_file->f_pos;
460                 mutex_unlock(&host_inode->i_mutex);
461         }
462         else /* Venus: we must read Venus dirents from a file */
463                 ret = coda_venus_readdir(coda_file, buf, filldir);
464
465         return ret;
466 }
467
468 static inline unsigned int CDT2DT(unsigned char cdt)
469 {
470         unsigned int dt;
471
472         switch(cdt) {
473         case CDT_UNKNOWN: dt = DT_UNKNOWN; break;
474         case CDT_FIFO:    dt = DT_FIFO;    break;
475         case CDT_CHR:     dt = DT_CHR;     break;
476         case CDT_DIR:     dt = DT_DIR;     break;
477         case CDT_BLK:     dt = DT_BLK;     break;
478         case CDT_REG:     dt = DT_REG;     break;
479         case CDT_LNK:     dt = DT_LNK;     break;
480         case CDT_SOCK:    dt = DT_SOCK;    break;
481         case CDT_WHT:     dt = DT_WHT;     break;
482         default:          dt = DT_UNKNOWN; break;
483         }
484         return dt;
485 }
486
487 /* support routines */
488 static int coda_venus_readdir(struct file *coda_file, void *buf,
489                               filldir_t filldir)
490 {
491         int result = 0; /* # of entries returned */
492         struct coda_file_info *cfi;
493         struct coda_inode_info *cii;
494         struct file *host_file;
495         struct dentry *de;
496         struct venus_dirent *vdir;
497         unsigned long vdir_size =
498             (unsigned long)(&((struct venus_dirent *)0)->d_name);
499         unsigned int type;
500         struct qstr name;
501         ino_t ino;
502         int ret;
503
504         cfi = CODA_FTOC(coda_file);
505         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
506         host_file = cfi->cfi_container;
507
508         de = coda_file->f_path.dentry;
509         cii = ITOC(de->d_inode);
510
511         vdir = kmalloc(sizeof(*vdir), GFP_KERNEL);
512         if (!vdir) return -ENOMEM;
513
514         if (coda_file->f_pos == 0) {
515                 ret = filldir(buf, ".", 1, 0, de->d_inode->i_ino, DT_DIR);
516                 if (ret < 0)
517                         goto out;
518                 result++;
519                 coda_file->f_pos++;
520         }
521         if (coda_file->f_pos == 1) {
522                 ret = filldir(buf, "..", 2, 1, de->d_parent->d_inode->i_ino, DT_DIR);
523                 if (ret < 0)
524                         goto out;
525                 result++;
526                 coda_file->f_pos++;
527         }
528         while (1) {
529                 /* read entries from the directory file */
530                 ret = kernel_read(host_file, coda_file->f_pos - 2, (char *)vdir,
531                                   sizeof(*vdir));
532                 if (ret < 0) {
533                         printk(KERN_ERR "coda readdir: read dir %s failed %d\n",
534                                coda_f2s(&cii->c_fid), ret);
535                         break;
536                 }
537                 if (ret == 0) break; /* end of directory file reached */
538
539                 /* catch truncated reads */
540                 if (ret < vdir_size || ret < vdir_size + vdir->d_namlen) {
541                         printk(KERN_ERR "coda readdir: short read on %s\n",
542                                coda_f2s(&cii->c_fid));
543                         ret = -EBADF;
544                         break;
545                 }
546                 /* validate whether the directory file actually makes sense */
547                 if (vdir->d_reclen < vdir_size + vdir->d_namlen) {
548                         printk(KERN_ERR "coda readdir: invalid dir %s\n",
549                                coda_f2s(&cii->c_fid));
550                         ret = -EBADF;
551                         break;
552                 }
553
554                 name.len = vdir->d_namlen;
555                 name.name = vdir->d_name;
556
557                 /* Make sure we skip '.' and '..', we already got those */
558                 if (name.name[0] == '.' && (name.len == 1 ||
559                     (vdir->d_name[1] == '.' && name.len == 2)))
560                         vdir->d_fileno = name.len = 0;
561
562                 /* skip null entries */
563                 if (vdir->d_fileno && name.len) {
564                         /* try to look up this entry in the dcache, that way
565                          * userspace doesn't have to worry about breaking
566                          * getcwd by having mismatched inode numbers for
567                          * internal volume mountpoints. */
568                         ino = find_inode_number(de, &name);
569                         if (!ino) ino = vdir->d_fileno;
570
571                         type = CDT2DT(vdir->d_type);
572                         ret = filldir(buf, name.name, name.len,
573                                       coda_file->f_pos, ino, type);
574                         /* failure means no space for filling in this round */
575                         if (ret < 0) break;
576                         result++;
577                 }
578                 /* we'll always have progress because d_reclen is unsigned and
579                  * we've already established it is non-zero. */
580                 coda_file->f_pos += vdir->d_reclen;
581         }
582 out:
583         kfree(vdir);
584         return result ? result : ret;
585 }
586
587 /* called when a cache lookup succeeds */
588 static int coda_dentry_revalidate(struct dentry *de, struct nameidata *nd)
589 {
590         struct inode *inode = de->d_inode;
591         struct coda_inode_info *cii;
592
593         if (!inode)
594                 return 1;
595         lock_kernel();
596         if (coda_isroot(inode))
597                 goto out;
598         if (is_bad_inode(inode))
599                 goto bad;
600
601         cii = ITOC(de->d_inode);
602         if (!(cii->c_flags & (C_PURGE | C_FLUSH)))
603                 goto out;
604
605         shrink_dcache_parent(de);
606
607         /* propagate for a flush */
608         if (cii->c_flags & C_FLUSH) 
609                 coda_flag_inode_children(inode, C_FLUSH);
610
611         if (atomic_read(&de->d_count) > 1)
612                 /* pretend it's valid, but don't change the flags */
613                 goto out;
614
615         /* clear the flags. */
616         cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
617
618 bad:
619         unlock_kernel();
620         return 0;
621 out:
622         unlock_kernel();
623         return 1;
624 }
625
626 /*
627  * This is the callback from dput() when d_count is going to 0.
628  * We use this to unhash dentries with bad inodes.
629  */
630 static int coda_dentry_delete(struct dentry * dentry)
631 {
632         int flags;
633
634         if (!dentry->d_inode) 
635                 return 0;
636
637         flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE;
638         if (is_bad_inode(dentry->d_inode) || flags) {
639                 return 1;
640         }
641         return 0;
642 }
643
644
645
646 /*
647  * This is called when we want to check if the inode has
648  * changed on the server.  Coda makes this easy since the
649  * cache manager Venus issues a downcall to the kernel when this 
650  * happens 
651  */
652 int coda_revalidate_inode(struct dentry *dentry)
653 {
654         struct coda_vattr attr;
655         int error = 0;
656         int old_mode;
657         ino_t old_ino;
658         struct inode *inode = dentry->d_inode;
659         struct coda_inode_info *cii = ITOC(inode);
660
661         lock_kernel();
662         if ( !cii->c_flags )
663                 goto ok;
664
665         if (cii->c_flags & (C_VATTR | C_PURGE | C_FLUSH)) {
666                 error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr);
667                 if ( error )
668                         goto return_bad;
669
670                 /* this inode may be lost if:
671                    - it's ino changed 
672                    - type changes must be permitted for repair and
673                    missing mount points.
674                 */
675                 old_mode = inode->i_mode;
676                 old_ino = inode->i_ino;
677                 coda_vattr_to_iattr(inode, &attr);
678
679                 if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
680                         printk("Coda: inode %ld, fid %s changed type!\n",
681                                inode->i_ino, coda_f2s(&(cii->c_fid)));
682                 }
683
684                 /* the following can happen when a local fid is replaced 
685                    with a global one, here we lose and declare the inode bad */
686                 if (inode->i_ino != old_ino)
687                         goto return_bad;
688                 
689                 coda_flag_inode_children(inode, C_FLUSH);
690                 cii->c_flags &= ~(C_VATTR | C_PURGE | C_FLUSH);
691         }
692
693 ok:
694         unlock_kernel();
695         return 0;
696
697 return_bad:
698         unlock_kernel();
699         return -EIO;
700 }