1 /* dir.c: AFS filesystem directory handling
3 * Copyright (C) 2002, 2018 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>
14 #include <linux/namei.h>
15 #include <linux/pagemap.h>
16 #include <linux/swap.h>
17 #include <linux/ctype.h>
18 #include <linux/sched.h>
19 #include <linux/task_io_accounting_ops.h>
23 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
25 static int afs_dir_open(struct inode
*inode
, struct file
*file
);
26 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
);
27 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
);
28 static int afs_d_delete(const struct dentry
*dentry
);
29 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
);
30 static int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
31 loff_t fpos
, u64 ino
, unsigned dtype
);
32 static int afs_lookup_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
33 loff_t fpos
, u64 ino
, unsigned dtype
);
34 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
36 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
);
37 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
);
38 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
);
39 static int afs_link(struct dentry
*from
, struct inode
*dir
,
40 struct dentry
*dentry
);
41 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
43 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
44 struct inode
*new_dir
, struct dentry
*new_dentry
,
46 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
);
47 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
50 static int afs_dir_set_page_dirty(struct page
*page
)
52 BUG(); /* This should never happen. */
55 const struct file_operations afs_dir_file_operations
= {
57 .release
= afs_release
,
58 .iterate_shared
= afs_readdir
,
60 .llseek
= generic_file_llseek
,
63 const struct inode_operations afs_dir_inode_operations
= {
68 .symlink
= afs_symlink
,
72 .permission
= afs_permission
,
73 .getattr
= afs_getattr
,
74 .setattr
= afs_setattr
,
75 .listxattr
= afs_listxattr
,
78 const struct address_space_operations afs_dir_aops
= {
79 .set_page_dirty
= afs_dir_set_page_dirty
,
80 .releasepage
= afs_dir_releasepage
,
81 .invalidatepage
= afs_dir_invalidatepage
,
84 const struct dentry_operations afs_fs_dentry_operations
= {
85 .d_revalidate
= afs_d_revalidate
,
86 .d_delete
= afs_d_delete
,
87 .d_release
= afs_d_release
,
88 .d_automount
= afs_d_automount
,
92 struct afs_lookup_one_cookie
{
93 struct dir_context ctx
;
99 struct afs_lookup_cookie
{
100 struct dir_context ctx
;
104 unsigned short nr_fids
;
105 struct afs_file_status
*statuses
;
106 struct afs_callback
*callbacks
;
107 struct afs_fid fids
[50];
111 * check that a directory page is valid
113 static bool afs_dir_check_page(struct afs_vnode
*dvnode
, struct page
*page
,
116 struct afs_xdr_dir_page
*dbuf
;
120 /* Determine how many magic numbers there should be in this page, but
121 * we must take care because the directory may change size under us.
123 off
= page_offset(page
);
127 latter
= i_size
- off
;
128 if (latter
>= PAGE_SIZE
)
132 qty
/= sizeof(union afs_xdr_dir_block
);
136 for (tmp
= 0; tmp
< qty
; tmp
++) {
137 if (dbuf
->blocks
[tmp
].hdr
.magic
!= AFS_DIR_MAGIC
) {
138 printk("kAFS: %s(%lx): bad magic %d/%d is %04hx\n",
139 __func__
, dvnode
->vfs_inode
.i_ino
, tmp
, qty
,
140 ntohs(dbuf
->blocks
[tmp
].hdr
.magic
));
141 trace_afs_dir_check_failed(dvnode
, off
, i_size
);
143 trace_afs_file_error(dvnode
, -EIO
, afs_file_error_dir_bad_magic
);
147 /* Make sure each block is NUL terminated so we can reasonably
148 * use string functions on it. The filenames in the page
149 * *should* be NUL-terminated anyway.
151 ((u8
*)&dbuf
->blocks
[tmp
])[AFS_DIR_BLOCK_SIZE
- 1] = 0;
157 afs_stat_v(dvnode
, n_read_dir
);
165 * Check the contents of a directory that we've just read.
167 static bool afs_dir_check_pages(struct afs_vnode
*dvnode
, struct afs_read
*req
)
169 struct afs_xdr_dir_page
*dbuf
;
170 unsigned int i
, j
, qty
= PAGE_SIZE
/ sizeof(union afs_xdr_dir_block
);
172 for (i
= 0; i
< req
->nr_pages
; i
++)
173 if (!afs_dir_check_page(dvnode
, req
->pages
[i
], req
->actual_len
))
178 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx r=%llx\n",
179 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
180 req
->file_size
, req
->len
, req
->actual_len
, req
->remain
);
181 pr_warn("DIR %llx %x %x %x\n",
182 req
->pos
, req
->index
, req
->nr_pages
, req
->offset
);
184 for (i
= 0; i
< req
->nr_pages
; i
++) {
185 dbuf
= kmap(req
->pages
[i
]);
186 for (j
= 0; j
< qty
; j
++) {
187 union afs_xdr_dir_block
*block
= &dbuf
->blocks
[j
];
189 pr_warn("[%02x] %32phN\n", i
* qty
+ j
, block
);
191 kunmap(req
->pages
[i
]);
197 * open an AFS directory file
199 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
201 _enter("{%lu}", inode
->i_ino
);
203 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
204 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
206 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
209 return afs_open(inode
, file
);
213 * Read the directory into the pagecache in one go, scrubbing the previous
214 * contents. The list of pages is returned, pinning them so that they don't
215 * get reclaimed during the iteration.
217 static struct afs_read
*afs_read_dir(struct afs_vnode
*dvnode
, struct key
*key
)
218 __acquires(&dvnode
->validate_lock
)
220 struct afs_read
*req
;
222 int nr_pages
, nr_inline
, i
, n
;
226 i_size
= i_size_read(&dvnode
->vfs_inode
);
228 return ERR_PTR(afs_bad(dvnode
, afs_file_error_dir_small
));
229 if (i_size
> 2048 * 1024) {
230 trace_afs_file_error(dvnode
, -EFBIG
, afs_file_error_dir_big
);
231 return ERR_PTR(-EFBIG
);
234 _enter("%llu", i_size
);
236 /* Get a request record to hold the page list. We want to hold it
237 * inline if we can, but we don't want to make an order 1 allocation.
239 nr_pages
= (i_size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
240 nr_inline
= nr_pages
;
241 if (nr_inline
> (PAGE_SIZE
- sizeof(*req
)) / sizeof(struct page
*))
244 req
= kzalloc(sizeof(*req
) + sizeof(struct page
*) * nr_inline
,
247 return ERR_PTR(-ENOMEM
);
249 refcount_set(&req
->usage
, 1);
250 req
->nr_pages
= nr_pages
;
251 req
->actual_len
= i_size
; /* May change */
252 req
->len
= nr_pages
* PAGE_SIZE
; /* We can ask for more than there is */
253 req
->data_version
= dvnode
->status
.data_version
; /* May change */
255 req
->pages
= req
->array
;
257 req
->pages
= kcalloc(nr_pages
, sizeof(struct page
*),
263 /* Get a list of all the pages that hold or will hold the directory
264 * content. We need to fill in any gaps that we might find where the
265 * memory reclaimer has been at work. If there are any gaps, we will
266 * need to reread the entire directory contents.
270 n
= find_get_pages_contig(dvnode
->vfs_inode
.i_mapping
, i
,
273 _debug("find %u at %u/%u", n
, i
, req
->nr_pages
);
275 gfp_t gfp
= dvnode
->vfs_inode
.i_mapping
->gfp_mask
;
277 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
278 afs_stat_v(dvnode
, n_inval
);
281 req
->pages
[i
] = __page_cache_alloc(gfp
);
284 ret
= add_to_page_cache_lru(req
->pages
[i
],
285 dvnode
->vfs_inode
.i_mapping
,
290 set_page_private(req
->pages
[i
], 1);
291 SetPagePrivate(req
->pages
[i
]);
292 unlock_page(req
->pages
[i
]);
297 } while (i
< req
->nr_pages
);
299 /* If we're going to reload, we need to lock all the pages to prevent
303 if (down_read_killable(&dvnode
->validate_lock
) < 0)
306 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
309 up_read(&dvnode
->validate_lock
);
310 if (down_write_killable(&dvnode
->validate_lock
) < 0)
313 if (!test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
314 trace_afs_reload_dir(dvnode
);
315 ret
= afs_fetch_data(dvnode
, key
, req
);
319 task_io_account_read(PAGE_SIZE
* req
->nr_pages
);
321 if (req
->len
< req
->file_size
)
322 goto content_has_grown
;
324 /* Validate the data we just read. */
326 if (!afs_dir_check_pages(dvnode
, req
))
329 // TODO: Trim excess pages
331 set_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
);
334 downgrade_write(&dvnode
->validate_lock
);
339 up_write(&dvnode
->validate_lock
);
342 _leave(" = %d", ret
);
346 up_write(&dvnode
->validate_lock
);
352 * deal with one block in an AFS directory
354 static int afs_dir_iterate_block(struct afs_vnode
*dvnode
,
355 struct dir_context
*ctx
,
356 union afs_xdr_dir_block
*block
,
359 union afs_xdr_dirent
*dire
;
360 unsigned offset
, next
, curr
;
364 _enter("%u,%x,%p,,",(unsigned)ctx
->pos
,blkoff
,block
);
366 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_xdr_dirent
);
368 /* walk through the block, an entry at a time */
369 for (offset
= (blkoff
== 0 ? AFS_DIR_RESV_BLOCKS0
: AFS_DIR_RESV_BLOCKS
);
370 offset
< AFS_DIR_SLOTS_PER_BLOCK
;
375 /* skip entries marked unused in the bitmap */
376 if (!(block
->hdr
.bitmap
[offset
/ 8] &
377 (1 << (offset
% 8)))) {
378 _debug("ENT[%zu.%u]: unused",
379 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
);
382 next
* sizeof(union afs_xdr_dirent
);
386 /* got a valid entry */
387 dire
= &block
->dirents
[offset
];
388 nlen
= strnlen(dire
->u
.name
,
390 offset
* sizeof(union afs_xdr_dirent
));
392 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
393 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
,
394 (offset
< curr
? "skip" : "fill"),
397 /* work out where the next possible entry is */
398 for (tmp
= nlen
; tmp
> 15; tmp
-= sizeof(union afs_xdr_dirent
)) {
399 if (next
>= AFS_DIR_SLOTS_PER_BLOCK
) {
400 _debug("ENT[%zu.%u]:"
401 " %u travelled beyond end dir block"
403 blkoff
/ sizeof(union afs_xdr_dir_block
),
404 offset
, next
, tmp
, nlen
);
405 return afs_bad(dvnode
, afs_file_error_dir_over_end
);
407 if (!(block
->hdr
.bitmap
[next
/ 8] &
408 (1 << (next
% 8)))) {
409 _debug("ENT[%zu.%u]:"
410 " %u unmarked extension (len %u/%zu)",
411 blkoff
/ sizeof(union afs_xdr_dir_block
),
412 offset
, next
, tmp
, nlen
);
413 return afs_bad(dvnode
, afs_file_error_dir_unmarked_ext
);
416 _debug("ENT[%zu.%u]: ext %u/%zu",
417 blkoff
/ sizeof(union afs_xdr_dir_block
),
422 /* skip if starts before the current position */
426 /* found the next entry */
427 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
428 ntohl(dire
->u
.vnode
),
429 (ctx
->actor
== afs_lookup_filldir
||
430 ctx
->actor
== afs_lookup_one_filldir
)?
431 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
432 _leave(" = 0 [full]");
436 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
439 _leave(" = 1 [more]");
444 * iterate through the data blob that lists the contents of an AFS directory
446 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
449 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
450 struct afs_xdr_dir_page
*dbuf
;
451 union afs_xdr_dir_block
*dblock
;
452 struct afs_read
*req
;
454 unsigned blkoff
, limit
;
457 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
459 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
460 _leave(" = -ESTALE");
464 req
= afs_read_dir(dvnode
, key
);
468 /* round the file position up to the next entry boundary */
469 ctx
->pos
+= sizeof(union afs_xdr_dirent
) - 1;
470 ctx
->pos
&= ~(sizeof(union afs_xdr_dirent
) - 1);
472 /* walk through the blocks in sequence */
474 while (ctx
->pos
< req
->actual_len
) {
475 blkoff
= ctx
->pos
& ~(sizeof(union afs_xdr_dir_block
) - 1);
477 /* Fetch the appropriate page from the directory and re-add it
480 page
= req
->pages
[blkoff
/ PAGE_SIZE
];
482 ret
= afs_bad(dvnode
, afs_file_error_dir_missing_page
);
485 mark_page_accessed(page
);
487 limit
= blkoff
& ~(PAGE_SIZE
- 1);
491 /* deal with the individual blocks stashed on this page */
493 dblock
= &dbuf
->blocks
[(blkoff
% PAGE_SIZE
) /
494 sizeof(union afs_xdr_dir_block
)];
495 ret
= afs_dir_iterate_block(dvnode
, ctx
, dblock
, blkoff
);
501 blkoff
+= sizeof(union afs_xdr_dir_block
);
503 } while (ctx
->pos
< dir
->i_size
&& blkoff
< limit
);
510 up_read(&dvnode
->validate_lock
);
512 _leave(" = %d", ret
);
517 * read an AFS directory
519 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
521 return afs_dir_iterate(file_inode(file
), ctx
, afs_file_key(file
));
525 * Search the directory for a single name
526 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
527 * uniquifier through dtype
529 static int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
,
530 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
532 struct afs_lookup_one_cookie
*cookie
=
533 container_of(ctx
, struct afs_lookup_one_cookie
, ctx
);
535 _enter("{%s,%u},%s,%u,,%llu,%u",
536 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
537 (unsigned long long) ino
, dtype
);
539 /* insanity checks first */
540 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
541 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
543 if (cookie
->name
.len
!= nlen
||
544 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
549 cookie
->fid
.vnode
= ino
;
550 cookie
->fid
.unique
= dtype
;
553 _leave(" = -1 [found]");
558 * Do a lookup of a single name in a directory
559 * - just returns the FID the dentry name maps to if found
561 static int afs_do_lookup_one(struct inode
*dir
, struct dentry
*dentry
,
562 struct afs_fid
*fid
, struct key
*key
)
564 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
565 struct afs_lookup_one_cookie cookie
= {
566 .ctx
.actor
= afs_lookup_one_filldir
,
567 .name
= dentry
->d_name
,
568 .fid
.vid
= as
->volume
->vid
572 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
574 /* search the directory */
575 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
);
577 _leave(" = %d [iter]", ret
);
583 _leave(" = -ENOENT [not found]");
588 _leave(" = 0 { vn=%llu u=%u }", fid
->vnode
, fid
->unique
);
593 * search the directory for a name
594 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
595 * uniquifier through dtype
597 static int afs_lookup_filldir(struct dir_context
*ctx
, const char *name
,
598 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
600 struct afs_lookup_cookie
*cookie
=
601 container_of(ctx
, struct afs_lookup_cookie
, ctx
);
604 _enter("{%s,%u},%s,%u,,%llu,%u",
605 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
606 (unsigned long long) ino
, dtype
);
608 /* insanity checks first */
609 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
610 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
613 if (cookie
->nr_fids
< 50) {
614 cookie
->fids
[cookie
->nr_fids
].vnode
= ino
;
615 cookie
->fids
[cookie
->nr_fids
].unique
= dtype
;
618 } else if (cookie
->name
.len
== nlen
&&
619 memcmp(cookie
->name
.name
, name
, nlen
) == 0) {
620 cookie
->fids
[0].vnode
= ino
;
621 cookie
->fids
[0].unique
= dtype
;
623 if (cookie
->one_only
)
627 ret
= cookie
->nr_fids
>= 50 ? -1 : 0;
628 _leave(" = %d", ret
);
633 * Do a lookup in a directory. We make use of bulk lookup to query a slew of
634 * files in one go and create inodes for them. The inode of the file we were
635 * asked for is returned.
637 static struct inode
*afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
640 struct afs_lookup_cookie
*cookie
;
641 struct afs_cb_interest
*cbi
= NULL
;
642 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
643 struct afs_iget_data data
;
644 struct afs_fs_cursor fc
;
645 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
646 struct inode
*inode
= NULL
;
649 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
651 cookie
= kzalloc(sizeof(struct afs_lookup_cookie
), GFP_KERNEL
);
653 return ERR_PTR(-ENOMEM
);
655 cookie
->ctx
.actor
= afs_lookup_filldir
;
656 cookie
->name
= dentry
->d_name
;
657 cookie
->nr_fids
= 1; /* slot 0 is saved for the fid we actually want */
659 read_seqlock_excl(&dvnode
->cb_lock
);
660 if (dvnode
->cb_interest
&&
661 dvnode
->cb_interest
->server
&&
662 test_bit(AFS_SERVER_FL_NO_IBULK
, &dvnode
->cb_interest
->server
->flags
))
663 cookie
->one_only
= true;
664 read_sequnlock_excl(&dvnode
->cb_lock
);
666 for (i
= 0; i
< 50; i
++)
667 cookie
->fids
[i
].vid
= as
->volume
->vid
;
669 /* search the directory */
670 ret
= afs_dir_iterate(dir
, &cookie
->ctx
, key
);
672 inode
= ERR_PTR(ret
);
676 inode
= ERR_PTR(-ENOENT
);
680 /* Check to see if we already have an inode for the primary fid. */
681 data
.volume
= dvnode
->volume
;
682 data
.fid
= cookie
->fids
[0];
683 inode
= ilookup5(dir
->i_sb
, cookie
->fids
[0].vnode
, afs_iget5_test
, &data
);
687 /* Need space for examining all the selected files */
688 inode
= ERR_PTR(-ENOMEM
);
689 cookie
->statuses
= kcalloc(cookie
->nr_fids
, sizeof(struct afs_file_status
),
691 if (!cookie
->statuses
)
694 cookie
->callbacks
= kcalloc(cookie
->nr_fids
, sizeof(struct afs_callback
),
696 if (!cookie
->callbacks
)
699 /* Try FS.InlineBulkStatus first. Abort codes for the individual
700 * lookups contained therein are stored in the reply without aborting
701 * the whole operation.
703 if (cookie
->one_only
)
704 goto no_inline_bulk_status
;
706 inode
= ERR_PTR(-ERESTARTSYS
);
707 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
708 while (afs_select_fileserver(&fc
)) {
709 if (test_bit(AFS_SERVER_FL_NO_IBULK
,
710 &fc
.cbi
->server
->flags
)) {
711 fc
.ac
.abort_code
= RX_INVALID_OPERATION
;
712 fc
.ac
.error
= -ECONNABORTED
;
715 afs_fs_inline_bulk_status(&fc
,
720 cookie
->nr_fids
, NULL
);
723 if (fc
.ac
.error
== 0)
724 cbi
= afs_get_cb_interest(fc
.cbi
);
725 if (fc
.ac
.abort_code
== RX_INVALID_OPERATION
)
726 set_bit(AFS_SERVER_FL_NO_IBULK
, &fc
.cbi
->server
->flags
);
727 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
732 if (fc
.ac
.abort_code
!= RX_INVALID_OPERATION
)
735 no_inline_bulk_status
:
736 /* We could try FS.BulkStatus next, but this aborts the entire op if
737 * any of the lookups fails - so, for the moment, revert to
738 * FS.FetchStatus for just the primary fid.
741 inode
= ERR_PTR(-ERESTARTSYS
);
742 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
743 while (afs_select_fileserver(&fc
)) {
744 afs_fs_fetch_status(&fc
,
752 if (fc
.ac
.error
== 0)
753 cbi
= afs_get_cb_interest(fc
.cbi
);
754 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
760 for (i
= 0; i
< cookie
->nr_fids
; i
++)
761 cookie
->statuses
[i
].abort_code
= 0;
764 /* Turn all the files into inodes and save the first one - which is the
765 * one we actually want.
767 if (cookie
->statuses
[0].abort_code
!= 0)
768 inode
= ERR_PTR(afs_abort_to_error(cookie
->statuses
[0].abort_code
));
770 for (i
= 0; i
< cookie
->nr_fids
; i
++) {
773 if (cookie
->statuses
[i
].abort_code
!= 0)
776 ti
= afs_iget(dir
->i_sb
, key
, &cookie
->fids
[i
],
777 &cookie
->statuses
[i
],
778 &cookie
->callbacks
[i
],
789 afs_put_cb_interest(afs_v2net(dvnode
), cbi
);
790 kfree(cookie
->callbacks
);
792 kfree(cookie
->statuses
);
799 * Look up an entry in a directory with @sys substitution.
801 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
804 struct afs_sysnames
*subs
;
805 struct afs_net
*net
= afs_i2net(dir
);
807 char *buf
, *p
, *name
;
812 ret
= ERR_PTR(-ENOMEM
);
813 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
816 if (dentry
->d_name
.len
> 4) {
817 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
818 p
+= dentry
->d_name
.len
- 4;
821 /* There is an ordered list of substitutes that we have to try. */
822 read_lock(&net
->sysnames_lock
);
823 subs
= net
->sysnames
;
824 refcount_inc(&subs
->usage
);
825 read_unlock(&net
->sysnames_lock
);
827 for (i
= 0; i
< subs
->nr
; i
++) {
828 name
= subs
->subs
[i
];
829 len
= dentry
->d_name
.len
- 4 + strlen(name
);
830 if (len
>= AFSNAMEMAX
) {
831 ret
= ERR_PTR(-ENAMETOOLONG
);
836 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
837 if (IS_ERR(ret
) || d_is_positive(ret
))
842 /* We don't want to d_add() the @sys dentry here as we don't want to
843 * the cached dentry to hide changes to the sysnames list.
847 afs_put_sysnames(subs
);
855 * look up an entry in a directory
857 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
860 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
866 _enter("{%llx:%llu},%p{%pd},",
867 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
869 ASSERTCMP(d_inode(dentry
), ==, NULL
);
871 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
872 _leave(" = -ENAMETOOLONG");
873 return ERR_PTR(-ENAMETOOLONG
);
876 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
877 _leave(" = -ESTALE");
878 return ERR_PTR(-ESTALE
);
881 key
= afs_request_key(dvnode
->volume
->cell
);
883 _leave(" = %ld [key]", PTR_ERR(key
));
884 return ERR_CAST(key
);
887 ret
= afs_validate(dvnode
, key
);
890 _leave(" = %d [val]", ret
);
894 if (dentry
->d_name
.len
>= 4 &&
895 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
896 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
897 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
898 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
899 return afs_lookup_atsys(dir
, dentry
, key
);
901 afs_stat_v(dvnode
, n_lookup
);
902 inode
= afs_do_lookup(dir
, dentry
, key
);
904 if (inode
== ERR_PTR(-ENOENT
)) {
905 inode
= afs_try_auto_mntpt(dentry
, dir
);
908 (void *)(unsigned long)dvnode
->status
.data_version
;
910 d
= d_splice_alias(inode
, dentry
);
911 if (!IS_ERR_OR_NULL(d
)) {
912 d
->d_fsdata
= dentry
->d_fsdata
;
913 trace_afs_lookup(dvnode
, &d
->d_name
,
914 inode
? AFS_FS_I(inode
) : NULL
);
916 trace_afs_lookup(dvnode
, &dentry
->d_name
,
917 inode
? AFS_FS_I(inode
) : NULL
);
923 * check that a dentry lookup hit has found a valid entry
924 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
927 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
929 struct afs_vnode
*vnode
, *dir
;
930 struct afs_fid
uninitialized_var(fid
);
931 struct dentry
*parent
;
934 long dir_version
, de_version
;
937 if (flags
& LOOKUP_RCU
)
940 if (d_really_is_positive(dentry
)) {
941 vnode
= AFS_FS_I(d_inode(dentry
));
942 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
943 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
946 _enter("{neg n=%pd}", dentry
);
949 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
953 if (d_really_is_positive(dentry
)) {
954 inode
= d_inode(dentry
);
956 vnode
= AFS_FS_I(inode
);
957 afs_validate(vnode
, key
);
958 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
963 /* lock down the parent dentry so we can peer at it */
964 parent
= dget_parent(dentry
);
965 dir
= AFS_FS_I(d_inode(parent
));
967 /* validate the parent directory */
968 afs_validate(dir
, key
);
970 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
971 _debug("%pd: parent dir deleted", dentry
);
975 /* We only need to invalidate a dentry if the server's copy changed
976 * behind our back. If we made the change, it's no problem. Note that
977 * on a 32-bit system, we only have 32 bits in the dentry to store the
980 dir_version
= (long)dir
->status
.data_version
;
981 de_version
= (long)dentry
->d_fsdata
;
982 if (de_version
== dir_version
)
985 dir_version
= (long)dir
->invalid_before
;
986 if (de_version
- dir_version
>= 0)
989 _debug("dir modified");
990 afs_stat_v(dir
, n_reval
);
992 /* search the directory for this vnode */
993 ret
= afs_do_lookup_one(&dir
->vfs_inode
, dentry
, &fid
, key
);
996 /* the filename maps to something */
997 if (d_really_is_negative(dentry
))
999 inode
= d_inode(dentry
);
1000 if (is_bad_inode(inode
)) {
1001 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1003 goto out_bad_parent
;
1006 vnode
= AFS_FS_I(inode
);
1008 /* if the vnode ID has changed, then the dirent points to a
1010 if (fid
.vnode
!= vnode
->fid
.vnode
) {
1011 _debug("%pd: dirent changed [%llu != %llu]",
1017 /* if the vnode ID uniqifier has changed, then the file has
1018 * been deleted and replaced, and the original vnode ID has
1020 if (fid
.unique
!= vnode
->fid
.unique
) {
1021 _debug("%pd: file deleted (uq %u -> %u I:%u)",
1024 vnode
->vfs_inode
.i_generation
);
1025 write_seqlock(&vnode
->cb_lock
);
1026 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1027 write_sequnlock(&vnode
->cb_lock
);
1033 /* the filename is unknown */
1034 _debug("%pd: dirent not found", dentry
);
1035 if (d_really_is_positive(dentry
))
1040 _debug("failed to iterate dir %pd: %d",
1042 goto out_bad_parent
;
1046 dentry
->d_fsdata
= (void *)dir_version
;
1049 _leave(" = 1 [valid]");
1052 /* the dirent, if it exists, now points to a different vnode */
1054 spin_lock(&dentry
->d_lock
);
1055 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
1056 spin_unlock(&dentry
->d_lock
);
1059 _debug("dropping dentry %pd2", dentry
);
1064 _leave(" = 0 [bad]");
1069 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1071 * - called from dput() when d_count is going to 0.
1072 * - return 1 to request dentry be unhashed, 0 otherwise
1074 static int afs_d_delete(const struct dentry
*dentry
)
1076 _enter("%pd", dentry
);
1078 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1081 if (d_really_is_positive(dentry
) &&
1082 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1083 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1086 _leave(" = 0 [keep]");
1090 _leave(" = 1 [zap]");
1095 * Clean up sillyrename files on dentry removal.
1097 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
)
1099 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1100 afs_silly_iput(dentry
, inode
);
1105 * handle dentry release
1107 void afs_d_release(struct dentry
*dentry
)
1109 _enter("%pd", dentry
);
1113 * Create a new inode for create/mkdir/symlink
1115 static void afs_vnode_new_inode(struct afs_fs_cursor
*fc
,
1116 struct dentry
*new_dentry
,
1117 struct afs_fid
*newfid
,
1118 struct afs_file_status
*newstatus
,
1119 struct afs_callback
*newcb
)
1121 struct afs_vnode
*vnode
;
1122 struct inode
*inode
;
1124 if (fc
->ac
.error
< 0)
1127 inode
= afs_iget(fc
->vnode
->vfs_inode
.i_sb
, fc
->key
,
1128 newfid
, newstatus
, newcb
, fc
->cbi
, fc
->vnode
);
1129 if (IS_ERR(inode
)) {
1130 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1131 * the new directory on the server.
1133 fc
->ac
.error
= PTR_ERR(inode
);
1137 vnode
= AFS_FS_I(inode
);
1138 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1139 afs_vnode_commit_status(fc
, vnode
, 0);
1140 d_instantiate(new_dentry
, inode
);
1144 * create a directory on an AFS filesystem
1146 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
1148 struct afs_file_status newstatus
;
1149 struct afs_fs_cursor fc
;
1150 struct afs_callback newcb
;
1151 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1152 struct afs_fid newfid
;
1154 u64 data_version
= dvnode
->status
.data_version
;
1159 _enter("{%llx:%llu},{%pd},%ho",
1160 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1162 key
= afs_request_key(dvnode
->volume
->cell
);
1169 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1170 while (afs_select_fileserver(&fc
)) {
1171 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1172 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
, data_version
,
1173 &newfid
, &newstatus
, &newcb
);
1176 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1177 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1178 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, &newcb
);
1179 ret
= afs_end_vnode_operation(&fc
);
1187 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1188 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1189 afs_edit_dir_for_create
);
1199 _leave(" = %d", ret
);
1204 * Remove a subdir from a directory.
1206 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1208 if (d_really_is_positive(dentry
)) {
1209 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1211 clear_nlink(&vnode
->vfs_inode
);
1212 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1213 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1214 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1219 * remove a directory from an AFS filesystem
1221 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1223 struct afs_fs_cursor fc
;
1224 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1226 u64 data_version
= dvnode
->status
.data_version
;
1229 _enter("{%llx:%llu},{%pd}",
1230 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1232 key
= afs_request_key(dvnode
->volume
->cell
);
1238 /* Try to make sure we have a callback promise on the victim. */
1239 if (d_really_is_positive(dentry
)) {
1240 vnode
= AFS_FS_I(d_inode(dentry
));
1241 ret
= afs_validate(vnode
, key
);
1247 ret
= down_write_killable(&vnode
->rmdir_lock
);
1253 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1254 while (afs_select_fileserver(&fc
)) {
1255 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1256 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, true,
1260 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1261 ret
= afs_end_vnode_operation(&fc
);
1263 afs_dir_remove_subdir(dentry
);
1264 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1265 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1266 afs_edit_dir_for_rmdir
);
1271 up_write(&vnode
->rmdir_lock
);
1279 * Remove a link to a file or symlink from a directory.
1281 * If the file was not deleted due to excess hard links, the fileserver will
1282 * break the callback promise on the file - if it had one - before it returns
1283 * to us, and if it was deleted, it won't
1285 * However, if we didn't have a callback promise outstanding, or it was
1286 * outstanding on a different server, then it won't break it either...
1288 int afs_dir_remove_link(struct dentry
*dentry
, struct key
*key
,
1289 unsigned long d_version_before
,
1290 unsigned long d_version_after
)
1295 /* There were no intervening changes on the server if the version
1296 * number we got back was incremented by exactly 1.
1298 dir_valid
= (d_version_after
== d_version_before
+ 1);
1300 if (d_really_is_positive(dentry
)) {
1301 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1303 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1305 } else if (dir_valid
) {
1306 drop_nlink(&vnode
->vfs_inode
);
1307 if (vnode
->vfs_inode
.i_nlink
== 0) {
1308 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1309 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1313 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1315 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1316 kdebug("AFS_VNODE_DELETED");
1318 ret
= afs_validate(vnode
, key
);
1322 _debug("nlink %d [val %d]", vnode
->vfs_inode
.i_nlink
, ret
);
1329 * Remove a file or symlink from an AFS filesystem.
1331 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1333 struct afs_fs_cursor fc
;
1334 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1336 unsigned long d_version
= (unsigned long)dentry
->d_fsdata
;
1337 bool need_rehash
= false;
1338 u64 data_version
= dvnode
->status
.data_version
;
1341 _enter("{%llx:%llu},{%pd}",
1342 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1344 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1345 return -ENAMETOOLONG
;
1347 key
= afs_request_key(dvnode
->volume
->cell
);
1353 /* Try to make sure we have a callback promise on the victim. */
1354 if (d_really_is_positive(dentry
)) {
1355 vnode
= AFS_FS_I(d_inode(dentry
));
1356 ret
= afs_validate(vnode
, key
);
1361 spin_lock(&dentry
->d_lock
);
1362 if (vnode
&& d_count(dentry
) > 1) {
1363 spin_unlock(&dentry
->d_lock
);
1364 /* Start asynchronous writeout of the inode */
1365 write_inode_now(d_inode(dentry
), 0);
1366 ret
= afs_sillyrename(dvnode
, vnode
, dentry
, key
);
1369 if (!d_unhashed(dentry
)) {
1370 /* Prevent a race with RCU lookup. */
1374 spin_unlock(&dentry
->d_lock
);
1377 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1378 while (afs_select_fileserver(&fc
)) {
1379 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1381 if (test_bit(AFS_SERVER_FL_IS_YFS
, &fc
.cbi
->server
->flags
) &&
1382 !test_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
)) {
1383 yfs_fs_remove_file2(&fc
, vnode
, dentry
->d_name
.name
,
1385 if (fc
.ac
.error
!= -ECONNABORTED
||
1386 fc
.ac
.abort_code
!= RXGEN_OPCODE
)
1388 set_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
);
1391 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, false,
1395 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1396 ret
= afs_end_vnode_operation(&fc
);
1398 ret
= afs_dir_remove_link(
1399 dentry
, key
, d_version
,
1400 (unsigned long)dvnode
->status
.data_version
);
1402 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1403 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1404 afs_edit_dir_for_unlink
);
1407 if (need_rehash
&& ret
< 0 && ret
!= -ENOENT
)
1413 _leave(" = %d", ret
);
1418 * create a regular file on an AFS filesystem
1420 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
1423 struct afs_fs_cursor fc
;
1424 struct afs_file_status newstatus
;
1425 struct afs_callback newcb
;
1426 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1427 struct afs_fid newfid
;
1429 u64 data_version
= dvnode
->status
.data_version
;
1434 _enter("{%llx:%llu},{%pd},%ho,",
1435 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1437 ret
= -ENAMETOOLONG
;
1438 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1441 key
= afs_request_key(dvnode
->volume
->cell
);
1448 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1449 while (afs_select_fileserver(&fc
)) {
1450 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1451 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
, data_version
,
1452 &newfid
, &newstatus
, &newcb
);
1455 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1456 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1457 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, &newcb
);
1458 ret
= afs_end_vnode_operation(&fc
);
1465 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1466 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1467 afs_edit_dir_for_create
);
1477 _leave(" = %d", ret
);
1482 * create a hard link between files in an AFS filesystem
1484 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1485 struct dentry
*dentry
)
1487 struct afs_fs_cursor fc
;
1488 struct afs_vnode
*dvnode
, *vnode
;
1493 vnode
= AFS_FS_I(d_inode(from
));
1494 dvnode
= AFS_FS_I(dir
);
1495 data_version
= dvnode
->status
.data_version
;
1497 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1498 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1499 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1502 ret
= -ENAMETOOLONG
;
1503 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1506 key
= afs_request_key(dvnode
->volume
->cell
);
1513 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1514 if (mutex_lock_interruptible_nested(&vnode
->io_lock
, 1) < 0) {
1515 afs_end_vnode_operation(&fc
);
1519 while (afs_select_fileserver(&fc
)) {
1520 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1521 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1522 afs_fs_link(&fc
, vnode
, dentry
->d_name
.name
, data_version
);
1525 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1526 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
);
1527 ihold(&vnode
->vfs_inode
);
1528 d_instantiate(dentry
, &vnode
->vfs_inode
);
1530 mutex_unlock(&vnode
->io_lock
);
1531 ret
= afs_end_vnode_operation(&fc
);
1538 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1539 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &vnode
->fid
,
1540 afs_edit_dir_for_link
);
1550 _leave(" = %d", ret
);
1555 * create a symlink in an AFS filesystem
1557 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1558 const char *content
)
1560 struct afs_fs_cursor fc
;
1561 struct afs_file_status newstatus
;
1562 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1563 struct afs_fid newfid
;
1565 u64 data_version
= dvnode
->status
.data_version
;
1568 _enter("{%llx:%llu},{%pd},%s",
1569 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1572 ret
= -ENAMETOOLONG
;
1573 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1577 if (strlen(content
) >= AFSPATHMAX
)
1580 key
= afs_request_key(dvnode
->volume
->cell
);
1587 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1588 while (afs_select_fileserver(&fc
)) {
1589 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1590 afs_fs_symlink(&fc
, dentry
->d_name
.name
,
1591 content
, data_version
,
1592 &newfid
, &newstatus
);
1595 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1596 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1597 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, NULL
);
1598 ret
= afs_end_vnode_operation(&fc
);
1605 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1606 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1607 afs_edit_dir_for_symlink
);
1617 _leave(" = %d", ret
);
1622 * rename a file in an AFS filesystem and/or move it between directories
1624 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1625 struct inode
*new_dir
, struct dentry
*new_dentry
,
1628 struct afs_fs_cursor fc
;
1629 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1630 struct dentry
*tmp
= NULL
, *rehash
= NULL
;
1631 struct inode
*new_inode
;
1633 u64 orig_data_version
, new_data_version
;
1634 bool new_negative
= d_is_negative(new_dentry
);
1640 /* Don't allow silly-rename files be moved around. */
1641 if (old_dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1644 vnode
= AFS_FS_I(d_inode(old_dentry
));
1645 orig_dvnode
= AFS_FS_I(old_dir
);
1646 new_dvnode
= AFS_FS_I(new_dir
);
1647 orig_data_version
= orig_dvnode
->status
.data_version
;
1648 new_data_version
= new_dvnode
->status
.data_version
;
1650 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1651 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1652 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1653 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1656 key
= afs_request_key(orig_dvnode
->volume
->cell
);
1662 /* For non-directories, check whether the target is busy and if so,
1663 * make a copy of the dentry and then do a silly-rename. If the
1664 * silly-rename succeeds, the copied dentry is hashed and becomes the
1667 if (d_is_positive(new_dentry
) && !d_is_dir(new_dentry
)) {
1668 /* To prevent any new references to the target during the
1669 * rename, we unhash the dentry in advance.
1671 if (!d_unhashed(new_dentry
)) {
1673 rehash
= new_dentry
;
1676 if (d_count(new_dentry
) > 2) {
1677 /* copy the target dentry's name */
1679 tmp
= d_alloc(new_dentry
->d_parent
,
1680 &new_dentry
->d_name
);
1684 ret
= afs_sillyrename(new_dvnode
,
1685 AFS_FS_I(d_inode(new_dentry
)),
1692 new_negative
= true;
1693 orig_data_version
= orig_dvnode
->status
.data_version
;
1694 new_data_version
= new_dvnode
->status
.data_version
;
1699 if (afs_begin_vnode_operation(&fc
, orig_dvnode
, key
)) {
1700 if (orig_dvnode
!= new_dvnode
) {
1701 if (mutex_lock_interruptible_nested(&new_dvnode
->io_lock
, 1) < 0) {
1702 afs_end_vnode_operation(&fc
);
1706 while (afs_select_fileserver(&fc
)) {
1707 fc
.cb_break
= afs_calc_vnode_cb_break(orig_dvnode
);
1708 fc
.cb_break_2
= afs_calc_vnode_cb_break(new_dvnode
);
1709 afs_fs_rename(&fc
, old_dentry
->d_name
.name
,
1710 new_dvnode
, new_dentry
->d_name
.name
,
1711 orig_data_version
, new_data_version
);
1714 afs_vnode_commit_status(&fc
, orig_dvnode
, fc
.cb_break
);
1715 afs_vnode_commit_status(&fc
, new_dvnode
, fc
.cb_break_2
);
1716 if (orig_dvnode
!= new_dvnode
)
1717 mutex_unlock(&new_dvnode
->io_lock
);
1718 ret
= afs_end_vnode_operation(&fc
);
1726 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
))
1727 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1728 afs_edit_dir_for_rename_0
);
1730 if (!new_negative
&&
1731 test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1732 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1733 afs_edit_dir_for_rename_1
);
1735 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1736 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1737 &vnode
->fid
, afs_edit_dir_for_rename_2
);
1739 new_inode
= d_inode(new_dentry
);
1741 spin_lock(&new_inode
->i_lock
);
1742 if (new_inode
->i_nlink
> 0)
1743 drop_nlink(new_inode
);
1744 spin_unlock(&new_inode
->i_lock
);
1746 d_move(old_dentry
, new_dentry
);
1758 _leave(" = %d", ret
);
1763 * Release a directory page and clean up its private state if it's not busy
1764 * - return true if the page can now be released, false if not
1766 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
)
1768 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1770 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, page
->index
);
1772 set_page_private(page
, 0);
1773 ClearPagePrivate(page
);
1775 /* The directory will need reloading. */
1776 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1777 afs_stat_v(dvnode
, n_relpg
);
1782 * invalidate part or all of a page
1783 * - release a page and clean up its private data if offset is 0 (indicating
1786 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
1787 unsigned int length
)
1789 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1791 _enter("{%lu},%u,%u", page
->index
, offset
, length
);
1793 BUG_ON(!PageLocked(page
));
1795 /* The directory will need reloading. */
1796 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1797 afs_stat_v(dvnode
, n_inval
);
1799 /* we clean up only if the entire page is being invalidated */
1800 if (offset
== 0 && length
== PAGE_SIZE
) {
1801 set_page_private(page
, 0);
1802 ClearPagePrivate(page
);