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
,
80 .migrate_folio
= filemap_migrate_folio
,
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
,
91 struct afs_lookup_one_cookie
{
92 struct dir_context ctx
;
98 struct afs_lookup_cookie
{
99 struct dir_context ctx
;
103 unsigned short nr_fids
;
104 struct afs_fid fids
[50];
108 * Drop the refs that we're holding on the folios we were reading into. We've
109 * got refs on the first nr_pages pages.
111 static void afs_dir_read_cleanup(struct afs_read
*req
)
113 struct address_space
*mapping
= req
->vnode
->netfs
.inode
.i_mapping
;
115 pgoff_t last
= req
->nr_pages
- 1;
117 XA_STATE(xas
, &mapping
->i_pages
, 0);
119 if (unlikely(!req
->nr_pages
))
123 xas_for_each(&xas
, folio
, last
) {
124 if (xas_retry(&xas
, folio
))
126 BUG_ON(xa_is_value(folio
));
127 ASSERTCMP(folio_file_mapping(folio
), ==, mapping
);
136 * check that a directory folio is valid
138 static bool afs_dir_check_folio(struct afs_vnode
*dvnode
, struct folio
*folio
,
141 union afs_xdr_dir_block
*block
;
145 /* Determine how many magic numbers there should be in this folio, but
146 * we must take care because the directory may change size under us.
148 pos
= folio_pos(folio
);
152 size
= min_t(loff_t
, folio_size(folio
), i_size
- pos
);
153 for (offset
= 0; offset
< size
; offset
+= sizeof(*block
)) {
154 block
= kmap_local_folio(folio
, offset
);
155 if (block
->hdr
.magic
!= AFS_DIR_MAGIC
) {
156 printk("kAFS: %s(%lx): [%llx] bad magic %zx/%zx is %04hx\n",
157 __func__
, dvnode
->netfs
.inode
.i_ino
,
158 pos
, offset
, size
, ntohs(block
->hdr
.magic
));
159 trace_afs_dir_check_failed(dvnode
, pos
+ offset
, i_size
);
161 trace_afs_file_error(dvnode
, -EIO
, afs_file_error_dir_bad_magic
);
165 /* Make sure each block is NUL terminated so we can reasonably
166 * use string functions on it. The filenames in the folio
167 * *should* be NUL-terminated anyway.
169 ((u8
*)block
)[AFS_DIR_BLOCK_SIZE
- 1] = 0;
174 afs_stat_v(dvnode
, n_read_dir
);
182 * Dump the contents of a directory.
184 static void afs_dir_dump(struct afs_vnode
*dvnode
, struct afs_read
*req
)
186 union afs_xdr_dir_block
*block
;
187 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
189 pgoff_t last
= req
->nr_pages
- 1;
192 XA_STATE(xas
, &mapping
->i_pages
, 0);
194 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx\n",
195 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
196 req
->file_size
, req
->len
, req
->actual_len
);
197 pr_warn("DIR %llx %x %zx %zx\n",
198 req
->pos
, req
->nr_pages
,
199 req
->iter
->iov_offset
, iov_iter_count(req
->iter
));
201 xas_for_each(&xas
, folio
, last
) {
202 if (xas_retry(&xas
, folio
))
205 BUG_ON(folio_file_mapping(folio
) != mapping
);
207 size
= min_t(loff_t
, folio_size(folio
), req
->actual_len
- folio_pos(folio
));
208 for (offset
= 0; offset
< size
; offset
+= sizeof(*block
)) {
209 block
= kmap_local_folio(folio
, offset
);
210 pr_warn("[%02lx] %32phN\n", folio_index(folio
) + offset
, block
);
217 * Check all the blocks in a directory. All the folios are held pinned.
219 static int afs_dir_check(struct afs_vnode
*dvnode
, struct afs_read
*req
)
221 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
223 pgoff_t last
= req
->nr_pages
- 1;
226 XA_STATE(xas
, &mapping
->i_pages
, 0);
228 if (unlikely(!req
->nr_pages
))
232 xas_for_each(&xas
, folio
, last
) {
233 if (xas_retry(&xas
, folio
))
236 BUG_ON(folio_file_mapping(folio
) != mapping
);
238 if (!afs_dir_check_folio(dvnode
, folio
, req
->actual_len
)) {
239 afs_dir_dump(dvnode
, req
);
250 * open an AFS directory file
252 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
254 _enter("{%lu}", inode
->i_ino
);
256 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
257 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
259 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
262 return afs_open(inode
, file
);
266 * Read the directory into the pagecache in one go, scrubbing the previous
267 * contents. The list of folios is returned, pinning them so that they don't
268 * get reclaimed during the iteration.
270 static struct afs_read
*afs_read_dir(struct afs_vnode
*dvnode
, struct key
*key
)
271 __acquires(&dvnode
->validate_lock
)
273 struct address_space
*mapping
= dvnode
->netfs
.inode
.i_mapping
;
274 struct afs_read
*req
;
281 req
= kzalloc(sizeof(*req
), GFP_KERNEL
);
283 return ERR_PTR(-ENOMEM
);
285 refcount_set(&req
->usage
, 1);
287 req
->key
= key_get(key
);
288 req
->cleanup
= afs_dir_read_cleanup
;
291 i_size
= i_size_read(&dvnode
->netfs
.inode
);
293 ret
= afs_bad(dvnode
, afs_file_error_dir_small
);
296 if (i_size
> 2048 * 1024) {
297 trace_afs_file_error(dvnode
, -EFBIG
, afs_file_error_dir_big
);
302 _enter("%llu", i_size
);
304 nr_pages
= (i_size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
306 req
->actual_len
= i_size
; /* May change */
307 req
->len
= nr_pages
* PAGE_SIZE
; /* We can ask for more than there is */
308 req
->data_version
= dvnode
->status
.data_version
; /* May change */
309 iov_iter_xarray(&req
->def_iter
, ITER_DEST
, &dvnode
->netfs
.inode
.i_mapping
->i_pages
,
311 req
->iter
= &req
->def_iter
;
313 /* Fill in any gaps that we might find where the memory reclaimer has
314 * been at work and pin all the folios. If there are any gaps, we will
315 * need to reread the entire directory contents.
318 while (i
< nr_pages
) {
321 folio
= filemap_get_folio(mapping
, i
);
323 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
324 afs_stat_v(dvnode
, n_inval
);
327 folio
= __filemap_get_folio(mapping
,
328 i
, FGP_LOCK
| FGP_CREAT
,
332 folio_attach_private(folio
, (void *)1);
336 req
->nr_pages
+= folio_nr_pages(folio
);
337 i
+= folio_nr_pages(folio
);
340 /* If we're going to reload, we need to lock all the pages to prevent
344 if (down_read_killable(&dvnode
->validate_lock
) < 0)
347 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
350 up_read(&dvnode
->validate_lock
);
351 if (down_write_killable(&dvnode
->validate_lock
) < 0)
354 if (!test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
355 trace_afs_reload_dir(dvnode
);
356 ret
= afs_fetch_data(dvnode
, req
);
360 task_io_account_read(PAGE_SIZE
* req
->nr_pages
);
362 if (req
->len
< req
->file_size
) {
363 /* The content has grown, so we need to expand the
366 up_write(&dvnode
->validate_lock
);
370 /* Validate the data we just read. */
371 ret
= afs_dir_check(dvnode
, req
);
375 // TODO: Trim excess pages
377 set_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
);
380 downgrade_write(&dvnode
->validate_lock
);
385 up_write(&dvnode
->validate_lock
);
388 _leave(" = %d", ret
);
393 * deal with one block in an AFS directory
395 static int afs_dir_iterate_block(struct afs_vnode
*dvnode
,
396 struct dir_context
*ctx
,
397 union afs_xdr_dir_block
*block
,
400 union afs_xdr_dirent
*dire
;
401 unsigned offset
, next
, curr
, nr_slots
;
405 _enter("%llx,%x", ctx
->pos
, blkoff
);
407 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_xdr_dirent
);
409 /* walk through the block, an entry at a time */
410 for (offset
= (blkoff
== 0 ? AFS_DIR_RESV_BLOCKS0
: AFS_DIR_RESV_BLOCKS
);
411 offset
< AFS_DIR_SLOTS_PER_BLOCK
;
414 /* skip entries marked unused in the bitmap */
415 if (!(block
->hdr
.bitmap
[offset
/ 8] &
416 (1 << (offset
% 8)))) {
417 _debug("ENT[%zu.%u]: unused",
418 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
);
422 next
* sizeof(union afs_xdr_dirent
);
426 /* got a valid entry */
427 dire
= &block
->dirents
[offset
];
428 nlen
= strnlen(dire
->u
.name
,
430 offset
* sizeof(union afs_xdr_dirent
));
431 if (nlen
> AFSNAMEMAX
- 1) {
432 _debug("ENT[%zu]: name too long (len %u/%zu)",
433 blkoff
/ sizeof(union afs_xdr_dir_block
),
435 return afs_bad(dvnode
, afs_file_error_dir_name_too_long
);
438 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
439 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
,
440 (offset
< curr
? "skip" : "fill"),
443 nr_slots
= afs_dir_calc_slots(nlen
);
444 next
= offset
+ nr_slots
;
445 if (next
> AFS_DIR_SLOTS_PER_BLOCK
) {
446 _debug("ENT[%zu.%u]:"
447 " %u extends beyond end dir block"
449 blkoff
/ sizeof(union afs_xdr_dir_block
),
451 return afs_bad(dvnode
, afs_file_error_dir_over_end
);
454 /* Check that the name-extension dirents are all allocated */
455 for (tmp
= 1; tmp
< nr_slots
; tmp
++) {
456 unsigned int ix
= offset
+ tmp
;
457 if (!(block
->hdr
.bitmap
[ix
/ 8] & (1 << (ix
% 8)))) {
459 " %u unmarked extension (%u/%u)",
460 blkoff
/ sizeof(union afs_xdr_dir_block
),
461 offset
, tmp
, nr_slots
);
462 return afs_bad(dvnode
, afs_file_error_dir_unmarked_ext
);
466 /* skip if starts before the current position */
469 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
473 /* found the next entry */
474 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
475 ntohl(dire
->u
.vnode
),
476 (ctx
->actor
== afs_lookup_filldir
||
477 ctx
->actor
== afs_lookup_one_filldir
)?
478 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
479 _leave(" = 0 [full]");
483 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
486 _leave(" = 1 [more]");
491 * iterate through the data blob that lists the contents of an AFS directory
493 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
494 struct key
*key
, afs_dataversion_t
*_dir_version
)
496 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
497 union afs_xdr_dir_block
*dblock
;
498 struct afs_read
*req
;
500 unsigned offset
, size
;
503 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
505 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
506 _leave(" = -ESTALE");
510 req
= afs_read_dir(dvnode
, key
);
513 *_dir_version
= req
->data_version
;
515 /* round the file position up to the next entry boundary */
516 ctx
->pos
+= sizeof(union afs_xdr_dirent
) - 1;
517 ctx
->pos
&= ~(sizeof(union afs_xdr_dirent
) - 1);
519 /* walk through the blocks in sequence */
521 while (ctx
->pos
< req
->actual_len
) {
522 /* Fetch the appropriate folio from the directory and re-add it
523 * to the LRU. We have all the pages pinned with an extra ref.
525 folio
= __filemap_get_folio(dir
->i_mapping
, ctx
->pos
/ PAGE_SIZE
,
528 ret
= afs_bad(dvnode
, afs_file_error_dir_missing_page
);
532 offset
= round_down(ctx
->pos
, sizeof(*dblock
)) - folio_file_pos(folio
);
533 size
= min_t(loff_t
, folio_size(folio
),
534 req
->actual_len
- folio_file_pos(folio
));
537 dblock
= kmap_local_folio(folio
, offset
);
538 ret
= afs_dir_iterate_block(dvnode
, ctx
, dblock
,
539 folio_file_pos(folio
) + offset
);
540 kunmap_local(dblock
);
544 } while (offset
+= sizeof(*dblock
), offset
< size
);
550 up_read(&dvnode
->validate_lock
);
552 _leave(" = %d", ret
);
557 * read an AFS directory
559 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
561 afs_dataversion_t dir_version
;
563 return afs_dir_iterate(file_inode(file
), ctx
, afs_file_key(file
),
568 * Search the directory for a single name
569 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
570 * uniquifier through dtype
572 static bool afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
,
573 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
575 struct afs_lookup_one_cookie
*cookie
=
576 container_of(ctx
, struct afs_lookup_one_cookie
, ctx
);
578 _enter("{%s,%u},%s,%u,,%llu,%u",
579 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
580 (unsigned long long) ino
, dtype
);
582 /* insanity checks first */
583 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
584 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
586 if (cookie
->name
.len
!= nlen
||
587 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
588 _leave(" = true [keep looking]");
592 cookie
->fid
.vnode
= ino
;
593 cookie
->fid
.unique
= dtype
;
596 _leave(" = false [found]");
601 * Do a lookup of a single name in a directory
602 * - just returns the FID the dentry name maps to if found
604 static int afs_do_lookup_one(struct inode
*dir
, struct dentry
*dentry
,
605 struct afs_fid
*fid
, struct key
*key
,
606 afs_dataversion_t
*_dir_version
)
608 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
609 struct afs_lookup_one_cookie cookie
= {
610 .ctx
.actor
= afs_lookup_one_filldir
,
611 .name
= dentry
->d_name
,
612 .fid
.vid
= as
->volume
->vid
616 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
618 /* search the directory */
619 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
, _dir_version
);
621 _leave(" = %d [iter]", ret
);
626 _leave(" = -ENOENT [not found]");
631 _leave(" = 0 { vn=%llu u=%u }", fid
->vnode
, fid
->unique
);
636 * search the directory for a name
637 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
638 * uniquifier through dtype
640 static bool afs_lookup_filldir(struct dir_context
*ctx
, const char *name
,
641 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
643 struct afs_lookup_cookie
*cookie
=
644 container_of(ctx
, struct afs_lookup_cookie
, ctx
);
646 _enter("{%s,%u},%s,%u,,%llu,%u",
647 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
648 (unsigned long long) ino
, dtype
);
650 /* insanity checks first */
651 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
652 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
655 if (cookie
->nr_fids
< 50) {
656 cookie
->fids
[cookie
->nr_fids
].vnode
= ino
;
657 cookie
->fids
[cookie
->nr_fids
].unique
= dtype
;
660 } else if (cookie
->name
.len
== nlen
&&
661 memcmp(cookie
->name
.name
, name
, nlen
) == 0) {
662 cookie
->fids
[1].vnode
= ino
;
663 cookie
->fids
[1].unique
= dtype
;
665 if (cookie
->one_only
)
669 return cookie
->nr_fids
< 50;
673 * Deal with the result of a successful lookup operation. Turn all the files
674 * into inodes and save the first one - which is the one we actually want.
676 static void afs_do_lookup_success(struct afs_operation
*op
)
678 struct afs_vnode_param
*vp
;
679 struct afs_vnode
*vnode
;
686 for (i
= 0; i
< op
->nr_files
; i
++) {
690 abort_code
= vp
->scb
.status
.abort_code
;
691 if (abort_code
!= 0) {
692 op
->ac
.abort_code
= abort_code
;
693 op
->error
= afs_abort_to_error(abort_code
);
702 vp
= &op
->more_files
[i
- 2];
706 if (!vp
->scb
.have_status
&& !vp
->scb
.have_error
)
709 _debug("do [%u]", i
);
711 if (!test_bit(AFS_VNODE_UNSET
, &vp
->vnode
->flags
))
712 afs_vnode_commit_status(op
, vp
);
713 } else if (vp
->scb
.status
.abort_code
== 0) {
714 inode
= afs_iget(op
, vp
);
715 if (!IS_ERR(inode
)) {
716 vnode
= AFS_FS_I(inode
);
717 afs_cache_permit(vnode
, op
->key
,
718 0 /* Assume vnode->cb_break is 0 */ +
722 vp
->put_vnode
= true;
725 _debug("- abort %d %llx:%llx.%x",
726 vp
->scb
.status
.abort_code
,
727 vp
->fid
.vid
, vp
->fid
.vnode
, vp
->fid
.unique
);
734 static const struct afs_operation_ops afs_inline_bulk_status_operation
= {
735 .issue_afs_rpc
= afs_fs_inline_bulk_status
,
736 .issue_yfs_rpc
= yfs_fs_inline_bulk_status
,
737 .success
= afs_do_lookup_success
,
740 static const struct afs_operation_ops afs_lookup_fetch_status_operation
= {
741 .issue_afs_rpc
= afs_fs_fetch_status
,
742 .issue_yfs_rpc
= yfs_fs_fetch_status
,
743 .success
= afs_do_lookup_success
,
744 .aborted
= afs_check_for_remote_deletion
,
748 * See if we know that the server we expect to use doesn't support
749 * FS.InlineBulkStatus.
751 static bool afs_server_supports_ibulk(struct afs_vnode
*dvnode
)
753 struct afs_server_list
*slist
;
754 struct afs_volume
*volume
= dvnode
->volume
;
755 struct afs_server
*server
;
759 if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK
, &volume
->flags
))
763 slist
= rcu_dereference(volume
->servers
);
765 for (i
= 0; i
< slist
->nr_servers
; i
++) {
766 server
= slist
->servers
[i
].server
;
767 if (server
== dvnode
->cb_server
) {
768 if (test_bit(AFS_SERVER_FL_NO_IBULK
, &server
->flags
))
779 * Do a lookup in a directory. We make use of bulk lookup to query a slew of
780 * files in one go and create inodes for them. The inode of the file we were
781 * asked for is returned.
783 static struct inode
*afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
786 struct afs_lookup_cookie
*cookie
;
787 struct afs_vnode_param
*vp
;
788 struct afs_operation
*op
;
789 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
;
790 struct inode
*inode
= NULL
, *ti
;
791 afs_dataversion_t data_version
= READ_ONCE(dvnode
->status
.data_version
);
795 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
797 cookie
= kzalloc(sizeof(struct afs_lookup_cookie
), GFP_KERNEL
);
799 return ERR_PTR(-ENOMEM
);
801 for (i
= 0; i
< ARRAY_SIZE(cookie
->fids
); i
++)
802 cookie
->fids
[i
].vid
= dvnode
->fid
.vid
;
803 cookie
->ctx
.actor
= afs_lookup_filldir
;
804 cookie
->name
= dentry
->d_name
;
805 cookie
->nr_fids
= 2; /* slot 0 is saved for the fid we actually want
806 * and slot 1 for the directory */
808 if (!afs_server_supports_ibulk(dvnode
))
809 cookie
->one_only
= true;
811 /* search the directory */
812 ret
= afs_dir_iterate(dir
, &cookie
->ctx
, key
, &data_version
);
816 dentry
->d_fsdata
= (void *)(unsigned long)data_version
;
822 /* Check to see if we already have an inode for the primary fid. */
823 inode
= ilookup5(dir
->i_sb
, cookie
->fids
[1].vnode
,
824 afs_ilookup5_test_by_fid
, &cookie
->fids
[1]);
826 goto out
; /* We do */
828 /* Okay, we didn't find it. We need to query the server - and whilst
829 * we're doing that, we're going to attempt to look up a bunch of other
832 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
838 afs_op_set_vnode(op
, 0, dvnode
);
839 afs_op_set_fid(op
, 1, &cookie
->fids
[1]);
841 op
->nr_files
= cookie
->nr_fids
;
842 _debug("nr_files %u", op
->nr_files
);
844 /* Need space for examining all the selected files */
846 if (op
->nr_files
> 2) {
847 op
->more_files
= kvcalloc(op
->nr_files
- 2,
848 sizeof(struct afs_vnode_param
),
853 for (i
= 2; i
< op
->nr_files
; i
++) {
854 vp
= &op
->more_files
[i
- 2];
855 vp
->fid
= cookie
->fids
[i
];
857 /* Find any inodes that already exist and get their
860 ti
= ilookup5_nowait(dir
->i_sb
, vp
->fid
.vnode
,
861 afs_ilookup5_test_by_fid
, &vp
->fid
);
862 if (!IS_ERR_OR_NULL(ti
)) {
863 vnode
= AFS_FS_I(ti
);
864 vp
->dv_before
= vnode
->status
.data_version
;
865 vp
->cb_break_before
= afs_calc_vnode_cb_break(vnode
);
867 vp
->put_vnode
= true;
868 vp
->speculative
= true; /* vnode not locked */
873 /* Try FS.InlineBulkStatus first. Abort codes for the individual
874 * lookups contained therein are stored in the reply without aborting
875 * the whole operation.
877 op
->error
= -ENOTSUPP
;
878 if (!cookie
->one_only
) {
879 op
->ops
= &afs_inline_bulk_status_operation
;
880 afs_begin_vnode_operation(op
);
881 afs_wait_for_operation(op
);
884 if (op
->error
== -ENOTSUPP
) {
885 /* We could try FS.BulkStatus next, but this aborts the entire
886 * op if any of the lookups fails - so, for the moment, revert
887 * to FS.FetchStatus for op->file[1].
889 op
->fetch_status
.which
= 1;
890 op
->ops
= &afs_lookup_fetch_status_operation
;
891 afs_begin_vnode_operation(op
);
892 afs_wait_for_operation(op
);
894 inode
= ERR_PTR(op
->error
);
897 if (op
->error
== 0) {
898 inode
= &op
->file
[1].vnode
->netfs
.inode
;
899 op
->file
[1].vnode
= NULL
;
902 if (op
->file
[0].scb
.have_status
)
903 dentry
->d_fsdata
= (void *)(unsigned long)op
->file
[0].scb
.status
.data_version
;
905 dentry
->d_fsdata
= (void *)(unsigned long)op
->file
[0].dv_before
;
906 ret
= afs_put_operation(op
);
910 return inode
?: ERR_PTR(ret
);
914 * Look up an entry in a directory with @sys substitution.
916 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
919 struct afs_sysnames
*subs
;
920 struct afs_net
*net
= afs_i2net(dir
);
922 char *buf
, *p
, *name
;
927 ret
= ERR_PTR(-ENOMEM
);
928 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
931 if (dentry
->d_name
.len
> 4) {
932 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
933 p
+= dentry
->d_name
.len
- 4;
936 /* There is an ordered list of substitutes that we have to try. */
937 read_lock(&net
->sysnames_lock
);
938 subs
= net
->sysnames
;
939 refcount_inc(&subs
->usage
);
940 read_unlock(&net
->sysnames_lock
);
942 for (i
= 0; i
< subs
->nr
; i
++) {
943 name
= subs
->subs
[i
];
944 len
= dentry
->d_name
.len
- 4 + strlen(name
);
945 if (len
>= AFSNAMEMAX
) {
946 ret
= ERR_PTR(-ENAMETOOLONG
);
951 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
952 if (IS_ERR(ret
) || d_is_positive(ret
))
957 /* We don't want to d_add() the @sys dentry here as we don't want to
958 * the cached dentry to hide changes to the sysnames list.
962 afs_put_sysnames(subs
);
970 * look up an entry in a directory
972 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
975 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
976 struct afs_fid fid
= {};
982 _enter("{%llx:%llu},%p{%pd},",
983 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
985 ASSERTCMP(d_inode(dentry
), ==, NULL
);
987 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
988 _leave(" = -ENAMETOOLONG");
989 return ERR_PTR(-ENAMETOOLONG
);
992 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
993 _leave(" = -ESTALE");
994 return ERR_PTR(-ESTALE
);
997 key
= afs_request_key(dvnode
->volume
->cell
);
999 _leave(" = %ld [key]", PTR_ERR(key
));
1000 return ERR_CAST(key
);
1003 ret
= afs_validate(dvnode
, key
);
1006 _leave(" = %d [val]", ret
);
1007 return ERR_PTR(ret
);
1010 if (dentry
->d_name
.len
>= 4 &&
1011 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
1012 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
1013 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
1014 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
1015 return afs_lookup_atsys(dir
, dentry
, key
);
1017 afs_stat_v(dvnode
, n_lookup
);
1018 inode
= afs_do_lookup(dir
, dentry
, key
);
1020 if (inode
== ERR_PTR(-ENOENT
))
1021 inode
= afs_try_auto_mntpt(dentry
, dir
);
1023 if (!IS_ERR_OR_NULL(inode
))
1024 fid
= AFS_FS_I(inode
)->fid
;
1026 _debug("splice %p", dentry
->d_inode
);
1027 d
= d_splice_alias(inode
, dentry
);
1028 if (!IS_ERR_OR_NULL(d
)) {
1029 d
->d_fsdata
= dentry
->d_fsdata
;
1030 trace_afs_lookup(dvnode
, &d
->d_name
, &fid
);
1032 trace_afs_lookup(dvnode
, &dentry
->d_name
, &fid
);
1039 * Check the validity of a dentry under RCU conditions.
1041 static int afs_d_revalidate_rcu(struct dentry
*dentry
)
1043 struct afs_vnode
*dvnode
;
1044 struct dentry
*parent
;
1046 long dir_version
, de_version
;
1048 _enter("%p", dentry
);
1050 /* Check the parent directory is still valid first. */
1051 parent
= READ_ONCE(dentry
->d_parent
);
1052 dir
= d_inode_rcu(parent
);
1055 dvnode
= AFS_FS_I(dir
);
1056 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
))
1059 if (!afs_check_validity(dvnode
))
1062 /* We only need to invalidate a dentry if the server's copy changed
1063 * behind our back. If we made the change, it's no problem. Note that
1064 * on a 32-bit system, we only have 32 bits in the dentry to store the
1067 dir_version
= (long)READ_ONCE(dvnode
->status
.data_version
);
1068 de_version
= (long)READ_ONCE(dentry
->d_fsdata
);
1069 if (de_version
!= dir_version
) {
1070 dir_version
= (long)READ_ONCE(dvnode
->invalid_before
);
1071 if (de_version
- dir_version
< 0)
1075 return 1; /* Still valid */
1079 * check that a dentry lookup hit has found a valid entry
1080 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
1083 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
1085 struct afs_vnode
*vnode
, *dir
;
1087 struct dentry
*parent
;
1088 struct inode
*inode
;
1090 afs_dataversion_t dir_version
, invalid_before
;
1094 if (flags
& LOOKUP_RCU
)
1095 return afs_d_revalidate_rcu(dentry
);
1097 if (d_really_is_positive(dentry
)) {
1098 vnode
= AFS_FS_I(d_inode(dentry
));
1099 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
1100 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
1103 _enter("{neg n=%pd}", dentry
);
1106 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
1110 /* Hold the parent dentry so we can peer at it */
1111 parent
= dget_parent(dentry
);
1112 dir
= AFS_FS_I(d_inode(parent
));
1114 /* validate the parent directory */
1115 afs_validate(dir
, key
);
1117 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
1118 _debug("%pd: parent dir deleted", dentry
);
1122 /* We only need to invalidate a dentry if the server's copy changed
1123 * behind our back. If we made the change, it's no problem. Note that
1124 * on a 32-bit system, we only have 32 bits in the dentry to store the
1127 dir_version
= dir
->status
.data_version
;
1128 de_version
= (long)dentry
->d_fsdata
;
1129 if (de_version
== (long)dir_version
)
1130 goto out_valid_noupdate
;
1132 invalid_before
= dir
->invalid_before
;
1133 if (de_version
- (long)invalid_before
>= 0)
1136 _debug("dir modified");
1137 afs_stat_v(dir
, n_reval
);
1139 /* search the directory for this vnode */
1140 ret
= afs_do_lookup_one(&dir
->netfs
.inode
, dentry
, &fid
, key
, &dir_version
);
1143 /* the filename maps to something */
1144 if (d_really_is_negative(dentry
))
1146 inode
= d_inode(dentry
);
1147 if (is_bad_inode(inode
)) {
1148 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1153 vnode
= AFS_FS_I(inode
);
1155 /* if the vnode ID has changed, then the dirent points to a
1157 if (fid
.vnode
!= vnode
->fid
.vnode
) {
1158 _debug("%pd: dirent changed [%llu != %llu]",
1164 /* if the vnode ID uniqifier has changed, then the file has
1165 * been deleted and replaced, and the original vnode ID has
1167 if (fid
.unique
!= vnode
->fid
.unique
) {
1168 _debug("%pd: file deleted (uq %u -> %u I:%u)",
1171 vnode
->netfs
.inode
.i_generation
);
1177 /* the filename is unknown */
1178 _debug("%pd: dirent not found", dentry
);
1179 if (d_really_is_positive(dentry
))
1184 _debug("failed to iterate dir %pd: %d",
1190 dentry
->d_fsdata
= (void *)(unsigned long)dir_version
;
1194 _leave(" = 1 [valid]");
1198 _debug("dropping dentry %pd2", dentry
);
1202 _leave(" = 0 [bad]");
1207 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1209 * - called from dput() when d_count is going to 0.
1210 * - return 1 to request dentry be unhashed, 0 otherwise
1212 static int afs_d_delete(const struct dentry
*dentry
)
1214 _enter("%pd", dentry
);
1216 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1219 if (d_really_is_positive(dentry
) &&
1220 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1221 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1224 _leave(" = 0 [keep]");
1228 _leave(" = 1 [zap]");
1233 * Clean up sillyrename files on dentry removal.
1235 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
)
1237 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1238 afs_silly_iput(dentry
, inode
);
1243 * handle dentry release
1245 void afs_d_release(struct dentry
*dentry
)
1247 _enter("%pd", dentry
);
1250 void afs_check_for_remote_deletion(struct afs_operation
*op
)
1252 struct afs_vnode
*vnode
= op
->file
[0].vnode
;
1254 switch (op
->ac
.abort_code
) {
1256 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1257 afs_break_callback(vnode
, afs_cb_break_for_deleted
);
1262 * Create a new inode for create/mkdir/symlink
1264 static void afs_vnode_new_inode(struct afs_operation
*op
)
1266 struct afs_vnode_param
*vp
= &op
->file
[1];
1267 struct afs_vnode
*vnode
;
1268 struct inode
*inode
;
1272 ASSERTCMP(op
->error
, ==, 0);
1274 inode
= afs_iget(op
, vp
);
1275 if (IS_ERR(inode
)) {
1276 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1277 * the new directory on the server.
1279 op
->error
= PTR_ERR(inode
);
1283 vnode
= AFS_FS_I(inode
);
1284 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1286 afs_cache_permit(vnode
, op
->key
, vnode
->cb_break
, &vp
->scb
);
1287 d_instantiate(op
->dentry
, inode
);
1290 static void afs_create_success(struct afs_operation
*op
)
1292 _enter("op=%08x", op
->debug_id
);
1293 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1294 afs_vnode_commit_status(op
, &op
->file
[0]);
1295 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1296 afs_vnode_new_inode(op
);
1299 static void afs_create_edit_dir(struct afs_operation
*op
)
1301 struct afs_vnode_param
*dvp
= &op
->file
[0];
1302 struct afs_vnode_param
*vp
= &op
->file
[1];
1303 struct afs_vnode
*dvnode
= dvp
->vnode
;
1305 _enter("op=%08x", op
->debug_id
);
1307 down_write(&dvnode
->validate_lock
);
1308 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1309 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1310 afs_edit_dir_add(dvnode
, &op
->dentry
->d_name
, &vp
->fid
,
1312 up_write(&dvnode
->validate_lock
);
1315 static void afs_create_put(struct afs_operation
*op
)
1317 _enter("op=%08x", op
->debug_id
);
1323 static const struct afs_operation_ops afs_mkdir_operation
= {
1324 .issue_afs_rpc
= afs_fs_make_dir
,
1325 .issue_yfs_rpc
= yfs_fs_make_dir
,
1326 .success
= afs_create_success
,
1327 .aborted
= afs_check_for_remote_deletion
,
1328 .edit_dir
= afs_create_edit_dir
,
1329 .put
= afs_create_put
,
1333 * create a directory on an AFS filesystem
1335 static int afs_mkdir(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1336 struct dentry
*dentry
, umode_t mode
)
1338 struct afs_operation
*op
;
1339 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1341 _enter("{%llx:%llu},{%pd},%ho",
1342 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1344 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1350 afs_op_set_vnode(op
, 0, dvnode
);
1351 op
->file
[0].dv_delta
= 1;
1352 op
->file
[0].modification
= true;
1353 op
->file
[0].update_ctime
= true;
1354 op
->dentry
= dentry
;
1355 op
->create
.mode
= S_IFDIR
| mode
;
1356 op
->create
.reason
= afs_edit_dir_for_mkdir
;
1357 op
->ops
= &afs_mkdir_operation
;
1358 return afs_do_sync_operation(op
);
1362 * Remove a subdir from a directory.
1364 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1366 if (d_really_is_positive(dentry
)) {
1367 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1369 clear_nlink(&vnode
->netfs
.inode
);
1370 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1371 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1372 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1376 static void afs_rmdir_success(struct afs_operation
*op
)
1378 _enter("op=%08x", op
->debug_id
);
1379 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1380 afs_vnode_commit_status(op
, &op
->file
[0]);
1381 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1384 static void afs_rmdir_edit_dir(struct afs_operation
*op
)
1386 struct afs_vnode_param
*dvp
= &op
->file
[0];
1387 struct afs_vnode
*dvnode
= dvp
->vnode
;
1389 _enter("op=%08x", op
->debug_id
);
1390 afs_dir_remove_subdir(op
->dentry
);
1392 down_write(&dvnode
->validate_lock
);
1393 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1394 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1395 afs_edit_dir_remove(dvnode
, &op
->dentry
->d_name
,
1396 afs_edit_dir_for_rmdir
);
1397 up_write(&dvnode
->validate_lock
);
1400 static void afs_rmdir_put(struct afs_operation
*op
)
1402 _enter("op=%08x", op
->debug_id
);
1403 if (op
->file
[1].vnode
)
1404 up_write(&op
->file
[1].vnode
->rmdir_lock
);
1407 static const struct afs_operation_ops afs_rmdir_operation
= {
1408 .issue_afs_rpc
= afs_fs_remove_dir
,
1409 .issue_yfs_rpc
= yfs_fs_remove_dir
,
1410 .success
= afs_rmdir_success
,
1411 .aborted
= afs_check_for_remote_deletion
,
1412 .edit_dir
= afs_rmdir_edit_dir
,
1413 .put
= afs_rmdir_put
,
1417 * remove a directory from an AFS filesystem
1419 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1421 struct afs_operation
*op
;
1422 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1425 _enter("{%llx:%llu},{%pd}",
1426 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1428 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1432 afs_op_set_vnode(op
, 0, dvnode
);
1433 op
->file
[0].dv_delta
= 1;
1434 op
->file
[0].modification
= true;
1435 op
->file
[0].update_ctime
= true;
1437 op
->dentry
= dentry
;
1438 op
->ops
= &afs_rmdir_operation
;
1440 /* Try to make sure we have a callback promise on the victim. */
1441 if (d_really_is_positive(dentry
)) {
1442 vnode
= AFS_FS_I(d_inode(dentry
));
1443 ret
= afs_validate(vnode
, op
->key
);
1449 ret
= down_write_killable(&vnode
->rmdir_lock
);
1452 op
->file
[1].vnode
= vnode
;
1455 return afs_do_sync_operation(op
);
1458 return afs_put_operation(op
);
1462 * Remove a link to a file or symlink from a directory.
1464 * If the file was not deleted due to excess hard links, the fileserver will
1465 * break the callback promise on the file - if it had one - before it returns
1466 * to us, and if it was deleted, it won't
1468 * However, if we didn't have a callback promise outstanding, or it was
1469 * outstanding on a different server, then it won't break it either...
1471 static void afs_dir_remove_link(struct afs_operation
*op
)
1473 struct afs_vnode
*dvnode
= op
->file
[0].vnode
;
1474 struct afs_vnode
*vnode
= op
->file
[1].vnode
;
1475 struct dentry
*dentry
= op
->dentry
;
1478 if (op
->error
!= 0 ||
1479 (op
->file
[1].scb
.have_status
&& op
->file
[1].scb
.have_error
))
1481 if (d_really_is_positive(dentry
))
1484 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1486 } else if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
1487 write_seqlock(&vnode
->cb_lock
);
1488 drop_nlink(&vnode
->netfs
.inode
);
1489 if (vnode
->netfs
.inode
.i_nlink
== 0) {
1490 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1491 __afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1493 write_sequnlock(&vnode
->cb_lock
);
1495 afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1497 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1498 _debug("AFS_VNODE_DELETED");
1500 ret
= afs_validate(vnode
, op
->key
);
1505 _debug("nlink %d [val %d]", vnode
->netfs
.inode
.i_nlink
, op
->error
);
1508 static void afs_unlink_success(struct afs_operation
*op
)
1510 _enter("op=%08x", op
->debug_id
);
1511 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1512 afs_check_dir_conflict(op
, &op
->file
[0]);
1513 afs_vnode_commit_status(op
, &op
->file
[0]);
1514 afs_vnode_commit_status(op
, &op
->file
[1]);
1515 afs_update_dentry_version(op
, &op
->file
[0], op
->dentry
);
1516 afs_dir_remove_link(op
);
1519 static void afs_unlink_edit_dir(struct afs_operation
*op
)
1521 struct afs_vnode_param
*dvp
= &op
->file
[0];
1522 struct afs_vnode
*dvnode
= dvp
->vnode
;
1524 _enter("op=%08x", op
->debug_id
);
1525 down_write(&dvnode
->validate_lock
);
1526 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
) &&
1527 dvnode
->status
.data_version
== dvp
->dv_before
+ dvp
->dv_delta
)
1528 afs_edit_dir_remove(dvnode
, &op
->dentry
->d_name
,
1529 afs_edit_dir_for_unlink
);
1530 up_write(&dvnode
->validate_lock
);
1533 static void afs_unlink_put(struct afs_operation
*op
)
1535 _enter("op=%08x", op
->debug_id
);
1536 if (op
->unlink
.need_rehash
&& op
->error
< 0 && op
->error
!= -ENOENT
)
1537 d_rehash(op
->dentry
);
1540 static const struct afs_operation_ops afs_unlink_operation
= {
1541 .issue_afs_rpc
= afs_fs_remove_file
,
1542 .issue_yfs_rpc
= yfs_fs_remove_file
,
1543 .success
= afs_unlink_success
,
1544 .aborted
= afs_check_for_remote_deletion
,
1545 .edit_dir
= afs_unlink_edit_dir
,
1546 .put
= afs_unlink_put
,
1550 * Remove a file or symlink from an AFS filesystem.
1552 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1554 struct afs_operation
*op
;
1555 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1556 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1559 _enter("{%llx:%llu},{%pd}",
1560 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1562 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1563 return -ENAMETOOLONG
;
1565 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1569 afs_op_set_vnode(op
, 0, dvnode
);
1570 op
->file
[0].dv_delta
= 1;
1571 op
->file
[0].modification
= true;
1572 op
->file
[0].update_ctime
= true;
1574 /* Try to make sure we have a callback promise on the victim. */
1575 ret
= afs_validate(vnode
, op
->key
);
1581 spin_lock(&dentry
->d_lock
);
1582 if (d_count(dentry
) > 1) {
1583 spin_unlock(&dentry
->d_lock
);
1584 /* Start asynchronous writeout of the inode */
1585 write_inode_now(d_inode(dentry
), 0);
1586 op
->error
= afs_sillyrename(dvnode
, vnode
, dentry
, op
->key
);
1589 if (!d_unhashed(dentry
)) {
1590 /* Prevent a race with RCU lookup. */
1592 op
->unlink
.need_rehash
= true;
1594 spin_unlock(&dentry
->d_lock
);
1596 op
->file
[1].vnode
= vnode
;
1597 op
->file
[1].update_ctime
= true;
1598 op
->file
[1].op_unlinked
= true;
1599 op
->dentry
= dentry
;
1600 op
->ops
= &afs_unlink_operation
;
1601 afs_begin_vnode_operation(op
);
1602 afs_wait_for_operation(op
);
1604 /* If there was a conflict with a third party, check the status of the
1607 if (op
->error
== 0 && (op
->flags
& AFS_OPERATION_DIR_CONFLICT
)) {
1608 op
->file
[1].update_ctime
= false;
1609 op
->fetch_status
.which
= 1;
1610 op
->ops
= &afs_fetch_status_operation
;
1611 afs_begin_vnode_operation(op
);
1612 afs_wait_for_operation(op
);
1615 return afs_put_operation(op
);
1618 return afs_put_operation(op
);
1621 static const struct afs_operation_ops afs_create_operation
= {
1622 .issue_afs_rpc
= afs_fs_create_file
,
1623 .issue_yfs_rpc
= yfs_fs_create_file
,
1624 .success
= afs_create_success
,
1625 .aborted
= afs_check_for_remote_deletion
,
1626 .edit_dir
= afs_create_edit_dir
,
1627 .put
= afs_create_put
,
1631 * create a regular file on an AFS filesystem
1633 static int afs_create(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1634 struct dentry
*dentry
, umode_t mode
, bool excl
)
1636 struct afs_operation
*op
;
1637 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1638 int ret
= -ENAMETOOLONG
;
1640 _enter("{%llx:%llu},{%pd},%ho",
1641 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1643 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1646 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1652 afs_op_set_vnode(op
, 0, dvnode
);
1653 op
->file
[0].dv_delta
= 1;
1654 op
->file
[0].modification
= true;
1655 op
->file
[0].update_ctime
= true;
1657 op
->dentry
= dentry
;
1658 op
->create
.mode
= S_IFREG
| mode
;
1659 op
->create
.reason
= afs_edit_dir_for_create
;
1660 op
->ops
= &afs_create_operation
;
1661 return afs_do_sync_operation(op
);
1665 _leave(" = %d", ret
);
1669 static void afs_link_success(struct afs_operation
*op
)
1671 struct afs_vnode_param
*dvp
= &op
->file
[0];
1672 struct afs_vnode_param
*vp
= &op
->file
[1];
1674 _enter("op=%08x", op
->debug_id
);
1675 op
->ctime
= dvp
->scb
.status
.mtime_client
;
1676 afs_vnode_commit_status(op
, dvp
);
1677 afs_vnode_commit_status(op
, vp
);
1678 afs_update_dentry_version(op
, dvp
, op
->dentry
);
1679 if (op
->dentry_2
->d_parent
== op
->dentry
->d_parent
)
1680 afs_update_dentry_version(op
, dvp
, op
->dentry_2
);
1681 ihold(&vp
->vnode
->netfs
.inode
);
1682 d_instantiate(op
->dentry
, &vp
->vnode
->netfs
.inode
);
1685 static void afs_link_put(struct afs_operation
*op
)
1687 _enter("op=%08x", op
->debug_id
);
1692 static const struct afs_operation_ops afs_link_operation
= {
1693 .issue_afs_rpc
= afs_fs_link
,
1694 .issue_yfs_rpc
= yfs_fs_link
,
1695 .success
= afs_link_success
,
1696 .aborted
= afs_check_for_remote_deletion
,
1697 .edit_dir
= afs_create_edit_dir
,
1698 .put
= afs_link_put
,
1702 * create a hard link between files in an AFS filesystem
1704 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1705 struct dentry
*dentry
)
1707 struct afs_operation
*op
;
1708 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1709 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(from
));
1710 int ret
= -ENAMETOOLONG
;
1712 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1713 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1714 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1717 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1720 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1726 ret
= afs_validate(vnode
, op
->key
);
1730 afs_op_set_vnode(op
, 0, dvnode
);
1731 afs_op_set_vnode(op
, 1, vnode
);
1732 op
->file
[0].dv_delta
= 1;
1733 op
->file
[0].modification
= true;
1734 op
->file
[0].update_ctime
= true;
1735 op
->file
[1].update_ctime
= true;
1737 op
->dentry
= dentry
;
1738 op
->dentry_2
= from
;
1739 op
->ops
= &afs_link_operation
;
1740 op
->create
.reason
= afs_edit_dir_for_link
;
1741 return afs_do_sync_operation(op
);
1744 afs_put_operation(op
);
1747 _leave(" = %d", ret
);
1751 static const struct afs_operation_ops afs_symlink_operation
= {
1752 .issue_afs_rpc
= afs_fs_symlink
,
1753 .issue_yfs_rpc
= yfs_fs_symlink
,
1754 .success
= afs_create_success
,
1755 .aborted
= afs_check_for_remote_deletion
,
1756 .edit_dir
= afs_create_edit_dir
,
1757 .put
= afs_create_put
,
1761 * create a symlink in an AFS filesystem
1763 static int afs_symlink(struct user_namespace
*mnt_userns
, struct inode
*dir
,
1764 struct dentry
*dentry
, const char *content
)
1766 struct afs_operation
*op
;
1767 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1770 _enter("{%llx:%llu},{%pd},%s",
1771 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1774 ret
= -ENAMETOOLONG
;
1775 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1779 if (strlen(content
) >= AFSPATHMAX
)
1782 op
= afs_alloc_operation(NULL
, dvnode
->volume
);
1788 afs_op_set_vnode(op
, 0, dvnode
);
1789 op
->file
[0].dv_delta
= 1;
1791 op
->dentry
= dentry
;
1792 op
->ops
= &afs_symlink_operation
;
1793 op
->create
.reason
= afs_edit_dir_for_symlink
;
1794 op
->create
.symlink
= content
;
1795 return afs_do_sync_operation(op
);
1799 _leave(" = %d", ret
);
1803 static void afs_rename_success(struct afs_operation
*op
)
1805 _enter("op=%08x", op
->debug_id
);
1807 op
->ctime
= op
->file
[0].scb
.status
.mtime_client
;
1808 afs_check_dir_conflict(op
, &op
->file
[1]);
1809 afs_vnode_commit_status(op
, &op
->file
[0]);
1810 if (op
->file
[1].vnode
!= op
->file
[0].vnode
) {
1811 op
->ctime
= op
->file
[1].scb
.status
.mtime_client
;
1812 afs_vnode_commit_status(op
, &op
->file
[1]);
1816 static void afs_rename_edit_dir(struct afs_operation
*op
)
1818 struct afs_vnode_param
*orig_dvp
= &op
->file
[0];
1819 struct afs_vnode_param
*new_dvp
= &op
->file
[1];
1820 struct afs_vnode
*orig_dvnode
= orig_dvp
->vnode
;
1821 struct afs_vnode
*new_dvnode
= new_dvp
->vnode
;
1822 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(op
->dentry
));
1823 struct dentry
*old_dentry
= op
->dentry
;
1824 struct dentry
*new_dentry
= op
->dentry_2
;
1825 struct inode
*new_inode
;
1827 _enter("op=%08x", op
->debug_id
);
1829 if (op
->rename
.rehash
) {
1830 d_rehash(op
->rename
.rehash
);
1831 op
->rename
.rehash
= NULL
;
1834 down_write(&orig_dvnode
->validate_lock
);
1835 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
) &&
1836 orig_dvnode
->status
.data_version
== orig_dvp
->dv_before
+ orig_dvp
->dv_delta
)
1837 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1838 afs_edit_dir_for_rename_0
);
1840 if (new_dvnode
!= orig_dvnode
) {
1841 up_write(&orig_dvnode
->validate_lock
);
1842 down_write(&new_dvnode
->validate_lock
);
1845 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
) &&
1846 new_dvnode
->status
.data_version
== new_dvp
->dv_before
+ new_dvp
->dv_delta
) {
1847 if (!op
->rename
.new_negative
)
1848 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1849 afs_edit_dir_for_rename_1
);
1851 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1852 &vnode
->fid
, afs_edit_dir_for_rename_2
);
1855 new_inode
= d_inode(new_dentry
);
1857 spin_lock(&new_inode
->i_lock
);
1858 if (S_ISDIR(new_inode
->i_mode
))
1859 clear_nlink(new_inode
);
1860 else if (new_inode
->i_nlink
> 0)
1861 drop_nlink(new_inode
);
1862 spin_unlock(&new_inode
->i_lock
);
1865 /* Now we can update d_fsdata on the dentries to reflect their
1866 * new parent's data_version.
1868 * Note that if we ever implement RENAME_EXCHANGE, we'll have
1869 * to update both dentries with opposing dir versions.
1871 afs_update_dentry_version(op
, new_dvp
, op
->dentry
);
1872 afs_update_dentry_version(op
, new_dvp
, op
->dentry_2
);
1874 d_move(old_dentry
, new_dentry
);
1876 up_write(&new_dvnode
->validate_lock
);
1879 static void afs_rename_put(struct afs_operation
*op
)
1881 _enter("op=%08x", op
->debug_id
);
1882 if (op
->rename
.rehash
)
1883 d_rehash(op
->rename
.rehash
);
1884 dput(op
->rename
.tmp
);
1886 d_rehash(op
->dentry
);
1889 static const struct afs_operation_ops afs_rename_operation
= {
1890 .issue_afs_rpc
= afs_fs_rename
,
1891 .issue_yfs_rpc
= yfs_fs_rename
,
1892 .success
= afs_rename_success
,
1893 .edit_dir
= afs_rename_edit_dir
,
1894 .put
= afs_rename_put
,
1898 * rename a file in an AFS filesystem and/or move it between directories
1900 static int afs_rename(struct user_namespace
*mnt_userns
, struct inode
*old_dir
,
1901 struct dentry
*old_dentry
, struct inode
*new_dir
,
1902 struct dentry
*new_dentry
, unsigned int flags
)
1904 struct afs_operation
*op
;
1905 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1911 /* Don't allow silly-rename files be moved around. */
1912 if (old_dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1915 vnode
= AFS_FS_I(d_inode(old_dentry
));
1916 orig_dvnode
= AFS_FS_I(old_dir
);
1917 new_dvnode
= AFS_FS_I(new_dir
);
1919 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1920 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1921 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1922 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1925 op
= afs_alloc_operation(NULL
, orig_dvnode
->volume
);
1929 ret
= afs_validate(vnode
, op
->key
);
1934 afs_op_set_vnode(op
, 0, orig_dvnode
);
1935 afs_op_set_vnode(op
, 1, new_dvnode
); /* May be same as orig_dvnode */
1936 op
->file
[0].dv_delta
= 1;
1937 op
->file
[1].dv_delta
= 1;
1938 op
->file
[0].modification
= true;
1939 op
->file
[1].modification
= true;
1940 op
->file
[0].update_ctime
= true;
1941 op
->file
[1].update_ctime
= true;
1943 op
->dentry
= old_dentry
;
1944 op
->dentry_2
= new_dentry
;
1945 op
->rename
.new_negative
= d_is_negative(new_dentry
);
1946 op
->ops
= &afs_rename_operation
;
1948 /* For non-directories, check whether the target is busy and if so,
1949 * make a copy of the dentry and then do a silly-rename. If the
1950 * silly-rename succeeds, the copied dentry is hashed and becomes the
1953 if (d_is_positive(new_dentry
) && !d_is_dir(new_dentry
)) {
1954 /* To prevent any new references to the target during the
1955 * rename, we unhash the dentry in advance.
1957 if (!d_unhashed(new_dentry
)) {
1959 op
->rename
.rehash
= new_dentry
;
1962 if (d_count(new_dentry
) > 2) {
1963 /* copy the target dentry's name */
1964 op
->rename
.tmp
= d_alloc(new_dentry
->d_parent
,
1965 &new_dentry
->d_name
);
1966 if (!op
->rename
.tmp
) {
1967 op
->error
= -ENOMEM
;
1971 ret
= afs_sillyrename(new_dvnode
,
1972 AFS_FS_I(d_inode(new_dentry
)),
1973 new_dentry
, op
->key
);
1979 op
->dentry_2
= op
->rename
.tmp
;
1980 op
->rename
.rehash
= NULL
;
1981 op
->rename
.new_negative
= true;
1985 /* This bit is potentially nasty as there's a potential race with
1986 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
1987 * to reflect it's new parent's new data_version after the op, but
1988 * d_revalidate may see old_dentry between the op having taken place
1989 * and the version being updated.
1991 * So drop the old_dentry for now to make other threads go through
1992 * lookup instead - which we hold a lock against.
1996 return afs_do_sync_operation(op
);
1999 return afs_put_operation(op
);
2003 * Release a directory folio and clean up its private state if it's not busy
2004 * - return true if the folio can now be released, false if not
2006 static bool afs_dir_release_folio(struct folio
*folio
, gfp_t gfp_flags
)
2008 struct afs_vnode
*dvnode
= AFS_FS_I(folio_inode(folio
));
2010 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, folio_index(folio
));
2012 folio_detach_private(folio
);
2014 /* The directory will need reloading. */
2015 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2016 afs_stat_v(dvnode
, n_relpg
);
2021 * Invalidate part or all of a folio.
2023 static void afs_dir_invalidate_folio(struct folio
*folio
, size_t offset
,
2026 struct afs_vnode
*dvnode
= AFS_FS_I(folio_inode(folio
));
2028 _enter("{%lu},%zu,%zu", folio
->index
, offset
, length
);
2030 BUG_ON(!folio_test_locked(folio
));
2032 /* The directory will need reloading. */
2033 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2034 afs_stat_v(dvnode
, n_inval
);
2036 /* we clean up only if the entire folio is being invalidated */
2037 if (offset
== 0 && length
== folio_size(folio
))
2038 folio_detach_private(folio
);