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 afs_vnode_commit_status(&fc
, AFS_FS_I(cookie
->inodes
[i
]),
807 scb
->cb_break
, NULL
, scb
);
811 if (scb
->status
.abort_code
!= 0)
814 iget_data
.fid
= cookie
->fids
[i
];
815 ti
= afs_iget(dir
->i_sb
, key
, &iget_data
, scb
, cbi
, dvnode
);
817 afs_cache_permit(AFS_FS_I(ti
), key
,
818 0 /* Assume vnode->cb_break is 0 */ +
819 iget_data
.cb_v_break
,
830 afs_put_cb_interest(afs_v2net(dvnode
), cbi
);
831 if (cookie
->inodes
) {
832 for (i
= 0; i
< cookie
->nr_fids
; i
++)
833 iput(cookie
->inodes
[i
]);
834 kfree(cookie
->inodes
);
837 kvfree(cookie
->statuses
);
844 * Look up an entry in a directory with @sys substitution.
846 static struct dentry
*afs_lookup_atsys(struct inode
*dir
, struct dentry
*dentry
,
849 struct afs_sysnames
*subs
;
850 struct afs_net
*net
= afs_i2net(dir
);
852 char *buf
, *p
, *name
;
857 ret
= ERR_PTR(-ENOMEM
);
858 p
= buf
= kmalloc(AFSNAMEMAX
, GFP_KERNEL
);
861 if (dentry
->d_name
.len
> 4) {
862 memcpy(p
, dentry
->d_name
.name
, dentry
->d_name
.len
- 4);
863 p
+= dentry
->d_name
.len
- 4;
866 /* There is an ordered list of substitutes that we have to try. */
867 read_lock(&net
->sysnames_lock
);
868 subs
= net
->sysnames
;
869 refcount_inc(&subs
->usage
);
870 read_unlock(&net
->sysnames_lock
);
872 for (i
= 0; i
< subs
->nr
; i
++) {
873 name
= subs
->subs
[i
];
874 len
= dentry
->d_name
.len
- 4 + strlen(name
);
875 if (len
>= AFSNAMEMAX
) {
876 ret
= ERR_PTR(-ENAMETOOLONG
);
881 ret
= lookup_one_len(buf
, dentry
->d_parent
, len
);
882 if (IS_ERR(ret
) || d_is_positive(ret
))
887 /* We don't want to d_add() the @sys dentry here as we don't want to
888 * the cached dentry to hide changes to the sysnames list.
892 afs_put_sysnames(subs
);
900 * look up an entry in a directory
902 static struct dentry
*afs_lookup(struct inode
*dir
, struct dentry
*dentry
,
905 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
911 _enter("{%llx:%llu},%p{%pd},",
912 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, dentry
);
914 ASSERTCMP(d_inode(dentry
), ==, NULL
);
916 if (dentry
->d_name
.len
>= AFSNAMEMAX
) {
917 _leave(" = -ENAMETOOLONG");
918 return ERR_PTR(-ENAMETOOLONG
);
921 if (test_bit(AFS_VNODE_DELETED
, &dvnode
->flags
)) {
922 _leave(" = -ESTALE");
923 return ERR_PTR(-ESTALE
);
926 key
= afs_request_key(dvnode
->volume
->cell
);
928 _leave(" = %ld [key]", PTR_ERR(key
));
929 return ERR_CAST(key
);
932 ret
= afs_validate(dvnode
, key
);
935 _leave(" = %d [val]", ret
);
939 if (dentry
->d_name
.len
>= 4 &&
940 dentry
->d_name
.name
[dentry
->d_name
.len
- 4] == '@' &&
941 dentry
->d_name
.name
[dentry
->d_name
.len
- 3] == 's' &&
942 dentry
->d_name
.name
[dentry
->d_name
.len
- 2] == 'y' &&
943 dentry
->d_name
.name
[dentry
->d_name
.len
- 1] == 's')
944 return afs_lookup_atsys(dir
, dentry
, key
);
946 afs_stat_v(dvnode
, n_lookup
);
947 inode
= afs_do_lookup(dir
, dentry
, key
);
949 if (inode
== ERR_PTR(-ENOENT
)) {
950 inode
= afs_try_auto_mntpt(dentry
, dir
);
953 (void *)(unsigned long)dvnode
->status
.data_version
;
955 d
= d_splice_alias(inode
, dentry
);
956 if (!IS_ERR_OR_NULL(d
)) {
957 d
->d_fsdata
= dentry
->d_fsdata
;
958 trace_afs_lookup(dvnode
, &d
->d_name
,
959 inode
? AFS_FS_I(inode
) : NULL
);
961 trace_afs_lookup(dvnode
, &dentry
->d_name
,
962 IS_ERR_OR_NULL(inode
) ? NULL
969 * check that a dentry lookup hit has found a valid entry
970 * - NOTE! the hit can be a negative hit too, so we can't assume we have an
973 static int afs_d_revalidate(struct dentry
*dentry
, unsigned int flags
)
975 struct afs_vnode
*vnode
, *dir
;
976 struct afs_fid
uninitialized_var(fid
);
977 struct dentry
*parent
;
980 afs_dataversion_t dir_version
;
984 if (flags
& LOOKUP_RCU
)
987 if (d_really_is_positive(dentry
)) {
988 vnode
= AFS_FS_I(d_inode(dentry
));
989 _enter("{v={%llx:%llu} n=%pd fl=%lx},",
990 vnode
->fid
.vid
, vnode
->fid
.vnode
, dentry
,
993 _enter("{neg n=%pd}", dentry
);
996 key
= afs_request_key(AFS_FS_S(dentry
->d_sb
)->volume
->cell
);
1000 if (d_really_is_positive(dentry
)) {
1001 inode
= d_inode(dentry
);
1003 vnode
= AFS_FS_I(inode
);
1004 afs_validate(vnode
, key
);
1005 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1010 /* lock down the parent dentry so we can peer at it */
1011 parent
= dget_parent(dentry
);
1012 dir
= AFS_FS_I(d_inode(parent
));
1014 /* validate the parent directory */
1015 afs_validate(dir
, key
);
1017 if (test_bit(AFS_VNODE_DELETED
, &dir
->flags
)) {
1018 _debug("%pd: parent dir deleted", dentry
);
1019 goto out_bad_parent
;
1022 /* We only need to invalidate a dentry if the server's copy changed
1023 * behind our back. If we made the change, it's no problem. Note that
1024 * on a 32-bit system, we only have 32 bits in the dentry to store the
1027 dir_version
= dir
->status
.data_version
;
1028 de_version
= (long)dentry
->d_fsdata
;
1029 if (de_version
== (long)dir_version
)
1030 goto out_valid_noupdate
;
1032 dir_version
= dir
->invalid_before
;
1033 if (de_version
- (long)dir_version
>= 0)
1036 _debug("dir modified");
1037 afs_stat_v(dir
, n_reval
);
1039 /* search the directory for this vnode */
1040 ret
= afs_do_lookup_one(&dir
->vfs_inode
, dentry
, &fid
, key
, &dir_version
);
1043 /* the filename maps to something */
1044 if (d_really_is_negative(dentry
))
1045 goto out_bad_parent
;
1046 inode
= d_inode(dentry
);
1047 if (is_bad_inode(inode
)) {
1048 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1050 goto out_bad_parent
;
1053 vnode
= AFS_FS_I(inode
);
1055 /* if the vnode ID has changed, then the dirent points to a
1057 if (fid
.vnode
!= vnode
->fid
.vnode
) {
1058 _debug("%pd: dirent changed [%llu != %llu]",
1064 /* if the vnode ID uniqifier has changed, then the file has
1065 * been deleted and replaced, and the original vnode ID has
1067 if (fid
.unique
!= vnode
->fid
.unique
) {
1068 _debug("%pd: file deleted (uq %u -> %u I:%u)",
1071 vnode
->vfs_inode
.i_generation
);
1072 write_seqlock(&vnode
->cb_lock
);
1073 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1074 write_sequnlock(&vnode
->cb_lock
);
1080 /* the filename is unknown */
1081 _debug("%pd: dirent not found", dentry
);
1082 if (d_really_is_positive(dentry
))
1087 _debug("failed to iterate dir %pd: %d",
1089 goto out_bad_parent
;
1093 dentry
->d_fsdata
= (void *)(unsigned long)dir_version
;
1097 _leave(" = 1 [valid]");
1100 /* the dirent, if it exists, now points to a different vnode */
1102 spin_lock(&dentry
->d_lock
);
1103 dentry
->d_flags
|= DCACHE_NFSFS_RENAMED
;
1104 spin_unlock(&dentry
->d_lock
);
1107 _debug("dropping dentry %pd2", dentry
);
1112 _leave(" = 0 [bad]");
1117 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1119 * - called from dput() when d_count is going to 0.
1120 * - return 1 to request dentry be unhashed, 0 otherwise
1122 static int afs_d_delete(const struct dentry
*dentry
)
1124 _enter("%pd", dentry
);
1126 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1129 if (d_really_is_positive(dentry
) &&
1130 (test_bit(AFS_VNODE_DELETED
, &AFS_FS_I(d_inode(dentry
))->flags
) ||
1131 test_bit(AFS_VNODE_PSEUDODIR
, &AFS_FS_I(d_inode(dentry
))->flags
)))
1134 _leave(" = 0 [keep]");
1138 _leave(" = 1 [zap]");
1143 * Clean up sillyrename files on dentry removal.
1145 static void afs_d_iput(struct dentry
*dentry
, struct inode
*inode
)
1147 if (dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1148 afs_silly_iput(dentry
, inode
);
1153 * handle dentry release
1155 void afs_d_release(struct dentry
*dentry
)
1157 _enter("%pd", dentry
);
1161 * Create a new inode for create/mkdir/symlink
1163 static void afs_vnode_new_inode(struct afs_fs_cursor
*fc
,
1164 struct dentry
*new_dentry
,
1165 struct afs_iget_data
*new_data
,
1166 struct afs_status_cb
*new_scb
)
1168 struct afs_vnode
*vnode
;
1169 struct inode
*inode
;
1171 if (fc
->ac
.error
< 0)
1174 inode
= afs_iget(fc
->vnode
->vfs_inode
.i_sb
, fc
->key
,
1175 new_data
, new_scb
, fc
->cbi
, fc
->vnode
);
1176 if (IS_ERR(inode
)) {
1177 /* ENOMEM or EINTR at a really inconvenient time - just abandon
1178 * the new directory on the server.
1180 fc
->ac
.error
= PTR_ERR(inode
);
1184 vnode
= AFS_FS_I(inode
);
1185 set_bit(AFS_VNODE_NEW_CONTENT
, &vnode
->flags
);
1186 if (fc
->ac
.error
== 0)
1187 afs_cache_permit(vnode
, fc
->key
, vnode
->cb_break
, new_scb
);
1188 d_instantiate(new_dentry
, inode
);
1191 static void afs_prep_for_new_inode(struct afs_fs_cursor
*fc
,
1192 struct afs_iget_data
*iget_data
)
1194 iget_data
->volume
= fc
->vnode
->volume
;
1195 iget_data
->cb_v_break
= fc
->vnode
->volume
->cb_v_break
;
1196 iget_data
->cb_s_break
= fc
->cbi
->server
->cb_s_break
;
1200 * Note that a dentry got changed. We need to set d_fsdata to the data version
1201 * number derived from the result of the operation. It doesn't matter if
1202 * d_fsdata goes backwards as we'll just revalidate.
1204 static void afs_update_dentry_version(struct afs_fs_cursor
*fc
,
1205 struct dentry
*dentry
,
1206 struct afs_status_cb
*scb
)
1208 if (fc
->ac
.error
== 0)
1210 (void *)(unsigned long)scb
->status
.data_version
;
1214 * create a directory on an AFS filesystem
1216 static int afs_mkdir(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
)
1218 struct afs_iget_data iget_data
;
1219 struct afs_status_cb
*scb
;
1220 struct afs_fs_cursor fc
;
1221 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1227 _enter("{%llx:%llu},{%pd},%ho",
1228 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1231 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1235 key
= afs_request_key(dvnode
->volume
->cell
);
1242 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1243 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1245 while (afs_select_fileserver(&fc
)) {
1246 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1247 afs_prep_for_new_inode(&fc
, &iget_data
);
1248 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
,
1249 &scb
[0], &iget_data
.fid
, &scb
[1]);
1252 afs_check_for_remote_deletion(&fc
, dvnode
);
1253 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1254 &data_version
, &scb
[0]);
1255 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1256 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1257 ret
= afs_end_vnode_operation(&fc
);
1265 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1266 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1267 afs_edit_dir_for_create
);
1280 _leave(" = %d", ret
);
1285 * Remove a subdir from a directory.
1287 static void afs_dir_remove_subdir(struct dentry
*dentry
)
1289 if (d_really_is_positive(dentry
)) {
1290 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1292 clear_nlink(&vnode
->vfs_inode
);
1293 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1294 clear_bit(AFS_VNODE_CB_PROMISED
, &vnode
->flags
);
1295 clear_bit(AFS_VNODE_DIR_VALID
, &vnode
->flags
);
1300 * remove a directory from an AFS filesystem
1302 static int afs_rmdir(struct inode
*dir
, struct dentry
*dentry
)
1304 struct afs_status_cb
*scb
;
1305 struct afs_fs_cursor fc
;
1306 struct afs_vnode
*dvnode
= AFS_FS_I(dir
), *vnode
= NULL
;
1310 _enter("{%llx:%llu},{%pd}",
1311 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1313 scb
= kzalloc(sizeof(struct afs_status_cb
), GFP_KERNEL
);
1317 key
= afs_request_key(dvnode
->volume
->cell
);
1323 /* Try to make sure we have a callback promise on the victim. */
1324 if (d_really_is_positive(dentry
)) {
1325 vnode
= AFS_FS_I(d_inode(dentry
));
1326 ret
= afs_validate(vnode
, key
);
1332 ret
= down_write_killable(&vnode
->rmdir_lock
);
1338 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1339 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1341 while (afs_select_fileserver(&fc
)) {
1342 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1343 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, true, scb
);
1346 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1347 &data_version
, scb
);
1348 afs_update_dentry_version(&fc
, dentry
, scb
);
1349 ret
= afs_end_vnode_operation(&fc
);
1351 afs_dir_remove_subdir(dentry
);
1352 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1353 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1354 afs_edit_dir_for_rmdir
);
1359 up_write(&vnode
->rmdir_lock
);
1368 * Remove a link to a file or symlink from a directory.
1370 * If the file was not deleted due to excess hard links, the fileserver will
1371 * break the callback promise on the file - if it had one - before it returns
1372 * to us, and if it was deleted, it won't
1374 * However, if we didn't have a callback promise outstanding, or it was
1375 * outstanding on a different server, then it won't break it either...
1377 static int afs_dir_remove_link(struct afs_vnode
*dvnode
, struct dentry
*dentry
,
1382 if (d_really_is_positive(dentry
)) {
1383 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1385 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
)) {
1387 } else if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
)) {
1388 write_seqlock(&vnode
->cb_lock
);
1389 drop_nlink(&vnode
->vfs_inode
);
1390 if (vnode
->vfs_inode
.i_nlink
== 0) {
1391 set_bit(AFS_VNODE_DELETED
, &vnode
->flags
);
1392 __afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1394 write_sequnlock(&vnode
->cb_lock
);
1397 afs_break_callback(vnode
, afs_cb_break_for_unlink
);
1399 if (test_bit(AFS_VNODE_DELETED
, &vnode
->flags
))
1400 kdebug("AFS_VNODE_DELETED");
1402 ret
= afs_validate(vnode
, key
);
1406 _debug("nlink %d [val %d]", vnode
->vfs_inode
.i_nlink
, ret
);
1413 * Remove a file or symlink from an AFS filesystem.
1415 static int afs_unlink(struct inode
*dir
, struct dentry
*dentry
)
1417 struct afs_fs_cursor fc
;
1418 struct afs_status_cb
*scb
;
1419 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1420 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(dentry
));
1422 bool need_rehash
= false;
1425 _enter("{%llx:%llu},{%pd}",
1426 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
);
1428 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1429 return -ENAMETOOLONG
;
1432 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1436 key
= afs_request_key(dvnode
->volume
->cell
);
1442 /* Try to make sure we have a callback promise on the victim. */
1443 ret
= afs_validate(vnode
, key
);
1447 spin_lock(&dentry
->d_lock
);
1448 if (d_count(dentry
) > 1) {
1449 spin_unlock(&dentry
->d_lock
);
1450 /* Start asynchronous writeout of the inode */
1451 write_inode_now(d_inode(dentry
), 0);
1452 ret
= afs_sillyrename(dvnode
, vnode
, dentry
, key
);
1455 if (!d_unhashed(dentry
)) {
1456 /* Prevent a race with RCU lookup. */
1460 spin_unlock(&dentry
->d_lock
);
1463 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1464 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1465 afs_dataversion_t data_version_2
= vnode
->status
.data_version
;
1467 while (afs_select_fileserver(&fc
)) {
1468 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1469 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1471 if (test_bit(AFS_SERVER_FL_IS_YFS
, &fc
.cbi
->server
->flags
) &&
1472 !test_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
)) {
1473 yfs_fs_remove_file2(&fc
, vnode
, dentry
->d_name
.name
,
1475 if (fc
.ac
.error
!= -ECONNABORTED
||
1476 fc
.ac
.abort_code
!= RXGEN_OPCODE
)
1478 set_bit(AFS_SERVER_FL_NO_RM2
, &fc
.cbi
->server
->flags
);
1481 afs_fs_remove(&fc
, vnode
, dentry
->d_name
.name
, false, &scb
[0]);
1484 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1485 &data_version
, &scb
[0]);
1486 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
,
1487 &data_version_2
, &scb
[1]);
1488 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1489 ret
= afs_end_vnode_operation(&fc
);
1490 if (ret
== 0 && !(scb
[1].have_status
|| scb
[1].have_error
))
1491 ret
= afs_dir_remove_link(dvnode
, dentry
, key
);
1493 test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1494 afs_edit_dir_remove(dvnode
, &dentry
->d_name
,
1495 afs_edit_dir_for_unlink
);
1498 if (need_rehash
&& ret
< 0 && ret
!= -ENOENT
)
1506 _leave(" = %d", ret
);
1511 * create a regular file on an AFS filesystem
1513 static int afs_create(struct inode
*dir
, struct dentry
*dentry
, umode_t mode
,
1516 struct afs_iget_data iget_data
;
1517 struct afs_fs_cursor fc
;
1518 struct afs_status_cb
*scb
;
1519 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1525 _enter("{%llx:%llu},{%pd},%ho,",
1526 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
, mode
);
1528 ret
= -ENAMETOOLONG
;
1529 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1532 key
= afs_request_key(dvnode
->volume
->cell
);
1539 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1544 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1545 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1547 while (afs_select_fileserver(&fc
)) {
1548 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1549 afs_prep_for_new_inode(&fc
, &iget_data
);
1550 afs_fs_create(&fc
, dentry
->d_name
.name
, mode
,
1551 &scb
[0], &iget_data
.fid
, &scb
[1]);
1554 afs_check_for_remote_deletion(&fc
, dvnode
);
1555 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1556 &data_version
, &scb
[0]);
1557 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1558 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1559 ret
= afs_end_vnode_operation(&fc
);
1566 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1567 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1568 afs_edit_dir_for_create
);
1581 _leave(" = %d", ret
);
1586 * create a hard link between files in an AFS filesystem
1588 static int afs_link(struct dentry
*from
, struct inode
*dir
,
1589 struct dentry
*dentry
)
1591 struct afs_fs_cursor fc
;
1592 struct afs_status_cb
*scb
;
1593 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1594 struct afs_vnode
*vnode
= AFS_FS_I(d_inode(from
));
1598 _enter("{%llx:%llu},{%llx:%llu},{%pd}",
1599 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1600 dvnode
->fid
.vid
, dvnode
->fid
.vnode
,
1603 ret
= -ENAMETOOLONG
;
1604 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1608 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1612 key
= afs_request_key(dvnode
->volume
->cell
);
1619 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1620 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1622 if (mutex_lock_interruptible_nested(&vnode
->io_lock
, 1) < 0) {
1623 afs_end_vnode_operation(&fc
);
1627 while (afs_select_fileserver(&fc
)) {
1628 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1629 fc
.cb_break_2
= afs_calc_vnode_cb_break(vnode
);
1630 afs_fs_link(&fc
, vnode
, dentry
->d_name
.name
,
1634 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1635 &data_version
, &scb
[0]);
1636 afs_vnode_commit_status(&fc
, vnode
, fc
.cb_break_2
,
1638 ihold(&vnode
->vfs_inode
);
1639 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1640 d_instantiate(dentry
, &vnode
->vfs_inode
);
1642 mutex_unlock(&vnode
->io_lock
);
1643 ret
= afs_end_vnode_operation(&fc
);
1650 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1651 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &vnode
->fid
,
1652 afs_edit_dir_for_link
);
1665 _leave(" = %d", ret
);
1670 * create a symlink in an AFS filesystem
1672 static int afs_symlink(struct inode
*dir
, struct dentry
*dentry
,
1673 const char *content
)
1675 struct afs_iget_data iget_data
;
1676 struct afs_fs_cursor fc
;
1677 struct afs_status_cb
*scb
;
1678 struct afs_vnode
*dvnode
= AFS_FS_I(dir
);
1682 _enter("{%llx:%llu},{%pd},%s",
1683 dvnode
->fid
.vid
, dvnode
->fid
.vnode
, dentry
,
1686 ret
= -ENAMETOOLONG
;
1687 if (dentry
->d_name
.len
>= AFSNAMEMAX
)
1691 if (strlen(content
) >= AFSPATHMAX
)
1695 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1699 key
= afs_request_key(dvnode
->volume
->cell
);
1706 if (afs_begin_vnode_operation(&fc
, dvnode
, key
, true)) {
1707 afs_dataversion_t data_version
= dvnode
->status
.data_version
+ 1;
1709 while (afs_select_fileserver(&fc
)) {
1710 fc
.cb_break
= afs_calc_vnode_cb_break(dvnode
);
1711 afs_prep_for_new_inode(&fc
, &iget_data
);
1712 afs_fs_symlink(&fc
, dentry
->d_name
.name
, content
,
1713 &scb
[0], &iget_data
.fid
, &scb
[1]);
1716 afs_check_for_remote_deletion(&fc
, dvnode
);
1717 afs_vnode_commit_status(&fc
, dvnode
, fc
.cb_break
,
1718 &data_version
, &scb
[0]);
1719 afs_update_dentry_version(&fc
, dentry
, &scb
[0]);
1720 afs_vnode_new_inode(&fc
, dentry
, &iget_data
, &scb
[1]);
1721 ret
= afs_end_vnode_operation(&fc
);
1728 if (test_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1729 afs_edit_dir_add(dvnode
, &dentry
->d_name
, &iget_data
.fid
,
1730 afs_edit_dir_for_symlink
);
1743 _leave(" = %d", ret
);
1748 * rename a file in an AFS filesystem and/or move it between directories
1750 static int afs_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1751 struct inode
*new_dir
, struct dentry
*new_dentry
,
1754 struct afs_fs_cursor fc
;
1755 struct afs_status_cb
*scb
;
1756 struct afs_vnode
*orig_dvnode
, *new_dvnode
, *vnode
;
1757 struct dentry
*tmp
= NULL
, *rehash
= NULL
;
1758 struct inode
*new_inode
;
1760 bool new_negative
= d_is_negative(new_dentry
);
1766 /* Don't allow silly-rename files be moved around. */
1767 if (old_dentry
->d_flags
& DCACHE_NFSFS_RENAMED
)
1770 vnode
= AFS_FS_I(d_inode(old_dentry
));
1771 orig_dvnode
= AFS_FS_I(old_dir
);
1772 new_dvnode
= AFS_FS_I(new_dir
);
1774 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1775 orig_dvnode
->fid
.vid
, orig_dvnode
->fid
.vnode
,
1776 vnode
->fid
.vid
, vnode
->fid
.vnode
,
1777 new_dvnode
->fid
.vid
, new_dvnode
->fid
.vnode
,
1781 scb
= kcalloc(2, sizeof(struct afs_status_cb
), GFP_KERNEL
);
1785 key
= afs_request_key(orig_dvnode
->volume
->cell
);
1791 /* For non-directories, check whether the target is busy and if so,
1792 * make a copy of the dentry and then do a silly-rename. If the
1793 * silly-rename succeeds, the copied dentry is hashed and becomes the
1796 if (d_is_positive(new_dentry
) && !d_is_dir(new_dentry
)) {
1797 /* To prevent any new references to the target during the
1798 * rename, we unhash the dentry in advance.
1800 if (!d_unhashed(new_dentry
)) {
1802 rehash
= new_dentry
;
1805 if (d_count(new_dentry
) > 2) {
1806 /* copy the target dentry's name */
1808 tmp
= d_alloc(new_dentry
->d_parent
,
1809 &new_dentry
->d_name
);
1813 ret
= afs_sillyrename(new_dvnode
,
1814 AFS_FS_I(d_inode(new_dentry
)),
1821 new_negative
= true;
1825 /* This bit is potentially nasty as there's a potential race with
1826 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
1827 * to reflect it's new parent's new data_version after the op, but
1828 * d_revalidate may see old_dentry between the op having taken place
1829 * and the version being updated.
1831 * So drop the old_dentry for now to make other threads go through
1832 * lookup instead - which we hold a lock against.
1837 if (afs_begin_vnode_operation(&fc
, orig_dvnode
, key
, true)) {
1838 afs_dataversion_t orig_data_version
;
1839 afs_dataversion_t new_data_version
;
1840 struct afs_status_cb
*new_scb
= &scb
[1];
1842 orig_data_version
= orig_dvnode
->status
.data_version
+ 1;
1844 if (orig_dvnode
!= new_dvnode
) {
1845 if (mutex_lock_interruptible_nested(&new_dvnode
->io_lock
, 1) < 0) {
1846 afs_end_vnode_operation(&fc
);
1847 goto error_rehash_old
;
1849 new_data_version
= new_dvnode
->status
.data_version
+ 1;
1851 new_data_version
= orig_data_version
;
1855 while (afs_select_fileserver(&fc
)) {
1856 fc
.cb_break
= afs_calc_vnode_cb_break(orig_dvnode
);
1857 fc
.cb_break_2
= afs_calc_vnode_cb_break(new_dvnode
);
1858 afs_fs_rename(&fc
, old_dentry
->d_name
.name
,
1859 new_dvnode
, new_dentry
->d_name
.name
,
1863 afs_vnode_commit_status(&fc
, orig_dvnode
, fc
.cb_break
,
1864 &orig_data_version
, &scb
[0]);
1865 if (new_dvnode
!= orig_dvnode
) {
1866 afs_vnode_commit_status(&fc
, new_dvnode
, fc
.cb_break_2
,
1867 &new_data_version
, &scb
[1]);
1868 mutex_unlock(&new_dvnode
->io_lock
);
1870 ret
= afs_end_vnode_operation(&fc
);
1872 goto error_rehash_old
;
1878 if (test_bit(AFS_VNODE_DIR_VALID
, &orig_dvnode
->flags
))
1879 afs_edit_dir_remove(orig_dvnode
, &old_dentry
->d_name
,
1880 afs_edit_dir_for_rename_0
);
1882 if (!new_negative
&&
1883 test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1884 afs_edit_dir_remove(new_dvnode
, &new_dentry
->d_name
,
1885 afs_edit_dir_for_rename_1
);
1887 if (test_bit(AFS_VNODE_DIR_VALID
, &new_dvnode
->flags
))
1888 afs_edit_dir_add(new_dvnode
, &new_dentry
->d_name
,
1889 &vnode
->fid
, afs_edit_dir_for_rename_2
);
1891 new_inode
= d_inode(new_dentry
);
1893 spin_lock(&new_inode
->i_lock
);
1894 if (new_inode
->i_nlink
> 0)
1895 drop_nlink(new_inode
);
1896 spin_unlock(&new_inode
->i_lock
);
1899 /* Now we can update d_fsdata on the dentries to reflect their
1900 * new parent's data_version.
1902 * Note that if we ever implement RENAME_EXCHANGE, we'll have
1903 * to update both dentries with opposing dir versions.
1905 if (new_dvnode
!= orig_dvnode
) {
1906 afs_update_dentry_version(&fc
, old_dentry
, &scb
[1]);
1907 afs_update_dentry_version(&fc
, new_dentry
, &scb
[1]);
1909 afs_update_dentry_version(&fc
, old_dentry
, &scb
[0]);
1910 afs_update_dentry_version(&fc
, new_dentry
, &scb
[0]);
1912 d_move(old_dentry
, new_dentry
);
1917 d_rehash(new_dentry
);
1928 _leave(" = %d", ret
);
1933 * Release a directory page and clean up its private state if it's not busy
1934 * - return true if the page can now be released, false if not
1936 static int afs_dir_releasepage(struct page
*page
, gfp_t gfp_flags
)
1938 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1940 _enter("{{%llx:%llu}[%lu]}", dvnode
->fid
.vid
, dvnode
->fid
.vnode
, page
->index
);
1942 set_page_private(page
, 0);
1943 ClearPagePrivate(page
);
1945 /* The directory will need reloading. */
1946 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1947 afs_stat_v(dvnode
, n_relpg
);
1952 * invalidate part or all of a page
1953 * - release a page and clean up its private data if offset is 0 (indicating
1956 static void afs_dir_invalidatepage(struct page
*page
, unsigned int offset
,
1957 unsigned int length
)
1959 struct afs_vnode
*dvnode
= AFS_FS_I(page
->mapping
->host
);
1961 _enter("{%lu},%u,%u", page
->index
, offset
, length
);
1963 BUG_ON(!PageLocked(page
));
1965 /* The directory will need reloading. */
1966 if (test_and_clear_bit(AFS_VNODE_DIR_VALID
, &dvnode
->flags
))
1967 afs_stat_v(dvnode
, n_inval
);
1969 /* we clean up only if the entire page is being invalidated */
1970 if (offset
== 0 && length
== PAGE_SIZE
) {
1971 set_page_private(page
, 0);
1972 ClearPagePrivate(page
);