?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: EHCI: fix handover for designated full-speed ports
[linux-2.6/x86.git] / fs / afs / dir.c
blob546c59522eb16e0307070102df305cc05766f419
1 /* dir.c: AFS filesystem directory handling
2 *
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/fs.h>
17 #include <linux/pagemap.h>
18 #include <linux/ctype.h>
19 #include <linux/sched.h>
20 #include "internal.h"
21
22 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
23 struct nameidata *nd);
24 static int afs_dir_open(struct inode *inode, struct file *file);
25 static int afs_readdir(struct file *file, void *dirent, filldir_t filldir);
26 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
27 static int afs_d_delete(struct dentry *dentry);
28 static void afs_d_release(struct dentry *dentry);
29 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
30 loff_t fpos, u64 ino, unsigned dtype);
31 static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
32 struct nameidata *nd);
33 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
34 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
35 static int afs_unlink(struct inode *dir, struct dentry *dentry);
36 static int afs_link(struct dentry *from, struct inode *dir,
37 struct dentry *dentry);
38 static int afs_symlink(struct inode *dir, struct dentry *dentry,
39 const char *content);
40 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
41 struct inode *new_dir, struct dentry *new_dentry);
42
43 const struct file_operations afs_dir_file_operations = {
44 .open = afs_dir_open,
45 .release = afs_release,
46 .readdir = afs_readdir,
47 };
48
49 const struct inode_operations afs_dir_inode_operations = {
50 .create = afs_create,
51 .lookup = afs_lookup,
52 .link = afs_link,
53 .unlink = afs_unlink,
54 .symlink = afs_symlink,
55 .mkdir = afs_mkdir,
56 .rmdir = afs_rmdir,
57 .rename = afs_rename,
58 .permission = afs_permission,
59 .getattr = afs_getattr,
60 .setattr = afs_setattr,
61 };
62
63 static struct dentry_operations afs_fs_dentry_operations = {
64 .d_revalidate = afs_d_revalidate,
65 .d_delete = afs_d_delete,
66 .d_release = afs_d_release,
67 };
68
69 #define AFS_DIR_HASHTBL_SIZE 128
70 #define AFS_DIR_DIRENT_SIZE 32
71 #define AFS_DIRENT_PER_BLOCK 64
72
73 union afs_dirent {
74 struct {
75 uint8_t valid;
76 uint8_t unused[1];
77 __be16 hash_next;
78 __be32 vnode;
79 __be32 unique;
80 uint8_t name[16];
81 uint8_t overflow[4]; /* if any char of the name (inc
82 * NUL) reaches here, consume
83 * the next dirent too */
84 } u;
85 uint8_t extended_name[32];
86 };
87
88 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */
89 struct afs_dir_pagehdr {
90 __be16 npages;
91 __be16 magic;
92 #define AFS_DIR_MAGIC htons(1234)
93 uint8_t nentries;
94 uint8_t bitmap[8];
95 uint8_t pad[19];
96 };
97
98 /* directory block layout */
99 union afs_dir_block {
100
101 struct afs_dir_pagehdr pagehdr;
102
103 struct {
104 struct afs_dir_pagehdr pagehdr;
105 uint8_t alloc_ctrs[128];
106 /* dir hash table */
107 uint16_t hashtable[AFS_DIR_HASHTBL_SIZE];
108 } hdr;
109
110 union afs_dirent dirents[AFS_DIRENT_PER_BLOCK];
111 };
112
113 /* layout on a linux VM page */
114 struct afs_dir_page {
115 union afs_dir_block blocks[PAGE_SIZE / sizeof(union afs_dir_block)];
116 };
117
118 struct afs_lookup_cookie {
119 struct afs_fid fid;
120 const char *name;
121 size_t nlen;
122 int found;
123 };
124
125 /*
126 * check that a directory page is valid
127 */
128 static inline void afs_dir_check_page(struct inode *dir, struct page *page)
129 {
130 struct afs_dir_page *dbuf;
131 loff_t latter;
132 int tmp, qty;
133
134 #if 0
135 /* check the page count */
136 qty = desc.size / sizeof(dbuf->blocks[0]);
137 if (qty == 0)
138 goto error;
139
140 if (page->index == 0 && qty != ntohs(dbuf->blocks[0].pagehdr.npages)) {
141 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n",
142 __FUNCTION__, dir->i_ino, qty,
143 ntohs(dbuf->blocks[0].pagehdr.npages));
144 goto error;
145 }
146 #endif
147
148 /* determine how many magic numbers there should be in this page */
149 latter = dir->i_size - page_offset(page);
150 if (latter >= PAGE_SIZE)
151 qty = PAGE_SIZE;
152 else
153 qty = latter;
154 qty /= sizeof(union afs_dir_block);
155
156 /* check them */
157 dbuf = page_address(page);
158 for (tmp = 0; tmp < qty; tmp++) {
159 if (dbuf->blocks[tmp].pagehdr.magic != AFS_DIR_MAGIC) {
160 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
161 __FUNCTION__, dir->i_ino, tmp, qty,
162 ntohs(dbuf->blocks[tmp].pagehdr.magic));
163 goto error;
164 }
165 }
166
167 SetPageChecked(page);
168 return;
169
170 error:
171 SetPageChecked(page);
172 SetPageError(page);
173 }
174
175 /*
176 * discard a page cached in the pagecache
177 */
178 static inline void afs_dir_put_page(struct page *page)
179 {
180 kunmap(page);
181 page_cache_release(page);
182 }
183
184 /*
185 * get a page into the pagecache
186 */
187 static struct page *afs_dir_get_page(struct inode *dir, unsigned long index,
188 struct key *key)
189 {
190 struct page *page;
191 struct file file = {
192 .private_data = key,
193 };
194
195 _enter("{%lu},%lu", dir->i_ino, index);
196
197 page = read_mapping_page(dir->i_mapping, index, &file);
198 if (!IS_ERR(page)) {
199 kmap(page);
200 if (!PageChecked(page))
201 afs_dir_check_page(dir, page);
202 if (PageError(page))
203 goto fail;
204 }
205 return page;
206
207 fail:
208 afs_dir_put_page(page);
209 _leave(" = -EIO");
210 return ERR_PTR(-EIO);
211 }
212
213 /*
214 * open an AFS directory file
215 */
216 static int afs_dir_open(struct inode *inode, struct file *file)
217 {
218 _enter("{%lu}", inode->i_ino);
219
220 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
221 BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
222
223 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))
224 return -ENOENT;
225
226 return afs_open(inode, file);
227 }
228
229 /*
230 * deal with one block in an AFS directory
231 */
232 static int afs_dir_iterate_block(unsigned *fpos,
233 union afs_dir_block *block,
234 unsigned blkoff,
235 void *cookie,
236 filldir_t filldir)
237 {
238 union afs_dirent *dire;
239 unsigned offset, next, curr;
240 size_t nlen;
241 int tmp, ret;
242
243 _enter("%u,%x,%p,,",*fpos,blkoff,block);
244
245 curr = (*fpos - blkoff) / sizeof(union afs_dirent);
246
247 /* walk through the block, an entry at a time */
248 for (offset = AFS_DIRENT_PER_BLOCK - block->pagehdr.nentries;
249 offset < AFS_DIRENT_PER_BLOCK;
250 offset = next
251 ) {
252 next = offset + 1;
253
254 /* skip entries marked unused in the bitmap */
255 if (!(block->pagehdr.bitmap[offset / 8] &
256 (1 << (offset % 8)))) {
257 _debug("ENT[%Zu.%u]: unused",
258 blkoff / sizeof(union afs_dir_block), offset);
259 if (offset >= curr)
260 *fpos = blkoff +
261 next * sizeof(union afs_dirent);
262 continue;
263 }
264
265 /* got a valid entry */
266 dire = &block->dirents[offset];
267 nlen = strnlen(dire->u.name,
268 sizeof(*block) -
269 offset * sizeof(union afs_dirent));
270
271 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"",
272 blkoff / sizeof(union afs_dir_block), offset,
273 (offset < curr ? "skip" : "fill"),
274 nlen, dire->u.name);
275
276 /* work out where the next possible entry is */
277 for (tmp = nlen; tmp > 15; tmp -= sizeof(union afs_dirent)) {
278 if (next >= AFS_DIRENT_PER_BLOCK) {
279 _debug("ENT[%Zu.%u]:"
280 " %u travelled beyond end dir block"
281 " (len %u/%Zu)",
282 blkoff / sizeof(union afs_dir_block),
283 offset, next, tmp, nlen);
284 return -EIO;
285 }
286 if (!(block->pagehdr.bitmap[next / 8] &
287 (1 << (next % 8)))) {
288 _debug("ENT[%Zu.%u]:"
289 " %u unmarked extension (len %u/%Zu)",
290 blkoff / sizeof(union afs_dir_block),
291 offset, next, tmp, nlen);
292 return -EIO;
293 }
294
295 _debug("ENT[%Zu.%u]: ext %u/%Zu",
296 blkoff / sizeof(union afs_dir_block),
297 next, tmp, nlen);
298 next++;
299 }
300
301 /* skip if starts before the current position */
302 if (offset < curr)
303 continue;
304
305 /* found the next entry */
306 ret = filldir(cookie,
307 dire->u.name,
308 nlen,
309 blkoff + offset * sizeof(union afs_dirent),
310 ntohl(dire->u.vnode),
311 filldir == afs_lookup_filldir ?
312 ntohl(dire->u.unique) : DT_UNKNOWN);
313 if (ret < 0) {
314 _leave(" = 0 [full]");
315 return 0;
316 }
317
318 *fpos = blkoff + next * sizeof(union afs_dirent);
319 }
320
321 _leave(" = 1 [more]");
322 return 1;
323 }
324
325 /*
326 * iterate through the data blob that lists the contents of an AFS directory
327 */
328 static int afs_dir_iterate(struct inode *dir, unsigned *fpos, void *cookie,
329 filldir_t filldir, struct key *key)
330 {
331 union afs_dir_block *dblock;
332 struct afs_dir_page *dbuf;
333 struct page *page;
334 unsigned blkoff, limit;
335 int ret;
336
337 _enter("{%lu},%u,,", dir->i_ino, *fpos);
338
339 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {
340 _leave(" = -ESTALE");
341 return -ESTALE;
342 }
343
344 /* round the file position up to the next entry boundary */
345 *fpos += sizeof(union afs_dirent) - 1;
346 *fpos &= ~(sizeof(union afs_dirent) - 1);
347
348 /* walk through the blocks in sequence */
349 ret = 0;
350 while (*fpos < dir->i_size) {
351 blkoff = *fpos & ~(sizeof(union afs_dir_block) - 1);
352
353 /* fetch the appropriate page from the directory */
354 page = afs_dir_get_page(dir, blkoff / PAGE_SIZE, key);
355 if (IS_ERR(page)) {
356 ret = PTR_ERR(page);
357 break;
358 }
359
360 limit = blkoff & ~(PAGE_SIZE - 1);
361
362 dbuf = page_address(page);
363
364 /* deal with the individual blocks stashed on this page */
365 do {
366 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) /
367 sizeof(union afs_dir_block)];
368 ret = afs_dir_iterate_block(fpos, dblock, blkoff,
369 cookie, filldir);
370 if (ret != 1) {
371 afs_dir_put_page(page);
372 goto out;
373 }
374
375 blkoff += sizeof(union afs_dir_block);
376
377 } while (*fpos < dir->i_size && blkoff < limit);
378
379 afs_dir_put_page(page);
380 ret = 0;
381 }
382
383 out:
384 _leave(" = %d", ret);
385 return ret;
386 }
387
388 /*
389 * read an AFS directory
390 */
391 static int afs_readdir(struct file *file, void *cookie, filldir_t filldir)
392 {
393 unsigned fpos;
394 int ret;
395
396 _enter("{%Ld,{%lu}}",
397 file->f_pos, file->f_path.dentry->d_inode->i_ino);
398
399 ASSERT(file->private_data != NULL);
400
401 fpos = file->f_pos;
402 ret = afs_dir_iterate(file->f_path.dentry->d_inode, &fpos,
403 cookie, filldir, file->private_data);
404 file->f_pos = fpos;
405
406 _leave(" = %d", ret);
407 return ret;
408 }
409
410 /*
411 * search the directory for a name
412 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
413 * uniquifier through dtype
414 */
415 static int afs_lookup_filldir(void *_cookie, const char *name, int nlen,
416 loff_t fpos, u64 ino, unsigned dtype)
417 {
418 struct afs_lookup_cookie *cookie = _cookie;
419
420 _enter("{%s,%Zu},%s,%u,,%llu,%u",
421 cookie->name, cookie->nlen, name, nlen,
422 (unsigned long long) ino, dtype);
423
424 /* insanity checks first */
425 BUILD_BUG_ON(sizeof(union afs_dir_block) != 2048);
426 BUILD_BUG_ON(sizeof(union afs_dirent) != 32);
427
428 if (cookie->nlen != nlen || memcmp(cookie->name, name, nlen) != 0) {
429 _leave(" = 0 [no]");
430 return 0;
431 }
432
433 cookie->fid.vnode = ino;
434 cookie->fid.unique = dtype;
435 cookie->found = 1;
436
437 _leave(" = -1 [found]");
438 return -1;
439 }
440
441 /*
442 * do a lookup in a directory
443 * - just returns the FID the dentry name maps to if found
444 */
445 static int afs_do_lookup(struct inode *dir, struct dentry *dentry,
446 struct afs_fid *fid, struct key *key)
447 {
448 struct afs_lookup_cookie cookie;
449 struct afs_super_info *as;
450 unsigned fpos;
451 int ret;
452
453 _enter("{%lu},%p{%s},", dir->i_ino, dentry, dentry->d_name.name);
454
455 as = dir->i_sb->s_fs_info;
456
457 /* search the directory */
458 cookie.name = dentry->d_name.name;
459 cookie.nlen = dentry->d_name.len;
460 cookie.fid.vid = as->volume->vid;
461 cookie.found = 0;
462
463 fpos = 0;
464 ret = afs_dir_iterate(dir, &fpos, &cookie, afs_lookup_filldir,
465 key);
466 if (ret < 0) {
467 _leave(" = %d [iter]", ret);
468 return ret;
469 }
470
471 ret = -ENOENT;
472 if (!cookie.found) {
473 _leave(" = -ENOENT [not found]");
474 return -ENOENT;
475 }
476
477 *fid = cookie.fid;
478 _leave(" = 0 { vn=%u u=%u }", fid->vnode, fid->unique);
479 return 0;
480 }
481
482 /*
483 * look up an entry in a directory
484 */
485 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
486 struct nameidata *nd)
487 {
488 struct afs_vnode *vnode;
489 struct afs_fid fid;
490 struct inode *inode;
491 struct key *key;
492 int ret;
493
494 vnode = AFS_FS_I(dir);
495
496 _enter("{%x:%u},%p{%s},",
497 vnode->fid.vid, vnode->fid.vnode, dentry, dentry->d_name.name);
498
499 ASSERTCMP(dentry->d_inode, ==, NULL);
500
501 if (dentry->d_name.len >= AFSNAMEMAX) {
502 _leave(" = -ENAMETOOLONG");
503 return ERR_PTR(-ENAMETOOLONG);
504 }
505
506 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
507 _leave(" = -ESTALE");
508 return ERR_PTR(-ESTALE);
509 }
510
511 key = afs_request_key(vnode->volume->cell);
512 if (IS_ERR(key)) {
513 _leave(" = %ld [key]", PTR_ERR(key));
514 return ERR_PTR(PTR_ERR(key));
515 }
516
517 ret = afs_validate(vnode, key);
518 if (ret < 0) {
519 key_put(key);
520 _leave(" = %d [val]", ret);
521 return ERR_PTR(ret);
522 }
523
524 ret = afs_do_lookup(dir, dentry, &fid, key);
525 if (ret < 0) {
526 key_put(key);
527 if (ret == -ENOENT) {
528 d_add(dentry, NULL);
529 _leave(" = NULL [negative]");
530 return NULL;
531 }
532 _leave(" = %d [do]", ret);
533 return ERR_PTR(ret);
534 }
535 dentry->d_fsdata = (void *)(unsigned long) vnode->status.data_version;
536
537 /* instantiate the dentry */
538 inode = afs_iget(dir->i_sb, key, &fid, NULL, NULL);
539 key_put(key);
540 if (IS_ERR(inode)) {
541 _leave(" = %ld", PTR_ERR(inode));
542 return ERR_PTR(PTR_ERR(inode));
543 }
544
545 dentry->d_op = &afs_fs_dentry_operations;
546
547 d_add(dentry, inode);
548 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%lu }",
549 fid.vnode,
550 fid.unique,
551 dentry->d_inode->i_ino,
552 dentry->d_inode->i_version);
553
554 return NULL;
555 }
556
557 /*
558 * check that a dentry lookup hit has found a valid entry
559 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
560 * inode
561 */
562 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd)
563 {
564 struct afs_vnode *vnode, *dir;
565 struct afs_fid fid;
566 struct dentry *parent;
567 struct key *key;
568 void *dir_version;
569 int ret;
570
571 vnode = AFS_FS_I(dentry->d_inode);
572
573 if (dentry->d_inode)
574 _enter("{v={%x:%u} n=%s fl=%lx},",
575 vnode->fid.vid, vnode->fid.vnode, dentry->d_name.name,
576 vnode->flags);
577 else
578 _enter("{neg n=%s}", dentry->d_name.name);
579
580 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);
581 if (IS_ERR(key))
582 key = NULL;
583
584 /* lock down the parent dentry so we can peer at it */
585 parent = dget_parent(dentry);
586 if (!parent->d_inode)
587 goto out_bad;
588
589 dir = AFS_FS_I(parent->d_inode);
590
591 /* validate the parent directory */
592 if (test_bit(AFS_VNODE_MODIFIED, &dir->flags))
593 afs_validate(dir, key);
594
595 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
596 _debug("%s: parent dir deleted", dentry->d_name.name);
597 goto out_bad;
598 }
599
600 dir_version = (void *) (unsigned long) dir->status.data_version;
601 if (dentry->d_fsdata == dir_version)
602 goto out_valid; /* the dir contents are unchanged */
603
604 _debug("dir modified");
605
606 /* search the directory for this vnode */
607 ret = afs_do_lookup(&dir->vfs_inode, dentry, &fid, key);
608 switch (ret) {
609 case 0:
610 /* the filename maps to something */
611 if (!dentry->d_inode)
612 goto out_bad;
613 if (is_bad_inode(dentry->d_inode)) {
614 printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n",
615 parent->d_name.name, dentry->d_name.name);
616 goto out_bad;
617 }
618
619 /* if the vnode ID has changed, then the dirent points to a
620 * different file */
621 if (fid.vnode != vnode->fid.vnode) {
622 _debug("%s: dirent changed [%u != %u]",
623 dentry->d_name.name, fid.vnode,
624 vnode->fid.vnode);
625 goto not_found;
626 }
627
628 /* if the vnode ID uniqifier has changed, then the file has
629 * been deleted and replaced, and the original vnode ID has
630 * been reused */
631 if (fid.unique != vnode->fid.unique) {
632 _debug("%s: file deleted (uq %u -> %u I:%lu)",
633 dentry->d_name.name, fid.unique,
634 vnode->fid.unique, dentry->d_inode->i_version);
635 spin_lock(&vnode->lock);
636 set_bit(AFS_VNODE_DELETED, &vnode->flags);
637 spin_unlock(&vnode->lock);
638 goto not_found;
639 }
640 goto out_valid;
641
642 case -ENOENT:
643 /* the filename is unknown */
644 _debug("%s: dirent not found", dentry->d_name.name);
645 if (dentry->d_inode)
646 goto not_found;
647 goto out_valid;
648
649 default:
650 _debug("failed to iterate dir %s: %d",
651 parent->d_name.name, ret);
652 goto out_bad;
653 }
654
655 out_valid:
656 dentry->d_fsdata = dir_version;
657 out_skip:
658 dput(parent);
659 key_put(key);
660 _leave(" = 1 [valid]");
661 return 1;
662
663 /* the dirent, if it exists, now points to a different vnode */
664 not_found:
665 spin_lock(&dentry->d_lock);
666 dentry->d_flags |= DCACHE_NFSFS_RENAMED;
667 spin_unlock(&dentry->d_lock);
668
669 out_bad:
670 if (dentry->d_inode) {
671 /* don't unhash if we have submounts */
672 if (have_submounts(dentry))
673 goto out_skip;
674 }
675
676 _debug("dropping dentry %s/%s",
677 parent->d_name.name, dentry->d_name.name);
678 shrink_dcache_parent(dentry);
679 d_drop(dentry);
680 dput(parent);
681 key_put(key);
682
683 _leave(" = 0 [bad]");
684 return 0;
685 }
686
687 /*
688 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
689 * sleep)
690 * - called from dput() when d_count is going to 0.
691 * - return 1 to request dentry be unhashed, 0 otherwise
692 */
693 static int afs_d_delete(struct dentry *dentry)
694 {
695 _enter("%s", dentry->d_name.name);
696
697 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
698 goto zap;
699
700 if (dentry->d_inode &&
701 test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dentry->d_inode)->flags))
702 goto zap;
703
704 _leave(" = 0 [keep]");
705 return 0;
706
707 zap:
708 _leave(" = 1 [zap]");
709 return 1;
710 }
711
712 /*
713 * handle dentry release
714 */
715 static void afs_d_release(struct dentry *dentry)
716 {
717 _enter("%s", dentry->d_name.name);
718 }
719
720 /*
721 * create a directory on an AFS filesystem
722 */
723 static int afs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
724 {
725 struct afs_file_status status;
726 struct afs_callback cb;
727 struct afs_server *server;
728 struct afs_vnode *dvnode, *vnode;
729 struct afs_fid fid;
730 struct inode *inode;
731 struct key *key;
732 int ret;
733
734 dvnode = AFS_FS_I(dir);
735
736 _enter("{%x:%u},{%s},%o",
737 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
738
739 ret = -ENAMETOOLONG;
740 if (dentry->d_name.len >= AFSNAMEMAX)
741 goto error;
742
743 key = afs_request_key(dvnode->volume->cell);
744 if (IS_ERR(key)) {
745 ret = PTR_ERR(key);
746 goto error;
747 }
748
749 mode |= S_IFDIR;
750 ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
751 mode, &fid, &status, &cb, &server);
752 if (ret < 0)
753 goto mkdir_error;
754
755 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
756 if (IS_ERR(inode)) {
757 /* ENOMEM at a really inconvenient time - just abandon the new
758 * directory on the server */
759 ret = PTR_ERR(inode);
760 goto iget_error;
761 }
762
763 /* apply the status report we've got for the new vnode */
764 vnode = AFS_FS_I(inode);
765 spin_lock(&vnode->lock);
766 vnode->update_cnt++;
767 spin_unlock(&vnode->lock);
768 afs_vnode_finalise_status_update(vnode, server);
769 afs_put_server(server);
770
771 d_instantiate(dentry, inode);
772 if (d_unhashed(dentry)) {
773 _debug("not hashed");
774 d_rehash(dentry);
775 }
776 key_put(key);
777 _leave(" = 0");
778 return 0;
779
780 iget_error:
781 afs_put_server(server);
782 mkdir_error:
783 key_put(key);
784 error:
785 d_drop(dentry);
786 _leave(" = %d", ret);
787 return ret;
788 }
789
790 /*
791 * remove a directory from an AFS filesystem
792 */
793 static int afs_rmdir(struct inode *dir, struct dentry *dentry)
794 {
795 struct afs_vnode *dvnode, *vnode;
796 struct key *key;
797 int ret;
798
799 dvnode = AFS_FS_I(dir);
800
801 _enter("{%x:%u},{%s}",
802 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
803
804 ret = -ENAMETOOLONG;
805 if (dentry->d_name.len >= AFSNAMEMAX)
806 goto error;
807
808 key = afs_request_key(dvnode->volume->cell);
809 if (IS_ERR(key)) {
810 ret = PTR_ERR(key);
811 goto error;
812 }
813
814 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, true);
815 if (ret < 0)
816 goto rmdir_error;
817
818 if (dentry->d_inode) {
819 vnode = AFS_FS_I(dentry->d_inode);
820 clear_nlink(&vnode->vfs_inode);
821 set_bit(AFS_VNODE_DELETED, &vnode->flags);
822 afs_discard_callback_on_delete(vnode);
823 }
824
825 key_put(key);
826 _leave(" = 0");
827 return 0;
828
829 rmdir_error:
830 key_put(key);
831 error:
832 _leave(" = %d", ret);
833 return ret;
834 }
835
836 /*
837 * remove a file from an AFS filesystem
838 */
839 static int afs_unlink(struct inode *dir, struct dentry *dentry)
840 {
841 struct afs_vnode *dvnode, *vnode;
842 struct key *key;
843 int ret;
844
845 dvnode = AFS_FS_I(dir);
846
847 _enter("{%x:%u},{%s}",
848 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name);
849
850 ret = -ENAMETOOLONG;
851 if (dentry->d_name.len >= AFSNAMEMAX)
852 goto error;
853
854 key = afs_request_key(dvnode->volume->cell);
855 if (IS_ERR(key)) {
856 ret = PTR_ERR(key);
857 goto error;
858 }
859
860 if (dentry->d_inode) {
861 vnode = AFS_FS_I(dentry->d_inode);
862
863 /* make sure we have a callback promise on the victim */
864 ret = afs_validate(vnode, key);
865 if (ret < 0)
866 goto error;
867 }
868
869 ret = afs_vnode_remove(dvnode, key, dentry->d_name.name, false);
870 if (ret < 0)
871 goto remove_error;
872
873 if (dentry->d_inode) {
874 /* if the file wasn't deleted due to excess hard links, the
875 * fileserver will break the callback promise on the file - if
876 * it had one - before it returns to us, and if it was deleted,
877 * it won't
878 *
879 * however, if we didn't have a callback promise outstanding,
880 * or it was outstanding on a different server, then it won't
881 * break it either...
882 */
883 vnode = AFS_FS_I(dentry->d_inode);
884 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
885 _debug("AFS_VNODE_DELETED");
886 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags))
887 _debug("AFS_VNODE_CB_BROKEN");
888 set_bit(AFS_VNODE_CB_BROKEN, &vnode->flags);
889 ret = afs_validate(vnode, key);
890 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret);
891 }
892
893 key_put(key);
894 _leave(" = 0");
895 return 0;
896
897 remove_error:
898 key_put(key);
899 error:
900 _leave(" = %d", ret);
901 return ret;
902 }
903
904 /*
905 * create a regular file on an AFS filesystem
906 */
907 static int afs_create(struct inode *dir, struct dentry *dentry, int mode,
908 struct nameidata *nd)
909 {
910 struct afs_file_status status;
911 struct afs_callback cb;
912 struct afs_server *server;
913 struct afs_vnode *dvnode, *vnode;
914 struct afs_fid fid;
915 struct inode *inode;
916 struct key *key;
917 int ret;
918
919 dvnode = AFS_FS_I(dir);
920
921 _enter("{%x:%u},{%s},%o,",
922 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name, mode);
923
924 ret = -ENAMETOOLONG;
925 if (dentry->d_name.len >= AFSNAMEMAX)
926 goto error;
927
928 key = afs_request_key(dvnode->volume->cell);
929 if (IS_ERR(key)) {
930 ret = PTR_ERR(key);
931 goto error;
932 }
933
934 mode |= S_IFREG;
935 ret = afs_vnode_create(dvnode, key, dentry->d_name.name,
936 mode, &fid, &status, &cb, &server);
937 if (ret < 0)
938 goto create_error;
939
940 inode = afs_iget(dir->i_sb, key, &fid, &status, &cb);
941 if (IS_ERR(inode)) {
942 /* ENOMEM at a really inconvenient time - just abandon the new
943 * directory on the server */
944 ret = PTR_ERR(inode);
945 goto iget_error;
946 }
947
948 /* apply the status report we've got for the new vnode */
949 vnode = AFS_FS_I(inode);
950 spin_lock(&vnode->lock);
951 vnode->update_cnt++;
952 spin_unlock(&vnode->lock);
953 afs_vnode_finalise_status_update(vnode, server);
954 afs_put_server(server);
955
956 d_instantiate(dentry, inode);
957 if (d_unhashed(dentry)) {
958 _debug("not hashed");
959 d_rehash(dentry);
960 }
961 key_put(key);
962 _leave(" = 0");
963 return 0;
964
965 iget_error:
966 afs_put_server(server);
967 create_error:
968 key_put(key);
969 error:
970 d_drop(dentry);
971 _leave(" = %d", ret);
972 return ret;
973 }
974
975 /*
976 * create a hard link between files in an AFS filesystem
977 */
978 static int afs_link(struct dentry *from, struct inode *dir,
979 struct dentry *dentry)
980 {
981 struct afs_vnode *dvnode, *vnode;
982 struct key *key;
983 int ret;
984
985 vnode = AFS_FS_I(from->d_inode);
986 dvnode = AFS_FS_I(dir);
987
988 _enter("{%x:%u},{%x:%u},{%s}",
989 vnode->fid.vid, vnode->fid.vnode,
990 dvnode->fid.vid, dvnode->fid.vnode,
991 dentry->d_name.name);
992
993 ret = -ENAMETOOLONG;
994 if (dentry->d_name.len >= AFSNAMEMAX)
995 goto error;
996
997 key = afs_request_key(dvnode->volume->cell);
998 if (IS_ERR(key)) {
999 ret = PTR_ERR(key);
1000 goto error;
1001 }
1002
1003 ret = afs_vnode_link(dvnode, vnode, key, dentry->d_name.name);
1004 if (ret < 0)
1005 goto link_error;
1006
1007 atomic_inc(&vnode->vfs_inode.i_count);
1008 d_instantiate(dentry, &vnode->vfs_inode);
1009 key_put(key);
1010 _leave(" = 0");
1011 return 0;
1012
1013 link_error:
1014 key_put(key);
1015 error:
1016 d_drop(dentry);
1017 _leave(" = %d", ret);
1018 return ret;
1019 }
1020
1021 /*
1022 * create a symlink in an AFS filesystem
1023 */
1024 static int afs_symlink(struct inode *dir, struct dentry *dentry,
1025 const char *content)
1026 {
1027 struct afs_file_status status;
1028 struct afs_server *server;
1029 struct afs_vnode *dvnode, *vnode;
1030 struct afs_fid fid;
1031 struct inode *inode;
1032 struct key *key;
1033 int ret;
1034
1035 dvnode = AFS_FS_I(dir);
1036
1037 _enter("{%x:%u},{%s},%s",
1038 dvnode->fid.vid, dvnode->fid.vnode, dentry->d_name.name,
1039 content);
1040
1041 ret = -ENAMETOOLONG;
1042 if (dentry->d_name.len >= AFSNAMEMAX)
1043 goto error;
1044
1045 ret = -EINVAL;
1046 if (strlen(content) >= AFSPATHMAX)
1047 goto error;
1048
1049 key = afs_request_key(dvnode->volume->cell);
1050 if (IS_ERR(key)) {
1051 ret = PTR_ERR(key);
1052 goto error;
1053 }
1054
1055 ret = afs_vnode_symlink(dvnode, key, dentry->d_name.name, content,
1056 &fid, &status, &server);
1057 if (ret < 0)
1058 goto create_error;
1059
1060 inode = afs_iget(dir->i_sb, key, &fid, &status, NULL);
1061 if (IS_ERR(inode)) {
1062 /* ENOMEM at a really inconvenient time - just abandon the new
1063 * directory on the server */
1064 ret = PTR_ERR(inode);
1065 goto iget_error;
1066 }
1067
1068 /* apply the status report we've got for the new vnode */
1069 vnode = AFS_FS_I(inode);
1070 spin_lock(&vnode->lock);
1071 vnode->update_cnt++;
1072 spin_unlock(&vnode->lock);
1073 afs_vnode_finalise_status_update(vnode, server);
1074 afs_put_server(server);
1075
1076 d_instantiate(dentry, inode);
1077 if (d_unhashed(dentry)) {
1078 _debug("not hashed");
1079 d_rehash(dentry);
1080 }
1081 key_put(key);
1082 _leave(" = 0");
1083 return 0;
1084
1085 iget_error:
1086 afs_put_server(server);
1087 create_error:
1088 key_put(key);
1089 error:
1090 d_drop(dentry);
1091 _leave(" = %d", ret);
1092 return ret;
1093 }
1094
1095 /*
1096 * rename a file in an AFS filesystem and/or move it between directories
1097 */
1098 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry,
1099 struct inode *new_dir, struct dentry *new_dentry)
1100 {
1101 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
1102 struct key *key;
1103 int ret;
1104
1105 vnode = AFS_FS_I(old_dentry->d_inode);
1106 orig_dvnode = AFS_FS_I(old_dir);
1107 new_dvnode = AFS_FS_I(new_dir);
1108
1109 _enter("{%x:%u},{%x:%u},{%x:%u},{%s}",
1110 orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
1111 vnode->fid.vid, vnode->fid.vnode,
1112 new_dvnode->fid.vid, new_dvnode->fid.vnode,
1113 new_dentry->d_name.name);
1114
1115 ret = -ENAMETOOLONG;
1116 if (new_dentry->d_name.len >= AFSNAMEMAX)
1117 goto error;
1118
1119 key = afs_request_key(orig_dvnode->volume->cell);
1120 if (IS_ERR(key)) {
1121 ret = PTR_ERR(key);
1122 goto error;
1123 }
1124
1125 ret = afs_vnode_rename(orig_dvnode, new_dvnode, key,
1126 old_dentry->d_name.name,
1127 new_dentry->d_name.name);
1128 if (ret < 0)
1129 goto rename_error;
1130 key_put(key);
1131 _leave(" = 0");
1132 return 0;
1133
1134 rename_error:
1135 key_put(key);
1136 error:
1137 d_drop(new_dentry);
1138 _leave(" = %d", ret);
1139 return ret;
1140 }
x86 "subsystem" repository