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 int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
, int nlen
,
28 loff_t fpos
, u64 ino
, unsigned dtype
);
29 static int 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 inode
*dir
, struct dentry
*dentry
, umode_t mode
,
33 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
);
34 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
);
35 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
);
36 static int afs_link(struct dentry
*from
, struct inode
*dir
,
37 struct dentry
*dentry
);
38 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
40 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
41 struct inode
*new_dir
, struct dentry
*new_dentry
,
43 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
);
44 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
47 static int afs_dir_set_page_dirty(struct page
*page
)
49 BUG(); /* This should never happen. */
52 const struct file_operations afs_dir_file_operations
= {
54 .release
= afs_release
,
55 .iterate_shared
= afs_readdir
,
57 .llseek
= generic_file_llseek
,
60 const struct inode_operations afs_dir_inode_operations
= {
65 .symlink
= afs_symlink
,
69 .permission
= afs_permission
,
70 .getattr
= afs_getattr
,
71 .setattr
= afs_setattr
,
72 .listxattr
= afs_listxattr
,
75 const struct address_space_operations afs_dir_aops
= {
76 .set_page_dirty
= afs_dir_set_page_dirty
,
77 .releasepage
= afs_dir_releasepage
,
78 .invalidatepage
= afs_dir_invalidatepage
,
81 const struct dentry_operations afs_fs_dentry_operations
= {
82 .d_revalidate
= afs_d_revalidate
,
83 .d_delete
= afs_d_delete
,
84 .d_release
= afs_d_release
,
85 .d_automount
= afs_d_automount
,
89 struct afs_lookup_one_cookie
{
90 struct dir_context ctx
;
96 struct afs_lookup_cookie
{
97 struct dir_context ctx
;
101 unsigned short nr_fids
;
102 struct inode
**inodes
;
103 struct afs_status_cb
*statuses
;
104 struct afs_fid fids
[50];
108 * check that a directory page is valid
110 static bool afs_dir_check_page(struct afs_vnode
*dvnode
, struct page
*page
,
113 struct afs_xdr_dir_page
*dbuf
;
117 /* Determine how many magic numbers there should be in this page, but
118 * we must take care because the directory may change size under us.
120 off
= page_offset(page
);
124 latter
= i_size
- off
;
125 if (latter
>= PAGE_SIZE
)
129 qty
/= sizeof(union afs_xdr_dir_block
);
133 for (tmp
= 0; tmp
< qty
; tmp
++) {
134 if (dbuf
->blocks
[tmp
].hdr
.magic
!= AFS_DIR_MAGIC
) {
135 printk("kAFS: %s(%lx): bad magic %d/%d is %04hx\n",
136 __func__
, dvnode
->vfs_inode
.i_ino
, tmp
, qty
,
137 ntohs(dbuf
->blocks
[tmp
].hdr
.magic
));
138 trace_afs_dir_check_failed(dvnode
, off
, i_size
);
140 trace_afs_file_error(dvnode
, -EIO
, afs_file_error_dir_bad_magic
);
144 /* Make sure each block is NUL terminated so we can reasonably
145 * use string functions on it. The filenames in the page
146 * *should* be NUL-terminated anyway.
148 ((u8
*)&dbuf
->blocks
[tmp
])[AFS_DIR_BLOCK_SIZE
- 1] = 0;
154 afs_stat_v(dvnode
, n_read_dir
);
162 * Check the contents of a directory that we've just read.
164 static bool afs_dir_check_pages(struct afs_vnode
*dvnode
, struct afs_read
*req
)
166 struct afs_xdr_dir_page
*dbuf
;
167 unsigned int i
, j
, qty
= PAGE_SIZE
/ sizeof(union afs_xdr_dir_block
);
169 for (i
= 0; i
< req
->nr_pages
; i
++)
170 if (!afs_dir_check_page(dvnode
, req
->pages
[i
], req
->actual_len
))
175 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx r=%llx\n",
176 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
177 req
->file_size
, req
->len
, req
->actual_len
, req
->remain
);
178 pr_warn("DIR %llx %x %x %x\n",
179 req
->pos
, req
->index
, req
->nr_pages
, req
->offset
);
181 for (i
= 0; i
< req
->nr_pages
; i
++) {
182 dbuf
= kmap(req
->pages
[i
]);
183 for (j
= 0; j
< qty
; j
++) {
184 union afs_xdr_dir_block
*block
= &dbuf
->blocks
[j
];
186 pr_warn("[%02x] %32phN\n", i
* qty
+ j
, block
);
188 kunmap(req
->pages
[i
]);
194 * open an AFS directory file
196 static int afs_dir_open(struct inode
*inode
, struct file
*file
)
198 _enter("{%lu}", inode
->i_ino
);
200 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
201 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
203 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(inode
)->flags
))
206 return afs_open(inode
, file
);
210 * Read the directory into the pagecache in one go, scrubbing the previous
211 * contents. The list of pages is returned, pinning them so that they don't
212 * get reclaimed during the iteration.
214 static struct afs_read
*afs_read_dir(struct afs_vnode
*dvnode
, struct key
*key
)
215 __acquires(&dvnode
->validate_lock
)
217 struct afs_read
*req
;
219 int nr_pages
, nr_inline
, i
, n
;
223 i_size
= i_size_read(&dvnode
->vfs_inode
);
225 return ERR_PTR(afs_bad(dvnode
, afs_file_error_dir_small
));
226 if (i_size
> 2048 * 1024) {
227 trace_afs_file_error(dvnode
, -EFBIG
, afs_file_error_dir_big
);
228 return ERR_PTR(-EFBIG
);
231 _enter("%llu", i_size
);
233 /* Get a request record to hold the page list. We want to hold it
234 * inline if we can, but we don't want to make an order 1 allocation.
236 nr_pages
= (i_size
+ PAGE_SIZE
- 1) / PAGE_SIZE
;
237 nr_inline
= nr_pages
;
238 if (nr_inline
> (PAGE_SIZE
- sizeof(*req
)) / sizeof(struct page
*))
241 req
= kzalloc(struct_size(req
, array
, nr_inline
), GFP_KERNEL
);
243 return ERR_PTR(-ENOMEM
);
245 refcount_set(&req
->usage
, 1);
246 req
->nr_pages
= nr_pages
;
247 req
->actual_len
= i_size
; /* May change */
248 req
->len
= nr_pages
* PAGE_SIZE
; /* We can ask for more than there is */
249 req
->data_version
= dvnode
->status
.data_version
; /* May change */
251 req
->pages
= req
->array
;
253 req
->pages
= kcalloc(nr_pages
, sizeof(struct page
*),
259 /* Get a list of all the pages that hold or will hold the directory
260 * content. We need to fill in any gaps that we might find where the
261 * memory reclaimer has been at work. If there are any gaps, we will
262 * need to reread the entire directory contents.
266 n
= find_get_pages_contig(dvnode
->vfs_inode
.i_mapping
, i
,
269 _debug("find %u at %u/%u", n
, i
, req
->nr_pages
);
271 gfp_t gfp
= dvnode
->vfs_inode
.i_mapping
->gfp_mask
;
273 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
274 afs_stat_v(dvnode
, n_inval
);
277 req
->pages
[i
] = __page_cache_alloc(gfp
);
280 ret
= add_to_page_cache_lru(req
->pages
[i
],
281 dvnode
->vfs_inode
.i_mapping
,
286 set_page_private(req
->pages
[i
], 1);
287 SetPagePrivate(req
->pages
[i
]);
288 unlock_page(req
->pages
[i
]);
293 } while (i
< req
->nr_pages
);
295 /* If we're going to reload, we need to lock all the pages to prevent
299 if (down_read_killable(&dvnode
->validate_lock
) < 0)
302 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
305 up_read(&dvnode
->validate_lock
);
306 if (down_write_killable(&dvnode
->validate_lock
) < 0)
309 if (!test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
310 trace_afs_reload_dir(dvnode
);
311 ret
= afs_fetch_data(dvnode
, key
, req
);
315 task_io_account_read(PAGE_SIZE
* req
->nr_pages
);
317 if (req
->len
< req
->file_size
)
318 goto content_has_grown
;
320 /* Validate the data we just read. */
322 if (!afs_dir_check_pages(dvnode
, req
))
325 // TODO: Trim excess pages
327 set_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
);
330 downgrade_write(&dvnode
->validate_lock
);
335 up_write(&dvnode
->validate_lock
);
338 _leave(" = %d", ret
);
342 up_write(&dvnode
->validate_lock
);
348 * deal with one block in an AFS directory
350 static int afs_dir_iterate_block(struct afs_vnode
*dvnode
,
351 struct dir_context
*ctx
,
352 union afs_xdr_dir_block
*block
,
355 union afs_xdr_dirent
*dire
;
356 unsigned offset
, next
, curr
;
360 _enter("%u,%x,%p,,",(unsigned)ctx
->pos
,blkoff
,block
);
362 curr
= (ctx
->pos
- blkoff
) / sizeof(union afs_xdr_dirent
);
364 /* walk through the block, an entry at a time */
365 for (offset
= (blkoff
== 0 ? AFS_DIR_RESV_BLOCKS0
: AFS_DIR_RESV_BLOCKS
);
366 offset
< AFS_DIR_SLOTS_PER_BLOCK
;
371 /* skip entries marked unused in the bitmap */
372 if (!(block
->hdr
.bitmap
[offset
/ 8] &
373 (1 << (offset
% 8)))) {
374 _debug("ENT[%zu.%u]: unused",
375 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
);
378 next
* sizeof(union afs_xdr_dirent
);
382 /* got a valid entry */
383 dire
= &block
->dirents
[offset
];
384 nlen
= strnlen(dire
->u
.name
,
386 offset
* sizeof(union afs_xdr_dirent
));
388 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
389 blkoff
/ sizeof(union afs_xdr_dir_block
), offset
,
390 (offset
< curr
? "skip" : "fill"),
393 /* work out where the next possible entry is */
394 for (tmp
= nlen
; tmp
> 15; tmp
-= sizeof(union afs_xdr_dirent
)) {
395 if (next
>= AFS_DIR_SLOTS_PER_BLOCK
) {
396 _debug("ENT[%zu.%u]:"
397 " %u travelled beyond end dir block"
399 blkoff
/ sizeof(union afs_xdr_dir_block
),
400 offset
, next
, tmp
, nlen
);
401 return afs_bad(dvnode
, afs_file_error_dir_over_end
);
403 if (!(block
->hdr
.bitmap
[next
/ 8] &
404 (1 << (next
% 8)))) {
405 _debug("ENT[%zu.%u]:"
406 " %u unmarked extension (len %u/%zu)",
407 blkoff
/ sizeof(union afs_xdr_dir_block
),
408 offset
, next
, tmp
, nlen
);
409 return afs_bad(dvnode
, afs_file_error_dir_unmarked_ext
);
412 _debug("ENT[%zu.%u]: ext %u/%zu",
413 blkoff
/ sizeof(union afs_xdr_dir_block
),
418 /* skip if starts before the current position */
422 /* found the next entry */
423 if (!dir_emit(ctx
, dire
->u
.name
, nlen
,
424 ntohl(dire
->u
.vnode
),
425 (ctx
->actor
== afs_lookup_filldir
||
426 ctx
->actor
== afs_lookup_one_filldir
)?
427 ntohl(dire
->u
.unique
) : DT_UNKNOWN
)) {
428 _leave(" = 0 [full]");
432 ctx
->pos
= blkoff
+ next
* sizeof(union afs_xdr_dirent
);
435 _leave(" = 1 [more]");
440 * iterate through the data blob that lists the contents of an AFS directory
442 static int afs_dir_iterate(struct inode
*dir
, struct dir_context
*ctx
,
443 struct key
*key
, afs_dataversion_t
*_dir_version
)
445 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
446 struct afs_xdr_dir_page
*dbuf
;
447 union afs_xdr_dir_block
*dblock
;
448 struct afs_read
*req
;
450 unsigned blkoff
, limit
;
453 _enter("{%lu},%u,,", dir
->i_ino
, (unsigned)ctx
->pos
);
455 if (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(dir
)->flags
)) {
456 _leave(" = -ESTALE");
460 req
= afs_read_dir(dvnode
, key
);
463 *_dir_version
= req
->data_version
;
465 /* round the file position up to the next entry boundary */
466 ctx
->pos
+= sizeof(union afs_xdr_dirent
) - 1;
467 ctx
->pos
&= ~(sizeof(union afs_xdr_dirent
) - 1);
469 /* walk through the blocks in sequence */
471 while (ctx
->pos
< req
->actual_len
) {
472 blkoff
= ctx
->pos
& ~(sizeof(union afs_xdr_dir_block
) - 1);
474 /* Fetch the appropriate page from the directory and re-add it
477 page
= req
->pages
[blkoff
/ PAGE_SIZE
];
479 ret
= afs_bad(dvnode
, afs_file_error_dir_missing_page
);
482 mark_page_accessed(page
);
484 limit
= blkoff
& ~(PAGE_SIZE
- 1);
488 /* deal with the individual blocks stashed on this page */
490 dblock
= &dbuf
->blocks
[(blkoff
% PAGE_SIZE
) /
491 sizeof(union afs_xdr_dir_block
)];
492 ret
= afs_dir_iterate_block(dvnode
, ctx
, dblock
, blkoff
);
498 blkoff
+= sizeof(union afs_xdr_dir_block
);
500 } while (ctx
->pos
< dir
->i_size
&& blkoff
< limit
);
507 up_read(&dvnode
->validate_lock
);
509 _leave(" = %d", ret
);
514 * read an AFS directory
516 static int afs_readdir(struct file
*file
, struct dir_context
*ctx
)
518 afs_dataversion_t dir_version
;
520 return afs_dir_iterate(file_inode(file
), ctx
, afs_file_key(file
),
525 * Search the directory for a single name
526 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
527 * uniquifier through dtype
529 static int afs_lookup_one_filldir(struct dir_context
*ctx
, const char *name
,
530 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
532 struct afs_lookup_one_cookie
*cookie
=
533 container_of(ctx
, struct afs_lookup_one_cookie
, ctx
);
535 _enter("{%s,%u},%s,%u,,%llu,%u",
536 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
537 (unsigned long long) ino
, dtype
);
539 /* insanity checks first */
540 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
541 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
543 if (cookie
->name
.len
!= nlen
||
544 memcmp(cookie
->name
.name
, name
, nlen
) != 0) {
549 cookie
->fid
.vnode
= ino
;
550 cookie
->fid
.unique
= dtype
;
553 _leave(" = -1 [found]");
558 * Do a lookup of a single name in a directory
559 * - just returns the FID the dentry name maps to if found
561 static int afs_do_lookup_one(struct inode
*dir
, struct dentry
*dentry
,
562 struct afs_fid
*fid
, struct key
*key
,
563 afs_dataversion_t
*_dir_version
)
565 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
566 struct afs_lookup_one_cookie cookie
= {
567 .ctx
.actor
= afs_lookup_one_filldir
,
568 .name
= dentry
->d_name
,
569 .fid
.vid
= as
->volume
->vid
573 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
575 /* search the directory */
576 ret
= afs_dir_iterate(dir
, &cookie
.ctx
, key
, _dir_version
);
578 _leave(" = %d [iter]", ret
);
584 _leave(" = -ENOENT [not found]");
589 _leave(" = 0 { vn=%llu u=%u }", fid
->vnode
, fid
->unique
);
594 * search the directory for a name
595 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
596 * uniquifier through dtype
598 static int afs_lookup_filldir(struct dir_context
*ctx
, const char *name
,
599 int nlen
, loff_t fpos
, u64 ino
, unsigned dtype
)
601 struct afs_lookup_cookie
*cookie
=
602 container_of(ctx
, struct afs_lookup_cookie
, ctx
);
605 _enter("{%s,%u},%s,%u,,%llu,%u",
606 cookie
->name
.name
, cookie
->name
.len
, name
, nlen
,
607 (unsigned long long) ino
, dtype
);
609 /* insanity checks first */
610 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block
) != 2048);
611 BUILD_BUG_ON(sizeof(union afs_xdr_dirent
) != 32);
614 if (cookie
->nr_fids
< 50) {
615 cookie
->fids
[cookie
->nr_fids
].vnode
= ino
;
616 cookie
->fids
[cookie
->nr_fids
].unique
= dtype
;
619 } else if (cookie
->name
.len
== nlen
&&
620 memcmp(cookie
->name
.name
, name
, nlen
) == 0) {
621 cookie
->fids
[0].vnode
= ino
;
622 cookie
->fids
[0].unique
= dtype
;
624 if (cookie
->one_only
)
628 ret
= cookie
->nr_fids
>= 50 ? -1 : 0;
629 _leave(" = %d", ret
);
634 * Do a lookup in a directory. We make use of bulk lookup to query a slew of
635 * files in one go and create inodes for them. The inode of the file we were
636 * asked for is returned.
638 static struct inode
*afs_do_lookup(struct inode
*dir
, struct dentry
*dentry
,
641 struct afs_lookup_cookie
*cookie
;
642 struct afs_cb_interest
*dcbi
, *cbi
= NULL
;
643 struct afs_super_info
*as
= dir
->i_sb
->s_fs_info
;
644 struct afs_status_cb
*scb
;
645 struct afs_iget_data iget_data
;
646 struct afs_fs_cursor fc
;
647 struct afs_server
*server
;
648 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
;
649 struct inode
*inode
= NULL
, *ti
;
650 afs_dataversion_t data_version
= READ_ONCE(dvnode
->status
.data_version
);
653 _enter("{%lu},%p{%pd},", dir
->i_ino
, dentry
, dentry
);
655 cookie
= kzalloc(sizeof(struct afs_lookup_cookie
), GFP_KERNEL
);
657 return ERR_PTR(-ENOMEM
);
659 cookie
->ctx
.actor
= afs_lookup_filldir
;
660 cookie
->name
= dentry
->d_name
;
661 cookie
->nr_fids
= 1; /* slot 0 is saved for the fid we actually want */
663 read_seqlock_excl(&dvnode
->cb_lock
);
664 dcbi
= rcu_dereference_protected(dvnode
->cb_interest
,
665 lockdep_is_held(&dvnode
->cb_lock
.lock
));
667 server
= dcbi
->server
;
669 test_bit(AFS_SERVER_FL_NO_IBULK
, &server
->flags
))
670 cookie
->one_only
= true;
672 read_sequnlock_excl(&dvnode
->cb_lock
);
674 for (i
= 0; i
< 50; i
++)
675 cookie
->fids
[i
].vid
= as
->volume
->vid
;
677 /* search the directory */
678 ret
= afs_dir_iterate(dir
, &cookie
->ctx
, key
, &data_version
);
680 inode
= ERR_PTR(ret
);
684 dentry
->d_fsdata
= (void *)(unsigned long)data_version
;
686 inode
= ERR_PTR(-ENOENT
);
690 /* Check to see if we already have an inode for the primary fid. */
691 iget_data
.fid
= cookie
->fids
[0];
692 iget_data
.volume
= dvnode
->volume
;
693 iget_data
.cb_v_break
= dvnode
->volume
->cb_v_break
;
694 iget_data
.cb_s_break
= 0;
695 inode
= ilookup5(dir
->i_sb
, cookie
->fids
[0].vnode
,
696 afs_iget5_test
, &iget_data
);
700 /* Need space for examining all the selected files */
701 inode
= ERR_PTR(-ENOMEM
);
702 cookie
->statuses
= kvcalloc(cookie
->nr_fids
, sizeof(struct afs_status_cb
),
704 if (!cookie
->statuses
)
707 cookie
->inodes
= kcalloc(cookie
->nr_fids
, sizeof(struct inode
*),
712 for (i
= 1; i
< cookie
->nr_fids
; i
++) {
713 scb
= &cookie
->statuses
[i
];
715 /* Find any inodes that already exist and get their
718 iget_data
.fid
= cookie
->fids
[i
];
719 ti
= ilookup5_nowait(dir
->i_sb
, iget_data
.fid
.vnode
,
720 afs_iget5_test
, &iget_data
);
721 if (!IS_ERR_OR_NULL(ti
)) {
722 vnode
= AFS_FS_I(ti
);
723 scb
->cb_break
= afs_calc_vnode_cb_break(vnode
);
724 cookie
->inodes
[i
] = ti
;
728 /* Try FS.InlineBulkStatus first. Abort codes for the individual
729 * lookups contained therein are stored in the reply without aborting
730 * the whole operation.
732 if (cookie
->one_only
)
733 goto no_inline_bulk_status
;
735 inode
= ERR_PTR(-ERESTARTSYS
);
736 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
737 while (afs_select_fileserver(&fc
)) {
738 if (test_bit(AFS_SERVER_FL_NO_IBULK
,
739 &fc
.cbi
->server
->flags
)) {
740 fc
.ac
.abort_code
= RX_INVALID_OPERATION
;
741 fc
.ac
.error
= -ECONNABORTED
;
744 iget_data
.cb_v_break
= dvnode
->volume
->cb_v_break
;
745 iget_data
.cb_s_break
= fc
.cbi
->server
->cb_s_break
;
746 afs_fs_inline_bulk_status(&fc
,
750 cookie
->nr_fids
, NULL
);
753 if (fc
.ac
.error
== 0)
754 cbi
= afs_get_cb_interest(fc
.cbi
);
755 if (fc
.ac
.abort_code
== RX_INVALID_OPERATION
)
756 set_bit(AFS_SERVER_FL_NO_IBULK
, &fc
.cbi
->server
->flags
);
757 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
762 if (fc
.ac
.abort_code
!= RX_INVALID_OPERATION
)
765 no_inline_bulk_status
:
766 /* We could try FS.BulkStatus next, but this aborts the entire op if
767 * any of the lookups fails - so, for the moment, revert to
768 * FS.FetchStatus for just the primary fid.
770 inode
= ERR_PTR(-ERESTARTSYS
);
771 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
772 while (afs_select_fileserver(&fc
)) {
773 iget_data
.cb_v_break
= dvnode
->volume
->cb_v_break
;
774 iget_data
.cb_s_break
= fc
.cbi
->server
->cb_s_break
;
775 scb
= &cookie
->statuses
[0];
776 afs_fs_fetch_status(&fc
,
783 if (fc
.ac
.error
== 0)
784 cbi
= afs_get_cb_interest(fc
.cbi
);
785 inode
= ERR_PTR(afs_end_vnode_operation(&fc
));
792 /* Turn all the files into inodes and save the first one - which is the
793 * one we actually want.
795 scb
= &cookie
->statuses
[0];
796 if (scb
->status
.abort_code
!= 0)
797 inode
= ERR_PTR(afs_abort_to_error(scb
->status
.abort_code
));
799 for (i
= 0; i
< cookie
->nr_fids
; i
++) {
800 struct afs_status_cb
*scb
= &cookie
->statuses
[i
];
802 if (!scb
->have_status
&& !scb
->have_error
)
805 if (cookie
->inodes
[i
]) {
806 struct afs_vnode
*iv
= AFS_FS_I(cookie
->inodes
[i
]);
808 if (test_bit(AFS_VNODE_UNSET
, &iv
->flags
))
811 afs_vnode_commit_status(&fc
, iv
,
812 scb
->cb_break
, NULL
, scb
);
816 if (scb
->status
.abort_code
!= 0)
819 iget_data
.fid
= cookie
->fids
[i
];
820 ti
= afs_iget(dir
->i_sb
, key
, &iget_data
, scb
, cbi
, dvnode
);
822 afs_cache_permit(AFS_FS_I(ti
), key
,
823 0 /* Assume vnode->cb_break is 0 */ +
824 iget_data
.cb_v_break
,
835 afs_put_cb_interest(afs_v2net(dvnode
), cbi
);
836 if (cookie
->inodes
) {
837 for (i
= 0; i
< cookie
->nr_fids
; i
++)
838 iput(cookie
->inodes
[i
]);
839 kfree(cookie
->inodes
);
842 kvfree(cookie
->statuses
);
849 * Look up an entry in a directory with @sys substitution.
851 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
854 struct afs_sysnames
*subs
;
855 struct afs_net
*net
= afs_i2net(dir
);
857 char *buf
, *p
, *name
;
862 ret
= ERR_PTR(-ENOMEM
);
863 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
866 if (dentry
->d_name
.len
> 4) {
867 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
868 p
+= dentry
->d_name
.len
- 4;
871 /* There is an ordered list of substitutes that we have to try. */
872 read_lock(&net
->sysnames_lock
);
873 subs
= net
->sysnames
;
874 refcount_inc(&subs
->usage
);
875 read_unlock(&net
->sysnames_lock
);
877 for (i
= 0; i
< subs
->nr
; i
++) {
878 name
= subs
->subs
[i
];
879 len
= dentry
->d_name
.len
- 4 + strlen(name
);
880 if (len
>= AFSNAMEMAX
) {
881 ret
= ERR_PTR(-ENAMETOOLONG
);
886 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
887 if (IS_ERR(ret
) || d_is_positive(ret
))
892 /* We don't want to d_add() the @sys dentry here as we don't want to
893 * the cached dentry to hide changes to the sysnames list.
897 afs_put_sysnames(subs
);
905 * look up an entry in a directory
907 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
910 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
916 _enter("{%llx:%llu},%p{%pd},",
917 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
919 ASSERTCMP(d_inode(dentry
), ==, NULL
);
921 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
922 _leave(" = -ENAMETOOLONG");
923 return ERR_PTR(-ENAMETOOLONG
);
926 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
927 _leave(" = -ESTALE");
928 return ERR_PTR(-ESTALE
);
931 key
= afs_request_key(dvnode
->volume
->cell
);
933 _leave(" = %ld [key]", PTR_ERR(key
));
934 return ERR_CAST(key
);
937 ret
= afs_validate(dvnode
, key
);
940 _leave(" = %d [val]", ret
);
944 if (dentry
->d_name
.len
>= 4 &&
945 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
946 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
947 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
948 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
949 return afs_lookup_atsys(dir
, dentry
, key
);
951 afs_stat_v(dvnode
, n_lookup
);
952 inode
= afs_do_lookup(dir
, dentry
, key
);
954 if (inode
== ERR_PTR(-ENOENT
)) {
955 inode
= afs_try_auto_mntpt(dentry
, dir
);
958 (void *)(unsigned long)dvnode
->status
.data_version
;
960 d
= d_splice_alias(inode
, dentry
);
961 if (!IS_ERR_OR_NULL(d
)) {
962 d
->d_fsdata
= dentry
->d_fsdata
;
963 trace_afs_lookup(dvnode
, &d
->d_name
,
964 inode
? AFS_FS_I(inode
) : NULL
);
966 trace_afs_lookup(dvnode
, &dentry
->d_name
,
967 IS_ERR_OR_NULL(inode
) ? NULL
974 * Check the validity of a dentry under RCU conditions.
976 static int afs_d_revalidate_rcu(struct dentry
*dentry
)
978 struct afs_vnode
*dvnode
, *vnode
;
979 struct dentry
*parent
;
980 struct inode
*dir
, *inode
;
981 long dir_version
, de_version
;
983 _enter("%p", dentry
);
985 /* Check the parent directory is still valid first. */
986 parent
= READ_ONCE(dentry
->d_parent
);
987 dir
= d_inode_rcu(parent
);
990 dvnode
= AFS_FS_I(dir
);
991 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
))
994 if (!afs_check_validity(dvnode
))
997 /* We only need to invalidate a dentry if the server's copy changed
998 * behind our back. If we made the change, it's no problem. Note that
999 * on a 32-bit system, we only have 32 bits in the dentry to store the
1002 dir_version
= (long)READ_ONCE(dvnode
->status
.data_version
);
1003 de_version
= (long)READ_ONCE(dentry
->d_fsdata
);
1004 if (de_version
!= dir_version
) {
1005 dir_version
= (long)READ_ONCE(dvnode
->invalid_before
);
1006 if (de_version
- dir_version
< 0)
1010 /* Check to see if the vnode referred to by the dentry still
1013 if (d_really_is_positive(dentry
)) {
1014 inode
= d_inode_rcu(dentry
);
1016 vnode
= AFS_FS_I(inode
);
1017 if (!afs_check_validity(vnode
))
1022 return 1; /* Still valid */
1026 * check that a dentry lookup hit has found a valid entry
1027 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
1030 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
1032 struct afs_vnode
*vnode
, *dir
;
1033 struct afs_fid
uninitialized_var(fid
);
1034 struct dentry
*parent
;
1035 struct inode
*inode
;
1037 afs_dataversion_t dir_version
;
1041 if (flags
& LOOKUP_RCU
)
1042 return afs_d_revalidate_rcu(dentry
);
1044 if (d_really_is_positive(dentry
)) {
1045 vnode
= AFS_FS_I(d_inode(dentry
));
1046 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
1047 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
1050 _enter("{neg n=%pd}", dentry
);
1053 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
1057 if (d_really_is_positive(dentry
)) {
1058 inode
= d_inode(dentry
);
1060 vnode
= AFS_FS_I(inode
);
1061 afs_validate(vnode
, key
);
1062 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1067 /* lock down the parent dentry so we can peer at it */
1068 parent
= dget_parent(dentry
);
1069 dir
= AFS_FS_I(d_inode(parent
));
1071 /* validate the parent directory */
1072 afs_validate(dir
, key
);
1074 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
1075 _debug("%pd: parent dir deleted", dentry
);
1076 goto out_bad_parent
;
1079 /* We only need to invalidate a dentry if the server's copy changed
1080 * behind our back. If we made the change, it's no problem. Note that
1081 * on a 32-bit system, we only have 32 bits in the dentry to store the
1084 dir_version
= dir
->status
.data_version
;
1085 de_version
= (long)dentry
->d_fsdata
;
1086 if (de_version
== (long)dir_version
)
1087 goto out_valid_noupdate
;
1089 dir_version
= dir
->invalid_before
;
1090 if (de_version
- (long)dir_version
>= 0)
1093 _debug("dir modified");
1094 afs_stat_v(dir
, n_reval
);
1096 /* search the directory for this vnode */
1097 ret
= afs_do_lookup_one(&dir
->vfs_inode
, dentry
, &fid
, key
, &dir_version
);
1100 /* the filename maps to something */
1101 if (d_really_is_negative(dentry
))
1102 goto out_bad_parent
;
1103 inode
= d_inode(dentry
);
1104 if (is_bad_inode(inode
)) {
1105 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1107 goto out_bad_parent
;
1110 vnode
= AFS_FS_I(inode
);
1112 /* if the vnode ID has changed, then the dirent points to a
1114 if (fid
.vnode
!= vnode
->fid
.vnode
) {
1115 _debug("%pd: dirent changed [%llu != %llu]",
1121 /* if the vnode ID uniqifier has changed, then the file has
1122 * been deleted and replaced, and the original vnode ID has
1124 if (fid
.unique
!= vnode
->fid
.unique
) {
1125 _debug("%pd: file deleted (uq %u -> %u I:%u)",
1128 vnode
->vfs_inode
.i_generation
);
1129 write_seqlock(&vnode
->cb_lock
);
1130 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1131 write_sequnlock(&vnode
->cb_lock
);
1137 /* the filename is unknown */
1138 _debug("%pd: dirent not found", dentry
);
1139 if (d_really_is_positive(dentry
))
1144 _debug("failed to iterate dir %pd: %d",
1146 goto out_bad_parent
;
1150 dentry
->d_fsdata
= (void *)(unsigned long)dir_version
;
1154 _leave(" = 1 [valid]");
1157 /* the dirent, if it exists, now points to a different vnode */
1159 spin_lock(&dentry
->d_lock
);
1160 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
1161 spin_unlock(&dentry
->d_lock
);
1164 _debug("dropping dentry %pd2", dentry
);
1169 _leave(" = 0 [bad]");
1174 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1176 * - called from dput() when d_count is going to 0.
1177 * - return 1 to request dentry be unhashed, 0 otherwise
1179 static int afs_d_delete(const struct dentry
*dentry
)
1181 _enter("%pd", dentry
);
1183 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1186 if (d_really_is_positive(dentry
) &&
1187 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1188 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1191 _leave(" = 0 [keep]");
1195 _leave(" = 1 [zap]");
1200 * Clean up sillyrename files on dentry removal.
1202 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
)
1204 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1205 afs_silly_iput(dentry
, inode
);
1210 * handle dentry release
1212 void afs_d_release(struct dentry
*dentry
)
1214 _enter("%pd", dentry
);
1218 * Create a new inode for create/mkdir/symlink
1220 static void afs_vnode_new_inode(struct afs_fs_cursor
*fc
,
1221 struct dentry
*new_dentry
,
1222 struct afs_iget_data
*new_data
,
1223 struct afs_status_cb
*new_scb
)
1225 struct afs_vnode
*vnode
;
1226 struct inode
*inode
;
1228 if (fc
->ac
.error
< 0)
1231 inode
= afs_iget(fc
->vnode
->vfs_inode
.i_sb
, fc
->key
,
1232 new_data
, new_scb
, fc
->cbi
, fc
->vnode
);
1233 if (IS_ERR(inode
)) {
1234 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1235 * the new directory on the server.
1237 fc
->ac
.error
= PTR_ERR(inode
);
1241 vnode
= AFS_FS_I(inode
);
1242 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1243 if (fc
->ac
.error
== 0)
1244 afs_cache_permit(vnode
, fc
->key
, vnode
->cb_break
, new_scb
);
1245 d_instantiate(new_dentry
, inode
);
1248 static void afs_prep_for_new_inode(struct afs_fs_cursor
*fc
,
1249 struct afs_iget_data
*iget_data
)
1251 iget_data
->volume
= fc
->vnode
->volume
;
1252 iget_data
->cb_v_break
= fc
->vnode
->volume
->cb_v_break
;
1253 iget_data
->cb_s_break
= fc
->cbi
->server
->cb_s_break
;
1257 * Note that a dentry got changed. We need to set d_fsdata to the data version
1258 * number derived from the result of the operation. It doesn't matter if
1259 * d_fsdata goes backwards as we'll just revalidate.
1261 static void afs_update_dentry_version(struct afs_fs_cursor
*fc
,
1262 struct dentry
*dentry
,
1263 struct afs_status_cb
*scb
)
1265 if (fc
->ac
.error
== 0)
1267 (void *)(unsigned long)scb
->status
.data_version
;
1271 * create a directory on an AFS filesystem
1273 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
1275 struct afs_iget_data iget_data
;
1276 struct afs_status_cb
*scb
;
1277 struct afs_fs_cursor fc
;
1278 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1284 _enter("{%llx:%llu},{%pd},%ho",
1285 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1288 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1292 key
= afs_request_key(dvnode
->volume
->cell
);
1299 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1300 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1302 while (afs_select_fileserver(&fc
)) {
1303 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1304 afs_prep_for_new_inode(&fc
, &iget_data
);
1305 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
,
1306 &scb
[0], &iget_data
.fid
, &scb
[1]);
1309 afs_check_for_remote_deletion(&fc
, dvnode
);
1310 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1311 &data_version
, &scb
[0]);
1312 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1313 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1314 ret
= afs_end_vnode_operation(&fc
);
1322 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1323 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1324 afs_edit_dir_for_create
);
1337 _leave(" = %d", ret
);
1342 * Remove a subdir from a directory.
1344 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1346 if (d_really_is_positive(dentry
)) {
1347 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1349 clear_nlink(&vnode
->vfs_inode
);
1350 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1351 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1352 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1357 * remove a directory from an AFS filesystem
1359 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1361 struct afs_status_cb
*scb
;
1362 struct afs_fs_cursor fc
;
1363 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1367 _enter("{%llx:%llu},{%pd}",
1368 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1370 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
1374 key
= afs_request_key(dvnode
->volume
->cell
);
1380 /* Try to make sure we have a callback promise on the victim. */
1381 if (d_really_is_positive(dentry
)) {
1382 vnode
= AFS_FS_I(d_inode(dentry
));
1383 ret
= afs_validate(vnode
, key
);
1389 ret
= down_write_killable(&vnode
->rmdir_lock
);
1395 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1396 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1398 while (afs_select_fileserver(&fc
)) {
1399 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1400 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, true, scb
);
1403 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1404 &data_version
, scb
);
1405 afs_update_dentry_version(&fc
, dentry
, scb
);
1406 ret
= afs_end_vnode_operation(&fc
);
1408 afs_dir_remove_subdir(dentry
);
1409 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1410 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1411 afs_edit_dir_for_rmdir
);
1416 up_write(&vnode
->rmdir_lock
);
1425 * Remove a link to a file or symlink from a directory.
1427 * If the file was not deleted due to excess hard links, the fileserver will
1428 * break the callback promise on the file - if it had one - before it returns
1429 * to us, and if it was deleted, it won't
1431 * However, if we didn't have a callback promise outstanding, or it was
1432 * outstanding on a different server, then it won't break it either...
1434 static int afs_dir_remove_link(struct afs_vnode
*dvnode
, struct dentry
*dentry
,
1439 if (d_really_is_positive(dentry
)) {
1440 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1442 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1444 } else if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
1445 write_seqlock(&vnode
->cb_lock
);
1446 drop_nlink(&vnode
->vfs_inode
);
1447 if (vnode
->vfs_inode
.i_nlink
== 0) {
1448 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1449 __afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1451 write_sequnlock(&vnode
->cb_lock
);
1454 afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1456 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1457 kdebug("AFS_VNODE_DELETED");
1459 ret
= afs_validate(vnode
, key
);
1463 _debug("nlink %d [val %d]", vnode
->vfs_inode
.i_nlink
, ret
);
1470 * Remove a file or symlink from an AFS filesystem.
1472 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1474 struct afs_fs_cursor fc
;
1475 struct afs_status_cb
*scb
;
1476 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1477 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1479 bool need_rehash
= false;
1482 _enter("{%llx:%llu},{%pd}",
1483 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1485 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1486 return -ENAMETOOLONG
;
1489 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1493 key
= afs_request_key(dvnode
->volume
->cell
);
1499 /* Try to make sure we have a callback promise on the victim. */
1500 ret
= afs_validate(vnode
, key
);
1504 spin_lock(&dentry
->d_lock
);
1505 if (d_count(dentry
) > 1) {
1506 spin_unlock(&dentry
->d_lock
);
1507 /* Start asynchronous writeout of the inode */
1508 write_inode_now(d_inode(dentry
), 0);
1509 ret
= afs_sillyrename(dvnode
, vnode
, dentry
, key
);
1512 if (!d_unhashed(dentry
)) {
1513 /* Prevent a race with RCU lookup. */
1517 spin_unlock(&dentry
->d_lock
);
1520 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1521 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1522 afs_dataversion_t data_version_2
= vnode
->status
.data_version
;
1524 while (afs_select_fileserver(&fc
)) {
1525 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1526 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1528 if (test_bit(AFS_SERVER_FL_IS_YFS
, &fc
.cbi
->server
->flags
) &&
1529 !test_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
)) {
1530 yfs_fs_remove_file2(&fc
, vnode
, dentry
->d_name
.name
,
1532 if (fc
.ac
.error
!= -ECONNABORTED
||
1533 fc
.ac
.abort_code
!= RXGEN_OPCODE
)
1535 set_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
);
1538 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, false, &scb
[0]);
1541 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1542 &data_version
, &scb
[0]);
1543 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
,
1544 &data_version_2
, &scb
[1]);
1545 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1546 ret
= afs_end_vnode_operation(&fc
);
1547 if (ret
== 0 && !(scb
[1].have_status
|| scb
[1].have_error
))
1548 ret
= afs_dir_remove_link(dvnode
, dentry
, key
);
1550 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1551 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1552 afs_edit_dir_for_unlink
);
1555 if (need_rehash
&& ret
< 0 && ret
!= -ENOENT
)
1563 _leave(" = %d", ret
);
1568 * create a regular file on an AFS filesystem
1570 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
1573 struct afs_iget_data iget_data
;
1574 struct afs_fs_cursor fc
;
1575 struct afs_status_cb
*scb
;
1576 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1582 _enter("{%llx:%llu},{%pd},%ho,",
1583 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1585 ret
= -ENAMETOOLONG
;
1586 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1589 key
= afs_request_key(dvnode
->volume
->cell
);
1596 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1601 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1602 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1604 while (afs_select_fileserver(&fc
)) {
1605 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1606 afs_prep_for_new_inode(&fc
, &iget_data
);
1607 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
,
1608 &scb
[0], &iget_data
.fid
, &scb
[1]);
1611 afs_check_for_remote_deletion(&fc
, dvnode
);
1612 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1613 &data_version
, &scb
[0]);
1614 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1615 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1616 ret
= afs_end_vnode_operation(&fc
);
1623 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1624 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1625 afs_edit_dir_for_create
);
1638 _leave(" = %d", ret
);
1643 * create a hard link between files in an AFS filesystem
1645 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1646 struct dentry
*dentry
)
1648 struct afs_fs_cursor fc
;
1649 struct afs_status_cb
*scb
;
1650 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1651 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(from
));
1655 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1656 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1657 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1660 ret
= -ENAMETOOLONG
;
1661 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1665 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1669 key
= afs_request_key(dvnode
->volume
->cell
);
1676 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1677 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1679 if (mutex_lock_interruptible_nested(&vnode
->io_lock
, 1) < 0) {
1680 afs_end_vnode_operation(&fc
);
1684 while (afs_select_fileserver(&fc
)) {
1685 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1686 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1687 afs_fs_link(&fc
, vnode
, dentry
->d_name
.name
,
1691 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1692 &data_version
, &scb
[0]);
1693 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
,
1695 ihold(&vnode
->vfs_inode
);
1696 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1697 d_instantiate(dentry
, &vnode
->vfs_inode
);
1699 mutex_unlock(&vnode
->io_lock
);
1700 ret
= afs_end_vnode_operation(&fc
);
1707 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1708 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &vnode
->fid
,
1709 afs_edit_dir_for_link
);
1722 _leave(" = %d", ret
);
1727 * create a symlink in an AFS filesystem
1729 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1730 const char *content
)
1732 struct afs_iget_data iget_data
;
1733 struct afs_fs_cursor fc
;
1734 struct afs_status_cb
*scb
;
1735 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1739 _enter("{%llx:%llu},{%pd},%s",
1740 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1743 ret
= -ENAMETOOLONG
;
1744 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1748 if (strlen(content
) >= AFSPATHMAX
)
1752 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1756 key
= afs_request_key(dvnode
->volume
->cell
);
1763 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1764 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1766 while (afs_select_fileserver(&fc
)) {
1767 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1768 afs_prep_for_new_inode(&fc
, &iget_data
);
1769 afs_fs_symlink(&fc
, dentry
->d_name
.name
, content
,
1770 &scb
[0], &iget_data
.fid
, &scb
[1]);
1773 afs_check_for_remote_deletion(&fc
, dvnode
);
1774 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1775 &data_version
, &scb
[0]);
1776 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1777 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1778 ret
= afs_end_vnode_operation(&fc
);
1785 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1786 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1787 afs_edit_dir_for_symlink
);
1800 _leave(" = %d", ret
);
1805 * rename a file in an AFS filesystem and/or move it between directories
1807 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1808 struct inode
*new_dir
, struct dentry
*new_dentry
,
1811 struct afs_fs_cursor fc
;
1812 struct afs_status_cb
*scb
;
1813 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1814 struct dentry
*tmp
= NULL
, *rehash
= NULL
;
1815 struct inode
*new_inode
;
1817 bool new_negative
= d_is_negative(new_dentry
);
1823 /* Don't allow silly-rename files be moved around. */
1824 if (old_dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1827 vnode
= AFS_FS_I(d_inode(old_dentry
));
1828 orig_dvnode
= AFS_FS_I(old_dir
);
1829 new_dvnode
= AFS_FS_I(new_dir
);
1831 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1832 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1833 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1834 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1838 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1842 key
= afs_request_key(orig_dvnode
->volume
->cell
);
1848 /* For non-directories, check whether the target is busy and if so,
1849 * make a copy of the dentry and then do a silly-rename. If the
1850 * silly-rename succeeds, the copied dentry is hashed and becomes the
1853 if (d_is_positive(new_dentry
) && !d_is_dir(new_dentry
)) {
1854 /* To prevent any new references to the target during the
1855 * rename, we unhash the dentry in advance.
1857 if (!d_unhashed(new_dentry
)) {
1859 rehash
= new_dentry
;
1862 if (d_count(new_dentry
) > 2) {
1863 /* copy the target dentry's name */
1865 tmp
= d_alloc(new_dentry
->d_parent
,
1866 &new_dentry
->d_name
);
1870 ret
= afs_sillyrename(new_dvnode
,
1871 AFS_FS_I(d_inode(new_dentry
)),
1878 new_negative
= true;
1882 /* This bit is potentially nasty as there's a potential race with
1883 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
1884 * to reflect it's new parent's new data_version after the op, but
1885 * d_revalidate may see old_dentry between the op having taken place
1886 * and the version being updated.
1888 * So drop the old_dentry for now to make other threads go through
1889 * lookup instead - which we hold a lock against.
1894 if (afs_begin_vnode_operation(&fc
, orig_dvnode
, key
, true)) {
1895 afs_dataversion_t orig_data_version
;
1896 afs_dataversion_t new_data_version
;
1897 struct afs_status_cb
*new_scb
= &scb
[1];
1899 orig_data_version
= orig_dvnode
->status
.data_version
+ 1;
1901 if (orig_dvnode
!= new_dvnode
) {
1902 if (mutex_lock_interruptible_nested(&new_dvnode
->io_lock
, 1) < 0) {
1903 afs_end_vnode_operation(&fc
);
1904 goto error_rehash_old
;
1906 new_data_version
= new_dvnode
->status
.data_version
+ 1;
1908 new_data_version
= orig_data_version
;
1912 while (afs_select_fileserver(&fc
)) {
1913 fc
.cb_break
= afs_calc_vnode_cb_break(orig_dvnode
);
1914 fc
.cb_break_2
= afs_calc_vnode_cb_break(new_dvnode
);
1915 afs_fs_rename(&fc
, old_dentry
->d_name
.name
,
1916 new_dvnode
, new_dentry
->d_name
.name
,
1920 afs_vnode_commit_status(&fc
, orig_dvnode
, fc
.cb_break
,
1921 &orig_data_version
, &scb
[0]);
1922 if (new_dvnode
!= orig_dvnode
) {
1923 afs_vnode_commit_status(&fc
, new_dvnode
, fc
.cb_break_2
,
1924 &new_data_version
, &scb
[1]);
1925 mutex_unlock(&new_dvnode
->io_lock
);
1927 ret
= afs_end_vnode_operation(&fc
);
1929 goto error_rehash_old
;
1935 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
))
1936 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1937 afs_edit_dir_for_rename_0
);
1939 if (!new_negative
&&
1940 test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1941 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1942 afs_edit_dir_for_rename_1
);
1944 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1945 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1946 &vnode
->fid
, afs_edit_dir_for_rename_2
);
1948 new_inode
= d_inode(new_dentry
);
1950 spin_lock(&new_inode
->i_lock
);
1951 if (new_inode
->i_nlink
> 0)
1952 drop_nlink(new_inode
);
1953 spin_unlock(&new_inode
->i_lock
);
1956 /* Now we can update d_fsdata on the dentries to reflect their
1957 * new parent's data_version.
1959 * Note that if we ever implement RENAME_EXCHANGE, we'll have
1960 * to update both dentries with opposing dir versions.
1962 if (new_dvnode
!= orig_dvnode
) {
1963 afs_update_dentry_version(&fc
, old_dentry
, &scb
[1]);
1964 afs_update_dentry_version(&fc
, new_dentry
, &scb
[1]);
1966 afs_update_dentry_version(&fc
, old_dentry
, &scb
[0]);
1967 afs_update_dentry_version(&fc
, new_dentry
, &scb
[0]);
1969 d_move(old_dentry
, new_dentry
);
1974 d_rehash(new_dentry
);
1985 _leave(" = %d", ret
);
1990 * Release a directory page and clean up its private state if it's not busy
1991 * - return true if the page can now be released, false if not
1993 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
)
1995 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1997 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, page
->index
);
1999 set_page_private(page
, 0);
2000 ClearPagePrivate(page
);
2002 /* The directory will need reloading. */
2003 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2004 afs_stat_v(dvnode
, n_relpg
);
2009 * invalidate part or all of a page
2010 * - release a page and clean up its private data if offset is 0 (indicating
2013 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
2014 unsigned int length
)
2016 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
2018 _enter("{%lu},%u,%u", page
->index
, offset
, length
);
2020 BUG_ON(!PageLocked(page
));
2022 /* The directory will need reloading. */
2023 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
2024 afs_stat_v(dvnode
, n_inval
);
2026 /* we clean up only if the entire page is being invalidated */
2027 if (offset
== 0 && length
== PAGE_SIZE
) {
2028 set_page_private(page
, 0);
2029 ClearPagePrivate(page
);