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