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: &xas, entry: folio))
125	continue;
126	BUG_ON(xa_is_value(folio));
127	ASSERTCMP(folio->mapping, ==, 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(vnode: dvnode, off: pos + offset, i_size);
160	kunmap_local(block);
161	trace_afs_file_error(vnode: dvnode, error: -EIO, where: 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: &xas, entry: folio))
203	continue;
204
205	BUG_ON(folio->mapping != 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 + 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: &xas, entry: folio))
234	continue;
235
236	BUG_ON(folio->mapping != mapping);
237
238	if (!afs_dir_check_folio(dvnode, folio, i_size: 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(size: sizeof(*req), GFP_KERNEL);
283	if (!req)
284	return ERR_PTR(error: -ENOMEM);
285
286	refcount_set(r: &req->usage, n: 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(inode: &dvnode->netfs.inode);
293	if (i_size < remote_size)
294	i_size = remote_size;
295	if (i_size < 2048) {
296	ret = afs_bad(vnode: dvnode, where: afs_file_error_dir_small);
297	goto error;
298	}
299	if (i_size > 2048 * 1024) {
300	trace_afs_file_error(vnode: dvnode, error: -EFBIG, where: 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(i: &req->def_iter, ITER_DEST, xarray: &dvnode->netfs.inode.i_mapping->i_pages,
313	start: 0, count: 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, index: i);
325	if (IS_ERR(ptr: folio)) {
326	if (test_and_clear_bit(AFS_VNODE_DIR_VALID, addr: &dvnode->flags))
327	afs_stat_v(dvnode, n_inval);
328	folio = __filemap_get_folio(mapping,
329	index: i, FGP_LOCK | FGP_CREAT,
330	gfp: mapping->gfp_mask);
331	if (IS_ERR(ptr: folio)) {
332	ret = PTR_ERR(ptr: folio);
333	goto error;
334	}
335	folio_attach_private(folio, data: (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(sem: &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(sem: &dvnode->validate_lock);
354	if (down_write_killable(sem: &dvnode->validate_lock) < 0)
355	goto error;
356
357	if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {
358	trace_afs_reload_dir(vnode: 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(sem: &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, addr: &dvnode->flags);
382	}
383
384	downgrade_write(sem: &dvnode->validate_lock);
385	success:
386	return req;
387
388	error_unlock:
389	up_write(sem: &dvnode->validate_lock);
390	error:
391	afs_put_read(req);
392	_leave(" = %d", ret);
393	return ERR_PTR(error: 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(p: dire->u.name,
433	maxlen: 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(vnode: dvnode, where: 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(name_len: 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(vnode: dvnode, where: 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(vnode: dvnode, where: 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, name: dire->u.name, namelen: nlen,
479	ntohl(dire->u.vnode),
480	type: (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(inode: 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(ptr: req))
516	return PTR_ERR(ptr: 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(mapping: dir->i_mapping, index: ctx->pos / PAGE_SIZE,
530	FGP_ACCESSED, gfp: 0);
531	if (IS_ERR(ptr: folio)) {
532	ret = afs_bad(vnode: dvnode, where: 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, block: dblock,
543	blkoff: 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(sem: &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(dir: file_inode(f: file), ctx, key: afs_file_key(file),
568	dir_version: &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(p: cookie->name.name, q: name, size: 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, ctx: &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(p: cookie->name.name, q: name, size: 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->call_abort_code = abort_code;
697	afs_op_set_error(op, error: afs_abort_to_error(abort_code));
698	op->cumul_error.abort_code = abort_code;
699	}
700	break;
701
702	case 1:
703	vp = &op->file[1];
704	break;
705
706	default:
707	vp = &op->more_files[i - 2];
708	break;
709	}
710
711	if (vp->scb.status.abort_code)
712	trace_afs_bulkstat_error(op, fid: &vp->fid, index: i, abort: vp->scb.status.abort_code);
713	if (!vp->scb.have_status && !vp->scb.have_error)
714	continue;
715
716	_debug("do [%u]", i);
717	if (vp->vnode) {
718	if (!test_bit(AFS_VNODE_UNSET, &vp->vnode->flags))
719	afs_vnode_commit_status(op, vp);
720	} else if (vp->scb.status.abort_code == 0) {
721	inode = afs_iget(op, vp);
722	if (!IS_ERR(ptr: inode)) {
723	vnode = AFS_FS_I(inode);
724	afs_cache_permit(vnode, op->key,
725	0 /* Assume vnode->cb_break is 0 */ +
726	op->cb_v_break,
727	&vp->scb);
728	vp->vnode = vnode;
729	vp->put_vnode = true;
730	}
731	} else {
732	_debug("- abort %d %llx:%llx.%x",
733	vp->scb.status.abort_code,
734	vp->fid.vid, vp->fid.vnode, vp->fid.unique);
735	}
736	}
737
738	_leave("");
739	}
740
741	static const struct afs_operation_ops afs_inline_bulk_status_operation = {
742	.issue_afs_rpc = afs_fs_inline_bulk_status,
743	.issue_yfs_rpc = yfs_fs_inline_bulk_status,
744	.success = afs_do_lookup_success,
745	};
746
747	static const struct afs_operation_ops afs_lookup_fetch_status_operation = {
748	.issue_afs_rpc = afs_fs_fetch_status,
749	.issue_yfs_rpc = yfs_fs_fetch_status,
750	.success = afs_do_lookup_success,
751	.aborted = afs_check_for_remote_deletion,
752	};
753
754	/*
755	* See if we know that the server we expect to use doesn't support
756	* FS.InlineBulkStatus.
757	*/
758	static bool afs_server_supports_ibulk(struct afs_vnode *dvnode)
759	{
760	struct afs_server_list *slist;
761	struct afs_volume *volume = dvnode->volume;
762	struct afs_server *server;
763	bool ret = true;
764	int i;
765
766	if (!test_bit(AFS_VOLUME_MAYBE_NO_IBULK, &volume->flags))
767	return true;
768
769	rcu_read_lock();
770	slist = rcu_dereference(volume->servers);
771
772	for (i = 0; i < slist->nr_servers; i++) {
773	server = slist->servers[i].server;
774	if (server == dvnode->cb_server) {
775	if (test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags))
776	ret = false;
777	break;
778	}
779	}
780
781	rcu_read_unlock();
782	return ret;
783	}
784
785	/*
786	* Do a lookup in a directory. We make use of bulk lookup to query a slew of
787	* files in one go and create inodes for them. The inode of the file we were
788	* asked for is returned.
789	*/
790	static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry,
791	struct key *key)
792	{
793	struct afs_lookup_cookie *cookie;
794	struct afs_vnode_param *vp;
795	struct afs_operation *op;
796	struct afs_vnode *dvnode = AFS_FS_I(inode: dir), *vnode;
797	struct inode *inode = NULL, *ti;
798	afs_dataversion_t data_version = READ_ONCE(dvnode->status.data_version);
799	long ret;
800	int i;
801
802	_enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
803
804	cookie = kzalloc(size: sizeof(struct afs_lookup_cookie), GFP_KERNEL);
805	if (!cookie)
806	return ERR_PTR(error: -ENOMEM);
807
808	for (i = 0; i < ARRAY_SIZE(cookie->fids); i++)
809	cookie->fids[i].vid = dvnode->fid.vid;
810	cookie->ctx.actor = afs_lookup_filldir;
811	cookie->name = dentry->d_name;
812	cookie->nr_fids = 2; /* slot 1 is saved for the fid we actually want
813	* and slot 0 for the directory */
814
815	if (!afs_server_supports_ibulk(dvnode))
816	cookie->one_only = true;
817
818	/* search the directory */
819	ret = afs_dir_iterate(dir, ctx: &cookie->ctx, key, dir_version: &data_version);
820	if (ret < 0)
821	goto out;
822
823	dentry->d_fsdata = (void *)(unsigned long)data_version;
824
825	ret = -ENOENT;
826	if (!cookie->found)
827	goto out;
828
829	/* Check to see if we already have an inode for the primary fid. */
830	inode = ilookup5(sb: dir->i_sb, hashval: cookie->fids[1].vnode,
831	test: afs_ilookup5_test_by_fid, data: &cookie->fids[1]);
832	if (inode)
833	goto out; /* We do */
834
835	/* Okay, we didn't find it. We need to query the server - and whilst
836	* we're doing that, we're going to attempt to look up a bunch of other
837	* vnodes also.
838	*/
839	op = afs_alloc_operation(NULL, dvnode->volume);
840	if (IS_ERR(ptr: op)) {
841	ret = PTR_ERR(ptr: op);
842	goto out;
843	}
844
845	afs_op_set_vnode(op, n: 0, vnode: dvnode);
846	afs_op_set_fid(op, n: 1, fid: &cookie->fids[1]);
847
848	op->nr_files = cookie->nr_fids;
849	_debug("nr_files %u", op->nr_files);
850
851	/* Need space for examining all the selected files */
852	if (op->nr_files > 2) {
853	op->more_files = kvcalloc(n: op->nr_files - 2,
854	size: sizeof(struct afs_vnode_param),
855	GFP_KERNEL);
856	if (!op->more_files) {
857	afs_op_nomem(op);
858	goto out_op;
859	}
860
861	for (i = 2; i < op->nr_files; i++) {
862	vp = &op->more_files[i - 2];
863	vp->fid = cookie->fids[i];
864
865	/* Find any inodes that already exist and get their
866	* callback counters.
867	*/
868	ti = ilookup5_nowait(sb: dir->i_sb, hashval: vp->fid.vnode,
869	test: afs_ilookup5_test_by_fid, data: &vp->fid);
870	if (!IS_ERR_OR_NULL(ptr: ti)) {
871	vnode = AFS_FS_I(inode: ti);
872	vp->dv_before = vnode->status.data_version;
873	vp->cb_break_before = afs_calc_vnode_cb_break(vnode);
874	vp->vnode = vnode;
875	vp->put_vnode = true;
876	vp->speculative = true; /* vnode not locked */
877	}
878	}
879	}
880
881	/* Try FS.InlineBulkStatus first. Abort codes for the individual
882	* lookups contained therein are stored in the reply without aborting
883	* the whole operation.
884	*/
885	afs_op_set_error(op, error: -ENOTSUPP);
886	if (!cookie->one_only) {
887	op->ops = &afs_inline_bulk_status_operation;
888	afs_begin_vnode_operation(op);
889	afs_wait_for_operation(op);
890	}
891
892	if (afs_op_error(op) == -ENOTSUPP) {
893	/* We could try FS.BulkStatus next, but this aborts the entire
894	* op if any of the lookups fails - so, for the moment, revert
895	* to FS.FetchStatus for op->file[1].
896	*/
897	op->fetch_status.which = 1;
898	op->ops = &afs_lookup_fetch_status_operation;
899	afs_begin_vnode_operation(op);
900	afs_wait_for_operation(op);
901	}
902
903	out_op:
904	if (!afs_op_error(op)) {
905	if (op->file[1].scb.status.abort_code) {
906	afs_op_accumulate_error(op, error: -ECONNABORTED,
907	abort_code: op->file[1].scb.status.abort_code);
908	} else {
909	inode = &op->file[1].vnode->netfs.inode;
910	op->file[1].vnode = NULL;
911	}
912	}
913
914	if (op->file[0].scb.have_status)
915	dentry->d_fsdata = (void *)(unsigned long)op->file[0].scb.status.data_version;
916	else
917	dentry->d_fsdata = (void *)(unsigned long)op->file[0].dv_before;
918	ret = afs_put_operation(op);
919	out:
920	kfree(objp: cookie);
921	_leave("");
922	return inode ?: ERR_PTR(error: ret);
923	}
924
925	/*
926	* Look up an entry in a directory with @sys substitution.
927	*/
928	static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry,
929	struct key *key)
930	{
931	struct afs_sysnames *subs;
932	struct afs_net *net = afs_i2net(inode: dir);
933	struct dentry *ret;
934	char *buf, *p, *name;
935	int len, i;
936
937	_enter("");
938
939	ret = ERR_PTR(error: -ENOMEM);
940	p = buf = kmalloc(AFSNAMEMAX, GFP_KERNEL);
941	if (!buf)
942	goto out_p;
943	if (dentry->d_name.len > 4) {
944	memcpy(p, dentry->d_name.name, dentry->d_name.len - 4);
945	p += dentry->d_name.len - 4;
946	}
947
948	/* There is an ordered list of substitutes that we have to try. */
949	read_lock(&net->sysnames_lock);
950	subs = net->sysnames;
951	refcount_inc(r: &subs->usage);
952	read_unlock(&net->sysnames_lock);
953
954	for (i = 0; i < subs->nr; i++) {
955	name = subs->subs[i];
956	len = dentry->d_name.len - 4 + strlen(name);
957	if (len >= AFSNAMEMAX) {
958	ret = ERR_PTR(error: -ENAMETOOLONG);
959	goto out_s;
960	}
961
962	strcpy(p, q: name);
963	ret = lookup_one_len(buf, dentry->d_parent, len);
964	if (IS_ERR(ptr: ret) || d_is_positive(dentry: ret))
965	goto out_s;
966	dput(ret);
967	}
968
969	/* We don't want to d_add() the @sys dentry here as we don't want to
970	* the cached dentry to hide changes to the sysnames list.
971	*/
972	ret = NULL;
973	out_s:
974	afs_put_sysnames(subs);
975	kfree(objp: buf);
976	out_p:
977	key_put(key);
978	return ret;
979	}
980
981	/*
982	* look up an entry in a directory
983	*/
984	static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
985	unsigned int flags)
986	{
987	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
988	struct afs_fid fid = {};
989	struct inode *inode;
990	struct dentry *d;
991	struct key *key;
992	int ret;
993
994	_enter("{%llx:%llu},%p{%pd},",
995	dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry);
996
997	ASSERTCMP(d_inode(dentry), ==, NULL);
998
999	if (dentry->d_name.len >= AFSNAMEMAX) {
1000	_leave(" = -ENAMETOOLONG");
1001	return ERR_PTR(error: -ENAMETOOLONG);
1002	}
1003
1004	if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {
1005	_leave(" = -ESTALE");
1006	return ERR_PTR(error: -ESTALE);
1007	}
1008
1009	key = afs_request_key(dvnode->volume->cell);
1010	if (IS_ERR(ptr: key)) {
1011	_leave(" = %ld [key]", PTR_ERR(key));
1012	return ERR_CAST(ptr: key);
1013	}
1014
1015	ret = afs_validate(vnode: dvnode, key);
1016	if (ret < 0) {
1017	key_put(key);
1018	_leave(" = %d [val]", ret);
1019	return ERR_PTR(error: ret);
1020	}
1021
1022	if (dentry->d_name.len >= 4 &&
1023	dentry->d_name.name[dentry->d_name.len - 4] == '@' &&
1024	dentry->d_name.name[dentry->d_name.len - 3] == 's' &&
1025	dentry->d_name.name[dentry->d_name.len - 2] == 'y' &&
1026	dentry->d_name.name[dentry->d_name.len - 1] == 's')
1027	return afs_lookup_atsys(dir, dentry, key);
1028
1029	afs_stat_v(dvnode, n_lookup);
1030	inode = afs_do_lookup(dir, dentry, key);
1031	key_put(key);
1032	if (inode == ERR_PTR(error: -ENOENT))
1033	inode = afs_try_auto_mntpt(dentry, dir);
1034
1035	if (!IS_ERR_OR_NULL(ptr: inode))
1036	fid = AFS_FS_I(inode)->fid;
1037
1038	_debug("splice %p", dentry->d_inode);
1039	d = d_splice_alias(inode, dentry);
1040	if (!IS_ERR_OR_NULL(ptr: d)) {
1041	d->d_fsdata = dentry->d_fsdata;
1042	trace_afs_lookup(dvnode, name: &d->d_name, fid: &fid);
1043	} else {
1044	trace_afs_lookup(dvnode, name: &dentry->d_name, fid: &fid);
1045	}
1046	_leave("");
1047	return d;
1048	}
1049
1050	/*
1051	* Check the validity of a dentry under RCU conditions.
1052	*/
1053	static int afs_d_revalidate_rcu(struct dentry *dentry)
1054	{
1055	struct afs_vnode *dvnode;
1056	struct dentry *parent;
1057	struct inode *dir;
1058	long dir_version, de_version;
1059
1060	_enter("%p", dentry);
1061
1062	/* Check the parent directory is still valid first. */
1063	parent = READ_ONCE(dentry->d_parent);
1064	dir = d_inode_rcu(dentry: parent);
1065	if (!dir)
1066	return -ECHILD;
1067	dvnode = AFS_FS_I(inode: dir);
1068	if (test_bit(AFS_VNODE_DELETED, &dvnode->flags))
1069	return -ECHILD;
1070
1071	if (!afs_check_validity(vnode: dvnode))
1072	return -ECHILD;
1073
1074	/* We only need to invalidate a dentry if the server's copy changed
1075	* behind our back. If we made the change, it's no problem. Note that
1076	* on a 32-bit system, we only have 32 bits in the dentry to store the
1077	* version.
1078	*/
1079	dir_version = (long)READ_ONCE(dvnode->status.data_version);
1080	de_version = (long)READ_ONCE(dentry->d_fsdata);
1081	if (de_version != dir_version) {
1082	dir_version = (long)READ_ONCE(dvnode->invalid_before);
1083	if (de_version - dir_version < 0)
1084	return -ECHILD;
1085	}
1086
1087	return 1; /* Still valid */
1088	}
1089
1090	/*
1091	* check that a dentry lookup hit has found a valid entry
1092	* - NOTE! the hit can be a negative hit too, so we can't assume we have an
1093	* inode
1094	*/
1095	static int afs_d_revalidate(struct dentry *dentry, unsigned int flags)
1096	{
1097	struct afs_vnode *vnode, *dir;
1098	struct afs_fid fid;
1099	struct dentry *parent;
1100	struct inode *inode;
1101	struct key *key;
1102	afs_dataversion_t dir_version, invalid_before;
1103	long de_version;
1104	int ret;
1105
1106	if (flags & LOOKUP_RCU)
1107	return afs_d_revalidate_rcu(dentry);
1108
1109	if (d_really_is_positive(dentry)) {
1110	vnode = AFS_FS_I(inode: d_inode(dentry));
1111	_enter("{v={%llx:%llu} n=%pd fl=%lx},",
1112	vnode->fid.vid, vnode->fid.vnode, dentry,
1113	vnode->flags);
1114	} else {
1115	_enter("{neg n=%pd}", dentry);
1116	}
1117
1118	key = afs_request_key(AFS_FS_S(sb: dentry->d_sb)->volume->cell);
1119	if (IS_ERR(ptr: key))
1120	key = NULL;
1121
1122	/* Hold the parent dentry so we can peer at it */
1123	parent = dget_parent(dentry);
1124	dir = AFS_FS_I(inode: d_inode(dentry: parent));
1125
1126	/* validate the parent directory */
1127	ret = afs_validate(vnode: dir, key);
1128	if (ret == -ERESTARTSYS) {
1129	dput(parent);
1130	key_put(key);
1131	return ret;
1132	}
1133
1134	if (test_bit(AFS_VNODE_DELETED, &dir->flags)) {
1135	_debug("%pd: parent dir deleted", dentry);
1136	goto not_found;
1137	}
1138
1139	/* We only need to invalidate a dentry if the server's copy changed
1140	* behind our back. If we made the change, it's no problem. Note that
1141	* on a 32-bit system, we only have 32 bits in the dentry to store the
1142	* version.
1143	*/
1144	dir_version = dir->status.data_version;
1145	de_version = (long)dentry->d_fsdata;
1146	if (de_version == (long)dir_version)
1147	goto out_valid_noupdate;
1148
1149	invalid_before = dir->invalid_before;
1150	if (de_version - (long)invalid_before >= 0)
1151	goto out_valid;
1152
1153	_debug("dir modified");
1154	afs_stat_v(dir, n_reval);
1155
1156	/* search the directory for this vnode */
1157	ret = afs_do_lookup_one(dir: &dir->netfs.inode, dentry, fid: &fid, key, dir_version: &dir_version);
1158	switch (ret) {
1159	case 0:
1160	/* the filename maps to something */
1161	if (d_really_is_negative(dentry))
1162	goto not_found;
1163	inode = d_inode(dentry);
1164	if (is_bad_inode(inode)) {
1165	printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n",
1166	dentry);
1167	goto not_found;
1168	}
1169
1170	vnode = AFS_FS_I(inode);
1171
1172	/* if the vnode ID has changed, then the dirent points to a
1173	* different file */
1174	if (fid.vnode != vnode->fid.vnode) {
1175	_debug("%pd: dirent changed [%llu != %llu]",
1176	dentry, fid.vnode,
1177	vnode->fid.vnode);
1178	goto not_found;
1179	}
1180
1181	/* if the vnode ID uniqifier has changed, then the file has
1182	* been deleted and replaced, and the original vnode ID has
1183	* been reused */
1184	if (fid.unique != vnode->fid.unique) {
1185	_debug("%pd: file deleted (uq %u -> %u I:%u)",
1186	dentry, fid.unique,
1187	vnode->fid.unique,
1188	vnode->netfs.inode.i_generation);
1189	goto not_found;
1190	}
1191	goto out_valid;
1192
1193	case -ENOENT:
1194	/* the filename is unknown */
1195	_debug("%pd: dirent not found", dentry);
1196	if (d_really_is_positive(dentry))
1197	goto not_found;
1198	goto out_valid;
1199
1200	default:
1201	_debug("failed to iterate dir %pd: %d",
1202	parent, ret);
1203	goto not_found;
1204	}
1205
1206	out_valid:
1207	dentry->d_fsdata = (void *)(unsigned long)dir_version;
1208	out_valid_noupdate:
1209	dput(parent);
1210	key_put(key);
1211	_leave(" = 1 [valid]");
1212	return 1;
1213
1214	not_found:
1215	_debug("dropping dentry %pd2", dentry);
1216	dput(parent);
1217	key_put(key);
1218
1219	_leave(" = 0 [bad]");
1220	return 0;
1221	}
1222
1223	/*
1224	* allow the VFS to enquire as to whether a dentry should be unhashed (mustn't
1225	* sleep)
1226	* - called from dput() when d_count is going to 0.
1227	* - return 1 to request dentry be unhashed, 0 otherwise
1228	*/
1229	static int afs_d_delete(const struct dentry *dentry)
1230	{
1231	_enter("%pd", dentry);
1232
1233	if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1234	goto zap;
1235
1236	if (d_really_is_positive(dentry) &&
1237	(test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) ||
1238	test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags)))
1239	goto zap;
1240
1241	_leave(" = 0 [keep]");
1242	return 0;
1243
1244	zap:
1245	_leave(" = 1 [zap]");
1246	return 1;
1247	}
1248
1249	/*
1250	* Clean up sillyrename files on dentry removal.
1251	*/
1252	static void afs_d_iput(struct dentry *dentry, struct inode *inode)
1253	{
1254	if (dentry->d_flags & DCACHE_NFSFS_RENAMED)
1255	afs_silly_iput(dentry, inode);
1256	iput(inode);
1257	}
1258
1259	/*
1260	* handle dentry release
1261	*/
1262	void afs_d_release(struct dentry *dentry)
1263	{
1264	_enter("%pd", dentry);
1265	}
1266
1267	void afs_check_for_remote_deletion(struct afs_operation *op)
1268	{
1269	struct afs_vnode *vnode = op->file[0].vnode;
1270
1271	switch (afs_op_abort_code(op)) {
1272	case VNOVNODE:
1273	set_bit(AFS_VNODE_DELETED, addr: &vnode->flags);
1274	clear_nlink(inode: &vnode->netfs.inode);
1275	afs_break_callback(vnode, afs_cb_break_for_deleted);
1276	}
1277	}
1278
1279	/*
1280	* Create a new inode for create/mkdir/symlink
1281	*/
1282	static void afs_vnode_new_inode(struct afs_operation *op)
1283	{
1284	struct afs_vnode_param *vp = &op->file[1];
1285	struct afs_vnode *vnode;
1286	struct inode *inode;
1287
1288	_enter("");
1289
1290	ASSERTCMP(afs_op_error(op), ==, 0);
1291
1292	inode = afs_iget(op, vp);
1293	if (IS_ERR(ptr: inode)) {
1294	/* ENOMEM or EINTR at a really inconvenient time - just abandon
1295	* the new directory on the server.
1296	*/
1297	afs_op_accumulate_error(op, error: PTR_ERR(ptr: inode), abort_code: 0);
1298	return;
1299	}
1300
1301	vnode = AFS_FS_I(inode);
1302	set_bit(AFS_VNODE_NEW_CONTENT, addr: &vnode->flags);
1303	if (!afs_op_error(op))
1304	afs_cache_permit(vnode, op->key, vnode->cb_break, &vp->scb);
1305	d_instantiate(op->dentry, inode);
1306	}
1307
1308	static void afs_create_success(struct afs_operation *op)
1309	{
1310	_enter("op=%08x", op->debug_id);
1311	op->ctime = op->file[0].scb.status.mtime_client;
1312	afs_vnode_commit_status(op, &op->file[0]);
1313	afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry);
1314	afs_vnode_new_inode(op);
1315	}
1316
1317	static void afs_create_edit_dir(struct afs_operation *op)
1318	{
1319	struct afs_vnode_param *dvp = &op->file[0];
1320	struct afs_vnode_param *vp = &op->file[1];
1321	struct afs_vnode *dvnode = dvp->vnode;
1322
1323	_enter("op=%08x", op->debug_id);
1324
1325	down_write(sem: &dvnode->validate_lock);
1326	if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
1327	dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
1328	afs_edit_dir_add(dvnode, &op->dentry->d_name, &vp->fid,
1329	op->create.reason);
1330	up_write(sem: &dvnode->validate_lock);
1331	}
1332
1333	static void afs_create_put(struct afs_operation *op)
1334	{
1335	_enter("op=%08x", op->debug_id);
1336
1337	if (afs_op_error(op))
1338	d_drop(dentry: op->dentry);
1339	}
1340
1341	static const struct afs_operation_ops afs_mkdir_operation = {
1342	.issue_afs_rpc = afs_fs_make_dir,
1343	.issue_yfs_rpc = yfs_fs_make_dir,
1344	.success = afs_create_success,
1345	.aborted = afs_check_for_remote_deletion,
1346	.edit_dir = afs_create_edit_dir,
1347	.put = afs_create_put,
1348	};
1349
1350	/*
1351	* create a directory on an AFS filesystem
1352	*/
1353	static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
1354	struct dentry *dentry, umode_t mode)
1355	{
1356	struct afs_operation *op;
1357	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1358
1359	_enter("{%llx:%llu},{%pd},%ho",
1360	dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
1361
1362	op = afs_alloc_operation(NULL, dvnode->volume);
1363	if (IS_ERR(ptr: op)) {
1364	d_drop(dentry);
1365	return PTR_ERR(ptr: op);
1366	}
1367
1368	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1369	op->file[0].dv_delta = 1;
1370	op->file[0].modification = true;
1371	op->file[0].update_ctime = true;
1372	op->dentry = dentry;
1373	op->create.mode = S_IFDIR | mode;
1374	op->create.reason = afs_edit_dir_for_mkdir;
1375	op->mtime = current_time(inode: dir);
1376	op->ops = &afs_mkdir_operation;
1377	return afs_do_sync_operation(op);
1378	}
1379
1380	/*
1381	* Remove a subdir from a directory.
1382	*/
1383	static void afs_dir_remove_subdir(struct dentry *dentry)
1384	{
1385	if (d_really_is_positive(dentry)) {
1386	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry));
1387
1388	clear_nlink(inode: &vnode->netfs.inode);
1389	set_bit(AFS_VNODE_DELETED, addr: &vnode->flags);
1390	atomic64_set(v: &vnode->cb_expires_at, AFS_NO_CB_PROMISE);
1391	clear_bit(AFS_VNODE_DIR_VALID, addr: &vnode->flags);
1392	}
1393	}
1394
1395	static void afs_rmdir_success(struct afs_operation *op)
1396	{
1397	_enter("op=%08x", op->debug_id);
1398	op->ctime = op->file[0].scb.status.mtime_client;
1399	afs_vnode_commit_status(op, &op->file[0]);
1400	afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry);
1401	}
1402
1403	static void afs_rmdir_edit_dir(struct afs_operation *op)
1404	{
1405	struct afs_vnode_param *dvp = &op->file[0];
1406	struct afs_vnode *dvnode = dvp->vnode;
1407
1408	_enter("op=%08x", op->debug_id);
1409	afs_dir_remove_subdir(dentry: op->dentry);
1410
1411	down_write(sem: &dvnode->validate_lock);
1412	if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
1413	dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
1414	afs_edit_dir_remove(dvnode, &op->dentry->d_name,
1415	afs_edit_dir_for_rmdir);
1416	up_write(sem: &dvnode->validate_lock);
1417	}
1418
1419	static void afs_rmdir_put(struct afs_operation *op)
1420	{
1421	_enter("op=%08x", op->debug_id);
1422	if (op->file[1].vnode)
1423	up_write(sem: &op->file[1].vnode->rmdir_lock);
1424	}
1425
1426	static const struct afs_operation_ops afs_rmdir_operation = {
1427	.issue_afs_rpc = afs_fs_remove_dir,
1428	.issue_yfs_rpc = yfs_fs_remove_dir,
1429	.success = afs_rmdir_success,
1430	.aborted = afs_check_for_remote_deletion,
1431	.edit_dir = afs_rmdir_edit_dir,
1432	.put = afs_rmdir_put,
1433	};
1434
1435	/*
1436	* remove a directory from an AFS filesystem
1437	*/
1438	static int afs_rmdir(struct inode *dir, struct dentry *dentry)
1439	{
1440	struct afs_operation *op;
1441	struct afs_vnode *dvnode = AFS_FS_I(inode: dir), *vnode = NULL;
1442	int ret;
1443
1444	_enter("{%llx:%llu},{%pd}",
1445	dvnode->fid.vid, dvnode->fid.vnode, dentry);
1446
1447	op = afs_alloc_operation(NULL, dvnode->volume);
1448	if (IS_ERR(ptr: op))
1449	return PTR_ERR(ptr: op);
1450
1451	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1452	op->file[0].dv_delta = 1;
1453	op->file[0].modification = true;
1454	op->file[0].update_ctime = true;
1455
1456	op->dentry = dentry;
1457	op->ops = &afs_rmdir_operation;
1458
1459	/* Try to make sure we have a callback promise on the victim. */
1460	if (d_really_is_positive(dentry)) {
1461	vnode = AFS_FS_I(inode: d_inode(dentry));
1462	ret = afs_validate(vnode, key: op->key);
1463	if (ret < 0)
1464	goto error;
1465	}
1466
1467	if (vnode) {
1468	ret = down_write_killable(sem: &vnode->rmdir_lock);
1469	if (ret < 0)
1470	goto error;
1471	op->file[1].vnode = vnode;
1472	}
1473
1474	return afs_do_sync_operation(op);
1475
1476	error:
1477	return afs_put_operation(op);
1478	}
1479
1480	/*
1481	* Remove a link to a file or symlink from a directory.
1482	*
1483	* If the file was not deleted due to excess hard links, the fileserver will
1484	* break the callback promise on the file - if it had one - before it returns
1485	* to us, and if it was deleted, it won't
1486	*
1487	* However, if we didn't have a callback promise outstanding, or it was
1488	* outstanding on a different server, then it won't break it either...
1489	*/
1490	static void afs_dir_remove_link(struct afs_operation *op)
1491	{
1492	struct afs_vnode *dvnode = op->file[0].vnode;
1493	struct afs_vnode *vnode = op->file[1].vnode;
1494	struct dentry *dentry = op->dentry;
1495	int ret;
1496
1497	if (afs_op_error(op) ||
1498	(op->file[1].scb.have_status && op->file[1].scb.have_error))
1499	return;
1500	if (d_really_is_positive(dentry))
1501	return;
1502
1503	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
1504	/* Already done */
1505	} else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {
1506	write_seqlock(sl: &vnode->cb_lock);
1507	drop_nlink(inode: &vnode->netfs.inode);
1508	if (vnode->netfs.inode.i_nlink == 0) {
1509	set_bit(AFS_VNODE_DELETED, addr: &vnode->flags);
1510	__afs_break_callback(vnode, afs_cb_break_for_unlink);
1511	}
1512	write_sequnlock(sl: &vnode->cb_lock);
1513	} else {
1514	afs_break_callback(vnode, afs_cb_break_for_unlink);
1515
1516	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
1517	_debug("AFS_VNODE_DELETED");
1518
1519	ret = afs_validate(vnode, key: op->key);
1520	if (ret != -ESTALE)
1521	afs_op_set_error(op, error: ret);
1522	}
1523
1524	_debug("nlink %d [val %d]", vnode->netfs.inode.i_nlink, afs_op_error(op));
1525	}
1526
1527	static void afs_unlink_success(struct afs_operation *op)
1528	{
1529	_enter("op=%08x", op->debug_id);
1530	op->ctime = op->file[0].scb.status.mtime_client;
1531	afs_check_dir_conflict(op, dvp: &op->file[0]);
1532	afs_vnode_commit_status(op, &op->file[0]);
1533	afs_vnode_commit_status(op, &op->file[1]);
1534	afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry);
1535	afs_dir_remove_link(op);
1536	}
1537
1538	static void afs_unlink_edit_dir(struct afs_operation *op)
1539	{
1540	struct afs_vnode_param *dvp = &op->file[0];
1541	struct afs_vnode *dvnode = dvp->vnode;
1542
1543	_enter("op=%08x", op->debug_id);
1544	down_write(sem: &dvnode->validate_lock);
1545	if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
1546	dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
1547	afs_edit_dir_remove(dvnode, &op->dentry->d_name,
1548	afs_edit_dir_for_unlink);
1549	up_write(sem: &dvnode->validate_lock);
1550	}
1551
1552	static void afs_unlink_put(struct afs_operation *op)
1553	{
1554	_enter("op=%08x", op->debug_id);
1555	if (op->unlink.need_rehash && afs_op_error(op) < 0 && afs_op_error(op) != -ENOENT)
1556	d_rehash(op->dentry);
1557	}
1558
1559	static const struct afs_operation_ops afs_unlink_operation = {
1560	.issue_afs_rpc = afs_fs_remove_file,
1561	.issue_yfs_rpc = yfs_fs_remove_file,
1562	.success = afs_unlink_success,
1563	.aborted = afs_check_for_remote_deletion,
1564	.edit_dir = afs_unlink_edit_dir,
1565	.put = afs_unlink_put,
1566	};
1567
1568	/*
1569	* Remove a file or symlink from an AFS filesystem.
1570	*/
1571	static int afs_unlink(struct inode *dir, struct dentry *dentry)
1572	{
1573	struct afs_operation *op;
1574	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1575	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry));
1576	int ret;
1577
1578	_enter("{%llx:%llu},{%pd}",
1579	dvnode->fid.vid, dvnode->fid.vnode, dentry);
1580
1581	if (dentry->d_name.len >= AFSNAMEMAX)
1582	return -ENAMETOOLONG;
1583
1584	op = afs_alloc_operation(NULL, dvnode->volume);
1585	if (IS_ERR(ptr: op))
1586	return PTR_ERR(ptr: op);
1587
1588	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1589	op->file[0].dv_delta = 1;
1590	op->file[0].modification = true;
1591	op->file[0].update_ctime = true;
1592
1593	/* Try to make sure we have a callback promise on the victim. */
1594	ret = afs_validate(vnode, key: op->key);
1595	if (ret < 0) {
1596	afs_op_set_error(op, error: ret);
1597	goto error;
1598	}
1599
1600	spin_lock(lock: &dentry->d_lock);
1601	if (d_count(dentry) > 1) {
1602	spin_unlock(lock: &dentry->d_lock);
1603	/* Start asynchronous writeout of the inode */
1604	write_inode_now(d_inode(dentry), sync: 0);
1605	afs_op_set_error(op, error: afs_sillyrename(dvnode, vnode, dentry, op->key));
1606	goto error;
1607	}
1608	if (!d_unhashed(dentry)) {
1609	/* Prevent a race with RCU lookup. */
1610	__d_drop(dentry);
1611	op->unlink.need_rehash = true;
1612	}
1613	spin_unlock(lock: &dentry->d_lock);
1614
1615	op->file[1].vnode = vnode;
1616	op->file[1].update_ctime = true;
1617	op->file[1].op_unlinked = true;
1618	op->dentry = dentry;
1619	op->ops = &afs_unlink_operation;
1620	afs_begin_vnode_operation(op);
1621	afs_wait_for_operation(op);
1622
1623	/* If there was a conflict with a third party, check the status of the
1624	* unlinked vnode.
1625	*/
1626	if (afs_op_error(op) == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) {
1627	op->file[1].update_ctime = false;
1628	op->fetch_status.which = 1;
1629	op->ops = &afs_fetch_status_operation;
1630	afs_begin_vnode_operation(op);
1631	afs_wait_for_operation(op);
1632	}
1633
1634	return afs_put_operation(op);
1635
1636	error:
1637	return afs_put_operation(op);
1638	}
1639
1640	static const struct afs_operation_ops afs_create_operation = {
1641	.issue_afs_rpc = afs_fs_create_file,
1642	.issue_yfs_rpc = yfs_fs_create_file,
1643	.success = afs_create_success,
1644	.aborted = afs_check_for_remote_deletion,
1645	.edit_dir = afs_create_edit_dir,
1646	.put = afs_create_put,
1647	};
1648
1649	/*
1650	* create a regular file on an AFS filesystem
1651	*/
1652	static int afs_create(struct mnt_idmap *idmap, struct inode *dir,
1653	struct dentry *dentry, umode_t mode, bool excl)
1654	{
1655	struct afs_operation *op;
1656	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1657	int ret = -ENAMETOOLONG;
1658
1659	_enter("{%llx:%llu},{%pd},%ho",
1660	dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
1661
1662	if (dentry->d_name.len >= AFSNAMEMAX)
1663	goto error;
1664
1665	op = afs_alloc_operation(NULL, dvnode->volume);
1666	if (IS_ERR(ptr: op)) {
1667	ret = PTR_ERR(ptr: op);
1668	goto error;
1669	}
1670
1671	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1672	op->file[0].dv_delta = 1;
1673	op->file[0].modification = true;
1674	op->file[0].update_ctime = true;
1675
1676	op->dentry = dentry;
1677	op->create.mode = S_IFREG | mode;
1678	op->create.reason = afs_edit_dir_for_create;
1679	op->mtime = current_time(inode: dir);
1680	op->ops = &afs_create_operation;
1681	return afs_do_sync_operation(op);
1682
1683	error:
1684	d_drop(dentry);
1685	_leave(" = %d", ret);
1686	return ret;
1687	}
1688
1689	static void afs_link_success(struct afs_operation *op)
1690	{
1691	struct afs_vnode_param *dvp = &op->file[0];
1692	struct afs_vnode_param *vp = &op->file[1];
1693
1694	_enter("op=%08x", op->debug_id);
1695	op->ctime = dvp->scb.status.mtime_client;
1696	afs_vnode_commit_status(op, dvp);
1697	afs_vnode_commit_status(op, vp);
1698	afs_update_dentry_version(op, dir_vp: dvp, dentry: op->dentry);
1699	if (op->dentry_2->d_parent == op->dentry->d_parent)
1700	afs_update_dentry_version(op, dir_vp: dvp, dentry: op->dentry_2);
1701	ihold(inode: &vp->vnode->netfs.inode);
1702	d_instantiate(op->dentry, &vp->vnode->netfs.inode);
1703	}
1704
1705	static void afs_link_put(struct afs_operation *op)
1706	{
1707	_enter("op=%08x", op->debug_id);
1708	if (afs_op_error(op))
1709	d_drop(dentry: op->dentry);
1710	}
1711
1712	static const struct afs_operation_ops afs_link_operation = {
1713	.issue_afs_rpc = afs_fs_link,
1714	.issue_yfs_rpc = yfs_fs_link,
1715	.success = afs_link_success,
1716	.aborted = afs_check_for_remote_deletion,
1717	.edit_dir = afs_create_edit_dir,
1718	.put = afs_link_put,
1719	};
1720
1721	/*
1722	* create a hard link between files in an AFS filesystem
1723	*/
1724	static int afs_link(struct dentry *from, struct inode *dir,
1725	struct dentry *dentry)
1726	{
1727	struct afs_operation *op;
1728	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1729	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry: from));
1730	int ret = -ENAMETOOLONG;
1731
1732	_enter("{%llx:%llu},{%llx:%llu},{%pd}",
1733	vnode->fid.vid, vnode->fid.vnode,
1734	dvnode->fid.vid, dvnode->fid.vnode,
1735	dentry);
1736
1737	if (dentry->d_name.len >= AFSNAMEMAX)
1738	goto error;
1739
1740	op = afs_alloc_operation(NULL, dvnode->volume);
1741	if (IS_ERR(ptr: op)) {
1742	ret = PTR_ERR(ptr: op);
1743	goto error;
1744	}
1745
1746	ret = afs_validate(vnode, key: op->key);
1747	if (ret < 0)
1748	goto error_op;
1749
1750	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1751	afs_op_set_vnode(op, n: 1, vnode);
1752	op->file[0].dv_delta = 1;
1753	op->file[0].modification = true;
1754	op->file[0].update_ctime = true;
1755	op->file[1].update_ctime = true;
1756
1757	op->dentry = dentry;
1758	op->dentry_2 = from;
1759	op->ops = &afs_link_operation;
1760	op->create.reason = afs_edit_dir_for_link;
1761	return afs_do_sync_operation(op);
1762
1763	error_op:
1764	afs_put_operation(op);
1765	error:
1766	d_drop(dentry);
1767	_leave(" = %d", ret);
1768	return ret;
1769	}
1770
1771	static const struct afs_operation_ops afs_symlink_operation = {
1772	.issue_afs_rpc = afs_fs_symlink,
1773	.issue_yfs_rpc = yfs_fs_symlink,
1774	.success = afs_create_success,
1775	.aborted = afs_check_for_remote_deletion,
1776	.edit_dir = afs_create_edit_dir,
1777	.put = afs_create_put,
1778	};
1779
1780	/*
1781	* create a symlink in an AFS filesystem
1782	*/
1783	static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,
1784	struct dentry *dentry, const char *content)
1785	{
1786	struct afs_operation *op;
1787	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1788	int ret;
1789
1790	_enter("{%llx:%llu},{%pd},%s",
1791	dvnode->fid.vid, dvnode->fid.vnode, dentry,
1792	content);
1793
1794	ret = -ENAMETOOLONG;
1795	if (dentry->d_name.len >= AFSNAMEMAX)
1796	goto error;
1797
1798	ret = -EINVAL;
1799	if (strlen(content) >= AFSPATHMAX)
1800	goto error;
1801
1802	op = afs_alloc_operation(NULL, dvnode->volume);
1803	if (IS_ERR(ptr: op)) {
1804	ret = PTR_ERR(ptr: op);
1805	goto error;
1806	}
1807
1808	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1809	op->file[0].dv_delta = 1;
1810
1811	op->dentry = dentry;
1812	op->ops = &afs_symlink_operation;
1813	op->create.reason = afs_edit_dir_for_symlink;
1814	op->create.symlink = content;
1815	op->mtime = current_time(inode: dir);
1816	return afs_do_sync_operation(op);
1817
1818	error:
1819	d_drop(dentry);
1820	_leave(" = %d", ret);
1821	return ret;
1822	}
1823
1824	static void afs_rename_success(struct afs_operation *op)
1825	{
1826	_enter("op=%08x", op->debug_id);
1827
1828	op->ctime = op->file[0].scb.status.mtime_client;
1829	afs_check_dir_conflict(op, dvp: &op->file[1]);
1830	afs_vnode_commit_status(op, &op->file[0]);
1831	if (op->file[1].vnode != op->file[0].vnode) {
1832	op->ctime = op->file[1].scb.status.mtime_client;
1833	afs_vnode_commit_status(op, &op->file[1]);
1834	}
1835	}
1836
1837	static void afs_rename_edit_dir(struct afs_operation *op)
1838	{
1839	struct afs_vnode_param *orig_dvp = &op->file[0];
1840	struct afs_vnode_param *new_dvp = &op->file[1];
1841	struct afs_vnode *orig_dvnode = orig_dvp->vnode;
1842	struct afs_vnode *new_dvnode = new_dvp->vnode;
1843	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry: op->dentry));
1844	struct dentry *old_dentry = op->dentry;
1845	struct dentry *new_dentry = op->dentry_2;
1846	struct inode *new_inode;
1847
1848	_enter("op=%08x", op->debug_id);
1849
1850	if (op->rename.rehash) {
1851	d_rehash(op->rename.rehash);
1852	op->rename.rehash = NULL;
1853	}
1854
1855	down_write(sem: &orig_dvnode->validate_lock);
1856	if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags) &&
1857	orig_dvnode->status.data_version == orig_dvp->dv_before + orig_dvp->dv_delta)
1858	afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name,
1859	afs_edit_dir_for_rename_0);
1860
1861	if (new_dvnode != orig_dvnode) {
1862	up_write(sem: &orig_dvnode->validate_lock);
1863	down_write(sem: &new_dvnode->validate_lock);
1864	}
1865
1866	if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags) &&
1867	new_dvnode->status.data_version == new_dvp->dv_before + new_dvp->dv_delta) {
1868	if (!op->rename.new_negative)
1869	afs_edit_dir_remove(new_dvnode, &new_dentry->d_name,
1870	afs_edit_dir_for_rename_1);
1871
1872	afs_edit_dir_add(new_dvnode, &new_dentry->d_name,
1873	&vnode->fid, afs_edit_dir_for_rename_2);
1874	}
1875
1876	new_inode = d_inode(dentry: new_dentry);
1877	if (new_inode) {
1878	spin_lock(lock: &new_inode->i_lock);
1879	if (S_ISDIR(new_inode->i_mode))
1880	clear_nlink(inode: new_inode);
1881	else if (new_inode->i_nlink > 0)
1882	drop_nlink(inode: new_inode);
1883	spin_unlock(lock: &new_inode->i_lock);
1884	}
1885
1886	/* Now we can update d_fsdata on the dentries to reflect their
1887	* new parent's data_version.
1888	*
1889	* Note that if we ever implement RENAME_EXCHANGE, we'll have
1890	* to update both dentries with opposing dir versions.
1891	*/
1892	afs_update_dentry_version(op, dir_vp: new_dvp, dentry: op->dentry);
1893	afs_update_dentry_version(op, dir_vp: new_dvp, dentry: op->dentry_2);
1894
1895	d_move(old_dentry, new_dentry);
1896
1897	up_write(sem: &new_dvnode->validate_lock);
1898	}
1899
1900	static void afs_rename_put(struct afs_operation *op)
1901	{
1902	_enter("op=%08x", op->debug_id);
1903	if (op->rename.rehash)
1904	d_rehash(op->rename.rehash);
1905	dput(op->rename.tmp);
1906	if (afs_op_error(op))
1907	d_rehash(op->dentry);
1908	}
1909
1910	static const struct afs_operation_ops afs_rename_operation = {
1911	.issue_afs_rpc = afs_fs_rename,
1912	.issue_yfs_rpc = yfs_fs_rename,
1913	.success = afs_rename_success,
1914	.edit_dir = afs_rename_edit_dir,
1915	.put = afs_rename_put,
1916	};
1917
1918	/*
1919	* rename a file in an AFS filesystem and/or move it between directories
1920	*/
1921	static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
1922	struct dentry *old_dentry, struct inode *new_dir,
1923	struct dentry *new_dentry, unsigned int flags)
1924	{
1925	struct afs_operation *op;
1926	struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
1927	int ret;
1928
1929	if (flags)
1930	return -EINVAL;
1931
1932	/* Don't allow silly-rename files be moved around. */
1933	if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED)
1934	return -EINVAL;
1935
1936	vnode = AFS_FS_I(inode: d_inode(dentry: old_dentry));
1937	orig_dvnode = AFS_FS_I(inode: old_dir);
1938	new_dvnode = AFS_FS_I(inode: new_dir);
1939
1940	_enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1941	orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
1942	vnode->fid.vid, vnode->fid.vnode,
1943	new_dvnode->fid.vid, new_dvnode->fid.vnode,
1944	new_dentry);
1945
1946	op = afs_alloc_operation(NULL, orig_dvnode->volume);
1947	if (IS_ERR(ptr: op))
1948	return PTR_ERR(ptr: op);
1949
1950	ret = afs_validate(vnode, key: op->key);
1951	afs_op_set_error(op, error: ret);
1952	if (ret < 0)
1953	goto error;
1954
1955	afs_op_set_vnode(op, n: 0, vnode: orig_dvnode);
1956	afs_op_set_vnode(op, n: 1, vnode: new_dvnode); /* May be same as orig_dvnode */
1957	op->file[0].dv_delta = 1;
1958	op->file[1].dv_delta = 1;
1959	op->file[0].modification = true;
1960	op->file[1].modification = true;
1961	op->file[0].update_ctime = true;
1962	op->file[1].update_ctime = true;
1963
1964	op->dentry = old_dentry;
1965	op->dentry_2 = new_dentry;
1966	op->rename.new_negative = d_is_negative(dentry: new_dentry);
1967	op->ops = &afs_rename_operation;
1968
1969	/* For non-directories, check whether the target is busy and if so,
1970	* make a copy of the dentry and then do a silly-rename. If the
1971	* silly-rename succeeds, the copied dentry is hashed and becomes the
1972	* new target.
1973	*/
1974	if (d_is_positive(dentry: new_dentry) && !d_is_dir(dentry: new_dentry)) {
1975	/* To prevent any new references to the target during the
1976	* rename, we unhash the dentry in advance.
1977	*/
1978	if (!d_unhashed(dentry: new_dentry)) {
1979	d_drop(dentry: new_dentry);
1980	op->rename.rehash = new_dentry;
1981	}
1982
1983	if (d_count(dentry: new_dentry) > 2) {
1984	/* copy the target dentry's name */
1985	op->rename.tmp = d_alloc(new_dentry->d_parent,
1986	&new_dentry->d_name);
1987	if (!op->rename.tmp) {
1988	afs_op_nomem(op);
1989	goto error;
1990	}
1991
1992	ret = afs_sillyrename(new_dvnode,
1993	AFS_FS_I(inode: d_inode(dentry: new_dentry)),
1994	new_dentry, op->key);
1995	if (ret) {
1996	afs_op_set_error(op, error: ret);
1997	goto error;
1998	}
1999
2000	op->dentry_2 = op->rename.tmp;
2001	op->rename.rehash = NULL;
2002	op->rename.new_negative = true;
2003	}
2004	}
2005
2006	/* This bit is potentially nasty as there's a potential race with
2007	* afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
2008	* to reflect it's new parent's new data_version after the op, but
2009	* d_revalidate may see old_dentry between the op having taken place
2010	* and the version being updated.
2011	*
2012	* So drop the old_dentry for now to make other threads go through
2013	* lookup instead - which we hold a lock against.
2014	*/
2015	d_drop(dentry: old_dentry);
2016
2017	return afs_do_sync_operation(op);
2018
2019	error:
2020	return afs_put_operation(op);
2021	}
2022
2023	/*
2024	* Release a directory folio and clean up its private state if it's not busy
2025	* - return true if the folio can now be released, false if not
2026	*/
2027	static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags)
2028	{
2029	struct afs_vnode *dvnode = AFS_FS_I(inode: folio_inode(folio));
2030
2031	_enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, folio->index);
2032
2033	folio_detach_private(folio);
2034
2035	/* The directory will need reloading. */
2036	if (test_and_clear_bit(AFS_VNODE_DIR_VALID, addr: &dvnode->flags))
2037	afs_stat_v(dvnode, n_relpg);
2038	return true;
2039	}
2040
2041	/*
2042	* Invalidate part or all of a folio.
2043	*/
2044	static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,
2045	size_t length)
2046	{
2047	struct afs_vnode *dvnode = AFS_FS_I(inode: folio_inode(folio));
2048
2049	_enter("{%lu},%zu,%zu", folio->index, offset, length);
2050
2051	BUG_ON(!folio_test_locked(folio));
2052
2053	/* The directory will need reloading. */
2054	if (test_and_clear_bit(AFS_VNODE_DIR_VALID, addr: &dvnode->flags))
2055	afs_stat_v(dvnode, n_inval);
2056
2057	/* we clean up only if the entire folio is being invalidated */
2058	if (offset == 0 && length == folio_size(folio))
2059	folio_detach_private(folio);
2060	}
2061