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 int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
30 loff_t fpos
, u64 ino
, unsigned dtype
);
31 static int afs_lookup_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
32 loff_t fpos
, u64 ino
, unsigned dtype
);
33 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
35 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
);
36 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
);
37 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
);
38 static int afs_link(struct dentry
*from
, struct inode
*dir
,
39 struct dentry
*dentry
);
40 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
42 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
43 struct inode
*new_dir
, struct dentry
*new_dentry
,
45 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
);
46 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
49 static int afs_dir_set_page_dirty(struct page
*page
)
51 BUG(); /* This should never happen. */
54 const struct file_operations afs_dir_file_operations
= {
56 .release
= afs_release
,
57 .iterate_shared
= afs_readdir
,
59 .llseek
= generic_file_llseek
,
62 const struct inode_operations afs_dir_inode_operations
= {
67 .symlink
= afs_symlink
,
71 .permission
= afs_permission
,
72 .getattr
= afs_getattr
,
73 .setattr
= afs_setattr
,
74 .listxattr
= afs_listxattr
,
77 const struct address_space_operations afs_dir_aops
= {
78 .set_page_dirty
= afs_dir_set_page_dirty
,
79 .releasepage
= afs_dir_releasepage
,
80 .invalidatepage
= afs_dir_invalidatepage
,
83 const struct dentry_operations afs_fs_dentry_operations
= {
84 .d_revalidate
= afs_d_revalidate
,
85 .d_delete
= afs_d_delete
,
86 .d_release
= afs_d_release
,
87 .d_automount
= afs_d_automount
,
90 struct afs_lookup_one_cookie
{
91 struct dir_context ctx
;
97 struct afs_lookup_cookie
{
98 struct dir_context ctx
;
102 unsigned short nr_fids
;
103 struct afs_file_status
*statuses
;
104 struct afs_callback
*callbacks
;
105 struct afs_fid fids
[50];
109 * check that a directory page is valid
111 static bool afs_dir_check_page(struct afs_vnode
*dvnode
, struct page
*page
,
114 struct afs_xdr_dir_page
*dbuf
;
118 /* Determine how many magic numbers there should be in this page, but
119 * we must take care because the directory may change size under us.
121 off
= page_offset(page
);
125 latter
= i_size
- off
;
126 if (latter
>= PAGE_SIZE
)
130 qty
/= sizeof(union afs_xdr_dir_block
);
134 for (tmp
= 0; tmp
< qty
; tmp
++) {
135 if (dbuf
->blocks
[tmp
].hdr
.magic
!= AFS_DIR_MAGIC
) {
136 printk("kAFS: %s(%lx): bad magic %d/%d is %04hx\n",
137 __func__
, dvnode
->vfs_inode
.i_ino
, tmp
, qty
,
138 ntohs(dbuf
->blocks
[tmp
].hdr
.magic
));
139 trace_afs_dir_check_failed(dvnode
, off
, i_size
);
141 trace_afs_file_error(dvnode
, -EIO
, afs_file_error_dir_bad_magic
);
145 /* Make sure each block is NUL terminated so we can reasonably
146 * use string functions on it. The filenames in the page
147 * *should* be NUL-terminated anyway.
149 ((u8
*)&dbuf
->blocks
[tmp
])[AFS_DIR_BLOCK_SIZE
- 1] = 0;
155 afs_stat_v(dvnode
, n_read_dir
);
163 * open an AFS directory file
165 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
167 _enter("{%lu}", inode
->i_ino
);
169 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
170 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
172 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
175 return afs_open(inode
, file
);
179 * Read the directory into the pagecache in one go, scrubbing the previous
180 * contents. The list of pages is returned, pinning them so that they don't
181 * get reclaimed during the iteration.
183 static struct afs_read
*afs_read_dir(struct afs_vnode
*dvnode
, struct key
*key
)
184 __acquires(&dvnode
->validate_lock
)
186 struct afs_read
*req
;
188 int nr_pages
, nr_inline
, i
, n
;
192 i_size
= i_size_read(&dvnode
->vfs_inode
);
194 return ERR_PTR(afs_bad(dvnode
, afs_file_error_dir_small
));
195 if (i_size
> 2048 * 1024) {
196 trace_afs_file_error(dvnode
, -EFBIG
, afs_file_error_dir_big
);
197 return ERR_PTR(-EFBIG
);
200 _enter("%llu", i_size
);
202 /* Get a request record to hold the page list. We want to hold it
203 * inline if we can, but we don't want to make an order 1 allocation.
205 nr_pages
= (i_size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
206 nr_inline
= nr_pages
;
207 if (nr_inline
> (PAGE_SIZE
- sizeof(*req
)) / sizeof(struct page
*))
210 req
= kzalloc(sizeof(*req
) + sizeof(struct page
*) * nr_inline
,
213 return ERR_PTR(-ENOMEM
);
215 refcount_set(&req
->usage
, 1);
216 req
->nr_pages
= nr_pages
;
217 req
->actual_len
= i_size
; /* May change */
218 req
->len
= nr_pages
* PAGE_SIZE
; /* We can ask for more than there is */
219 req
->data_version
= dvnode
->status
.data_version
; /* May change */
221 req
->pages
= req
->array
;
223 req
->pages
= kcalloc(nr_pages
, sizeof(struct page
*),
229 /* Get a list of all the pages that hold or will hold the directory
230 * content. We need to fill in any gaps that we might find where the
231 * memory reclaimer has been at work. If there are any gaps, we will
232 * need to reread the entire directory contents.
236 n
= find_get_pages_contig(dvnode
->vfs_inode
.i_mapping
, i
,
239 _debug("find %u at %u/%u", n
, i
, req
->nr_pages
);
241 gfp_t gfp
= dvnode
->vfs_inode
.i_mapping
->gfp_mask
;
243 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
244 afs_stat_v(dvnode
, n_inval
);
247 req
->pages
[i
] = __page_cache_alloc(gfp
);
250 ret
= add_to_page_cache_lru(req
->pages
[i
],
251 dvnode
->vfs_inode
.i_mapping
,
256 set_page_private(req
->pages
[i
], 1);
257 SetPagePrivate(req
->pages
[i
]);
258 unlock_page(req
->pages
[i
]);
263 } while (i
< req
->nr_pages
);
265 /* If we're going to reload, we need to lock all the pages to prevent
269 if (down_read_killable(&dvnode
->validate_lock
) < 0)
272 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
275 up_read(&dvnode
->validate_lock
);
276 if (down_write_killable(&dvnode
->validate_lock
) < 0)
279 if (!test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
280 ret
= afs_fetch_data(dvnode
, key
, req
);
284 task_io_account_read(PAGE_SIZE
* req
->nr_pages
);
286 if (req
->len
< req
->file_size
)
287 goto content_has_grown
;
289 /* Validate the data we just read. */
291 for (i
= 0; i
< req
->nr_pages
; i
++)
292 if (!afs_dir_check_page(dvnode
, req
->pages
[i
],
296 // TODO: Trim excess pages
298 set_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
);
301 downgrade_write(&dvnode
->validate_lock
);
306 up_write(&dvnode
->validate_lock
);
309 _leave(" = %d", ret
);
313 up_write(&dvnode
->validate_lock
);
319 * deal with one block in an AFS directory
321 static int afs_dir_iterate_block(struct afs_vnode
*dvnode
,
322 struct dir_context
*ctx
,
323 union afs_xdr_dir_block
*block
,
326 union afs_xdr_dirent
*dire
;
327 unsigned offset
, next
, curr
;
331 _enter("%u,%x,%p,,",(unsigned)ctx
->pos
,blkoff
,block
);
333 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_xdr_dirent
);
335 /* walk through the block, an entry at a time */
336 for (offset
= (blkoff
== 0 ? AFS_DIR_RESV_BLOCKS0
: AFS_DIR_RESV_BLOCKS
);
337 offset
< AFS_DIR_SLOTS_PER_BLOCK
;
342 /* skip entries marked unused in the bitmap */
343 if (!(block
->hdr
.bitmap
[offset
/ 8] &
344 (1 << (offset
% 8)))) {
345 _debug("ENT[%zu.%u]: unused",
346 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
);
349 next
* sizeof(union afs_xdr_dirent
);
353 /* got a valid entry */
354 dire
= &block
->dirents
[offset
];
355 nlen
= strnlen(dire
->u
.name
,
357 offset
* sizeof(union afs_xdr_dirent
));
359 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
360 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
,
361 (offset
< curr
? "skip" : "fill"),
364 /* work out where the next possible entry is */
365 for (tmp
= nlen
; tmp
> 15; tmp
-= sizeof(union afs_xdr_dirent
)) {
366 if (next
>= AFS_DIR_SLOTS_PER_BLOCK
) {
367 _debug("ENT[%zu.%u]:"
368 " %u travelled beyond end dir block"
370 blkoff
/ sizeof(union afs_xdr_dir_block
),
371 offset
, next
, tmp
, nlen
);
372 return afs_bad(dvnode
, afs_file_error_dir_over_end
);
374 if (!(block
->hdr
.bitmap
[next
/ 8] &
375 (1 << (next
% 8)))) {
376 _debug("ENT[%zu.%u]:"
377 " %u unmarked extension (len %u/%zu)",
378 blkoff
/ sizeof(union afs_xdr_dir_block
),
379 offset
, next
, tmp
, nlen
);
380 return afs_bad(dvnode
, afs_file_error_dir_unmarked_ext
);
383 _debug("ENT[%zu.%u]: ext %u/%zu",
384 blkoff
/ sizeof(union afs_xdr_dir_block
),
389 /* skip if starts before the current position */
393 /* found the next entry */
394 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
395 ntohl(dire
->u
.vnode
),
396 (ctx
->actor
== afs_lookup_filldir
||
397 ctx
->actor
== afs_lookup_one_filldir
)?
398 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
399 _leave(" = 0 [full]");
403 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
406 _leave(" = 1 [more]");
411 * iterate through the data blob that lists the contents of an AFS directory
413 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
416 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
417 struct afs_xdr_dir_page
*dbuf
;
418 union afs_xdr_dir_block
*dblock
;
419 struct afs_read
*req
;
421 unsigned blkoff
, limit
;
424 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
426 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
427 _leave(" = -ESTALE");
431 req
= afs_read_dir(dvnode
, key
);
435 /* round the file position up to the next entry boundary */
436 ctx
->pos
+= sizeof(union afs_xdr_dirent
) - 1;
437 ctx
->pos
&= ~(sizeof(union afs_xdr_dirent
) - 1);
439 /* walk through the blocks in sequence */
441 while (ctx
->pos
< req
->actual_len
) {
442 blkoff
= ctx
->pos
& ~(sizeof(union afs_xdr_dir_block
) - 1);
444 /* Fetch the appropriate page from the directory and re-add it
447 page
= req
->pages
[blkoff
/ PAGE_SIZE
];
449 ret
= afs_bad(dvnode
, afs_file_error_dir_missing_page
);
452 mark_page_accessed(page
);
454 limit
= blkoff
& ~(PAGE_SIZE
- 1);
458 /* deal with the individual blocks stashed on this page */
460 dblock
= &dbuf
->blocks
[(blkoff
% PAGE_SIZE
) /
461 sizeof(union afs_xdr_dir_block
)];
462 ret
= afs_dir_iterate_block(dvnode
, ctx
, dblock
, blkoff
);
468 blkoff
+= sizeof(union afs_xdr_dir_block
);
470 } while (ctx
->pos
< dir
->i_size
&& blkoff
< limit
);
477 up_read(&dvnode
->validate_lock
);
479 _leave(" = %d", ret
);
484 * read an AFS directory
486 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
488 return afs_dir_iterate(file_inode(file
), ctx
, afs_file_key(file
));
492 * Search the directory for a single name
493 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
494 * uniquifier through dtype
496 static int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
,
497 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
499 struct afs_lookup_one_cookie
*cookie
=
500 container_of(ctx
, struct afs_lookup_one_cookie
, ctx
);
502 _enter("{%s,%u},%s,%u,,%llu,%u",
503 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
504 (unsigned long long) ino
, dtype
);
506 /* insanity checks first */
507 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
508 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
510 if (cookie
->name
.len
!= nlen
||
511 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
516 cookie
->fid
.vnode
= ino
;
517 cookie
->fid
.unique
= dtype
;
520 _leave(" = -1 [found]");
525 * Do a lookup of a single name in a directory
526 * - just returns the FID the dentry name maps to if found
528 static int afs_do_lookup_one(struct inode
*dir
, struct dentry
*dentry
,
529 struct afs_fid
*fid
, struct key
*key
)
531 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
532 struct afs_lookup_one_cookie cookie
= {
533 .ctx
.actor
= afs_lookup_one_filldir
,
534 .name
= dentry
->d_name
,
535 .fid
.vid
= as
->volume
->vid
539 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
541 /* search the directory */
542 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
);
544 _leave(" = %d [iter]", ret
);
550 _leave(" = -ENOENT [not found]");
555 _leave(" = 0 { vn=%llu u=%u }", fid
->vnode
, fid
->unique
);
560 * search the directory for a name
561 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
562 * uniquifier through dtype
564 static int afs_lookup_filldir(struct dir_context
*ctx
, const char *name
,
565 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
567 struct afs_lookup_cookie
*cookie
=
568 container_of(ctx
, struct afs_lookup_cookie
, ctx
);
571 _enter("{%s,%u},%s,%u,,%llu,%u",
572 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
573 (unsigned long long) ino
, dtype
);
575 /* insanity checks first */
576 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
577 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
580 if (cookie
->nr_fids
< 50) {
581 cookie
->fids
[cookie
->nr_fids
].vnode
= ino
;
582 cookie
->fids
[cookie
->nr_fids
].unique
= dtype
;
585 } else if (cookie
->name
.len
== nlen
&&
586 memcmp(cookie
->name
.name
, name
, nlen
) == 0) {
587 cookie
->fids
[0].vnode
= ino
;
588 cookie
->fids
[0].unique
= dtype
;
590 if (cookie
->one_only
)
594 ret
= cookie
->nr_fids
>= 50 ? -1 : 0;
595 _leave(" = %d", ret
);
600 * Do a lookup in a directory. We make use of bulk lookup to query a slew of
601 * files in one go and create inodes for them. The inode of the file we were
602 * asked for is returned.
604 static struct inode
*afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
607 struct afs_lookup_cookie
*cookie
;
608 struct afs_cb_interest
*cbi
= NULL
;
609 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
610 struct afs_iget_data data
;
611 struct afs_fs_cursor fc
;
612 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
613 struct inode
*inode
= NULL
;
616 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
618 cookie
= kzalloc(sizeof(struct afs_lookup_cookie
), GFP_KERNEL
);
620 return ERR_PTR(-ENOMEM
);
622 cookie
->ctx
.actor
= afs_lookup_filldir
;
623 cookie
->name
= dentry
->d_name
;
624 cookie
->nr_fids
= 1; /* slot 0 is saved for the fid we actually want */
626 read_seqlock_excl(&dvnode
->cb_lock
);
627 if (dvnode
->cb_interest
&&
628 dvnode
->cb_interest
->server
&&
629 test_bit(AFS_SERVER_FL_NO_IBULK
, &dvnode
->cb_interest
->server
->flags
))
630 cookie
->one_only
= true;
631 read_sequnlock_excl(&dvnode
->cb_lock
);
633 for (i
= 0; i
< 50; i
++)
634 cookie
->fids
[i
].vid
= as
->volume
->vid
;
636 /* search the directory */
637 ret
= afs_dir_iterate(dir
, &cookie
->ctx
, key
);
639 inode
= ERR_PTR(ret
);
643 inode
= ERR_PTR(-ENOENT
);
647 /* Check to see if we already have an inode for the primary fid. */
648 data
.volume
= dvnode
->volume
;
649 data
.fid
= cookie
->fids
[0];
650 inode
= ilookup5(dir
->i_sb
, cookie
->fids
[0].vnode
, afs_iget5_test
, &data
);
654 /* Need space for examining all the selected files */
655 inode
= ERR_PTR(-ENOMEM
);
656 cookie
->statuses
= kcalloc(cookie
->nr_fids
, sizeof(struct afs_file_status
),
658 if (!cookie
->statuses
)
661 cookie
->callbacks
= kcalloc(cookie
->nr_fids
, sizeof(struct afs_callback
),
663 if (!cookie
->callbacks
)
666 /* Try FS.InlineBulkStatus first. Abort codes for the individual
667 * lookups contained therein are stored in the reply without aborting
668 * the whole operation.
670 if (cookie
->one_only
)
671 goto no_inline_bulk_status
;
673 inode
= ERR_PTR(-ERESTARTSYS
);
674 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
675 while (afs_select_fileserver(&fc
)) {
676 if (test_bit(AFS_SERVER_FL_NO_IBULK
,
677 &fc
.cbi
->server
->flags
)) {
678 fc
.ac
.abort_code
= RX_INVALID_OPERATION
;
679 fc
.ac
.error
= -ECONNABORTED
;
682 afs_fs_inline_bulk_status(&fc
,
687 cookie
->nr_fids
, NULL
);
690 if (fc
.ac
.error
== 0)
691 cbi
= afs_get_cb_interest(fc
.cbi
);
692 if (fc
.ac
.abort_code
== RX_INVALID_OPERATION
)
693 set_bit(AFS_SERVER_FL_NO_IBULK
, &fc
.cbi
->server
->flags
);
694 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
699 if (fc
.ac
.abort_code
!= RX_INVALID_OPERATION
)
702 no_inline_bulk_status
:
703 /* We could try FS.BulkStatus next, but this aborts the entire op if
704 * any of the lookups fails - so, for the moment, revert to
705 * FS.FetchStatus for just the primary fid.
708 inode
= ERR_PTR(-ERESTARTSYS
);
709 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
710 while (afs_select_fileserver(&fc
)) {
711 afs_fs_fetch_status(&fc
,
719 if (fc
.ac
.error
== 0)
720 cbi
= afs_get_cb_interest(fc
.cbi
);
721 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
727 for (i
= 0; i
< cookie
->nr_fids
; i
++)
728 cookie
->statuses
[i
].abort_code
= 0;
731 /* Turn all the files into inodes and save the first one - which is the
732 * one we actually want.
734 if (cookie
->statuses
[0].abort_code
!= 0)
735 inode
= ERR_PTR(afs_abort_to_error(cookie
->statuses
[0].abort_code
));
737 for (i
= 0; i
< cookie
->nr_fids
; i
++) {
740 if (cookie
->statuses
[i
].abort_code
!= 0)
743 ti
= afs_iget(dir
->i_sb
, key
, &cookie
->fids
[i
],
744 &cookie
->statuses
[i
],
745 &cookie
->callbacks
[i
],
756 afs_put_cb_interest(afs_v2net(dvnode
), cbi
);
757 kfree(cookie
->callbacks
);
759 kfree(cookie
->statuses
);
766 * Look up an entry in a directory with @sys substitution.
768 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
771 struct afs_sysnames
*subs
;
772 struct afs_net
*net
= afs_i2net(dir
);
774 char *buf
, *p
, *name
;
779 ret
= ERR_PTR(-ENOMEM
);
780 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
783 if (dentry
->d_name
.len
> 4) {
784 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
785 p
+= dentry
->d_name
.len
- 4;
788 /* There is an ordered list of substitutes that we have to try. */
789 read_lock(&net
->sysnames_lock
);
790 subs
= net
->sysnames
;
791 refcount_inc(&subs
->usage
);
792 read_unlock(&net
->sysnames_lock
);
794 for (i
= 0; i
< subs
->nr
; i
++) {
795 name
= subs
->subs
[i
];
796 len
= dentry
->d_name
.len
- 4 + strlen(name
);
797 if (len
>= AFSNAMEMAX
) {
798 ret
= ERR_PTR(-ENAMETOOLONG
);
803 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
804 if (IS_ERR(ret
) || d_is_positive(ret
))
809 /* We don't want to d_add() the @sys dentry here as we don't want to
810 * the cached dentry to hide changes to the sysnames list.
814 afs_put_sysnames(subs
);
822 * look up an entry in a directory
824 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
827 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
833 _enter("{%llx:%llu},%p{%pd},",
834 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
836 ASSERTCMP(d_inode(dentry
), ==, NULL
);
838 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
839 _leave(" = -ENAMETOOLONG");
840 return ERR_PTR(-ENAMETOOLONG
);
843 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
844 _leave(" = -ESTALE");
845 return ERR_PTR(-ESTALE
);
848 key
= afs_request_key(dvnode
->volume
->cell
);
850 _leave(" = %ld [key]", PTR_ERR(key
));
851 return ERR_CAST(key
);
854 ret
= afs_validate(dvnode
, key
);
857 _leave(" = %d [val]", ret
);
861 if (dentry
->d_name
.len
>= 4 &&
862 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
863 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
864 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
865 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
866 return afs_lookup_atsys(dir
, dentry
, key
);
868 afs_stat_v(dvnode
, n_lookup
);
869 inode
= afs_do_lookup(dir
, dentry
, key
);
871 if (inode
== ERR_PTR(-ENOENT
)) {
872 inode
= afs_try_auto_mntpt(dentry
, dir
);
875 (void *)(unsigned long)dvnode
->status
.data_version
;
877 d
= d_splice_alias(inode
, dentry
);
878 if (!IS_ERR_OR_NULL(d
))
879 d
->d_fsdata
= dentry
->d_fsdata
;
884 * check that a dentry lookup hit has found a valid entry
885 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
888 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
890 struct afs_vnode
*vnode
, *dir
;
891 struct afs_fid
uninitialized_var(fid
);
892 struct dentry
*parent
;
895 long dir_version
, de_version
;
898 if (flags
& LOOKUP_RCU
)
901 if (d_really_is_positive(dentry
)) {
902 vnode
= AFS_FS_I(d_inode(dentry
));
903 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
904 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
907 _enter("{neg n=%pd}", dentry
);
910 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
914 if (d_really_is_positive(dentry
)) {
915 inode
= d_inode(dentry
);
917 vnode
= AFS_FS_I(inode
);
918 afs_validate(vnode
, key
);
919 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
924 /* lock down the parent dentry so we can peer at it */
925 parent
= dget_parent(dentry
);
926 dir
= AFS_FS_I(d_inode(parent
));
928 /* validate the parent directory */
929 afs_validate(dir
, key
);
931 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
932 _debug("%pd: parent dir deleted", dentry
);
936 /* We only need to invalidate a dentry if the server's copy changed
937 * behind our back. If we made the change, it's no problem. Note that
938 * on a 32-bit system, we only have 32 bits in the dentry to store the
941 dir_version
= (long)dir
->status
.data_version
;
942 de_version
= (long)dentry
->d_fsdata
;
943 if (de_version
== dir_version
)
946 dir_version
= (long)dir
->invalid_before
;
947 if (de_version
- dir_version
>= 0)
950 _debug("dir modified");
951 afs_stat_v(dir
, n_reval
);
953 /* search the directory for this vnode */
954 ret
= afs_do_lookup_one(&dir
->vfs_inode
, dentry
, &fid
, key
);
957 /* the filename maps to something */
958 if (d_really_is_negative(dentry
))
960 inode
= d_inode(dentry
);
961 if (is_bad_inode(inode
)) {
962 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
967 vnode
= AFS_FS_I(inode
);
969 /* if the vnode ID has changed, then the dirent points to a
971 if (fid
.vnode
!= vnode
->fid
.vnode
) {
972 _debug("%pd: dirent changed [%llu != %llu]",
978 /* if the vnode ID uniqifier has changed, then the file has
979 * been deleted and replaced, and the original vnode ID has
981 if (fid
.unique
!= vnode
->fid
.unique
) {
982 _debug("%pd: file deleted (uq %u -> %u I:%u)",
985 vnode
->vfs_inode
.i_generation
);
986 write_seqlock(&vnode
->cb_lock
);
987 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
988 write_sequnlock(&vnode
->cb_lock
);
994 /* the filename is unknown */
995 _debug("%pd: dirent not found", dentry
);
996 if (d_really_is_positive(dentry
))
1001 _debug("failed to iterate dir %pd: %d",
1003 goto out_bad_parent
;
1007 dentry
->d_fsdata
= (void *)dir_version
;
1010 _leave(" = 1 [valid]");
1013 /* the dirent, if it exists, now points to a different vnode */
1015 spin_lock(&dentry
->d_lock
);
1016 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
1017 spin_unlock(&dentry
->d_lock
);
1020 _debug("dropping dentry %pd2", dentry
);
1025 _leave(" = 0 [bad]");
1030 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1032 * - called from dput() when d_count is going to 0.
1033 * - return 1 to request dentry be unhashed, 0 otherwise
1035 static int afs_d_delete(const struct dentry
*dentry
)
1037 _enter("%pd", dentry
);
1039 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1042 if (d_really_is_positive(dentry
) &&
1043 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1044 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1047 _leave(" = 0 [keep]");
1051 _leave(" = 1 [zap]");
1056 * handle dentry release
1058 void afs_d_release(struct dentry
*dentry
)
1060 _enter("%pd", dentry
);
1064 * Create a new inode for create/mkdir/symlink
1066 static void afs_vnode_new_inode(struct afs_fs_cursor
*fc
,
1067 struct dentry
*new_dentry
,
1068 struct afs_fid
*newfid
,
1069 struct afs_file_status
*newstatus
,
1070 struct afs_callback
*newcb
)
1072 struct afs_vnode
*vnode
;
1073 struct inode
*inode
;
1075 if (fc
->ac
.error
< 0)
1078 inode
= afs_iget(fc
->vnode
->vfs_inode
.i_sb
, fc
->key
,
1079 newfid
, newstatus
, newcb
, fc
->cbi
);
1080 if (IS_ERR(inode
)) {
1081 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1082 * the new directory on the server.
1084 fc
->ac
.error
= PTR_ERR(inode
);
1088 vnode
= AFS_FS_I(inode
);
1089 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1090 afs_vnode_commit_status(fc
, vnode
, 0);
1091 d_instantiate(new_dentry
, inode
);
1095 * create a directory on an AFS filesystem
1097 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
1099 struct afs_file_status newstatus
;
1100 struct afs_fs_cursor fc
;
1101 struct afs_callback newcb
;
1102 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1103 struct afs_fid newfid
;
1105 u64 data_version
= dvnode
->status
.data_version
;
1110 _enter("{%llx:%llu},{%pd},%ho",
1111 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1113 key
= afs_request_key(dvnode
->volume
->cell
);
1120 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1121 while (afs_select_fileserver(&fc
)) {
1122 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1123 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
, data_version
,
1124 &newfid
, &newstatus
, &newcb
);
1127 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1128 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1129 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, &newcb
);
1130 ret
= afs_end_vnode_operation(&fc
);
1138 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1139 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1140 afs_edit_dir_for_create
);
1150 _leave(" = %d", ret
);
1155 * Remove a subdir from a directory.
1157 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1159 if (d_really_is_positive(dentry
)) {
1160 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1162 clear_nlink(&vnode
->vfs_inode
);
1163 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1164 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1165 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1170 * remove a directory from an AFS filesystem
1172 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1174 struct afs_fs_cursor fc
;
1175 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1177 u64 data_version
= dvnode
->status
.data_version
;
1180 _enter("{%llx:%llu},{%pd}",
1181 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1183 key
= afs_request_key(dvnode
->volume
->cell
);
1189 /* Try to make sure we have a callback promise on the victim. */
1190 if (d_really_is_positive(dentry
)) {
1191 vnode
= AFS_FS_I(d_inode(dentry
));
1192 ret
= afs_validate(vnode
, key
);
1198 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1199 while (afs_select_fileserver(&fc
)) {
1200 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1201 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, true,
1205 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1206 ret
= afs_end_vnode_operation(&fc
);
1208 afs_dir_remove_subdir(dentry
);
1209 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1210 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1211 afs_edit_dir_for_rmdir
);
1222 * Remove a link to a file or symlink from a directory.
1224 * If the file was not deleted due to excess hard links, the fileserver will
1225 * break the callback promise on the file - if it had one - before it returns
1226 * to us, and if it was deleted, it won't
1228 * However, if we didn't have a callback promise outstanding, or it was
1229 * outstanding on a different server, then it won't break it either...
1231 static int afs_dir_remove_link(struct dentry
*dentry
, struct key
*key
,
1232 unsigned long d_version_before
,
1233 unsigned long d_version_after
)
1238 /* There were no intervening changes on the server if the version
1239 * number we got back was incremented by exactly 1.
1241 dir_valid
= (d_version_after
== d_version_before
+ 1);
1243 if (d_really_is_positive(dentry
)) {
1244 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1246 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1248 } else if (dir_valid
) {
1249 drop_nlink(&vnode
->vfs_inode
);
1250 if (vnode
->vfs_inode
.i_nlink
== 0) {
1251 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1252 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1256 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1258 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1259 kdebug("AFS_VNODE_DELETED");
1261 ret
= afs_validate(vnode
, key
);
1265 _debug("nlink %d [val %d]", vnode
->vfs_inode
.i_nlink
, ret
);
1272 * Remove a file or symlink from an AFS filesystem.
1274 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1276 struct afs_fs_cursor fc
;
1277 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1279 unsigned long d_version
= (unsigned long)dentry
->d_fsdata
;
1280 u64 data_version
= dvnode
->status
.data_version
;
1283 _enter("{%llx:%llu},{%pd}",
1284 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1286 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1287 return -ENAMETOOLONG
;
1289 key
= afs_request_key(dvnode
->volume
->cell
);
1295 /* Try to make sure we have a callback promise on the victim. */
1296 if (d_really_is_positive(dentry
)) {
1297 vnode
= AFS_FS_I(d_inode(dentry
));
1298 ret
= afs_validate(vnode
, key
);
1304 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1305 while (afs_select_fileserver(&fc
)) {
1306 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1308 if (test_bit(AFS_SERVER_FL_IS_YFS
, &fc
.cbi
->server
->flags
) &&
1309 !test_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
)) {
1310 yfs_fs_remove_file2(&fc
, vnode
, dentry
->d_name
.name
,
1312 if (fc
.ac
.error
!= -ECONNABORTED
||
1313 fc
.ac
.abort_code
!= RXGEN_OPCODE
)
1315 set_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
);
1318 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, false,
1322 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1323 ret
= afs_end_vnode_operation(&fc
);
1325 ret
= afs_dir_remove_link(
1326 dentry
, key
, d_version
,
1327 (unsigned long)dvnode
->status
.data_version
);
1329 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1330 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1331 afs_edit_dir_for_unlink
);
1337 _leave(" = %d", ret
);
1342 * create a regular file on an AFS filesystem
1344 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
1347 struct afs_fs_cursor fc
;
1348 struct afs_file_status newstatus
;
1349 struct afs_callback newcb
;
1350 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1351 struct afs_fid newfid
;
1353 u64 data_version
= dvnode
->status
.data_version
;
1358 _enter("{%llx:%llu},{%pd},%ho,",
1359 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1361 ret
= -ENAMETOOLONG
;
1362 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1365 key
= afs_request_key(dvnode
->volume
->cell
);
1372 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1373 while (afs_select_fileserver(&fc
)) {
1374 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1375 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
, data_version
,
1376 &newfid
, &newstatus
, &newcb
);
1379 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1380 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1381 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, &newcb
);
1382 ret
= afs_end_vnode_operation(&fc
);
1389 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1390 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1391 afs_edit_dir_for_create
);
1401 _leave(" = %d", ret
);
1406 * create a hard link between files in an AFS filesystem
1408 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1409 struct dentry
*dentry
)
1411 struct afs_fs_cursor fc
;
1412 struct afs_vnode
*dvnode
, *vnode
;
1417 vnode
= AFS_FS_I(d_inode(from
));
1418 dvnode
= AFS_FS_I(dir
);
1419 data_version
= dvnode
->status
.data_version
;
1421 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1422 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1423 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1426 ret
= -ENAMETOOLONG
;
1427 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1430 key
= afs_request_key(dvnode
->volume
->cell
);
1437 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1438 if (mutex_lock_interruptible_nested(&vnode
->io_lock
, 1) < 0) {
1439 afs_end_vnode_operation(&fc
);
1443 while (afs_select_fileserver(&fc
)) {
1444 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1445 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1446 afs_fs_link(&fc
, vnode
, dentry
->d_name
.name
, data_version
);
1449 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1450 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
);
1451 ihold(&vnode
->vfs_inode
);
1452 d_instantiate(dentry
, &vnode
->vfs_inode
);
1454 mutex_unlock(&vnode
->io_lock
);
1455 ret
= afs_end_vnode_operation(&fc
);
1462 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1463 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &vnode
->fid
,
1464 afs_edit_dir_for_link
);
1474 _leave(" = %d", ret
);
1479 * create a symlink in an AFS filesystem
1481 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1482 const char *content
)
1484 struct afs_fs_cursor fc
;
1485 struct afs_file_status newstatus
;
1486 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1487 struct afs_fid newfid
;
1489 u64 data_version
= dvnode
->status
.data_version
;
1492 _enter("{%llx:%llu},{%pd},%s",
1493 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1496 ret
= -ENAMETOOLONG
;
1497 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1501 if (strlen(content
) >= AFSPATHMAX
)
1504 key
= afs_request_key(dvnode
->volume
->cell
);
1511 if (afs_begin_vnode_operation(&fc
, dvnode
, key
)) {
1512 while (afs_select_fileserver(&fc
)) {
1513 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1514 afs_fs_symlink(&fc
, dentry
->d_name
.name
,
1515 content
, data_version
,
1516 &newfid
, &newstatus
);
1519 afs_check_for_remote_deletion(&fc
, fc
.vnode
);
1520 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
);
1521 afs_vnode_new_inode(&fc
, dentry
, &newfid
, &newstatus
, NULL
);
1522 ret
= afs_end_vnode_operation(&fc
);
1529 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1530 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &newfid
,
1531 afs_edit_dir_for_symlink
);
1541 _leave(" = %d", ret
);
1546 * rename a file in an AFS filesystem and/or move it between directories
1548 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1549 struct inode
*new_dir
, struct dentry
*new_dentry
,
1552 struct afs_fs_cursor fc
;
1553 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1555 u64 orig_data_version
, new_data_version
;
1556 bool new_negative
= d_is_negative(new_dentry
);
1562 vnode
= AFS_FS_I(d_inode(old_dentry
));
1563 orig_dvnode
= AFS_FS_I(old_dir
);
1564 new_dvnode
= AFS_FS_I(new_dir
);
1565 orig_data_version
= orig_dvnode
->status
.data_version
;
1566 new_data_version
= new_dvnode
->status
.data_version
;
1568 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1569 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1570 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1571 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1574 key
= afs_request_key(orig_dvnode
->volume
->cell
);
1581 if (afs_begin_vnode_operation(&fc
, orig_dvnode
, key
)) {
1582 if (orig_dvnode
!= new_dvnode
) {
1583 if (mutex_lock_interruptible_nested(&new_dvnode
->io_lock
, 1) < 0) {
1584 afs_end_vnode_operation(&fc
);
1588 while (afs_select_fileserver(&fc
)) {
1589 fc
.cb_break
= afs_calc_vnode_cb_break(orig_dvnode
);
1590 fc
.cb_break_2
= afs_calc_vnode_cb_break(new_dvnode
);
1591 afs_fs_rename(&fc
, old_dentry
->d_name
.name
,
1592 new_dvnode
, new_dentry
->d_name
.name
,
1593 orig_data_version
, new_data_version
);
1596 afs_vnode_commit_status(&fc
, orig_dvnode
, fc
.cb_break
);
1597 afs_vnode_commit_status(&fc
, new_dvnode
, fc
.cb_break_2
);
1598 if (orig_dvnode
!= new_dvnode
)
1599 mutex_unlock(&new_dvnode
->io_lock
);
1600 ret
= afs_end_vnode_operation(&fc
);
1606 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
))
1607 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1608 afs_edit_dir_for_rename
);
1610 if (!new_negative
&&
1611 test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1612 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1613 afs_edit_dir_for_rename
);
1615 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1616 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1617 &vnode
->fid
, afs_edit_dir_for_rename
);
1623 _leave(" = %d", ret
);
1628 * Release a directory page and clean up its private state if it's not busy
1629 * - return true if the page can now be released, false if not
1631 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
)
1633 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1635 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, page
->index
);
1637 set_page_private(page
, 0);
1638 ClearPagePrivate(page
);
1640 /* The directory will need reloading. */
1641 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1642 afs_stat_v(dvnode
, n_relpg
);
1647 * invalidate part or all of a page
1648 * - release a page and clean up its private data if offset is 0 (indicating
1651 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
1652 unsigned int length
)
1654 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1656 _enter("{%lu},%u,%u", page
->index
, offset
, length
);
1658 BUG_ON(!PageLocked(page
));
1660 /* The directory will need reloading. */
1661 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1662 afs_stat_v(dvnode
, n_inval
);
1664 /* we clean up only if the entire page is being invalidated */
1665 if (offset
== 0 && length
== PAGE_SIZE
) {
1666 set_page_private(page
, 0);
1667 ClearPagePrivate(page
);