?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lockdep: fix spurious 'inconsistent lock state' warning
[firewire-audio.git] / fs / coda / dir.c
blobc5916228243c1516b2d62e6b06cea208523a09ac
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 }
AMDTP streaming driver for the Linux FireWire stack (Juju)