1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* dir.c: AFS filesystem directory handling
4 * Copyright (C) 2002, 2018 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/kernel.h>
10 #include <linux/namei.h>
11 #include <linux/pagemap.h>
12 #include <linux/swap.h>
13 #include <linux/ctype.h>
14 #include <linux/sched.h>
15 #include <linux/task_io_accounting_ops.h>
20 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
22 static int afs_dir_open(struct inode
*inode
, struct file
*file
);
23 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
);
24 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
);
25 static int afs_d_delete(const struct dentry
*dentry
);
26 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
);
27 static bool afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
28 loff_t fpos
, u64 ino
, unsigned dtype
);
29 static bool afs_lookup_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
30 loff_t fpos
, u64 ino
, unsigned dtype
);
31 static int afs_create(struct user_namespace
*mnt_userns
, struct inode
*dir
,
32 struct dentry
*dentry
, umode_t mode
, bool excl
);
33 static int afs_mkdir(struct user_namespace
*mnt_userns
, struct inode
*dir
,
34 struct dentry
*dentry
, umode_t mode
);
35 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
);
36 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
);
37 static int afs_link(struct dentry
*from
, struct inode
*dir
,
38 struct dentry
*dentry
);
39 static int afs_symlink(struct user_namespace
*mnt_userns
, struct inode
*dir
,
40 struct dentry
*dentry
, const char *content
);
41 static int afs_rename(struct user_namespace
*mnt_userns
, struct inode
*old_dir
,
42 struct dentry
*old_dentry
, struct inode
*new_dir
,
43 struct dentry
*new_dentry
, unsigned int flags
);
44 static bool afs_dir_release_folio(struct folio
*folio
, gfp_t gfp_flags
);
45 static void afs_dir_invalidate_folio(struct folio
*folio
, size_t offset
,
48 static bool afs_dir_dirty_folio(struct address_space
*mapping
,
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
,
76 const struct address_space_operations afs_dir_aops
= {
77 .dirty_folio
= afs_dir_dirty_folio
,
78 .release_folio
= afs_dir_release_folio
,
79 .invalidate_folio
= afs_dir_invalidate_folio
,
82 const struct dentry_operations afs_fs_dentry_operations
= {
83 .d_revalidate
= afs_d_revalidate
,
84 .d_delete
= afs_d_delete
,
85 .d_release
= afs_d_release
,
86 .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_fid fids
[50];
107 * Drop the refs that we're holding on the folios we were reading into. We've
108 * got refs on the first nr_pages pages.
110 static void afs_dir_read_cleanup(struct afs_read
*req
)
112 struct address_space
*mapping
= req
->vnode
->netfs
.inode
.i_mapping
;
114 pgoff_t last
= req
->nr_pages
- 1;
116 XA_STATE(xas
, &mapping
->i_pages
, 0);
118 if (unlikely(!req
->nr_pages
))
122 xas_for_each(&xas
, folio
, last
) {
123 if (xas_retry(&xas
, folio
))
125 BUG_ON(xa_is_value(folio
));
126 ASSERTCMP(folio_file_mapping(folio
), ==, mapping
);
135 * check that a directory folio is valid
137 static bool afs_dir_check_folio(struct afs_vnode
*dvnode
, struct folio
*folio
,
140 union afs_xdr_dir_block
*block
;
144 /* Determine how many magic numbers there should be in this folio, but
145 * we must take care because the directory may change size under us.
147 pos
= folio_pos(folio
);
151 size
= min_t(loff_t
, folio_size(folio
), i_size
- pos
);
152 for (offset
= 0; offset
< size
; offset
+= sizeof(*block
)) {
153 block
= kmap_local_folio(folio
, offset
);
154 if (block
->hdr
.magic
!= AFS_DIR_MAGIC
) {
155 printk("kAFS: %s(%lx): [%llx] bad magic %zx/%zx is %04hx\n",
156 __func__
, dvnode
->netfs
.inode
.i_ino
,
157 pos
, offset
, size
, ntohs(block
->hdr
.magic
));
158 trace_afs_dir_check_failed(dvnode
, pos
+ offset
, i_size
);
160 trace_afs_file_error(dvnode
, -EIO
, afs_file_error_dir_bad_magic
);
164 /* Make sure each block is NUL terminated so we can reasonably
165 * use string functions on it. The filenames in the folio
166 * *should* be NUL-terminated anyway.
168 ((u8
*)block
)[AFS_DIR_BLOCK_SIZE
- 1] = 0;
173 afs_stat_v(dvnode
, n_read_dir
);
181 * Dump the contents of a directory.
183 static void afs_dir_dump(struct afs_vnode
*dvnode
, struct afs_read
*req
)
185 union afs_xdr_dir_block
*block
;
186 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
188 pgoff_t last
= req
->nr_pages
- 1;
191 XA_STATE(xas
, &mapping
->i_pages
, 0);
193 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx\n",
194 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
195 req
->file_size
, req
->len
, req
->actual_len
);
196 pr_warn("DIR %llx %x %zx %zx\n",
197 req
->pos
, req
->nr_pages
,
198 req
->iter
->iov_offset
, iov_iter_count(req
->iter
));
200 xas_for_each(&xas
, folio
, last
) {
201 if (xas_retry(&xas
, folio
))
204 BUG_ON(folio_file_mapping(folio
) != mapping
);
206 size
= min_t(loff_t
, folio_size(folio
), req
->actual_len
- folio_pos(folio
));
207 for (offset
= 0; offset
< size
; offset
+= sizeof(*block
)) {
208 block
= kmap_local_folio(folio
, offset
);
209 pr_warn("[%02lx] %32phN\n", folio_index(folio
) + offset
, block
);
216 * Check all the blocks in a directory. All the folios are held pinned.
218 static int afs_dir_check(struct afs_vnode
*dvnode
, struct afs_read
*req
)
220 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
222 pgoff_t last
= req
->nr_pages
- 1;
225 XA_STATE(xas
, &mapping
->i_pages
, 0);
227 if (unlikely(!req
->nr_pages
))
231 xas_for_each(&xas
, folio
, last
) {
232 if (xas_retry(&xas
, folio
))
235 BUG_ON(folio_file_mapping(folio
) != mapping
);
237 if (!afs_dir_check_folio(dvnode
, folio
, req
->actual_len
)) {
238 afs_dir_dump(dvnode
, req
);
249 * open an AFS directory file
251 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
253 _enter("{%lu}", inode
->i_ino
);
255 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
256 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
258 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
261 return afs_open(inode
, file
);
265 * Read the directory into the pagecache in one go, scrubbing the previous
266 * contents. The list of folios is returned, pinning them so that they don't
267 * get reclaimed during the iteration.
269 static struct afs_read
*afs_read_dir(struct afs_vnode
*dvnode
, struct key
*key
)
270 __acquires(&dvnode
->validate_lock
)
272 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
273 struct afs_read
*req
;
280 req
= kzalloc(sizeof(*req
), GFP_KERNEL
);
282 return ERR_PTR(-ENOMEM
);
284 refcount_set(&req
->usage
, 1);
286 req
->key
= key_get(key
);
287 req
->cleanup
= afs_dir_read_cleanup
;
290 i_size
= i_size_read(&dvnode
->netfs
.inode
);
292 ret
= afs_bad(dvnode
, afs_file_error_dir_small
);
295 if (i_size
> 2048 * 1024) {
296 trace_afs_file_error(dvnode
, -EFBIG
, afs_file_error_dir_big
);
301 _enter("%llu", i_size
);
303 nr_pages
= (i_size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
305 req
->actual_len
= i_size
; /* May change */
306 req
->len
= nr_pages
* PAGE_SIZE
; /* We can ask for more than there is */
307 req
->data_version
= dvnode
->status
.data_version
; /* May change */
308 iov_iter_xarray(&req
->def_iter
, ITER_DEST
, &dvnode
->netfs
.inode
.i_mapping
->i_pages
,
310 req
->iter
= &req
->def_iter
;
312 /* Fill in any gaps that we might find where the memory reclaimer has
313 * been at work and pin all the folios. If there are any gaps, we will
314 * need to reread the entire directory contents.
317 while (i
< nr_pages
) {
320 folio
= filemap_get_folio(mapping
, i
);
322 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
323 afs_stat_v(dvnode
, n_inval
);
326 folio
= __filemap_get_folio(mapping
,
327 i
, FGP_LOCK
| FGP_CREAT
,
331 folio_attach_private(folio
, (void *)1);
335 req
->nr_pages
+= folio_nr_pages(folio
);
336 i
+= folio_nr_pages(folio
);
339 /* If we're going to reload, we need to lock all the pages to prevent
343 if (down_read_killable(&dvnode
->validate_lock
) < 0)
346 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
349 up_read(&dvnode
->validate_lock
);
350 if (down_write_killable(&dvnode
->validate_lock
) < 0)
353 if (!test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
354 trace_afs_reload_dir(dvnode
);
355 ret
= afs_fetch_data(dvnode
, req
);
359 task_io_account_read(PAGE_SIZE
* req
->nr_pages
);
361 if (req
->len
< req
->file_size
) {
362 /* The content has grown, so we need to expand the
365 up_write(&dvnode
->validate_lock
);
369 /* Validate the data we just read. */
370 ret
= afs_dir_check(dvnode
, req
);
374 // TODO: Trim excess pages
376 set_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
);
379 downgrade_write(&dvnode
->validate_lock
);
384 up_write(&dvnode
->validate_lock
);
387 _leave(" = %d", ret
);
392 * deal with one block in an AFS directory
394 static int afs_dir_iterate_block(struct afs_vnode
*dvnode
,
395 struct dir_context
*ctx
,
396 union afs_xdr_dir_block
*block
,
399 union afs_xdr_dirent
*dire
;
400 unsigned offset
, next
, curr
, nr_slots
;
404 _enter("%llx,%x", ctx
->pos
, blkoff
);
406 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_xdr_dirent
);
408 /* walk through the block, an entry at a time */
409 for (offset
= (blkoff
== 0 ? AFS_DIR_RESV_BLOCKS0
: AFS_DIR_RESV_BLOCKS
);
410 offset
< AFS_DIR_SLOTS_PER_BLOCK
;
413 /* skip entries marked unused in the bitmap */
414 if (!(block
->hdr
.bitmap
[offset
/ 8] &
415 (1 << (offset
% 8)))) {
416 _debug("ENT[%zu.%u]: unused",
417 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
);
421 next
* sizeof(union afs_xdr_dirent
);
425 /* got a valid entry */
426 dire
= &block
->dirents
[offset
];
427 nlen
= strnlen(dire
->u
.name
,
429 offset
* sizeof(union afs_xdr_dirent
));
430 if (nlen
> AFSNAMEMAX
- 1) {
431 _debug("ENT[%zu]: name too long (len %u/%zu)",
432 blkoff
/ sizeof(union afs_xdr_dir_block
),
434 return afs_bad(dvnode
, afs_file_error_dir_name_too_long
);
437 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
438 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
,
439 (offset
< curr
? "skip" : "fill"),
442 nr_slots
= afs_dir_calc_slots(nlen
);
443 next
= offset
+ nr_slots
;
444 if (next
> AFS_DIR_SLOTS_PER_BLOCK
) {
445 _debug("ENT[%zu.%u]:"
446 " %u extends beyond end dir block"
448 blkoff
/ sizeof(union afs_xdr_dir_block
),
450 return afs_bad(dvnode
, afs_file_error_dir_over_end
);
453 /* Check that the name-extension dirents are all allocated */
454 for (tmp
= 1; tmp
< nr_slots
; tmp
++) {
455 unsigned int ix
= offset
+ tmp
;
456 if (!(block
->hdr
.bitmap
[ix
/ 8] & (1 << (ix
% 8)))) {
458 " %u unmarked extension (%u/%u)",
459 blkoff
/ sizeof(union afs_xdr_dir_block
),
460 offset
, tmp
, nr_slots
);
461 return afs_bad(dvnode
, afs_file_error_dir_unmarked_ext
);
465 /* skip if starts before the current position */
468 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
472 /* found the next entry */
473 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
474 ntohl(dire
->u
.vnode
),
475 (ctx
->actor
== afs_lookup_filldir
||
476 ctx
->actor
== afs_lookup_one_filldir
)?
477 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
478 _leave(" = 0 [full]");
482 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
485 _leave(" = 1 [more]");
490 * iterate through the data blob that lists the contents of an AFS directory
492 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
493 struct key
*key
, afs_dataversion_t
*_dir_version
)
495 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
496 union afs_xdr_dir_block
*dblock
;
497 struct afs_read
*req
;
499 unsigned offset
, size
;
502 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
504 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
505 _leave(" = -ESTALE");
509 req
= afs_read_dir(dvnode
, key
);
512 *_dir_version
= req
->data_version
;
514 /* round the file position up to the next entry boundary */
515 ctx
->pos
+= sizeof(union afs_xdr_dirent
) - 1;
516 ctx
->pos
&= ~(sizeof(union afs_xdr_dirent
) - 1);
518 /* walk through the blocks in sequence */
520 while (ctx
->pos
< req
->actual_len
) {
521 /* Fetch the appropriate folio from the directory and re-add it
522 * to the LRU. We have all the pages pinned with an extra ref.
524 folio
= __filemap_get_folio(dir
->i_mapping
, ctx
->pos
/ PAGE_SIZE
,
527 ret
= afs_bad(dvnode
, afs_file_error_dir_missing_page
);
531 offset
= round_down(ctx
->pos
, sizeof(*dblock
)) - folio_file_pos(folio
);
532 size
= min_t(loff_t
, folio_size(folio
),
533 req
->actual_len
- folio_file_pos(folio
));
536 dblock
= kmap_local_folio(folio
, offset
);
537 ret
= afs_dir_iterate_block(dvnode
, ctx
, dblock
,
538 folio_file_pos(folio
) + offset
);
539 kunmap_local(dblock
);
543 } while (offset
+= sizeof(*dblock
), offset
< size
);
549 up_read(&dvnode
->validate_lock
);
551 _leave(" = %d", ret
);
556 * read an AFS directory
558 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
560 afs_dataversion_t dir_version
;
562 return afs_dir_iterate(file_inode(file
), ctx
, afs_file_key(file
),
567 * Search the directory for a single name
568 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
569 * uniquifier through dtype
571 static bool afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
,
572 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
574 struct afs_lookup_one_cookie
*cookie
=
575 container_of(ctx
, struct afs_lookup_one_cookie
, ctx
);
577 _enter("{%s,%u},%s,%u,,%llu,%u",
578 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
579 (unsigned long long) ino
, dtype
);
581 /* insanity checks first */
582 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
583 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
585 if (cookie
->name
.len
!= nlen
||
586 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
587 _leave(" = true [keep looking]");
591 cookie
->fid
.vnode
= ino
;
592 cookie
->fid
.unique
= dtype
;
595 _leave(" = false [found]");
600 * Do a lookup of a single name in a directory
601 * - just returns the FID the dentry name maps to if found
603 static int afs_do_lookup_one(struct inode
*dir
, struct dentry
*dentry
,
604 struct afs_fid
*fid
, struct key
*key
,
605 afs_dataversion_t
*_dir_version
)
607 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
608 struct afs_lookup_one_cookie cookie
= {
609 .ctx
.actor
= afs_lookup_one_filldir
,
610 .name
= dentry
->d_name
,
611 .fid
.vid
= as
->volume
->vid
615 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
617 /* search the directory */
618 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
, _dir_version
);
620 _leave(" = %d [iter]", ret
);
625 _leave(" = -ENOENT [not found]");
630 _leave(" = 0 { vn=%llu u=%u }", fid
->vnode
, fid
->unique
);
635 * search the directory for a name
636 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
637 * uniquifier through dtype
639 static bool afs_lookup_filldir(struct dir_context
*ctx
, const char *name
,
640 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
642 struct afs_lookup_cookie
*cookie
=
643 container_of(ctx
, struct afs_lookup_cookie
, ctx
);
645 _enter("{%s,%u},%s,%u,,%llu,%u",
646 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
647 (unsigned long long) ino
, dtype
);
649 /* insanity checks first */
650 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
651 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
654 if (cookie
->nr_fids
< 50) {
655 cookie
->fids
[cookie
->nr_fids
].vnode
= ino
;
656 cookie
->fids
[cookie
->nr_fids
].unique
= dtype
;
659 } else if (cookie
->name
.len
== nlen
&&
660 memcmp(cookie
->name
.name
, name
, nlen
) == 0) {
661 cookie
->fids
[1].vnode
= ino
;
662 cookie
->fids
[1].unique
= dtype
;
664 if (cookie
->one_only
)
668 return cookie
->nr_fids
< 50;
672 * Deal with the result of a successful lookup operation. Turn all the files
673 * into inodes and save the first one - which is the one we actually want.
675 static void afs_do_lookup_success(struct afs_operation
*op
)
677 struct afs_vnode_param
*vp
;
678 struct afs_vnode
*vnode
;
685 for (i
= 0; i
< op
->nr_files
; i
++) {
689 abort_code
= vp
->scb
.status
.abort_code
;
690 if (abort_code
!= 0) {
691 op
->ac
.abort_code
= abort_code
;
692 op
->error
= afs_abort_to_error(abort_code
);
701 vp
= &op
->more_files
[i
- 2];
705 if (!vp
->scb
.have_status
&& !vp
->scb
.have_error
)
708 _debug("do [%u]", i
);
710 if (!test_bit(AFS_VNODE_UNSET
, &vp
->vnode
->flags
))
711 afs_vnode_commit_status(op
, vp
);
712 } else if (vp
->scb
.status
.abort_code
== 0) {
713 inode
= afs_iget(op
, vp
);
714 if (!IS_ERR(inode
)) {
715 vnode
= AFS_FS_I(inode
);
716 afs_cache_permit(vnode
, op
->key
,
717 0 /* Assume vnode->cb_break is 0 */ +
721 vp
->put_vnode
= true;
724 _debug("- abort %d %llx:%llx.%x",
725 vp
->scb
.status
.abort_code
,
726 vp
->fid
.vid
, vp
->fid
.vnode
, vp
->fid
.unique
);
733 static const struct afs_operation_ops afs_inline_bulk_status_operation
= {
734 .issue_afs_rpc
= afs_fs_inline_bulk_status
,
735 .issue_yfs_rpc
= yfs_fs_inline_bulk_status
,
736 .success
= afs_do_lookup_success
,
739 static const struct afs_operation_ops afs_lookup_fetch_status_operation
= {
740 .issue_afs_rpc
= afs_fs_fetch_status
,
741 .issue_yfs_rpc
= yfs_fs_fetch_status
,
742 .success
= afs_do_lookup_success
,
743 .aborted
= afs_check_for_remote_deletion
,
747 * See if we know that the server we expect to use doesn't support
748 * FS.InlineBulkStatus.
750 static bool afs_server_supports_ibulk(struct afs_vnode
*dvnode
)
752 struct afs_server_list
*slist
;
753 struct afs_volume
*volume
= dvnode
->volume
;
754 struct afs_server
*server
;
758 if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK
, &volume
->flags
))
762 slist
= rcu_dereference(volume
->servers
);
764 for (i
= 0; i
< slist
->nr_servers
; i
++) {
765 server
= slist
->servers
[i
].server
;
766 if (server
== dvnode
->cb_server
) {
767 if (test_bit(AFS_SERVER_FL_NO_IBULK
, &server
->flags
))
778 * Do a lookup in a directory. We make use of bulk lookup to query a slew of
779 * files in one go and create inodes for them. The inode of the file we were
780 * asked for is returned.
782 static struct inode
*afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
785 struct afs_lookup_cookie
*cookie
;
786 struct afs_vnode_param
*vp
;
787 struct afs_operation
*op
;
788 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
;
789 struct inode
*inode
= NULL
, *ti
;
790 afs_dataversion_t data_version
= READ_ONCE(dvnode
->status
.data_version
);
794 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
796 cookie
= kzalloc(sizeof(struct afs_lookup_cookie
), GFP_KERNEL
);
798 return ERR_PTR(-ENOMEM
);
800 for (i
= 0; i
< ARRAY_SIZE(cookie
->fids
); i
++)
801 cookie
->fids
[i
].vid
= dvnode
->fid
.vid
;
802 cookie
->ctx
.actor
= afs_lookup_filldir
;
803 cookie
->name
= dentry
->d_name
;
804 cookie
->nr_fids
= 2; /* slot 0 is saved for the fid we actually want
805 * and slot 1 for the directory */
807 if (!afs_server_supports_ibulk(dvnode
))
808 cookie
->one_only
= true;
810 /* search the directory */
811 ret
= afs_dir_iterate(dir
, &cookie
->ctx
, key
, &data_version
);
815 dentry
->d_fsdata
= (void *)(unsigned long)data_version
;
821 /* Check to see if we already have an inode for the primary fid. */
822 inode
= ilookup5(dir
->i_sb
, cookie
->fids
[1].vnode
,
823 afs_ilookup5_test_by_fid
, &cookie
->fids
[1]);
825 goto out
; /* We do */
827 /* Okay, we didn't find it. We need to query the server - and whilst
828 * we're doing that, we're going to attempt to look up a bunch of other
831 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
837 afs_op_set_vnode(op
, 0, dvnode
);
838 afs_op_set_fid(op
, 1, &cookie
->fids
[1]);
840 op
->nr_files
= cookie
->nr_fids
;
841 _debug("nr_files %u", op
->nr_files
);
843 /* Need space for examining all the selected files */
845 if (op
->nr_files
> 2) {
846 op
->more_files
= kvcalloc(op
->nr_files
- 2,
847 sizeof(struct afs_vnode_param
),
852 for (i
= 2; i
< op
->nr_files
; i
++) {
853 vp
= &op
->more_files
[i
- 2];
854 vp
->fid
= cookie
->fids
[i
];
856 /* Find any inodes that already exist and get their
859 ti
= ilookup5_nowait(dir
->i_sb
, vp
->fid
.vnode
,
860 afs_ilookup5_test_by_fid
, &vp
->fid
);
861 if (!IS_ERR_OR_NULL(ti
)) {
862 vnode
= AFS_FS_I(ti
);
863 vp
->dv_before
= vnode
->status
.data_version
;
864 vp
->cb_break_before
= afs_calc_vnode_cb_break(vnode
);
866 vp
->put_vnode
= true;
867 vp
->speculative
= true; /* vnode not locked */
872 /* Try FS.InlineBulkStatus first. Abort codes for the individual
873 * lookups contained therein are stored in the reply without aborting
874 * the whole operation.
876 op
->error
= -ENOTSUPP
;
877 if (!cookie
->one_only
) {
878 op
->ops
= &afs_inline_bulk_status_operation
;
879 afs_begin_vnode_operation(op
);
880 afs_wait_for_operation(op
);
883 if (op
->error
== -ENOTSUPP
) {
884 /* We could try FS.BulkStatus next, but this aborts the entire
885 * op if any of the lookups fails - so, for the moment, revert
886 * to FS.FetchStatus for op->file[1].
888 op
->fetch_status
.which
= 1;
889 op
->ops
= &afs_lookup_fetch_status_operation
;
890 afs_begin_vnode_operation(op
);
891 afs_wait_for_operation(op
);
893 inode
= ERR_PTR(op
->error
);
896 if (op
->error
== 0) {
897 inode
= &op
->file
[1].vnode
->netfs
.inode
;
898 op
->file
[1].vnode
= NULL
;
901 if (op
->file
[0].scb
.have_status
)
902 dentry
->d_fsdata
= (void *)(unsigned long)op
->file
[0].scb
.status
.data_version
;
904 dentry
->d_fsdata
= (void *)(unsigned long)op
->file
[0].dv_before
;
905 ret
= afs_put_operation(op
);
909 return inode
?: ERR_PTR(ret
);
913 * Look up an entry in a directory with @sys substitution.
915 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
918 struct afs_sysnames
*subs
;
919 struct afs_net
*net
= afs_i2net(dir
);
921 char *buf
, *p
, *name
;
926 ret
= ERR_PTR(-ENOMEM
);
927 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
930 if (dentry
->d_name
.len
> 4) {
931 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
932 p
+= dentry
->d_name
.len
- 4;
935 /* There is an ordered list of substitutes that we have to try. */
936 read_lock(&net
->sysnames_lock
);
937 subs
= net
->sysnames
;
938 refcount_inc(&subs
->usage
);
939 read_unlock(&net
->sysnames_lock
);
941 for (i
= 0; i
< subs
->nr
; i
++) {
942 name
= subs
->subs
[i
];
943 len
= dentry
->d_name
.len
- 4 + strlen(name
);
944 if (len
>= AFSNAMEMAX
) {
945 ret
= ERR_PTR(-ENAMETOOLONG
);
950 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
951 if (IS_ERR(ret
) || d_is_positive(ret
))
956 /* We don't want to d_add() the @sys dentry here as we don't want to
957 * the cached dentry to hide changes to the sysnames list.
961 afs_put_sysnames(subs
);
969 * look up an entry in a directory
971 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
974 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
975 struct afs_fid fid
= {};
981 _enter("{%llx:%llu},%p{%pd},",
982 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
984 ASSERTCMP(d_inode(dentry
), ==, NULL
);
986 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
987 _leave(" = -ENAMETOOLONG");
988 return ERR_PTR(-ENAMETOOLONG
);
991 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
992 _leave(" = -ESTALE");
993 return ERR_PTR(-ESTALE
);
996 key
= afs_request_key(dvnode
->volume
->cell
);
998 _leave(" = %ld [key]", PTR_ERR(key
));
999 return ERR_CAST(key
);
1002 ret
= afs_validate(dvnode
, key
);
1005 _leave(" = %d [val]", ret
);
1006 return ERR_PTR(ret
);
1009 if (dentry
->d_name
.len
>= 4 &&
1010 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
1011 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
1012 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
1013 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
1014 return afs_lookup_atsys(dir
, dentry
, key
);
1016 afs_stat_v(dvnode
, n_lookup
);
1017 inode
= afs_do_lookup(dir
, dentry
, key
);
1019 if (inode
== ERR_PTR(-ENOENT
))
1020 inode
= afs_try_auto_mntpt(dentry
, dir
);
1022 if (!IS_ERR_OR_NULL(inode
))
1023 fid
= AFS_FS_I(inode
)->fid
;
1025 _debug("splice %p", dentry
->d_inode
);
1026 d
= d_splice_alias(inode
, dentry
);
1027 if (!IS_ERR_OR_NULL(d
)) {
1028 d
->d_fsdata
= dentry
->d_fsdata
;
1029 trace_afs_lookup(dvnode
, &d
->d_name
, &fid
);
1031 trace_afs_lookup(dvnode
, &dentry
->d_name
, &fid
);
1038 * Check the validity of a dentry under RCU conditions.
1040 static int afs_d_revalidate_rcu(struct dentry
*dentry
)
1042 struct afs_vnode
*dvnode
;
1043 struct dentry
*parent
;
1045 long dir_version
, de_version
;
1047 _enter("%p", dentry
);
1049 /* Check the parent directory is still valid first. */
1050 parent
= READ_ONCE(dentry
->d_parent
);
1051 dir
= d_inode_rcu(parent
);
1054 dvnode
= AFS_FS_I(dir
);
1055 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
))
1058 if (!afs_check_validity(dvnode
))
1061 /* We only need to invalidate a dentry if the server's copy changed
1062 * behind our back. If we made the change, it's no problem. Note that
1063 * on a 32-bit system, we only have 32 bits in the dentry to store the
1066 dir_version
= (long)READ_ONCE(dvnode
->status
.data_version
);
1067 de_version
= (long)READ_ONCE(dentry
->d_fsdata
);
1068 if (de_version
!= dir_version
) {
1069 dir_version
= (long)READ_ONCE(dvnode
->invalid_before
);
1070 if (de_version
- dir_version
< 0)
1074 return 1; /* Still valid */
1078 * check that a dentry lookup hit has found a valid entry
1079 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
1082 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
1084 struct afs_vnode
*vnode
, *dir
;
1086 struct dentry
*parent
;
1087 struct inode
*inode
;
1089 afs_dataversion_t dir_version
, invalid_before
;
1093 if (flags
& LOOKUP_RCU
)
1094 return afs_d_revalidate_rcu(dentry
);
1096 if (d_really_is_positive(dentry
)) {
1097 vnode
= AFS_FS_I(d_inode(dentry
));
1098 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
1099 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
1102 _enter("{neg n=%pd}", dentry
);
1105 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
1109 /* Hold the parent dentry so we can peer at it */
1110 parent
= dget_parent(dentry
);
1111 dir
= AFS_FS_I(d_inode(parent
));
1113 /* validate the parent directory */
1114 afs_validate(dir
, key
);
1116 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
1117 _debug("%pd: parent dir deleted", dentry
);
1121 /* We only need to invalidate a dentry if the server's copy changed
1122 * behind our back. If we made the change, it's no problem. Note that
1123 * on a 32-bit system, we only have 32 bits in the dentry to store the
1126 dir_version
= dir
->status
.data_version
;
1127 de_version
= (long)dentry
->d_fsdata
;
1128 if (de_version
== (long)dir_version
)
1129 goto out_valid_noupdate
;
1131 invalid_before
= dir
->invalid_before
;
1132 if (de_version
- (long)invalid_before
>= 0)
1135 _debug("dir modified");
1136 afs_stat_v(dir
, n_reval
);
1138 /* search the directory for this vnode */
1139 ret
= afs_do_lookup_one(&dir
->netfs
.inode
, dentry
, &fid
, key
, &dir_version
);
1142 /* the filename maps to something */
1143 if (d_really_is_negative(dentry
))
1145 inode
= d_inode(dentry
);
1146 if (is_bad_inode(inode
)) {
1147 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1152 vnode
= AFS_FS_I(inode
);
1154 /* if the vnode ID has changed, then the dirent points to a
1156 if (fid
.vnode
!= vnode
->fid
.vnode
) {
1157 _debug("%pd: dirent changed [%llu != %llu]",
1163 /* if the vnode ID uniqifier has changed, then the file has
1164 * been deleted and replaced, and the original vnode ID has
1166 if (fid
.unique
!= vnode
->fid
.unique
) {
1167 _debug("%pd: file deleted (uq %u -> %u I:%u)",
1170 vnode
->netfs
.inode
.i_generation
);
1176 /* the filename is unknown */
1177 _debug("%pd: dirent not found", dentry
);
1178 if (d_really_is_positive(dentry
))
1183 _debug("failed to iterate dir %pd: %d",
1189 dentry
->d_fsdata
= (void *)(unsigned long)dir_version
;
1193 _leave(" = 1 [valid]");
1197 _debug("dropping dentry %pd2", dentry
);
1201 _leave(" = 0 [bad]");
1206 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1208 * - called from dput() when d_count is going to 0.
1209 * - return 1 to request dentry be unhashed, 0 otherwise
1211 static int afs_d_delete(const struct dentry
*dentry
)
1213 _enter("%pd", dentry
);
1215 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1218 if (d_really_is_positive(dentry
) &&
1219 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1220 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1223 _leave(" = 0 [keep]");
1227 _leave(" = 1 [zap]");
1232 * Clean up sillyrename files on dentry removal.
1234 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
)
1236 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1237 afs_silly_iput(dentry
, inode
);
1242 * handle dentry release
1244 void afs_d_release(struct dentry
*dentry
)
1246 _enter("%pd", dentry
);
1249 void afs_check_for_remote_deletion(struct afs_operation
*op
)
1251 struct afs_vnode
*vnode
= op
->file
[0].vnode
;
1253 switch (op
->ac
.abort_code
) {
1255 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1256 afs_break_callback(vnode
, afs_cb_break_for_deleted
);
1261 * Create a new inode for create/mkdir/symlink
1263 static void afs_vnode_new_inode(struct afs_operation
*op
)
1265 struct afs_vnode_param
*vp
= &op
->file
[1];
1266 struct afs_vnode
*vnode
;
1267 struct inode
*inode
;
1271 ASSERTCMP(op
->error
, ==, 0);
1273 inode
= afs_iget(op
, vp
);
1274 if (IS_ERR(inode
)) {
1275 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1276 * the new directory on the server.
1278 op
->error
= PTR_ERR(inode
);
1282 vnode
= AFS_FS_I(inode
);
1283 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1285 afs_cache_permit(vnode
, op
->key
, vnode
->cb_break
, &vp
->scb
);
1286 d_instantiate(op
->dentry
, inode
);
1289 static void afs_create_success(struct afs_operation
*op
)
1291 _enter("op=%08x", op
->debug_id
);
1292 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1293 afs_vnode_commit_status(op
, &op
->file
[0]);
1294 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1295 afs_vnode_new_inode(op
);
1298 static void afs_create_edit_dir(struct afs_operation
*op
)
1300 struct afs_vnode_param
*dvp
= &op
->file
[0];
1301 struct afs_vnode_param
*vp
= &op
->file
[1];
1302 struct afs_vnode
*dvnode
= dvp
->vnode
;
1304 _enter("op=%08x", op
->debug_id
);
1306 down_write(&dvnode
->validate_lock
);
1307 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1308 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1309 afs_edit_dir_add(dvnode
, &op
->dentry
->d_name
, &vp
->fid
,
1311 up_write(&dvnode
->validate_lock
);
1314 static void afs_create_put(struct afs_operation
*op
)
1316 _enter("op=%08x", op
->debug_id
);
1322 static const struct afs_operation_ops afs_mkdir_operation
= {
1323 .issue_afs_rpc
= afs_fs_make_dir
,
1324 .issue_yfs_rpc
= yfs_fs_make_dir
,
1325 .success
= afs_create_success
,
1326 .aborted
= afs_check_for_remote_deletion
,
1327 .edit_dir
= afs_create_edit_dir
,
1328 .put
= afs_create_put
,
1332 * create a directory on an AFS filesystem
1334 static int afs_mkdir(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1335 struct dentry
*dentry
, umode_t mode
)
1337 struct afs_operation
*op
;
1338 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1340 _enter("{%llx:%llu},{%pd},%ho",
1341 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1343 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1349 afs_op_set_vnode(op
, 0, dvnode
);
1350 op
->file
[0].dv_delta
= 1;
1351 op
->file
[0].modification
= true;
1352 op
->file
[0].update_ctime
= true;
1353 op
->dentry
= dentry
;
1354 op
->create
.mode
= S_IFDIR
| mode
;
1355 op
->create
.reason
= afs_edit_dir_for_mkdir
;
1356 op
->ops
= &afs_mkdir_operation
;
1357 return afs_do_sync_operation(op
);
1361 * Remove a subdir from a directory.
1363 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1365 if (d_really_is_positive(dentry
)) {
1366 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1368 clear_nlink(&vnode
->netfs
.inode
);
1369 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1370 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1371 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1375 static void afs_rmdir_success(struct afs_operation
*op
)
1377 _enter("op=%08x", op
->debug_id
);
1378 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1379 afs_vnode_commit_status(op
, &op
->file
[0]);
1380 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1383 static void afs_rmdir_edit_dir(struct afs_operation
*op
)
1385 struct afs_vnode_param
*dvp
= &op
->file
[0];
1386 struct afs_vnode
*dvnode
= dvp
->vnode
;
1388 _enter("op=%08x", op
->debug_id
);
1389 afs_dir_remove_subdir(op
->dentry
);
1391 down_write(&dvnode
->validate_lock
);
1392 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1393 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1394 afs_edit_dir_remove(dvnode
, &op
->dentry
->d_name
,
1395 afs_edit_dir_for_rmdir
);
1396 up_write(&dvnode
->validate_lock
);
1399 static void afs_rmdir_put(struct afs_operation
*op
)
1401 _enter("op=%08x", op
->debug_id
);
1402 if (op
->file
[1].vnode
)
1403 up_write(&op
->file
[1].vnode
->rmdir_lock
);
1406 static const struct afs_operation_ops afs_rmdir_operation
= {
1407 .issue_afs_rpc
= afs_fs_remove_dir
,
1408 .issue_yfs_rpc
= yfs_fs_remove_dir
,
1409 .success
= afs_rmdir_success
,
1410 .aborted
= afs_check_for_remote_deletion
,
1411 .edit_dir
= afs_rmdir_edit_dir
,
1412 .put
= afs_rmdir_put
,
1416 * remove a directory from an AFS filesystem
1418 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1420 struct afs_operation
*op
;
1421 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1424 _enter("{%llx:%llu},{%pd}",
1425 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1427 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1431 afs_op_set_vnode(op
, 0, dvnode
);
1432 op
->file
[0].dv_delta
= 1;
1433 op
->file
[0].modification
= true;
1434 op
->file
[0].update_ctime
= true;
1436 op
->dentry
= dentry
;
1437 op
->ops
= &afs_rmdir_operation
;
1439 /* Try to make sure we have a callback promise on the victim. */
1440 if (d_really_is_positive(dentry
)) {
1441 vnode
= AFS_FS_I(d_inode(dentry
));
1442 ret
= afs_validate(vnode
, op
->key
);
1448 ret
= down_write_killable(&vnode
->rmdir_lock
);
1451 op
->file
[1].vnode
= vnode
;
1454 return afs_do_sync_operation(op
);
1457 return afs_put_operation(op
);
1461 * Remove a link to a file or symlink from a directory.
1463 * If the file was not deleted due to excess hard links, the fileserver will
1464 * break the callback promise on the file - if it had one - before it returns
1465 * to us, and if it was deleted, it won't
1467 * However, if we didn't have a callback promise outstanding, or it was
1468 * outstanding on a different server, then it won't break it either...
1470 static void afs_dir_remove_link(struct afs_operation
*op
)
1472 struct afs_vnode
*dvnode
= op
->file
[0].vnode
;
1473 struct afs_vnode
*vnode
= op
->file
[1].vnode
;
1474 struct dentry
*dentry
= op
->dentry
;
1477 if (op
->error
!= 0 ||
1478 (op
->file
[1].scb
.have_status
&& op
->file
[1].scb
.have_error
))
1480 if (d_really_is_positive(dentry
))
1483 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1485 } else if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
1486 write_seqlock(&vnode
->cb_lock
);
1487 drop_nlink(&vnode
->netfs
.inode
);
1488 if (vnode
->netfs
.inode
.i_nlink
== 0) {
1489 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1490 __afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1492 write_sequnlock(&vnode
->cb_lock
);
1494 afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1496 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1497 _debug("AFS_VNODE_DELETED");
1499 ret
= afs_validate(vnode
, op
->key
);
1504 _debug("nlink %d [val %d]", vnode
->netfs
.inode
.i_nlink
, op
->error
);
1507 static void afs_unlink_success(struct afs_operation
*op
)
1509 _enter("op=%08x", op
->debug_id
);
1510 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1511 afs_check_dir_conflict(op
, &op
->file
[0]);
1512 afs_vnode_commit_status(op
, &op
->file
[0]);
1513 afs_vnode_commit_status(op
, &op
->file
[1]);
1514 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1515 afs_dir_remove_link(op
);
1518 static void afs_unlink_edit_dir(struct afs_operation
*op
)
1520 struct afs_vnode_param
*dvp
= &op
->file
[0];
1521 struct afs_vnode
*dvnode
= dvp
->vnode
;
1523 _enter("op=%08x", op
->debug_id
);
1524 down_write(&dvnode
->validate_lock
);
1525 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1526 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1527 afs_edit_dir_remove(dvnode
, &op
->dentry
->d_name
,
1528 afs_edit_dir_for_unlink
);
1529 up_write(&dvnode
->validate_lock
);
1532 static void afs_unlink_put(struct afs_operation
*op
)
1534 _enter("op=%08x", op
->debug_id
);
1535 if (op
->unlink
.need_rehash
&& op
->error
< 0 && op
->error
!= -ENOENT
)
1536 d_rehash(op
->dentry
);
1539 static const struct afs_operation_ops afs_unlink_operation
= {
1540 .issue_afs_rpc
= afs_fs_remove_file
,
1541 .issue_yfs_rpc
= yfs_fs_remove_file
,
1542 .success
= afs_unlink_success
,
1543 .aborted
= afs_check_for_remote_deletion
,
1544 .edit_dir
= afs_unlink_edit_dir
,
1545 .put
= afs_unlink_put
,
1549 * Remove a file or symlink from an AFS filesystem.
1551 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1553 struct afs_operation
*op
;
1554 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1555 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1558 _enter("{%llx:%llu},{%pd}",
1559 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1561 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1562 return -ENAMETOOLONG
;
1564 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1568 afs_op_set_vnode(op
, 0, dvnode
);
1569 op
->file
[0].dv_delta
= 1;
1570 op
->file
[0].modification
= true;
1571 op
->file
[0].update_ctime
= true;
1573 /* Try to make sure we have a callback promise on the victim. */
1574 ret
= afs_validate(vnode
, op
->key
);
1580 spin_lock(&dentry
->d_lock
);
1581 if (d_count(dentry
) > 1) {
1582 spin_unlock(&dentry
->d_lock
);
1583 /* Start asynchronous writeout of the inode */
1584 write_inode_now(d_inode(dentry
), 0);
1585 op
->error
= afs_sillyrename(dvnode
, vnode
, dentry
, op
->key
);
1588 if (!d_unhashed(dentry
)) {
1589 /* Prevent a race with RCU lookup. */
1591 op
->unlink
.need_rehash
= true;
1593 spin_unlock(&dentry
->d_lock
);
1595 op
->file
[1].vnode
= vnode
;
1596 op
->file
[1].update_ctime
= true;
1597 op
->file
[1].op_unlinked
= true;
1598 op
->dentry
= dentry
;
1599 op
->ops
= &afs_unlink_operation
;
1600 afs_begin_vnode_operation(op
);
1601 afs_wait_for_operation(op
);
1603 /* If there was a conflict with a third party, check the status of the
1606 if (op
->error
== 0 && (op
->flags
& AFS_OPERATION_DIR_CONFLICT
)) {
1607 op
->file
[1].update_ctime
= false;
1608 op
->fetch_status
.which
= 1;
1609 op
->ops
= &afs_fetch_status_operation
;
1610 afs_begin_vnode_operation(op
);
1611 afs_wait_for_operation(op
);
1614 return afs_put_operation(op
);
1617 return afs_put_operation(op
);
1620 static const struct afs_operation_ops afs_create_operation
= {
1621 .issue_afs_rpc
= afs_fs_create_file
,
1622 .issue_yfs_rpc
= yfs_fs_create_file
,
1623 .success
= afs_create_success
,
1624 .aborted
= afs_check_for_remote_deletion
,
1625 .edit_dir
= afs_create_edit_dir
,
1626 .put
= afs_create_put
,
1630 * create a regular file on an AFS filesystem
1632 static int afs_create(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1633 struct dentry
*dentry
, umode_t mode
, bool excl
)
1635 struct afs_operation
*op
;
1636 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1637 int ret
= -ENAMETOOLONG
;
1639 _enter("{%llx:%llu},{%pd},%ho",
1640 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1642 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1645 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1651 afs_op_set_vnode(op
, 0, dvnode
);
1652 op
->file
[0].dv_delta
= 1;
1653 op
->file
[0].modification
= true;
1654 op
->file
[0].update_ctime
= true;
1656 op
->dentry
= dentry
;
1657 op
->create
.mode
= S_IFREG
| mode
;
1658 op
->create
.reason
= afs_edit_dir_for_create
;
1659 op
->ops
= &afs_create_operation
;
1660 return afs_do_sync_operation(op
);
1664 _leave(" = %d", ret
);
1668 static void afs_link_success(struct afs_operation
*op
)
1670 struct afs_vnode_param
*dvp
= &op
->file
[0];
1671 struct afs_vnode_param
*vp
= &op
->file
[1];
1673 _enter("op=%08x", op
->debug_id
);
1674 op
->ctime
= dvp
->scb
.status
.mtime_client
;
1675 afs_vnode_commit_status(op
, dvp
);
1676 afs_vnode_commit_status(op
, vp
);
1677 afs_update_dentry_version(op
, dvp
, op
->dentry
);
1678 if (op
->dentry_2
->d_parent
== op
->dentry
->d_parent
)
1679 afs_update_dentry_version(op
, dvp
, op
->dentry_2
);
1680 ihold(&vp
->vnode
->netfs
.inode
);
1681 d_instantiate(op
->dentry
, &vp
->vnode
->netfs
.inode
);
1684 static void afs_link_put(struct afs_operation
*op
)
1686 _enter("op=%08x", op
->debug_id
);
1691 static const struct afs_operation_ops afs_link_operation
= {
1692 .issue_afs_rpc
= afs_fs_link
,
1693 .issue_yfs_rpc
= yfs_fs_link
,
1694 .success
= afs_link_success
,
1695 .aborted
= afs_check_for_remote_deletion
,
1696 .edit_dir
= afs_create_edit_dir
,
1697 .put
= afs_link_put
,
1701 * create a hard link between files in an AFS filesystem
1703 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1704 struct dentry
*dentry
)
1706 struct afs_operation
*op
;
1707 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1708 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(from
));
1709 int ret
= -ENAMETOOLONG
;
1711 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1712 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1713 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1716 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1719 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1725 ret
= afs_validate(vnode
, op
->key
);
1729 afs_op_set_vnode(op
, 0, dvnode
);
1730 afs_op_set_vnode(op
, 1, vnode
);
1731 op
->file
[0].dv_delta
= 1;
1732 op
->file
[0].modification
= true;
1733 op
->file
[0].update_ctime
= true;
1734 op
->file
[1].update_ctime
= true;
1736 op
->dentry
= dentry
;
1737 op
->dentry_2
= from
;
1738 op
->ops
= &afs_link_operation
;
1739 op
->create
.reason
= afs_edit_dir_for_link
;
1740 return afs_do_sync_operation(op
);
1743 afs_put_operation(op
);
1746 _leave(" = %d", ret
);
1750 static const struct afs_operation_ops afs_symlink_operation
= {
1751 .issue_afs_rpc
= afs_fs_symlink
,
1752 .issue_yfs_rpc
= yfs_fs_symlink
,
1753 .success
= afs_create_success
,
1754 .aborted
= afs_check_for_remote_deletion
,
1755 .edit_dir
= afs_create_edit_dir
,
1756 .put
= afs_create_put
,
1760 * create a symlink in an AFS filesystem
1762 static int afs_symlink(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1763 struct dentry
*dentry
, const char *content
)
1765 struct afs_operation
*op
;
1766 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1769 _enter("{%llx:%llu},{%pd},%s",
1770 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1773 ret
= -ENAMETOOLONG
;
1774 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1778 if (strlen(content
) >= AFSPATHMAX
)
1781 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1787 afs_op_set_vnode(op
, 0, dvnode
);
1788 op
->file
[0].dv_delta
= 1;
1790 op
->dentry
= dentry
;
1791 op
->ops
= &afs_symlink_operation
;
1792 op
->create
.reason
= afs_edit_dir_for_symlink
;
1793 op
->create
.symlink
= content
;
1794 return afs_do_sync_operation(op
);
1798 _leave(" = %d", ret
);
1802 static void afs_rename_success(struct afs_operation
*op
)
1804 _enter("op=%08x", op
->debug_id
);
1806 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1807 afs_check_dir_conflict(op
, &op
->file
[1]);
1808 afs_vnode_commit_status(op
, &op
->file
[0]);
1809 if (op
->file
[1].vnode
!= op
->file
[0].vnode
) {
1810 op
->ctime
= op
->file
[1].scb
.status
.mtime_client
;
1811 afs_vnode_commit_status(op
, &op
->file
[1]);
1815 static void afs_rename_edit_dir(struct afs_operation
*op
)
1817 struct afs_vnode_param
*orig_dvp
= &op
->file
[0];
1818 struct afs_vnode_param
*new_dvp
= &op
->file
[1];
1819 struct afs_vnode
*orig_dvnode
= orig_dvp
->vnode
;
1820 struct afs_vnode
*new_dvnode
= new_dvp
->vnode
;
1821 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(op
->dentry
));
1822 struct dentry
*old_dentry
= op
->dentry
;
1823 struct dentry
*new_dentry
= op
->dentry_2
;
1824 struct inode
*new_inode
;
1826 _enter("op=%08x", op
->debug_id
);
1828 if (op
->rename
.rehash
) {
1829 d_rehash(op
->rename
.rehash
);
1830 op
->rename
.rehash
= NULL
;
1833 down_write(&orig_dvnode
->validate_lock
);
1834 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
) &&
1835 orig_dvnode
->status
.data_version
== orig_dvp
->dv_before
+ orig_dvp
->dv_delta
)
1836 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1837 afs_edit_dir_for_rename_0
);
1839 if (new_dvnode
!= orig_dvnode
) {
1840 up_write(&orig_dvnode
->validate_lock
);
1841 down_write(&new_dvnode
->validate_lock
);
1844 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
) &&
1845 new_dvnode
->status
.data_version
== new_dvp
->dv_before
+ new_dvp
->dv_delta
) {
1846 if (!op
->rename
.new_negative
)
1847 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1848 afs_edit_dir_for_rename_1
);
1850 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1851 &vnode
->fid
, afs_edit_dir_for_rename_2
);
1854 new_inode
= d_inode(new_dentry
);
1856 spin_lock(&new_inode
->i_lock
);
1857 if (S_ISDIR(new_inode
->i_mode
))
1858 clear_nlink(new_inode
);
1859 else if (new_inode
->i_nlink
> 0)
1860 drop_nlink(new_inode
);
1861 spin_unlock(&new_inode
->i_lock
);
1864 /* Now we can update d_fsdata on the dentries to reflect their
1865 * new parent's data_version.
1867 * Note that if we ever implement RENAME_EXCHANGE, we'll have
1868 * to update both dentries with opposing dir versions.
1870 afs_update_dentry_version(op
, new_dvp
, op
->dentry
);
1871 afs_update_dentry_version(op
, new_dvp
, op
->dentry_2
);
1873 d_move(old_dentry
, new_dentry
);
1875 up_write(&new_dvnode
->validate_lock
);
1878 static void afs_rename_put(struct afs_operation
*op
)
1880 _enter("op=%08x", op
->debug_id
);
1881 if (op
->rename
.rehash
)
1882 d_rehash(op
->rename
.rehash
);
1883 dput(op
->rename
.tmp
);
1885 d_rehash(op
->dentry
);
1888 static const struct afs_operation_ops afs_rename_operation
= {
1889 .issue_afs_rpc
= afs_fs_rename
,
1890 .issue_yfs_rpc
= yfs_fs_rename
,
1891 .success
= afs_rename_success
,
1892 .edit_dir
= afs_rename_edit_dir
,
1893 .put
= afs_rename_put
,
1897 * rename a file in an AFS filesystem and/or move it between directories
1899 static int afs_rename(struct user_namespace
*mnt_userns
, struct inode
*old_dir
,
1900 struct dentry
*old_dentry
, struct inode
*new_dir
,
1901 struct dentry
*new_dentry
, unsigned int flags
)
1903 struct afs_operation
*op
;
1904 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1910 /* Don't allow silly-rename files be moved around. */
1911 if (old_dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1914 vnode
= AFS_FS_I(d_inode(old_dentry
));
1915 orig_dvnode
= AFS_FS_I(old_dir
);
1916 new_dvnode
= AFS_FS_I(new_dir
);
1918 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1919 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1920 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1921 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1924 op
= afs_alloc_operation(NULL
, orig_dvnode
->volume
);
1928 ret
= afs_validate(vnode
, op
->key
);
1933 afs_op_set_vnode(op
, 0, orig_dvnode
);
1934 afs_op_set_vnode(op
, 1, new_dvnode
); /* May be same as orig_dvnode */
1935 op
->file
[0].dv_delta
= 1;
1936 op
->file
[1].dv_delta
= 1;
1937 op
->file
[0].modification
= true;
1938 op
->file
[1].modification
= true;
1939 op
->file
[0].update_ctime
= true;
1940 op
->file
[1].update_ctime
= true;
1942 op
->dentry
= old_dentry
;
1943 op
->dentry_2
= new_dentry
;
1944 op
->rename
.new_negative
= d_is_negative(new_dentry
);
1945 op
->ops
= &afs_rename_operation
;
1947 /* For non-directories, check whether the target is busy and if so,
1948 * make a copy of the dentry and then do a silly-rename. If the
1949 * silly-rename succeeds, the copied dentry is hashed and becomes the
1952 if (d_is_positive(new_dentry
) && !d_is_dir(new_dentry
)) {
1953 /* To prevent any new references to the target during the
1954 * rename, we unhash the dentry in advance.
1956 if (!d_unhashed(new_dentry
)) {
1958 op
->rename
.rehash
= new_dentry
;
1961 if (d_count(new_dentry
) > 2) {
1962 /* copy the target dentry's name */
1963 op
->rename
.tmp
= d_alloc(new_dentry
->d_parent
,
1964 &new_dentry
->d_name
);
1965 if (!op
->rename
.tmp
) {
1966 op
->error
= -ENOMEM
;
1970 ret
= afs_sillyrename(new_dvnode
,
1971 AFS_FS_I(d_inode(new_dentry
)),
1972 new_dentry
, op
->key
);
1978 op
->dentry_2
= op
->rename
.tmp
;
1979 op
->rename
.rehash
= NULL
;
1980 op
->rename
.new_negative
= true;
1984 /* This bit is potentially nasty as there's a potential race with
1985 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
1986 * to reflect it's new parent's new data_version after the op, but
1987 * d_revalidate may see old_dentry between the op having taken place
1988 * and the version being updated.
1990 * So drop the old_dentry for now to make other threads go through
1991 * lookup instead - which we hold a lock against.
1995 return afs_do_sync_operation(op
);
1998 return afs_put_operation(op
);
2002 * Release a directory folio and clean up its private state if it's not busy
2003 * - return true if the folio can now be released, false if not
2005 static bool afs_dir_release_folio(struct folio
*folio
, gfp_t gfp_flags
)
2007 struct afs_vnode
*dvnode
= AFS_FS_I(folio_inode(folio
));
2009 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, folio_index(folio
));
2011 folio_detach_private(folio
);
2013 /* The directory will need reloading. */
2014 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2015 afs_stat_v(dvnode
, n_relpg
);
2020 * Invalidate part or all of a folio.
2022 static void afs_dir_invalidate_folio(struct folio
*folio
, size_t offset
,
2025 struct afs_vnode
*dvnode
= AFS_FS_I(folio_inode(folio
));
2027 _enter("{%lu},%zu,%zu", folio
->index
, offset
, length
);
2029 BUG_ON(!folio_test_locked(folio
));
2031 /* The directory will need reloading. */
2032 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2033 afs_stat_v(dvnode
, n_inval
);
2035 /* we clean up only if the entire folio is being invalidated */
2036 if (offset
== 0 && length
== folio_size(folio
))
2037 folio_detach_private(folio
);