2086 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/* dir.c: AFS filesystem directory handling3 *4 * Copyright (C) 2002, 2018 Red Hat, Inc. All Rights Reserved.5 * Written by David Howells (dhowells@redhat.com)6 */7 8#include <linux/kernel.h>9#include <linux/fs.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/iversion.h>16#include <linux/task_io_accounting_ops.h>17#include "internal.h"18#include "afs_fs.h"19#include "xdr_fs.h"20 21static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,22 unsigned int flags);23static int afs_dir_open(struct inode *inode, struct file *file);24static int afs_readdir(struct file *file, struct dir_context *ctx);25static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);26static int afs_d_delete(const struct dentry *dentry);27static void afs_d_iput(struct dentry *dentry, struct inode *inode);28static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name, int nlen,29 loff_t fpos, u64 ino, unsigned dtype);30static bool afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,31 loff_t fpos, u64 ino, unsigned dtype);32static int afs_create(struct mnt_idmap *idmap, struct inode *dir,33 struct dentry *dentry, umode_t mode, bool excl);34static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,35 struct dentry *dentry, umode_t mode);36static int afs_rmdir(struct inode *dir, struct dentry *dentry);37static int afs_unlink(struct inode *dir, struct dentry *dentry);38static int afs_link(struct dentry *from, struct inode *dir,39 struct dentry *dentry);40static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,41 struct dentry *dentry, const char *content);42static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,43 struct dentry *old_dentry, struct inode *new_dir,44 struct dentry *new_dentry, unsigned int flags);45static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags);46static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,47 size_t length);48 49static bool afs_dir_dirty_folio(struct address_space *mapping,50 struct folio *folio)51{52 BUG(); /* This should never happen. */53}54 55const struct file_operations afs_dir_file_operations = {56 .open = afs_dir_open,57 .release = afs_release,58 .iterate_shared = afs_readdir,59 .lock = afs_lock,60 .llseek = generic_file_llseek,61};62 63const struct inode_operations afs_dir_inode_operations = {64 .create = afs_create,65 .lookup = afs_lookup,66 .link = afs_link,67 .unlink = afs_unlink,68 .symlink = afs_symlink,69 .mkdir = afs_mkdir,70 .rmdir = afs_rmdir,71 .rename = afs_rename,72 .permission = afs_permission,73 .getattr = afs_getattr,74 .setattr = afs_setattr,75};76 77const struct address_space_operations afs_dir_aops = {78 .dirty_folio = afs_dir_dirty_folio,79 .release_folio = afs_dir_release_folio,80 .invalidate_folio = afs_dir_invalidate_folio,81 .migrate_folio = filemap_migrate_folio,82};83 84const struct dentry_operations afs_fs_dentry_operations = {85 .d_revalidate = afs_d_revalidate,86 .d_delete = afs_d_delete,87 .d_release = afs_d_release,88 .d_automount = afs_d_automount,89 .d_iput = afs_d_iput,90};91 92struct afs_lookup_one_cookie {93 struct dir_context ctx;94 struct qstr name;95 bool found;96 struct afs_fid fid;97};98 99struct afs_lookup_cookie {100 struct dir_context ctx;101 struct qstr name;102 bool found;103 bool one_only;104 unsigned short nr_fids;105 struct afs_fid fids[50];106};107 108/*109 * Drop the refs that we're holding on the folios we were reading into. We've110 * got refs on the first nr_pages pages.111 */112static void afs_dir_read_cleanup(struct afs_read *req)113{114 struct address_space *mapping = req->vnode->netfs.inode.i_mapping;115 struct folio *folio;116 pgoff_t last = req->nr_pages - 1;117 118 XA_STATE(xas, &mapping->i_pages, 0);119 120 if (unlikely(!req->nr_pages))121 return;122 123 rcu_read_lock();124 xas_for_each(&xas, folio, last) {125 if (xas_retry(&xas, folio))126 continue;127 BUG_ON(xa_is_value(folio));128 ASSERTCMP(folio->mapping, ==, mapping);129 130 folio_put(folio);131 }132 133 rcu_read_unlock();134}135 136/*137 * check that a directory folio is valid138 */139static bool afs_dir_check_folio(struct afs_vnode *dvnode, struct folio *folio,140 loff_t i_size)141{142 union afs_xdr_dir_block *block;143 size_t offset, size;144 loff_t pos;145 146 /* Determine how many magic numbers there should be in this folio, but147 * we must take care because the directory may change size under us.148 */149 pos = folio_pos(folio);150 if (i_size <= pos)151 goto checked;152 153 size = min_t(loff_t, folio_size(folio), i_size - pos);154 for (offset = 0; offset < size; offset += sizeof(*block)) {155 block = kmap_local_folio(folio, offset);156 if (block->hdr.magic != AFS_DIR_MAGIC) {157 printk("kAFS: %s(%lx): [%llx] bad magic %zx/%zx is %04hx\n",158 __func__, dvnode->netfs.inode.i_ino,159 pos, offset, size, ntohs(block->hdr.magic));160 trace_afs_dir_check_failed(dvnode, pos + offset, i_size);161 kunmap_local(block);162 trace_afs_file_error(dvnode, -EIO, afs_file_error_dir_bad_magic);163 goto error;164 }165 166 /* Make sure each block is NUL terminated so we can reasonably167 * use string functions on it. The filenames in the folio168 * *should* be NUL-terminated anyway.169 */170 ((u8 *)block)[AFS_DIR_BLOCK_SIZE - 1] = 0;171 172 kunmap_local(block);173 }174checked:175 afs_stat_v(dvnode, n_read_dir);176 return true;177 178error:179 return false;180}181 182/*183 * Dump the contents of a directory.184 */185static void afs_dir_dump(struct afs_vnode *dvnode, struct afs_read *req)186{187 union afs_xdr_dir_block *block;188 struct address_space *mapping = dvnode->netfs.inode.i_mapping;189 struct folio *folio;190 pgoff_t last = req->nr_pages - 1;191 size_t offset, size;192 193 XA_STATE(xas, &mapping->i_pages, 0);194 195 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx\n",196 dvnode->fid.vid, dvnode->fid.vnode,197 req->file_size, req->len, req->actual_len);198 pr_warn("DIR %llx %x %zx %zx\n",199 req->pos, req->nr_pages,200 req->iter->iov_offset, iov_iter_count(req->iter));201 202 xas_for_each(&xas, folio, last) {203 if (xas_retry(&xas, folio))204 continue;205 206 BUG_ON(folio->mapping != mapping);207 208 size = min_t(loff_t, folio_size(folio), req->actual_len - folio_pos(folio));209 for (offset = 0; offset < size; offset += sizeof(*block)) {210 block = kmap_local_folio(folio, offset);211 pr_warn("[%02lx] %32phN\n", folio->index + offset, block);212 kunmap_local(block);213 }214 }215}216 217/*218 * Check all the blocks in a directory. All the folios are held pinned.219 */220static int afs_dir_check(struct afs_vnode *dvnode, struct afs_read *req)221{222 struct address_space *mapping = dvnode->netfs.inode.i_mapping;223 struct folio *folio;224 pgoff_t last = req->nr_pages - 1;225 int ret = 0;226 227 XA_STATE(xas, &mapping->i_pages, 0);228 229 if (unlikely(!req->nr_pages))230 return 0;231 232 rcu_read_lock();233 xas_for_each(&xas, folio, last) {234 if (xas_retry(&xas, folio))235 continue;236 237 BUG_ON(folio->mapping != mapping);238 239 if (!afs_dir_check_folio(dvnode, folio, req->actual_len)) {240 afs_dir_dump(dvnode, req);241 ret = -EIO;242 break;243 }244 }245 246 rcu_read_unlock();247 return ret;248}249 250/*251 * open an AFS directory file252 */253static int afs_dir_open(struct inode *inode, struct file *file)254{255 _enter("{%lu}", inode->i_ino);256 257 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);258 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);259 260 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))261 return -ENOENT;262 263 return afs_open(inode, file);264}265 266/*267 * Read the directory into the pagecache in one go, scrubbing the previous268 * contents. The list of folios is returned, pinning them so that they don't269 * get reclaimed during the iteration.270 */271static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)272 __acquires(&dvnode->validate_lock)273{274 struct address_space *mapping = dvnode->netfs.inode.i_mapping;275 struct afs_read *req;276 loff_t i_size;277 int nr_pages, i;278 int ret;279 loff_t remote_size = 0;280 281 _enter("");282 283 req = kzalloc(sizeof(*req), GFP_KERNEL);284 if (!req)285 return ERR_PTR(-ENOMEM);286 287 refcount_set(&req->usage, 1);288 req->vnode = dvnode;289 req->key = key_get(key);290 req->cleanup = afs_dir_read_cleanup;291 292expand:293 i_size = i_size_read(&dvnode->netfs.inode);294 if (i_size < remote_size)295 i_size = remote_size;296 if (i_size < 2048) {297 ret = afs_bad(dvnode, afs_file_error_dir_small);298 goto error;299 }300 if (i_size > 2048 * 1024) {301 trace_afs_file_error(dvnode, -EFBIG, afs_file_error_dir_big);302 ret = -EFBIG;303 goto error;304 }305 306 _enter("%llu", i_size);307 308 nr_pages = (i_size + PAGE_SIZE - 1) / PAGE_SIZE;309 310 req->actual_len = i_size; /* May change */311 req->len = nr_pages * PAGE_SIZE; /* We can ask for more than there is */312 req->data_version = dvnode->status.data_version; /* May change */313 iov_iter_xarray(&req->def_iter, ITER_DEST, &dvnode->netfs.inode.i_mapping->i_pages,314 0, i_size);315 req->iter = &req->def_iter;316 317 /* Fill in any gaps that we might find where the memory reclaimer has318 * been at work and pin all the folios. If there are any gaps, we will319 * need to reread the entire directory contents.320 */321 i = req->nr_pages;322 while (i < nr_pages) {323 struct folio *folio;324 325 folio = filemap_get_folio(mapping, i);326 if (IS_ERR(folio)) {327 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))328 afs_stat_v(dvnode, n_inval);329 folio = __filemap_get_folio(mapping,330 i, FGP_LOCK | FGP_CREAT,331 mapping->gfp_mask);332 if (IS_ERR(folio)) {333 ret = PTR_ERR(folio);334 goto error;335 }336 folio_attach_private(folio, (void *)1);337 folio_unlock(folio);338 }339 340 req->nr_pages += folio_nr_pages(folio);341 i += folio_nr_pages(folio);342 }343 344 /* If we're going to reload, we need to lock all the pages to prevent345 * races.346 */347 ret = -ERESTARTSYS;348 if (down_read_killable(&dvnode->validate_lock) < 0)349 goto error;350 351 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))352 goto success;353 354 up_read(&dvnode->validate_lock);355 if (down_write_killable(&dvnode->validate_lock) < 0)356 goto error;357 358 if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {359 trace_afs_reload_dir(dvnode);360 ret = afs_fetch_data(dvnode, req);361 if (ret < 0)362 goto error_unlock;363 364 task_io_account_read(PAGE_SIZE * req->nr_pages);365 366 if (req->len < req->file_size) {367 /* The content has grown, so we need to expand the368 * buffer.369 */370 up_write(&dvnode->validate_lock);371 remote_size = req->file_size;372 goto expand;373 }374 375 /* Validate the data we just read. */376 ret = afs_dir_check(dvnode, req);377 if (ret < 0)378 goto error_unlock;379 380 // TODO: Trim excess pages381 382 set_bit(AFS_VNODE_DIR_VALID, &dvnode->flags);383 }384 385 downgrade_write(&dvnode->validate_lock);386success:387 return req;388 389error_unlock:390 up_write(&dvnode->validate_lock);391error:392 afs_put_read(req);393 _leave(" = %d", ret);394 return ERR_PTR(ret);395}396 397/*398 * deal with one block in an AFS directory399 */400static int afs_dir_iterate_block(struct afs_vnode *dvnode,401 struct dir_context *ctx,402 union afs_xdr_dir_block *block,403 unsigned blkoff)404{405 union afs_xdr_dirent *dire;406 unsigned offset, next, curr, nr_slots;407 size_t nlen;408 int tmp;409 410 _enter("%llx,%x", ctx->pos, blkoff);411 412 curr = (ctx->pos - blkoff) / sizeof(union afs_xdr_dirent);413 414 /* walk through the block, an entry at a time */415 for (offset = (blkoff == 0 ? AFS_DIR_RESV_BLOCKS0 : AFS_DIR_RESV_BLOCKS);416 offset < AFS_DIR_SLOTS_PER_BLOCK;417 offset = next418 ) {419 /* skip entries marked unused in the bitmap */420 if (!(block->hdr.bitmap[offset / 8] &421 (1 << (offset % 8)))) {422 _debug("ENT[%zu.%u]: unused",423 blkoff / sizeof(union afs_xdr_dir_block), offset);424 next = offset + 1;425 if (offset >= curr)426 ctx->pos = blkoff +427 next * sizeof(union afs_xdr_dirent);428 continue;429 }430 431 /* got a valid entry */432 dire = &block->dirents[offset];433 nlen = strnlen(dire->u.name,434 sizeof(*block) -435 offset * sizeof(union afs_xdr_dirent));436 if (nlen > AFSNAMEMAX - 1) {437 _debug("ENT[%zu]: name too long (len %u/%zu)",438 blkoff / sizeof(union afs_xdr_dir_block),439 offset, nlen);440 return afs_bad(dvnode, afs_file_error_dir_name_too_long);441 }442 443 _debug("ENT[%zu.%u]: %s %zu \"%s\"",444 blkoff / sizeof(union afs_xdr_dir_block), offset,445 (offset < curr ? "skip" : "fill"),446 nlen, dire->u.name);447 448 nr_slots = afs_dir_calc_slots(nlen);449 next = offset + nr_slots;450 if (next > AFS_DIR_SLOTS_PER_BLOCK) {451 _debug("ENT[%zu.%u]:"452 " %u extends beyond end dir block"453 " (len %zu)",454 blkoff / sizeof(union afs_xdr_dir_block),455 offset, next, nlen);456 return afs_bad(dvnode, afs_file_error_dir_over_end);457 }458 459 /* Check that the name-extension dirents are all allocated */460 for (tmp = 1; tmp < nr_slots; tmp++) {461 unsigned int ix = offset + tmp;462 if (!(block->hdr.bitmap[ix / 8] & (1 << (ix % 8)))) {463 _debug("ENT[%zu.u]:"464 " %u unmarked extension (%u/%u)",465 blkoff / sizeof(union afs_xdr_dir_block),466 offset, tmp, nr_slots);467 return afs_bad(dvnode, afs_file_error_dir_unmarked_ext);468 }469 }470 471 /* skip if starts before the current position */472 if (offset < curr) {473 if (next > curr)474 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);475 continue;476 }477 478 /* found the next entry */479 if (!dir_emit(ctx, dire->u.name, nlen,480 ntohl(dire->u.vnode),481 (ctx->actor == afs_lookup_filldir ||482 ctx->actor == afs_lookup_one_filldir)?483 ntohl(dire->u.unique) : DT_UNKNOWN)) {484 _leave(" = 0 [full]");485 return 0;486 }487 488 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);489 }490 491 _leave(" = 1 [more]");492 return 1;493}494 495/*496 * iterate through the data blob that lists the contents of an AFS directory497 */498static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,499 struct key *key, afs_dataversion_t *_dir_version)500{501 struct afs_vnode *dvnode = AFS_FS_I(dir);502 union afs_xdr_dir_block *dblock;503 struct afs_read *req;504 struct folio *folio;505 unsigned offset, size;506 int ret;507 508 _enter("{%lu},%u,,", dir->i_ino, (unsigned)ctx->pos);509 510 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {511 _leave(" = -ESTALE");512 return -ESTALE;513 }514 515 req = afs_read_dir(dvnode, key);516 if (IS_ERR(req))517 return PTR_ERR(req);518 *_dir_version = req->data_version;519 520 /* round the file position up to the next entry boundary */521 ctx->pos += sizeof(union afs_xdr_dirent) - 1;522 ctx->pos &= ~(sizeof(union afs_xdr_dirent) - 1);523 524 /* walk through the blocks in sequence */525 ret = 0;526 while (ctx->pos < req->actual_len) {527 /* Fetch the appropriate folio from the directory and re-add it528 * to the LRU. We have all the pages pinned with an extra ref.529 */530 folio = __filemap_get_folio(dir->i_mapping, ctx->pos / PAGE_SIZE,531 FGP_ACCESSED, 0);532 if (IS_ERR(folio)) {533 ret = afs_bad(dvnode, afs_file_error_dir_missing_page);534 break;535 }536 537 offset = round_down(ctx->pos, sizeof(*dblock)) - folio_pos(folio);538 size = min_t(loff_t, folio_size(folio),539 req->actual_len - folio_pos(folio));540 541 do {542 dblock = kmap_local_folio(folio, offset);543 ret = afs_dir_iterate_block(dvnode, ctx, dblock,544 folio_pos(folio) + offset);545 kunmap_local(dblock);546 if (ret != 1)547 goto out;548 549 } while (offset += sizeof(*dblock), offset < size);550 551 ret = 0;552 }553 554out:555 up_read(&dvnode->validate_lock);556 afs_put_read(req);557 _leave(" = %d", ret);558 return ret;559}560 561/*562 * read an AFS directory563 */564static int afs_readdir(struct file *file, struct dir_context *ctx)565{566 afs_dataversion_t dir_version;567 568 return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file),569 &dir_version);570}571 572/*573 * Search the directory for a single name574 * - if afs_dir_iterate_block() spots this function, it'll pass the FID575 * uniquifier through dtype576 */577static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name,578 int nlen, loff_t fpos, u64 ino, unsigned dtype)579{580 struct afs_lookup_one_cookie *cookie =581 container_of(ctx, struct afs_lookup_one_cookie, ctx);582 583 _enter("{%s,%u},%s,%u,,%llu,%u",584 cookie->name.name, cookie->name.len, name, nlen,585 (unsigned long long) ino, dtype);586 587 /* insanity checks first */588 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);589 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);590 591 if (cookie->name.len != nlen ||592 memcmp(cookie->name.name, name, nlen) != 0) {593 _leave(" = true [keep looking]");594 return true;595 }596 597 cookie->fid.vnode = ino;598 cookie->fid.unique = dtype;599 cookie->found = 1;600 601 _leave(" = false [found]");602 return false;603}604 605/*606 * Do a lookup of a single name in a directory607 * - just returns the FID the dentry name maps to if found608 */609static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry,610 struct afs_fid *fid, struct key *key,611 afs_dataversion_t *_dir_version)612{613 struct afs_super_info *as = dir->i_sb->s_fs_info;614 struct afs_lookup_one_cookie cookie = {615 .ctx.actor = afs_lookup_one_filldir,616 .name = dentry->d_name,617 .fid.vid = as->volume->vid618 };619 int ret;620 621 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);622 623 /* search the directory */624 ret = afs_dir_iterate(dir, &cookie.ctx, key, _dir_version);625 if (ret < 0) {626 _leave(" = %d [iter]", ret);627 return ret;628 }629 630 if (!cookie.found) {631 _leave(" = -ENOENT [not found]");632 return -ENOENT;633 }634 635 *fid = cookie.fid;636 _leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique);637 return 0;638}639 640/*641 * search the directory for a name642 * - if afs_dir_iterate_block() spots this function, it'll pass the FID643 * uniquifier through dtype644 */645static bool afs_lookup_filldir(struct dir_context *ctx, const char *name,646 int nlen, loff_t fpos, u64 ino, unsigned dtype)647{648 struct afs_lookup_cookie *cookie =649 container_of(ctx, struct afs_lookup_cookie, ctx);650 651 _enter("{%s,%u},%s,%u,,%llu,%u",652 cookie->name.name, cookie->name.len, name, nlen,653 (unsigned long long) ino, dtype);654 655 /* insanity checks first */656 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);657 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);658 659 if (cookie->found) {660 if (cookie->nr_fids < 50) {661 cookie->fids[cookie->nr_fids].vnode = ino;662 cookie->fids[cookie->nr_fids].unique = dtype;663 cookie->nr_fids++;664 }665 } else if (cookie->name.len == nlen &&666 memcmp(cookie->name.name, name, nlen) == 0) {667 cookie->fids[1].vnode = ino;668 cookie->fids[1].unique = dtype;669 cookie->found = 1;670 if (cookie->one_only)671 return false;672 }673 674 return cookie->nr_fids < 50;675}676 677/*678 * Deal with the result of a successful lookup operation. Turn all the files679 * into inodes and save the first one - which is the one we actually want.680 */681static void afs_do_lookup_success(struct afs_operation *op)682{683 struct afs_vnode_param *vp;684 struct afs_vnode *vnode;685 struct inode *inode;686 u32 abort_code;687 int i;688 689 _enter("");690 691 for (i = 0; i < op->nr_files; i++) {692 switch (i) {693 case 0:694 vp = &op->file[0];695 abort_code = vp->scb.status.abort_code;696 if (abort_code != 0) {697 op->call_abort_code = abort_code;698 afs_op_set_error(op, afs_abort_to_error(abort_code));699 op->cumul_error.abort_code = abort_code;700 }701 break;702 703 case 1:704 vp = &op->file[1];705 break;706 707 default:708 vp = &op->more_files[i - 2];709 break;710 }711 712 if (vp->scb.status.abort_code)713 trace_afs_bulkstat_error(op, &vp->fid, i, vp->scb.status.abort_code);714 if (!vp->scb.have_status && !vp->scb.have_error)715 continue;716 717 _debug("do [%u]", i);718 if (vp->vnode) {719 if (!test_bit(AFS_VNODE_UNSET, &vp->vnode->flags))720 afs_vnode_commit_status(op, vp);721 } else if (vp->scb.status.abort_code == 0) {722 inode = afs_iget(op, vp);723 if (!IS_ERR(inode)) {724 vnode = AFS_FS_I(inode);725 afs_cache_permit(vnode, op->key,726 0 /* Assume vnode->cb_break is 0 */ +727 op->cb_v_break,728 &vp->scb);729 vp->vnode = vnode;730 vp->put_vnode = true;731 }732 } else {733 _debug("- abort %d %llx:%llx.%x",734 vp->scb.status.abort_code,735 vp->fid.vid, vp->fid.vnode, vp->fid.unique);736 }737 }738 739 _leave("");740}741 742static const struct afs_operation_ops afs_inline_bulk_status_operation = {743 .issue_afs_rpc = afs_fs_inline_bulk_status,744 .issue_yfs_rpc = yfs_fs_inline_bulk_status,745 .success = afs_do_lookup_success,746};747 748static const struct afs_operation_ops afs_lookup_fetch_status_operation = {749 .issue_afs_rpc = afs_fs_fetch_status,750 .issue_yfs_rpc = yfs_fs_fetch_status,751 .success = afs_do_lookup_success,752 .aborted = afs_check_for_remote_deletion,753};754 755/*756 * See if we know that the server we expect to use doesn't support757 * FS.InlineBulkStatus.758 */759static bool afs_server_supports_ibulk(struct afs_vnode *dvnode)760{761 struct afs_server_list *slist;762 struct afs_volume *volume = dvnode->volume;763 struct afs_server *server;764 bool ret = true;765 int i;766 767 if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK, &volume->flags))768 return true;769 770 rcu_read_lock();771 slist = rcu_dereference(volume->servers);772 773 for (i = 0; i < slist->nr_servers; i++) {774 server = slist->servers[i].server;775 if (server == dvnode->cb_server) {776 if (test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags))777 ret = false;778 break;779 }780 }781 782 rcu_read_unlock();783 return ret;784}785 786/*787 * Do a lookup in a directory. We make use of bulk lookup to query a slew of788 * files in one go and create inodes for them. The inode of the file we were789 * asked for is returned.790 */791static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry,792 struct key *key)793{794 struct afs_lookup_cookie *cookie;795 struct afs_vnode_param *vp;796 struct afs_operation *op;797 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode;798 struct inode *inode = NULL, *ti;799 afs_dataversion_t data_version = READ_ONCE(dvnode->status.data_version);800 long ret;801 int i;802 803 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);804 805 cookie = kzalloc(sizeof(struct afs_lookup_cookie), GFP_KERNEL);806 if (!cookie)807 return ERR_PTR(-ENOMEM);808 809 for (i = 0; i < ARRAY_SIZE(cookie->fids); i++)810 cookie->fids[i].vid = dvnode->fid.vid;811 cookie->ctx.actor = afs_lookup_filldir;812 cookie->name = dentry->d_name;813 cookie->nr_fids = 2; /* slot 1 is saved for the fid we actually want814 * and slot 0 for the directory */815 816 if (!afs_server_supports_ibulk(dvnode))817 cookie->one_only = true;818 819 /* search the directory */820 ret = afs_dir_iterate(dir, &cookie->ctx, key, &data_version);821 if (ret < 0)822 goto out;823 824 dentry->d_fsdata = (void *)(unsigned long)data_version;825 826 ret = -ENOENT;827 if (!cookie->found)828 goto out;829 830 /* Check to see if we already have an inode for the primary fid. */831 inode = ilookup5(dir->i_sb, cookie->fids[1].vnode,832 afs_ilookup5_test_by_fid, &cookie->fids[1]);833 if (inode)834 goto out; /* We do */835 836 /* Okay, we didn't find it. We need to query the server - and whilst837 * we're doing that, we're going to attempt to look up a bunch of other838 * vnodes also.839 */840 op = afs_alloc_operation(NULL, dvnode->volume);841 if (IS_ERR(op)) {842 ret = PTR_ERR(op);843 goto out;844 }845 846 afs_op_set_vnode(op, 0, dvnode);847 afs_op_set_fid(op, 1, &cookie->fids[1]);848 849 op->nr_files = cookie->nr_fids;850 _debug("nr_files %u", op->nr_files);851 852 /* Need space for examining all the selected files */853 if (op->nr_files > 2) {854 op->more_files = kvcalloc(op->nr_files - 2,855 sizeof(struct afs_vnode_param),856 GFP_KERNEL);857 if (!op->more_files) {858 afs_op_nomem(op);859 goto out_op;860 }861 862 for (i = 2; i < op->nr_files; i++) {863 vp = &op->more_files[i - 2];864 vp->fid = cookie->fids[i];865 866 /* Find any inodes that already exist and get their867 * callback counters.868 */869 ti = ilookup5_nowait(dir->i_sb, vp->fid.vnode,870 afs_ilookup5_test_by_fid, &vp->fid);871 if (!IS_ERR_OR_NULL(ti)) {872 vnode = AFS_FS_I(ti);873 vp->dv_before = vnode->status.data_version;874 vp->cb_break_before = afs_calc_vnode_cb_break(vnode);875 vp->vnode = vnode;876 vp->put_vnode = true;877 vp->speculative = true; /* vnode not locked */878 }879 }880 }881 882 /* Try FS.InlineBulkStatus first. Abort codes for the individual883 * lookups contained therein are stored in the reply without aborting884 * the whole operation.885 */886 afs_op_set_error(op, -ENOTSUPP);887 if (!cookie->one_only) {888 op->ops = &afs_inline_bulk_status_operation;889 afs_begin_vnode_operation(op);890 afs_wait_for_operation(op);891 }892 893 if (afs_op_error(op) == -ENOTSUPP) {894 /* We could try FS.BulkStatus next, but this aborts the entire895 * op if any of the lookups fails - so, for the moment, revert896 * to FS.FetchStatus for op->file[1].897 */898 op->fetch_status.which = 1;899 op->ops = &afs_lookup_fetch_status_operation;900 afs_begin_vnode_operation(op);901 afs_wait_for_operation(op);902 }903 904out_op:905 if (!afs_op_error(op)) {906 if (op->file[1].scb.status.abort_code) {907 afs_op_accumulate_error(op, -ECONNABORTED,908 op->file[1].scb.status.abort_code);909 } else {910 inode = &op->file[1].vnode->netfs.inode;911 op->file[1].vnode = NULL;912 }913 }914 915 if (op->file[0].scb.have_status)916 dentry->d_fsdata = (void *)(unsigned long)op->file[0].scb.status.data_version;917 else918 dentry->d_fsdata = (void *)(unsigned long)op->file[0].dv_before;919 ret = afs_put_operation(op);920out:921 kfree(cookie);922 _leave("");923 return inode ?: ERR_PTR(ret);924}925 926/*927 * Look up an entry in a directory with @sys substitution.928 */929static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry,930 struct key *key)931{932 struct afs_sysnames *subs;933 struct afs_net *net = afs_i2net(dir);934 struct dentry *ret;935 char *buf, *p, *name;936 int len, i;937 938 _enter("");939 940 ret = ERR_PTR(-ENOMEM);941 p = buf = kmalloc(AFSNAMEMAX, GFP_KERNEL);942 if (!buf)943 goto out_p;944 if (dentry->d_name.len > 4) {945 memcpy(p, dentry->d_name.name, dentry->d_name.len - 4);946 p += dentry->d_name.len - 4;947 }948 949 /* There is an ordered list of substitutes that we have to try. */950 read_lock(&net->sysnames_lock);951 subs = net->sysnames;952 refcount_inc(&subs->usage);953 read_unlock(&net->sysnames_lock);954 955 for (i = 0; i < subs->nr; i++) {956 name = subs->subs[i];957 len = dentry->d_name.len - 4 + strlen(name);958 if (len >= AFSNAMEMAX) {959 ret = ERR_PTR(-ENAMETOOLONG);960 goto out_s;961 }962 963 strcpy(p, name);964 ret = lookup_one_len(buf, dentry->d_parent, len);965 if (IS_ERR(ret) || d_is_positive(ret))966 goto out_s;967 dput(ret);968 }969 970 /* We don't want to d_add() the @sys dentry here as we don't want to971 * the cached dentry to hide changes to the sysnames list.972 */973 ret = NULL;974out_s:975 afs_put_sysnames(subs);976 kfree(buf);977out_p:978 key_put(key);979 return ret;980}981 982/*983 * look up an entry in a directory984 */985static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,986 unsigned int flags)987{988 struct afs_vnode *dvnode = AFS_FS_I(dir);989 struct afs_fid fid = {};990 struct inode *inode;991 struct dentry *d;992 struct key *key;993 int ret;994 995 _enter("{%llx:%llu},%p{%pd},",996 dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry);997 998 ASSERTCMP(d_inode(dentry), ==, NULL);999 1000 if (dentry->d_name.len >= AFSNAMEMAX) {1001 _leave(" = -ENAMETOOLONG");1002 return ERR_PTR(-ENAMETOOLONG);1003 }1004 1005 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {1006 _leave(" = -ESTALE");1007 return ERR_PTR(-ESTALE);1008 }1009 1010 key = afs_request_key(dvnode->volume->cell);1011 if (IS_ERR(key)) {1012 _leave(" = %ld [key]", PTR_ERR(key));1013 return ERR_CAST(key);1014 }1015 1016 ret = afs_validate(dvnode, key);1017 if (ret < 0) {1018 key_put(key);1019 _leave(" = %d [val]", ret);1020 return ERR_PTR(ret);1021 }1022 1023 if (dentry->d_name.len >= 4 &&1024 dentry->d_name.name[dentry->d_name.len - 4] == '@' &&1025 dentry->d_name.name[dentry->d_name.len - 3] == 's' &&1026 dentry->d_name.name[dentry->d_name.len - 2] == 'y' &&1027 dentry->d_name.name[dentry->d_name.len - 1] == 's')1028 return afs_lookup_atsys(dir, dentry, key);1029 1030 afs_stat_v(dvnode, n_lookup);1031 inode = afs_do_lookup(dir, dentry, key);1032 key_put(key);1033 if (inode == ERR_PTR(-ENOENT))1034 inode = afs_try_auto_mntpt(dentry, dir);1035 1036 if (!IS_ERR_OR_NULL(inode))1037 fid = AFS_FS_I(inode)->fid;1038 1039 _debug("splice %p", dentry->d_inode);1040 d = d_splice_alias(inode, dentry);1041 if (!IS_ERR_OR_NULL(d)) {1042 d->d_fsdata = dentry->d_fsdata;1043 trace_afs_lookup(dvnode, &d->d_name, &fid);1044 } else {1045 trace_afs_lookup(dvnode, &dentry->d_name, &fid);1046 }1047 _leave("");1048 return d;1049}1050 1051/*1052 * Check the validity of a dentry under RCU conditions.1053 */1054static int afs_d_revalidate_rcu(struct dentry *dentry)1055{1056 struct afs_vnode *dvnode;1057 struct dentry *parent;1058 struct inode *dir;1059 long dir_version, de_version;1060 1061 _enter("%p", dentry);1062 1063 /* Check the parent directory is still valid first. */1064 parent = READ_ONCE(dentry->d_parent);1065 dir = d_inode_rcu(parent);1066 if (!dir)1067 return -ECHILD;1068 dvnode = AFS_FS_I(dir);1069 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags))1070 return -ECHILD;1071 1072 if (!afs_check_validity(dvnode))1073 return -ECHILD;1074 1075 /* We only need to invalidate a dentry if the server's copy changed1076 * behind our back. If we made the change, it's no problem. Note that1077 * on a 32-bit system, we only have 32 bits in the dentry to store the1078 * version.1079 */1080 dir_version = (long)READ_ONCE(dvnode->status.data_version);1081 de_version = (long)READ_ONCE(dentry->d_fsdata);1082 if (de_version != dir_version) {1083 dir_version = (long)READ_ONCE(dvnode->invalid_before);1084 if (de_version - dir_version < 0)1085 return -ECHILD;1086 }1087 1088 return 1; /* Still valid */1089}1090 1091/*1092 * check that a dentry lookup hit has found a valid entry1093 * - NOTE! the hit can be a negative hit too, so we can't assume we have an1094 * inode1095 */1096static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)1097{1098 struct afs_vnode *vnode, *dir;1099 struct afs_fid fid;1100 struct dentry *parent;1101 struct inode *inode;1102 struct key *key;1103 afs_dataversion_t dir_version, invalid_before;1104 long de_version;1105 int ret;1106 1107 if (flags & LOOKUP_RCU)1108 return afs_d_revalidate_rcu(dentry);1109 1110 if (d_really_is_positive(dentry)) {1111 vnode = AFS_FS_I(d_inode(dentry));1112 _enter("{v={%llx:%llu} n=%pd fl=%lx},",1113 vnode->fid.vid, vnode->fid.vnode, dentry,1114 vnode->flags);1115 } else {1116 _enter("{neg n=%pd}", dentry);1117 }1118 1119 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell);1120 if (IS_ERR(key))1121 key = NULL;1122 1123 /* Hold the parent dentry so we can peer at it */1124 parent = dget_parent(dentry);1125 dir = AFS_FS_I(d_inode(parent));1126 1127 /* validate the parent directory */1128 ret = afs_validate(dir, key);1129 if (ret == -ERESTARTSYS) {1130 dput(parent);1131 key_put(key);1132 return ret;1133 }1134 1135 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {1136 _debug("%pd: parent dir deleted", dentry);1137 goto not_found;1138 }1139 1140 /* We only need to invalidate a dentry if the server's copy changed1141 * behind our back. If we made the change, it's no problem. Note that1142 * on a 32-bit system, we only have 32 bits in the dentry to store the1143 * version.1144 */1145 dir_version = dir->status.data_version;1146 de_version = (long)dentry->d_fsdata;1147 if (de_version == (long)dir_version)1148 goto out_valid_noupdate;1149 1150 invalid_before = dir->invalid_before;1151 if (de_version - (long)invalid_before >= 0)1152 goto out_valid;1153 1154 _debug("dir modified");1155 afs_stat_v(dir, n_reval);1156 1157 /* search the directory for this vnode */1158 ret = afs_do_lookup_one(&dir->netfs.inode, dentry, &fid, key, &dir_version);1159 switch (ret) {1160 case 0:1161 /* the filename maps to something */1162 if (d_really_is_negative(dentry))1163 goto not_found;1164 inode = d_inode(dentry);1165 if (is_bad_inode(inode)) {1166 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",1167 dentry);1168 goto not_found;1169 }1170 1171 vnode = AFS_FS_I(inode);1172 1173 /* if the vnode ID has changed, then the dirent points to a1174 * different file */1175 if (fid.vnode != vnode->fid.vnode) {1176 _debug("%pd: dirent changed [%llu != %llu]",1177 dentry, fid.vnode,1178 vnode->fid.vnode);1179 goto not_found;1180 }1181 1182 /* if the vnode ID uniqifier has changed, then the file has1183 * been deleted and replaced, and the original vnode ID has1184 * been reused */1185 if (fid.unique != vnode->fid.unique) {1186 _debug("%pd: file deleted (uq %u -> %u I:%u)",1187 dentry, fid.unique,1188 vnode->fid.unique,1189 vnode->netfs.inode.i_generation);1190 goto not_found;1191 }1192 goto out_valid;1193 1194 case -ENOENT:1195 /* the filename is unknown */1196 _debug("%pd: dirent not found", dentry);1197 if (d_really_is_positive(dentry))1198 goto not_found;1199 goto out_valid;1200 1201 default:1202 _debug("failed to iterate dir %pd: %d",1203 parent, ret);1204 goto not_found;1205 }1206 1207out_valid:1208 dentry->d_fsdata = (void *)(unsigned long)dir_version;1209out_valid_noupdate:1210 dput(parent);1211 key_put(key);1212 _leave(" = 1 [valid]");1213 return 1;1214 1215not_found:1216 _debug("dropping dentry %pd2", dentry);1217 dput(parent);1218 key_put(key);1219 1220 _leave(" = 0 [bad]");1221 return 0;1222}1223 1224/*1225 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't1226 * sleep)1227 * - called from dput() when d_count is going to 0.1228 * - return 1 to request dentry be unhashed, 0 otherwise1229 */1230static int afs_d_delete(const struct dentry *dentry)1231{1232 _enter("%pd", dentry);1233 1234 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)1235 goto zap;1236 1237 if (d_really_is_positive(dentry) &&1238 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) ||1239 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))1240 goto zap;1241 1242 _leave(" = 0 [keep]");1243 return 0;1244 1245zap:1246 _leave(" = 1 [zap]");1247 return 1;1248}1249 1250/*1251 * Clean up sillyrename files on dentry removal.1252 */1253static void afs_d_iput(struct dentry *dentry, struct inode *inode)1254{1255 if (dentry->d_flags & DCACHE_NFSFS_RENAMED)1256 afs_silly_iput(dentry, inode);1257 iput(inode);1258}1259 1260/*1261 * handle dentry release1262 */1263void afs_d_release(struct dentry *dentry)1264{1265 _enter("%pd", dentry);1266}1267 1268void afs_check_for_remote_deletion(struct afs_operation *op)1269{1270 struct afs_vnode *vnode = op->file[0].vnode;1271 1272 switch (afs_op_abort_code(op)) {1273 case VNOVNODE:1274 set_bit(AFS_VNODE_DELETED, &vnode->flags);1275 clear_nlink(&vnode->netfs.inode);1276 afs_break_callback(vnode, afs_cb_break_for_deleted);1277 }1278}1279 1280/*1281 * Create a new inode for create/mkdir/symlink1282 */1283static void afs_vnode_new_inode(struct afs_operation *op)1284{1285 struct afs_vnode_param *vp = &op->file[1];1286 struct afs_vnode *vnode;1287 struct inode *inode;1288 1289 _enter("");1290 1291 ASSERTCMP(afs_op_error(op), ==, 0);1292 1293 inode = afs_iget(op, vp);1294 if (IS_ERR(inode)) {1295 /* ENOMEM or EINTR at a really inconvenient time - just abandon1296 * the new directory on the server.1297 */1298 afs_op_accumulate_error(op, PTR_ERR(inode), 0);1299 return;1300 }1301 1302 vnode = AFS_FS_I(inode);1303 set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags);1304 if (!afs_op_error(op))1305 afs_cache_permit(vnode, op->key, vnode->cb_break, &vp->scb);1306 d_instantiate(op->dentry, inode);1307}1308 1309static void afs_create_success(struct afs_operation *op)1310{1311 _enter("op=%08x", op->debug_id);1312 op->ctime = op->file[0].scb.status.mtime_client;1313 afs_vnode_commit_status(op, &op->file[0]);1314 afs_update_dentry_version(op, &op->file[0], op->dentry);1315 afs_vnode_new_inode(op);1316}1317 1318static void afs_create_edit_dir(struct afs_operation *op)1319{1320 struct afs_vnode_param *dvp = &op->file[0];1321 struct afs_vnode_param *vp = &op->file[1];1322 struct afs_vnode *dvnode = dvp->vnode;1323 1324 _enter("op=%08x", op->debug_id);1325 1326 down_write(&dvnode->validate_lock);1327 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&1328 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)1329 afs_edit_dir_add(dvnode, &op->dentry->d_name, &vp->fid,1330 op->create.reason);1331 up_write(&dvnode->validate_lock);1332}1333 1334static void afs_create_put(struct afs_operation *op)1335{1336 _enter("op=%08x", op->debug_id);1337 1338 if (afs_op_error(op))1339 d_drop(op->dentry);1340}1341 1342static const struct afs_operation_ops afs_mkdir_operation = {1343 .issue_afs_rpc = afs_fs_make_dir,1344 .issue_yfs_rpc = yfs_fs_make_dir,1345 .success = afs_create_success,1346 .aborted = afs_check_for_remote_deletion,1347 .edit_dir = afs_create_edit_dir,1348 .put = afs_create_put,1349};1350 1351/*1352 * create a directory on an AFS filesystem1353 */1354static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,1355 struct dentry *dentry, umode_t mode)1356{1357 struct afs_operation *op;1358 struct afs_vnode *dvnode = AFS_FS_I(dir);1359 1360 _enter("{%llx:%llu},{%pd},%ho",1361 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);1362 1363 op = afs_alloc_operation(NULL, dvnode->volume);1364 if (IS_ERR(op)) {1365 d_drop(dentry);1366 return PTR_ERR(op);1367 }1368 1369 afs_op_set_vnode(op, 0, dvnode);1370 op->file[0].dv_delta = 1;1371 op->file[0].modification = true;1372 op->file[0].update_ctime = true;1373 op->dentry = dentry;1374 op->create.mode = S_IFDIR | mode;1375 op->create.reason = afs_edit_dir_for_mkdir;1376 op->mtime = current_time(dir);1377 op->ops = &afs_mkdir_operation;1378 return afs_do_sync_operation(op);1379}1380 1381/*1382 * Remove a subdir from a directory.1383 */1384static void afs_dir_remove_subdir(struct dentry *dentry)1385{1386 if (d_really_is_positive(dentry)) {1387 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));1388 1389 clear_nlink(&vnode->netfs.inode);1390 set_bit(AFS_VNODE_DELETED, &vnode->flags);1391 atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE);1392 clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags);1393 }1394}1395 1396static void afs_rmdir_success(struct afs_operation *op)1397{1398 _enter("op=%08x", op->debug_id);1399 op->ctime = op->file[0].scb.status.mtime_client;1400 afs_vnode_commit_status(op, &op->file[0]);1401 afs_update_dentry_version(op, &op->file[0], op->dentry);1402}1403 1404static void afs_rmdir_edit_dir(struct afs_operation *op)1405{1406 struct afs_vnode_param *dvp = &op->file[0];1407 struct afs_vnode *dvnode = dvp->vnode;1408 1409 _enter("op=%08x", op->debug_id);1410 afs_dir_remove_subdir(op->dentry);1411 1412 down_write(&dvnode->validate_lock);1413 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&1414 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)1415 afs_edit_dir_remove(dvnode, &op->dentry->d_name,1416 afs_edit_dir_for_rmdir);1417 up_write(&dvnode->validate_lock);1418}1419 1420static void afs_rmdir_put(struct afs_operation *op)1421{1422 _enter("op=%08x", op->debug_id);1423 if (op->file[1].vnode)1424 up_write(&op->file[1].vnode->rmdir_lock);1425}1426 1427static const struct afs_operation_ops afs_rmdir_operation = {1428 .issue_afs_rpc = afs_fs_remove_dir,1429 .issue_yfs_rpc = yfs_fs_remove_dir,1430 .success = afs_rmdir_success,1431 .aborted = afs_check_for_remote_deletion,1432 .edit_dir = afs_rmdir_edit_dir,1433 .put = afs_rmdir_put,1434};1435 1436/*1437 * remove a directory from an AFS filesystem1438 */1439static int afs_rmdir(struct inode *dir, struct dentry *dentry)1440{1441 struct afs_operation *op;1442 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode = NULL;1443 int ret;1444 1445 _enter("{%llx:%llu},{%pd}",1446 dvnode->fid.vid, dvnode->fid.vnode, dentry);1447 1448 op = afs_alloc_operation(NULL, dvnode->volume);1449 if (IS_ERR(op))1450 return PTR_ERR(op);1451 1452 afs_op_set_vnode(op, 0, dvnode);1453 op->file[0].dv_delta = 1;1454 op->file[0].modification = true;1455 op->file[0].update_ctime = true;1456 1457 op->dentry = dentry;1458 op->ops = &afs_rmdir_operation;1459 1460 /* Try to make sure we have a callback promise on the victim. */1461 if (d_really_is_positive(dentry)) {1462 vnode = AFS_FS_I(d_inode(dentry));1463 ret = afs_validate(vnode, op->key);1464 if (ret < 0)1465 goto error;1466 }1467 1468 if (vnode) {1469 ret = down_write_killable(&vnode->rmdir_lock);1470 if (ret < 0)1471 goto error;1472 op->file[1].vnode = vnode;1473 }1474 1475 return afs_do_sync_operation(op);1476 1477error:1478 return afs_put_operation(op);1479}1480 1481/*1482 * Remove a link to a file or symlink from a directory.1483 *1484 * If the file was not deleted due to excess hard links, the fileserver will1485 * break the callback promise on the file - if it had one - before it returns1486 * to us, and if it was deleted, it won't1487 *1488 * However, if we didn't have a callback promise outstanding, or it was1489 * outstanding on a different server, then it won't break it either...1490 */1491static void afs_dir_remove_link(struct afs_operation *op)1492{1493 struct afs_vnode *dvnode = op->file[0].vnode;1494 struct afs_vnode *vnode = op->file[1].vnode;1495 struct dentry *dentry = op->dentry;1496 int ret;1497 1498 if (afs_op_error(op) ||1499 (op->file[1].scb.have_status && op->file[1].scb.have_error))1500 return;1501 if (d_really_is_positive(dentry))1502 return;1503 1504 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {1505 /* Already done */1506 } else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {1507 write_seqlock(&vnode->cb_lock);1508 drop_nlink(&vnode->netfs.inode);1509 if (vnode->netfs.inode.i_nlink == 0) {1510 set_bit(AFS_VNODE_DELETED, &vnode->flags);1511 __afs_break_callback(vnode, afs_cb_break_for_unlink);1512 }1513 write_sequnlock(&vnode->cb_lock);1514 } else {1515 afs_break_callback(vnode, afs_cb_break_for_unlink);1516 1517 if (test_bit(AFS_VNODE_DELETED, &vnode->flags))1518 _debug("AFS_VNODE_DELETED");1519 1520 ret = afs_validate(vnode, op->key);1521 if (ret != -ESTALE)1522 afs_op_set_error(op, ret);1523 }1524 1525 _debug("nlink %d [val %d]", vnode->netfs.inode.i_nlink, afs_op_error(op));1526}1527 1528static void afs_unlink_success(struct afs_operation *op)1529{1530 _enter("op=%08x", op->debug_id);1531 op->ctime = op->file[0].scb.status.mtime_client;1532 afs_check_dir_conflict(op, &op->file[0]);1533 afs_vnode_commit_status(op, &op->file[0]);1534 afs_vnode_commit_status(op, &op->file[1]);1535 afs_update_dentry_version(op, &op->file[0], op->dentry);1536 afs_dir_remove_link(op);1537}1538 1539static void afs_unlink_edit_dir(struct afs_operation *op)1540{1541 struct afs_vnode_param *dvp = &op->file[0];1542 struct afs_vnode *dvnode = dvp->vnode;1543 1544 _enter("op=%08x", op->debug_id);1545 down_write(&dvnode->validate_lock);1546 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&1547 dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)1548 afs_edit_dir_remove(dvnode, &op->dentry->d_name,1549 afs_edit_dir_for_unlink);1550 up_write(&dvnode->validate_lock);1551}1552 1553static void afs_unlink_put(struct afs_operation *op)1554{1555 _enter("op=%08x", op->debug_id);1556 if (op->unlink.need_rehash && afs_op_error(op) < 0 && afs_op_error(op) != -ENOENT)1557 d_rehash(op->dentry);1558}1559 1560static const struct afs_operation_ops afs_unlink_operation = {1561 .issue_afs_rpc = afs_fs_remove_file,1562 .issue_yfs_rpc = yfs_fs_remove_file,1563 .success = afs_unlink_success,1564 .aborted = afs_check_for_remote_deletion,1565 .edit_dir = afs_unlink_edit_dir,1566 .put = afs_unlink_put,1567};1568 1569/*1570 * Remove a file or symlink from an AFS filesystem.1571 */1572static int afs_unlink(struct inode *dir, struct dentry *dentry)1573{1574 struct afs_operation *op;1575 struct afs_vnode *dvnode = AFS_FS_I(dir);1576 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry));1577 int ret;1578 1579 _enter("{%llx:%llu},{%pd}",1580 dvnode->fid.vid, dvnode->fid.vnode, dentry);1581 1582 if (dentry->d_name.len >= AFSNAMEMAX)1583 return -ENAMETOOLONG;1584 1585 op = afs_alloc_operation(NULL, dvnode->volume);1586 if (IS_ERR(op))1587 return PTR_ERR(op);1588 1589 afs_op_set_vnode(op, 0, dvnode);1590 op->file[0].dv_delta = 1;1591 op->file[0].modification = true;1592 op->file[0].update_ctime = true;1593 1594 /* Try to make sure we have a callback promise on the victim. */1595 ret = afs_validate(vnode, op->key);1596 if (ret < 0) {1597 afs_op_set_error(op, ret);1598 goto error;1599 }1600 1601 spin_lock(&dentry->d_lock);1602 if (d_count(dentry) > 1) {1603 spin_unlock(&dentry->d_lock);1604 /* Start asynchronous writeout of the inode */1605 write_inode_now(d_inode(dentry), 0);1606 afs_op_set_error(op, afs_sillyrename(dvnode, vnode, dentry, op->key));1607 goto error;1608 }1609 if (!d_unhashed(dentry)) {1610 /* Prevent a race with RCU lookup. */1611 __d_drop(dentry);1612 op->unlink.need_rehash = true;1613 }1614 spin_unlock(&dentry->d_lock);1615 1616 op->file[1].vnode = vnode;1617 op->file[1].update_ctime = true;1618 op->file[1].op_unlinked = true;1619 op->dentry = dentry;1620 op->ops = &afs_unlink_operation;1621 afs_begin_vnode_operation(op);1622 afs_wait_for_operation(op);1623 1624 /* If there was a conflict with a third party, check the status of the1625 * unlinked vnode.1626 */1627 if (afs_op_error(op) == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) {1628 op->file[1].update_ctime = false;1629 op->fetch_status.which = 1;1630 op->ops = &afs_fetch_status_operation;1631 afs_begin_vnode_operation(op);1632 afs_wait_for_operation(op);1633 }1634 1635 return afs_put_operation(op);1636 1637error:1638 return afs_put_operation(op);1639}1640 1641static const struct afs_operation_ops afs_create_operation = {1642 .issue_afs_rpc = afs_fs_create_file,1643 .issue_yfs_rpc = yfs_fs_create_file,1644 .success = afs_create_success,1645 .aborted = afs_check_for_remote_deletion,1646 .edit_dir = afs_create_edit_dir,1647 .put = afs_create_put,1648};1649 1650/*1651 * create a regular file on an AFS filesystem1652 */1653static int afs_create(struct mnt_idmap *idmap, struct inode *dir,1654 struct dentry *dentry, umode_t mode, bool excl)1655{1656 struct afs_operation *op;1657 struct afs_vnode *dvnode = AFS_FS_I(dir);1658 int ret = -ENAMETOOLONG;1659 1660 _enter("{%llx:%llu},{%pd},%ho",1661 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);1662 1663 if (dentry->d_name.len >= AFSNAMEMAX)1664 goto error;1665 1666 op = afs_alloc_operation(NULL, dvnode->volume);1667 if (IS_ERR(op)) {1668 ret = PTR_ERR(op);1669 goto error;1670 }1671 1672 afs_op_set_vnode(op, 0, dvnode);1673 op->file[0].dv_delta = 1;1674 op->file[0].modification = true;1675 op->file[0].update_ctime = true;1676 1677 op->dentry = dentry;1678 op->create.mode = S_IFREG | mode;1679 op->create.reason = afs_edit_dir_for_create;1680 op->mtime = current_time(dir);1681 op->ops = &afs_create_operation;1682 return afs_do_sync_operation(op);1683 1684error:1685 d_drop(dentry);1686 _leave(" = %d", ret);1687 return ret;1688}1689 1690static void afs_link_success(struct afs_operation *op)1691{1692 struct afs_vnode_param *dvp = &op->file[0];1693 struct afs_vnode_param *vp = &op->file[1];1694 1695 _enter("op=%08x", op->debug_id);1696 op->ctime = dvp->scb.status.mtime_client;1697 afs_vnode_commit_status(op, dvp);1698 afs_vnode_commit_status(op, vp);1699 afs_update_dentry_version(op, dvp, op->dentry);1700 if (op->dentry_2->d_parent == op->dentry->d_parent)1701 afs_update_dentry_version(op, dvp, op->dentry_2);1702 ihold(&vp->vnode->netfs.inode);1703 d_instantiate(op->dentry, &vp->vnode->netfs.inode);1704}1705 1706static void afs_link_put(struct afs_operation *op)1707{1708 _enter("op=%08x", op->debug_id);1709 if (afs_op_error(op))1710 d_drop(op->dentry);1711}1712 1713static const struct afs_operation_ops afs_link_operation = {1714 .issue_afs_rpc = afs_fs_link,1715 .issue_yfs_rpc = yfs_fs_link,1716 .success = afs_link_success,1717 .aborted = afs_check_for_remote_deletion,1718 .edit_dir = afs_create_edit_dir,1719 .put = afs_link_put,1720};1721 1722/*1723 * create a hard link between files in an AFS filesystem1724 */1725static int afs_link(struct dentry *from, struct inode *dir,1726 struct dentry *dentry)1727{1728 struct afs_operation *op;1729 struct afs_vnode *dvnode = AFS_FS_I(dir);1730 struct afs_vnode *vnode = AFS_FS_I(d_inode(from));1731 int ret = -ENAMETOOLONG;1732 1733 _enter("{%llx:%llu},{%llx:%llu},{%pd}",1734 vnode->fid.vid, vnode->fid.vnode,1735 dvnode->fid.vid, dvnode->fid.vnode,1736 dentry);1737 1738 if (dentry->d_name.len >= AFSNAMEMAX)1739 goto error;1740 1741 op = afs_alloc_operation(NULL, dvnode->volume);1742 if (IS_ERR(op)) {1743 ret = PTR_ERR(op);1744 goto error;1745 }1746 1747 ret = afs_validate(vnode, op->key);1748 if (ret < 0)1749 goto error_op;1750 1751 afs_op_set_vnode(op, 0, dvnode);1752 afs_op_set_vnode(op, 1, vnode);1753 op->file[0].dv_delta = 1;1754 op->file[0].modification = true;1755 op->file[0].update_ctime = true;1756 op->file[1].update_ctime = true;1757 1758 op->dentry = dentry;1759 op->dentry_2 = from;1760 op->ops = &afs_link_operation;1761 op->create.reason = afs_edit_dir_for_link;1762 return afs_do_sync_operation(op);1763 1764error_op:1765 afs_put_operation(op);1766error:1767 d_drop(dentry);1768 _leave(" = %d", ret);1769 return ret;1770}1771 1772static const struct afs_operation_ops afs_symlink_operation = {1773 .issue_afs_rpc = afs_fs_symlink,1774 .issue_yfs_rpc = yfs_fs_symlink,1775 .success = afs_create_success,1776 .aborted = afs_check_for_remote_deletion,1777 .edit_dir = afs_create_edit_dir,1778 .put = afs_create_put,1779};1780 1781/*1782 * create a symlink in an AFS filesystem1783 */1784static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,1785 struct dentry *dentry, const char *content)1786{1787 struct afs_operation *op;1788 struct afs_vnode *dvnode = AFS_FS_I(dir);1789 int ret;1790 1791 _enter("{%llx:%llu},{%pd},%s",1792 dvnode->fid.vid, dvnode->fid.vnode, dentry,1793 content);1794 1795 ret = -ENAMETOOLONG;1796 if (dentry->d_name.len >= AFSNAMEMAX)1797 goto error;1798 1799 ret = -EINVAL;1800 if (strlen(content) >= AFSPATHMAX)1801 goto error;1802 1803 op = afs_alloc_operation(NULL, dvnode->volume);1804 if (IS_ERR(op)) {1805 ret = PTR_ERR(op);1806 goto error;1807 }1808 1809 afs_op_set_vnode(op, 0, dvnode);1810 op->file[0].dv_delta = 1;1811 1812 op->dentry = dentry;1813 op->ops = &afs_symlink_operation;1814 op->create.reason = afs_edit_dir_for_symlink;1815 op->create.symlink = content;1816 op->mtime = current_time(dir);1817 return afs_do_sync_operation(op);1818 1819error:1820 d_drop(dentry);1821 _leave(" = %d", ret);1822 return ret;1823}1824 1825static void afs_rename_success(struct afs_operation *op)1826{1827 struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));1828 1829 _enter("op=%08x", op->debug_id);1830 1831 op->ctime = op->file[0].scb.status.mtime_client;1832 afs_check_dir_conflict(op, &op->file[1]);1833 afs_vnode_commit_status(op, &op->file[0]);1834 if (op->file[1].vnode != op->file[0].vnode) {1835 op->ctime = op->file[1].scb.status.mtime_client;1836 afs_vnode_commit_status(op, &op->file[1]);1837 }1838 1839 /* If we're moving a subdir between dirs, we need to update1840 * its DV counter too as the ".." will be altered.1841 */1842 if (S_ISDIR(vnode->netfs.inode.i_mode) &&1843 op->file[0].vnode != op->file[1].vnode) {1844 u64 new_dv;1845 1846 write_seqlock(&vnode->cb_lock);1847 1848 new_dv = vnode->status.data_version + 1;1849 vnode->status.data_version = new_dv;1850 inode_set_iversion_raw(&vnode->netfs.inode, new_dv);1851 1852 write_sequnlock(&vnode->cb_lock);1853 }1854}1855 1856static void afs_rename_edit_dir(struct afs_operation *op)1857{1858 struct afs_vnode_param *orig_dvp = &op->file[0];1859 struct afs_vnode_param *new_dvp = &op->file[1];1860 struct afs_vnode *orig_dvnode = orig_dvp->vnode;1861 struct afs_vnode *new_dvnode = new_dvp->vnode;1862 struct afs_vnode *vnode = AFS_FS_I(d_inode(op->dentry));1863 struct dentry *old_dentry = op->dentry;1864 struct dentry *new_dentry = op->dentry_2;1865 struct inode *new_inode;1866 1867 _enter("op=%08x", op->debug_id);1868 1869 if (op->rename.rehash) {1870 d_rehash(op->rename.rehash);1871 op->rename.rehash = NULL;1872 }1873 1874 down_write(&orig_dvnode->validate_lock);1875 if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags) &&1876 orig_dvnode->status.data_version == orig_dvp->dv_before + orig_dvp->dv_delta)1877 afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name,1878 afs_edit_dir_for_rename_0);1879 1880 if (new_dvnode != orig_dvnode) {1881 up_write(&orig_dvnode->validate_lock);1882 down_write(&new_dvnode->validate_lock);1883 }1884 1885 if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags) &&1886 new_dvnode->status.data_version == new_dvp->dv_before + new_dvp->dv_delta) {1887 if (!op->rename.new_negative)1888 afs_edit_dir_remove(new_dvnode, &new_dentry->d_name,1889 afs_edit_dir_for_rename_1);1890 1891 afs_edit_dir_add(new_dvnode, &new_dentry->d_name,1892 &vnode->fid, afs_edit_dir_for_rename_2);1893 }1894 1895 if (S_ISDIR(vnode->netfs.inode.i_mode) &&1896 new_dvnode != orig_dvnode &&1897 test_bit(AFS_VNODE_DIR_VALID, &vnode->flags))1898 afs_edit_dir_update_dotdot(vnode, new_dvnode,1899 afs_edit_dir_for_rename_sub);1900 1901 new_inode = d_inode(new_dentry);1902 if (new_inode) {1903 spin_lock(&new_inode->i_lock);1904 if (S_ISDIR(new_inode->i_mode))1905 clear_nlink(new_inode);1906 else if (new_inode->i_nlink > 0)1907 drop_nlink(new_inode);1908 spin_unlock(&new_inode->i_lock);1909 }1910 1911 /* Now we can update d_fsdata on the dentries to reflect their1912 * new parent's data_version.1913 *1914 * Note that if we ever implement RENAME_EXCHANGE, we'll have1915 * to update both dentries with opposing dir versions.1916 */1917 afs_update_dentry_version(op, new_dvp, op->dentry);1918 afs_update_dentry_version(op, new_dvp, op->dentry_2);1919 1920 d_move(old_dentry, new_dentry);1921 1922 up_write(&new_dvnode->validate_lock);1923}1924 1925static void afs_rename_put(struct afs_operation *op)1926{1927 _enter("op=%08x", op->debug_id);1928 if (op->rename.rehash)1929 d_rehash(op->rename.rehash);1930 dput(op->rename.tmp);1931 if (afs_op_error(op))1932 d_rehash(op->dentry);1933}1934 1935static const struct afs_operation_ops afs_rename_operation = {1936 .issue_afs_rpc = afs_fs_rename,1937 .issue_yfs_rpc = yfs_fs_rename,1938 .success = afs_rename_success,1939 .edit_dir = afs_rename_edit_dir,1940 .put = afs_rename_put,1941};1942 1943/*1944 * rename a file in an AFS filesystem and/or move it between directories1945 */1946static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,1947 struct dentry *old_dentry, struct inode *new_dir,1948 struct dentry *new_dentry, unsigned int flags)1949{1950 struct afs_operation *op;1951 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;1952 int ret;1953 1954 if (flags)1955 return -EINVAL;1956 1957 /* Don't allow silly-rename files be moved around. */1958 if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED)1959 return -EINVAL;1960 1961 vnode = AFS_FS_I(d_inode(old_dentry));1962 orig_dvnode = AFS_FS_I(old_dir);1963 new_dvnode = AFS_FS_I(new_dir);1964 1965 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",1966 orig_dvnode->fid.vid, orig_dvnode->fid.vnode,1967 vnode->fid.vid, vnode->fid.vnode,1968 new_dvnode->fid.vid, new_dvnode->fid.vnode,1969 new_dentry);1970 1971 op = afs_alloc_operation(NULL, orig_dvnode->volume);1972 if (IS_ERR(op))1973 return PTR_ERR(op);1974 1975 ret = afs_validate(vnode, op->key);1976 afs_op_set_error(op, ret);1977 if (ret < 0)1978 goto error;1979 1980 afs_op_set_vnode(op, 0, orig_dvnode);1981 afs_op_set_vnode(op, 1, new_dvnode); /* May be same as orig_dvnode */1982 op->file[0].dv_delta = 1;1983 op->file[1].dv_delta = 1;1984 op->file[0].modification = true;1985 op->file[1].modification = true;1986 op->file[0].update_ctime = true;1987 op->file[1].update_ctime = true;1988 1989 op->dentry = old_dentry;1990 op->dentry_2 = new_dentry;1991 op->rename.new_negative = d_is_negative(new_dentry);1992 op->ops = &afs_rename_operation;1993 1994 /* For non-directories, check whether the target is busy and if so,1995 * make a copy of the dentry and then do a silly-rename. If the1996 * silly-rename succeeds, the copied dentry is hashed and becomes the1997 * new target.1998 */1999 if (d_is_positive(new_dentry) && !d_is_dir(new_dentry)) {2000 /* To prevent any new references to the target during the2001 * rename, we unhash the dentry in advance.2002 */2003 if (!d_unhashed(new_dentry)) {2004 d_drop(new_dentry);2005 op->rename.rehash = new_dentry;2006 }2007 2008 if (d_count(new_dentry) > 2) {2009 /* copy the target dentry's name */2010 op->rename.tmp = d_alloc(new_dentry->d_parent,2011 &new_dentry->d_name);2012 if (!op->rename.tmp) {2013 afs_op_nomem(op);2014 goto error;2015 }2016 2017 ret = afs_sillyrename(new_dvnode,2018 AFS_FS_I(d_inode(new_dentry)),2019 new_dentry, op->key);2020 if (ret) {2021 afs_op_set_error(op, ret);2022 goto error;2023 }2024 2025 op->dentry_2 = op->rename.tmp;2026 op->rename.rehash = NULL;2027 op->rename.new_negative = true;2028 }2029 }2030 2031 /* This bit is potentially nasty as there's a potential race with2032 * afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry2033 * to reflect it's new parent's new data_version after the op, but2034 * d_revalidate may see old_dentry between the op having taken place2035 * and the version being updated.2036 *2037 * So drop the old_dentry for now to make other threads go through2038 * lookup instead - which we hold a lock against.2039 */2040 d_drop(old_dentry);2041 2042 return afs_do_sync_operation(op);2043 2044error:2045 return afs_put_operation(op);2046}2047 2048/*2049 * Release a directory folio and clean up its private state if it's not busy2050 * - return true if the folio can now be released, false if not2051 */2052static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags)2053{2054 struct afs_vnode *dvnode = AFS_FS_I(folio_inode(folio));2055 2056 _enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, folio->index);2057 2058 folio_detach_private(folio);2059 2060 /* The directory will need reloading. */2061 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))2062 afs_stat_v(dvnode, n_relpg);2063 return true;2064}2065 2066/*2067 * Invalidate part or all of a folio.2068 */2069static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,2070 size_t length)2071{2072 struct afs_vnode *dvnode = AFS_FS_I(folio_inode(folio));2073 2074 _enter("{%lu},%zu,%zu", folio->index, offset, length);2075 2076 BUG_ON(!folio_test_locked(folio));2077 2078 /* The directory will need reloading. */2079 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))2080 afs_stat_v(dvnode, n_inval);2081 2082 /* we clean up only if the entire folio is being invalidated */2083 if (offset == 0 && length == folio_size(folio))2084 folio_detach_private(folio);2085}2086