fs/afs/dir.c

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