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