1 /* dir.c: AFS filesystem directory handling
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
16 #include <linux/namei.h>
17 #include <linux/pagemap.h>
18 #include <linux/ctype.h>
19 #include <linux/sched.h>
22 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
24 static int afs_dir_open(struct inode
*inode
, struct file
*file
);
25 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
);
26 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
);
27 static int afs_d_delete(const 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
, umode_t mode
,
33 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t 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
,
40 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
41 struct inode
*new_dir
, struct dentry
*new_dentry
);
43 const struct file_operations afs_dir_file_operations
= {
45 .release
= afs_release
,
46 .iterate
= afs_readdir
,
48 .llseek
= generic_file_llseek
,
51 const struct inode_operations afs_dir_inode_operations
= {
56 .symlink
= afs_symlink
,
60 .permission
= afs_permission
,
61 .getattr
= afs_getattr
,
62 .setattr
= afs_setattr
,
65 const struct dentry_operations afs_fs_dentry_operations
= {
66 .d_revalidate
= afs_d_revalidate
,
67 .d_delete
= afs_d_delete
,
68 .d_release
= afs_d_release
,
69 .d_automount
= afs_d_automount
,
72 #define AFS_DIR_HASHTBL_SIZE 128
73 #define AFS_DIR_DIRENT_SIZE 32
74 #define AFS_DIRENT_PER_BLOCK 64
84 uint8_t overflow
[4]; /* if any char of the name (inc
85 * NUL) reaches here, consume
86 * the next dirent too */
88 uint8_t extended_name
[32];
91 /* AFS directory page header (one at the beginning of every 2048-byte chunk) */
92 struct afs_dir_pagehdr
{
95 #define AFS_DIR_MAGIC htons(1234)
101 /* directory block layout */
102 union afs_dir_block
{
104 struct afs_dir_pagehdr pagehdr
;
107 struct afs_dir_pagehdr pagehdr
;
108 uint8_t alloc_ctrs
[128];
110 uint16_t hashtable
[AFS_DIR_HASHTBL_SIZE
];
113 union afs_dirent dirents
[AFS_DIRENT_PER_BLOCK
];
116 /* layout on a linux VM page */
117 struct afs_dir_page
{
118 union afs_dir_block blocks
[PAGE_SIZE
/ sizeof(union afs_dir_block
)];
121 struct afs_lookup_cookie
{
122 struct dir_context ctx
;
129 * check that a directory page is valid
131 static inline void afs_dir_check_page(struct inode
*dir
, struct page
*page
)
133 struct afs_dir_page
*dbuf
;
138 /* check the page count */
139 qty
= desc
.size
/ sizeof(dbuf
->blocks
[0]);
143 if (page
->index
== 0 && qty
!= ntohs(dbuf
->blocks
[0].pagehdr
.npages
)) {
144 printk("kAFS: %s(%lu): wrong number of dir blocks %d!=%hu\n",
145 __func__
, dir
->i_ino
, qty
,
146 ntohs(dbuf
->blocks
[0].pagehdr
.npages
));
151 /* determine how many magic numbers there should be in this page */
152 latter
= dir
->i_size
- page_offset(page
);
153 if (latter
>= PAGE_SIZE
)
157 qty
/= sizeof(union afs_dir_block
);
160 dbuf
= page_address(page
);
161 for (tmp
= 0; tmp
< qty
; tmp
++) {
162 if (dbuf
->blocks
[tmp
].pagehdr
.magic
!= AFS_DIR_MAGIC
) {
163 printk("kAFS: %s(%lu): bad magic %d/%d is %04hx\n",
164 __func__
, dir
->i_ino
, tmp
, qty
,
165 ntohs(dbuf
->blocks
[tmp
].pagehdr
.magic
));
170 SetPageChecked(page
);
174 SetPageChecked(page
);
179 * discard a page cached in the pagecache
181 static inline void afs_dir_put_page(struct page
*page
)
184 page_cache_release(page
);
188 * get a page into the pagecache
190 static struct page
*afs_dir_get_page(struct inode
*dir
, unsigned long index
,
194 _enter("{%lu},%lu", dir
->i_ino
, index
);
196 page
= read_cache_page(dir
->i_mapping
, index
, afs_page_filler
, key
);
199 if (!PageChecked(page
))
200 afs_dir_check_page(dir
, page
);
207 afs_dir_put_page(page
);
209 return ERR_PTR(-EIO
);
213 * open an AFS directory file
215 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
217 _enter("{%lu}", inode
->i_ino
);
219 BUILD_BUG_ON(sizeof(union afs_dir_block
) != 2048);
220 BUILD_BUG_ON(sizeof(union afs_dirent
) != 32);
222 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
225 return afs_open(inode
, file
);
229 * deal with one block in an AFS directory
231 static int afs_dir_iterate_block(struct dir_context
*ctx
,
232 union afs_dir_block
*block
,
235 union afs_dirent
*dire
;
236 unsigned offset
, next
, curr
;
240 _enter("%u,%x,%p,,",(unsigned)ctx
->pos
,blkoff
,block
);
242 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_dirent
);
244 /* walk through the block, an entry at a time */
245 for (offset
= AFS_DIRENT_PER_BLOCK
- block
->pagehdr
.nentries
;
246 offset
< AFS_DIRENT_PER_BLOCK
;
251 /* skip entries marked unused in the bitmap */
252 if (!(block
->pagehdr
.bitmap
[offset
/ 8] &
253 (1 << (offset
% 8)))) {
254 _debug("ENT[%Zu.%u]: unused",
255 blkoff
/ sizeof(union afs_dir_block
), offset
);
258 next
* sizeof(union afs_dirent
);
262 /* got a valid entry */
263 dire
= &block
->dirents
[offset
];
264 nlen
= strnlen(dire
->u
.name
,
266 offset
* sizeof(union afs_dirent
));
268 _debug("ENT[%Zu.%u]: %s %Zu \"%s\"",
269 blkoff
/ sizeof(union afs_dir_block
), offset
,
270 (offset
< curr
? "skip" : "fill"),
273 /* work out where the next possible entry is */
274 for (tmp
= nlen
; tmp
> 15; tmp
-= sizeof(union afs_dirent
)) {
275 if (next
>= AFS_DIRENT_PER_BLOCK
) {
276 _debug("ENT[%Zu.%u]:"
277 " %u travelled beyond end dir block"
279 blkoff
/ sizeof(union afs_dir_block
),
280 offset
, next
, tmp
, nlen
);
283 if (!(block
->pagehdr
.bitmap
[next
/ 8] &
284 (1 << (next
% 8)))) {
285 _debug("ENT[%Zu.%u]:"
286 " %u unmarked extension (len %u/%Zu)",
287 blkoff
/ sizeof(union afs_dir_block
),
288 offset
, next
, tmp
, nlen
);
292 _debug("ENT[%Zu.%u]: ext %u/%Zu",
293 blkoff
/ sizeof(union afs_dir_block
),
298 /* skip if starts before the current position */
302 /* found the next entry */
303 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
304 ntohl(dire
->u
.vnode
),
305 ctx
->actor
== afs_lookup_filldir
?
306 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
307 _leave(" = 0 [full]");
311 ctx
->pos
= blkoff
+ next
* sizeof(union afs_dirent
);
314 _leave(" = 1 [more]");
319 * iterate through the data blob that lists the contents of an AFS directory
321 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
324 union afs_dir_block
*dblock
;
325 struct afs_dir_page
*dbuf
;
327 unsigned blkoff
, limit
;
330 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
332 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
333 _leave(" = -ESTALE");
337 /* round the file position up to the next entry boundary */
338 ctx
->pos
+= sizeof(union afs_dirent
) - 1;
339 ctx
->pos
&= ~(sizeof(union afs_dirent
) - 1);
341 /* walk through the blocks in sequence */
343 while (ctx
->pos
< dir
->i_size
) {
344 blkoff
= ctx
->pos
& ~(sizeof(union afs_dir_block
) - 1);
346 /* fetch the appropriate page from the directory */
347 page
= afs_dir_get_page(dir
, blkoff
/ PAGE_SIZE
, key
);
353 limit
= blkoff
& ~(PAGE_SIZE
- 1);
355 dbuf
= page_address(page
);
357 /* deal with the individual blocks stashed on this page */
359 dblock
= &dbuf
->blocks
[(blkoff
% PAGE_SIZE
) /
360 sizeof(union afs_dir_block
)];
361 ret
= afs_dir_iterate_block(ctx
, dblock
, blkoff
);
363 afs_dir_put_page(page
);
367 blkoff
+= sizeof(union afs_dir_block
);
369 } while (ctx
->pos
< dir
->i_size
&& blkoff
< limit
);
371 afs_dir_put_page(page
);
376 _leave(" = %d", ret
);
381 * read an AFS directory
383 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
385 return afs_dir_iterate(file_inode(file
),
386 ctx
, file
->private_data
);
390 * search the directory for a name
391 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
392 * uniquifier through dtype
394 static int afs_lookup_filldir(void *_cookie
, const char *name
, int nlen
,
395 loff_t fpos
, u64 ino
, unsigned dtype
)
397 struct afs_lookup_cookie
*cookie
= _cookie
;
399 _enter("{%s,%u},%s,%u,,%llu,%u",
400 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
401 (unsigned long long) ino
, dtype
);
403 /* insanity checks first */
404 BUILD_BUG_ON(sizeof(union afs_dir_block
) != 2048);
405 BUILD_BUG_ON(sizeof(union afs_dirent
) != 32);
407 if (cookie
->name
.len
!= nlen
||
408 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
413 cookie
->fid
.vnode
= ino
;
414 cookie
->fid
.unique
= dtype
;
417 _leave(" = -1 [found]");
422 * do a lookup in a directory
423 * - just returns the FID the dentry name maps to if found
425 static int afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
426 struct afs_fid
*fid
, struct key
*key
)
428 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
429 struct afs_lookup_cookie cookie
= {
430 .ctx
.actor
= afs_lookup_filldir
,
431 .name
= dentry
->d_name
,
432 .fid
.vid
= as
->volume
->vid
436 _enter("{%lu},%p{%s},", dir
->i_ino
, dentry
, dentry
->d_name
.name
);
438 /* search the directory */
439 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
);
441 _leave(" = %d [iter]", ret
);
447 _leave(" = -ENOENT [not found]");
452 _leave(" = 0 { vn=%u u=%u }", fid
->vnode
, fid
->unique
);
457 * Try to auto mount the mountpoint with pseudo directory, if the autocell
458 * operation is setted.
460 static struct inode
*afs_try_auto_mntpt(
461 int ret
, struct dentry
*dentry
, struct inode
*dir
, struct key
*key
,
464 const char *devname
= dentry
->d_name
.name
;
465 struct afs_vnode
*vnode
= AFS_FS_I(dir
);
468 _enter("%d, %p{%s}, {%x:%u}, %p",
469 ret
, dentry
, devname
, vnode
->fid
.vid
, vnode
->fid
.vnode
, key
);
471 if (ret
!= -ENOENT
||
472 !test_bit(AFS_VNODE_AUTOCELL
, &vnode
->flags
))
475 inode
= afs_iget_autocell(dir
, devname
, strlen(devname
), key
);
477 ret
= PTR_ERR(inode
);
481 *fid
= AFS_FS_I(inode
)->fid
;
482 _leave("= %p", inode
);
491 * look up an entry in a directory
493 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
496 struct afs_vnode
*vnode
;
502 vnode
= AFS_FS_I(dir
);
504 _enter("{%x:%u},%p{%s},",
505 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
, dentry
->d_name
.name
);
507 ASSERTCMP(dentry
->d_inode
, ==, NULL
);
509 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
510 _leave(" = -ENAMETOOLONG");
511 return ERR_PTR(-ENAMETOOLONG
);
514 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
515 _leave(" = -ESTALE");
516 return ERR_PTR(-ESTALE
);
519 key
= afs_request_key(vnode
->volume
->cell
);
521 _leave(" = %ld [key]", PTR_ERR(key
));
522 return ERR_CAST(key
);
525 ret
= afs_validate(vnode
, key
);
528 _leave(" = %d [val]", ret
);
532 ret
= afs_do_lookup(dir
, dentry
, &fid
, key
);
534 inode
= afs_try_auto_mntpt(ret
, dentry
, dir
, key
, &fid
);
535 if (!IS_ERR(inode
)) {
540 ret
= PTR_ERR(inode
);
542 if (ret
== -ENOENT
) {
544 _leave(" = NULL [negative]");
547 _leave(" = %d [do]", ret
);
550 dentry
->d_fsdata
= (void *)(unsigned long) vnode
->status
.data_version
;
552 /* instantiate the dentry */
553 inode
= afs_iget(dir
->i_sb
, key
, &fid
, NULL
, NULL
);
556 _leave(" = %ld", PTR_ERR(inode
));
557 return ERR_CAST(inode
);
561 d_add(dentry
, inode
);
562 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }",
565 dentry
->d_inode
->i_ino
,
566 dentry
->d_inode
->i_generation
);
572 * check that a dentry lookup hit has found a valid entry
573 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
576 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
578 struct afs_vnode
*vnode
, *dir
;
579 struct afs_fid
uninitialized_var(fid
);
580 struct dentry
*parent
;
585 if (flags
& LOOKUP_RCU
)
588 vnode
= AFS_FS_I(dentry
->d_inode
);
591 _enter("{v={%x:%u} n=%s fl=%lx},",
592 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
->d_name
.name
,
595 _enter("{neg n=%s}", dentry
->d_name
.name
);
597 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
601 /* lock down the parent dentry so we can peer at it */
602 parent
= dget_parent(dentry
);
603 if (!parent
->d_inode
)
606 dir
= AFS_FS_I(parent
->d_inode
);
608 /* validate the parent directory */
609 if (test_bit(AFS_VNODE_MODIFIED
, &dir
->flags
))
610 afs_validate(dir
, key
);
612 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
613 _debug("%s: parent dir deleted", dentry
->d_name
.name
);
617 dir_version
= (void *) (unsigned long) dir
->status
.data_version
;
618 if (dentry
->d_fsdata
== dir_version
)
619 goto out_valid
; /* the dir contents are unchanged */
621 _debug("dir modified");
623 /* search the directory for this vnode */
624 ret
= afs_do_lookup(&dir
->vfs_inode
, dentry
, &fid
, key
);
627 /* the filename maps to something */
628 if (!dentry
->d_inode
)
630 if (is_bad_inode(dentry
->d_inode
)) {
631 printk("kAFS: afs_d_revalidate: %s/%s has bad inode\n",
632 parent
->d_name
.name
, dentry
->d_name
.name
);
636 /* if the vnode ID has changed, then the dirent points to a
638 if (fid
.vnode
!= vnode
->fid
.vnode
) {
639 _debug("%s: dirent changed [%u != %u]",
640 dentry
->d_name
.name
, fid
.vnode
,
645 /* if the vnode ID uniqifier has changed, then the file has
646 * been deleted and replaced, and the original vnode ID has
648 if (fid
.unique
!= vnode
->fid
.unique
) {
649 _debug("%s: file deleted (uq %u -> %u I:%u)",
650 dentry
->d_name
.name
, fid
.unique
,
652 dentry
->d_inode
->i_generation
);
653 spin_lock(&vnode
->lock
);
654 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
655 spin_unlock(&vnode
->lock
);
661 /* the filename is unknown */
662 _debug("%s: dirent not found", dentry
->d_name
.name
);
668 _debug("failed to iterate dir %s: %d",
669 parent
->d_name
.name
, ret
);
674 dentry
->d_fsdata
= dir_version
;
678 _leave(" = 1 [valid]");
681 /* the dirent, if it exists, now points to a different vnode */
683 spin_lock(&dentry
->d_lock
);
684 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
685 spin_unlock(&dentry
->d_lock
);
688 /* don't unhash if we have submounts */
689 if (check_submounts_and_drop(dentry
) != 0)
692 _debug("dropping dentry %s/%s",
693 parent
->d_name
.name
, dentry
->d_name
.name
);
697 _leave(" = 0 [bad]");
702 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
704 * - called from dput() when d_count is going to 0.
705 * - return 1 to request dentry be unhashed, 0 otherwise
707 static int afs_d_delete(const struct dentry
*dentry
)
709 _enter("%s", dentry
->d_name
.name
);
711 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
714 if (dentry
->d_inode
&&
715 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dentry
->d_inode
)->flags
) ||
716 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(dentry
->d_inode
)->flags
)))
719 _leave(" = 0 [keep]");
723 _leave(" = 1 [zap]");
728 * handle dentry release
730 static void afs_d_release(struct dentry
*dentry
)
732 _enter("%s", dentry
->d_name
.name
);
736 * create a directory on an AFS filesystem
738 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
740 struct afs_file_status status
;
741 struct afs_callback cb
;
742 struct afs_server
*server
;
743 struct afs_vnode
*dvnode
, *vnode
;
749 dvnode
= AFS_FS_I(dir
);
751 _enter("{%x:%u},{%s},%ho",
752 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
->d_name
.name
, mode
);
755 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
758 key
= afs_request_key(dvnode
->volume
->cell
);
765 ret
= afs_vnode_create(dvnode
, key
, dentry
->d_name
.name
,
766 mode
, &fid
, &status
, &cb
, &server
);
770 inode
= afs_iget(dir
->i_sb
, key
, &fid
, &status
, &cb
);
772 /* ENOMEM at a really inconvenient time - just abandon the new
773 * directory on the server */
774 ret
= PTR_ERR(inode
);
778 /* apply the status report we've got for the new vnode */
779 vnode
= AFS_FS_I(inode
);
780 spin_lock(&vnode
->lock
);
782 spin_unlock(&vnode
->lock
);
783 afs_vnode_finalise_status_update(vnode
, server
);
784 afs_put_server(server
);
786 d_instantiate(dentry
, inode
);
787 if (d_unhashed(dentry
)) {
788 _debug("not hashed");
796 afs_put_server(server
);
801 _leave(" = %d", ret
);
806 * remove a directory from an AFS filesystem
808 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
810 struct afs_vnode
*dvnode
, *vnode
;
814 dvnode
= AFS_FS_I(dir
);
816 _enter("{%x:%u},{%s}",
817 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
->d_name
.name
);
820 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
823 key
= afs_request_key(dvnode
->volume
->cell
);
829 ret
= afs_vnode_remove(dvnode
, key
, dentry
->d_name
.name
, true);
833 if (dentry
->d_inode
) {
834 vnode
= AFS_FS_I(dentry
->d_inode
);
835 clear_nlink(&vnode
->vfs_inode
);
836 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
837 afs_discard_callback_on_delete(vnode
);
847 _leave(" = %d", ret
);
852 * remove a file from an AFS filesystem
854 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
856 struct afs_vnode
*dvnode
, *vnode
;
860 dvnode
= AFS_FS_I(dir
);
862 _enter("{%x:%u},{%s}",
863 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
->d_name
.name
);
866 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
869 key
= afs_request_key(dvnode
->volume
->cell
);
875 if (dentry
->d_inode
) {
876 vnode
= AFS_FS_I(dentry
->d_inode
);
878 /* make sure we have a callback promise on the victim */
879 ret
= afs_validate(vnode
, key
);
884 ret
= afs_vnode_remove(dvnode
, key
, dentry
->d_name
.name
, false);
888 if (dentry
->d_inode
) {
889 /* if the file wasn't deleted due to excess hard links, the
890 * fileserver will break the callback promise on the file - if
891 * it had one - before it returns to us, and if it was deleted,
894 * however, if we didn't have a callback promise outstanding,
895 * or it was outstanding on a different server, then it won't
898 vnode
= AFS_FS_I(dentry
->d_inode
);
899 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
900 _debug("AFS_VNODE_DELETED");
901 if (test_bit(AFS_VNODE_CB_BROKEN
, &vnode
->flags
))
902 _debug("AFS_VNODE_CB_BROKEN");
903 set_bit(AFS_VNODE_CB_BROKEN
, &vnode
->flags
);
904 ret
= afs_validate(vnode
, key
);
905 _debug("nlink %d [val %d]", vnode
->vfs_inode
.i_nlink
, ret
);
915 _leave(" = %d", ret
);
920 * create a regular file on an AFS filesystem
922 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
925 struct afs_file_status status
;
926 struct afs_callback cb
;
927 struct afs_server
*server
;
928 struct afs_vnode
*dvnode
, *vnode
;
934 dvnode
= AFS_FS_I(dir
);
936 _enter("{%x:%u},{%s},%ho,",
937 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
->d_name
.name
, mode
);
940 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
943 key
= afs_request_key(dvnode
->volume
->cell
);
950 ret
= afs_vnode_create(dvnode
, key
, dentry
->d_name
.name
,
951 mode
, &fid
, &status
, &cb
, &server
);
955 inode
= afs_iget(dir
->i_sb
, key
, &fid
, &status
, &cb
);
957 /* ENOMEM at a really inconvenient time - just abandon the new
958 * directory on the server */
959 ret
= PTR_ERR(inode
);
963 /* apply the status report we've got for the new vnode */
964 vnode
= AFS_FS_I(inode
);
965 spin_lock(&vnode
->lock
);
967 spin_unlock(&vnode
->lock
);
968 afs_vnode_finalise_status_update(vnode
, server
);
969 afs_put_server(server
);
971 d_instantiate(dentry
, inode
);
972 if (d_unhashed(dentry
)) {
973 _debug("not hashed");
981 afs_put_server(server
);
986 _leave(" = %d", ret
);
991 * create a hard link between files in an AFS filesystem
993 static int afs_link(struct dentry
*from
, struct inode
*dir
,
994 struct dentry
*dentry
)
996 struct afs_vnode
*dvnode
, *vnode
;
1000 vnode
= AFS_FS_I(from
->d_inode
);
1001 dvnode
= AFS_FS_I(dir
);
1003 _enter("{%x:%u},{%x:%u},{%s}",
1004 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1005 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1006 dentry
->d_name
.name
);
1008 ret
= -ENAMETOOLONG
;
1009 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1012 key
= afs_request_key(dvnode
->volume
->cell
);
1018 ret
= afs_vnode_link(dvnode
, vnode
, key
, dentry
->d_name
.name
);
1022 ihold(&vnode
->vfs_inode
);
1023 d_instantiate(dentry
, &vnode
->vfs_inode
);
1032 _leave(" = %d", ret
);
1037 * create a symlink in an AFS filesystem
1039 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1040 const char *content
)
1042 struct afs_file_status status
;
1043 struct afs_server
*server
;
1044 struct afs_vnode
*dvnode
, *vnode
;
1046 struct inode
*inode
;
1050 dvnode
= AFS_FS_I(dir
);
1052 _enter("{%x:%u},{%s},%s",
1053 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
->d_name
.name
,
1056 ret
= -ENAMETOOLONG
;
1057 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1061 if (strlen(content
) >= AFSPATHMAX
)
1064 key
= afs_request_key(dvnode
->volume
->cell
);
1070 ret
= afs_vnode_symlink(dvnode
, key
, dentry
->d_name
.name
, content
,
1071 &fid
, &status
, &server
);
1075 inode
= afs_iget(dir
->i_sb
, key
, &fid
, &status
, NULL
);
1076 if (IS_ERR(inode
)) {
1077 /* ENOMEM at a really inconvenient time - just abandon the new
1078 * directory on the server */
1079 ret
= PTR_ERR(inode
);
1083 /* apply the status report we've got for the new vnode */
1084 vnode
= AFS_FS_I(inode
);
1085 spin_lock(&vnode
->lock
);
1086 vnode
->update_cnt
++;
1087 spin_unlock(&vnode
->lock
);
1088 afs_vnode_finalise_status_update(vnode
, server
);
1089 afs_put_server(server
);
1091 d_instantiate(dentry
, inode
);
1092 if (d_unhashed(dentry
)) {
1093 _debug("not hashed");
1101 afs_put_server(server
);
1106 _leave(" = %d", ret
);
1111 * rename a file in an AFS filesystem and/or move it between directories
1113 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1114 struct inode
*new_dir
, struct dentry
*new_dentry
)
1116 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1120 vnode
= AFS_FS_I(old_dentry
->d_inode
);
1121 orig_dvnode
= AFS_FS_I(old_dir
);
1122 new_dvnode
= AFS_FS_I(new_dir
);
1124 _enter("{%x:%u},{%x:%u},{%x:%u},{%s}",
1125 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1126 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1127 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1128 new_dentry
->d_name
.name
);
1130 ret
= -ENAMETOOLONG
;
1131 if (new_dentry
->d_name
.len
>= AFSNAMEMAX
)
1134 key
= afs_request_key(orig_dvnode
->volume
->cell
);
1140 ret
= afs_vnode_rename(orig_dvnode
, new_dvnode
, key
,
1141 old_dentry
->d_name
.name
,
1142 new_dentry
->d_name
.name
);
1153 _leave(" = %d", ret
);