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_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(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_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: &xas, entry: folio))
234	continue;
235
236	BUG_ON(folio_file_mapping(folio) != 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->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(ptr: 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(inode: 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(size: sizeof(struct afs_lookup_cookie), GFP_KERNEL);
802	if (!cookie)
803	return ERR_PTR(error: -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, ctx: &cookie->ctx, key, dir_version: &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(sb: dir->i_sb, hashval: cookie->fids[1].vnode,
828	test: afs_ilookup5_test_by_fid, data: &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(ptr: op)) {
838	ret = PTR_ERR(ptr: op);
839	goto out;
840	}
841
842	afs_op_set_vnode(op, n: 0, vnode: dvnode);
843	afs_op_set_fid(op, n: 1, fid: &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(n: op->nr_files - 2,
852	size: 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(sb: dir->i_sb, hashval: vp->fid.vnode,
865	test: afs_ilookup5_test_by_fid, data: &vp->fid);
866	if (!IS_ERR_OR_NULL(ptr: ti)) {
867	vnode = AFS_FS_I(inode: 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(error: 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(objp: cookie);
913	_leave("");
914	return inode ?: ERR_PTR(error: 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(inode: dir);
925	struct dentry *ret;
926	char *buf, *p, *name;
927	int len, i;
928
929	_enter("");
930
931	ret = ERR_PTR(error: -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(r: &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(error: -ENAMETOOLONG);
951	goto out_s;
952	}
953
954	strcpy(p, q: name);
955	ret = lookup_one_len(buf, dentry->d_parent, len);
956	if (IS_ERR(ptr: ret) || d_is_positive(dentry: 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(objp: 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(inode: 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(error: -ENAMETOOLONG);
994	}
995
996	if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {
997	_leave(" = -ESTALE");
998	return ERR_PTR(error: -ESTALE);
999	}
1000
1001	key = afs_request_key(dvnode->volume->cell);
1002	if (IS_ERR(ptr: key)) {
1003	_leave(" = %ld [key]", PTR_ERR(key));
1004	return ERR_CAST(ptr: 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(error: 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(error: -ENOENT))
1025	inode = afs_try_auto_mntpt(dentry, dir);
1026
1027	if (!IS_ERR_OR_NULL(ptr: 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(ptr: d)) {
1033	d->d_fsdata = dentry->d_fsdata;
1034	trace_afs_lookup(dvnode, name: &d->d_name, fid: &fid);
1035	} else {
1036	trace_afs_lookup(dvnode, name: &dentry->d_name, fid: &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(dentry: parent);
1057	if (!dir)
1058	return -ECHILD;
1059	dvnode = AFS_FS_I(inode: 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(inode: 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(sb: dentry->d_sb)->volume->cell);
1111	if (IS_ERR(ptr: 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(inode: d_inode(dentry: 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: &dir->netfs.inode, dentry, fid: &fid, key, dir_version: &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, addr: &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(ptr: 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(ptr: inode);
1284	return;
1285	}
1286
1287	vnode = AFS_FS_I(inode);
1288	set_bit(AFS_VNODE_NEW_CONTENT, addr: &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, dir_vp: &op->file[0], dentry: 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(sem: &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(sem: &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(dentry: 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(inode: 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(ptr: op)) {
1350	d_drop(dentry);
1351	return PTR_ERR(ptr: op);
1352	}
1353
1354	afs_op_set_vnode(op, n: 0, vnode: 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->mtime = current_time(inode: dir);
1362	op->ops = &afs_mkdir_operation;
1363	return afs_do_sync_operation(op);
1364	}
1365
1366	/*
1367	* Remove a subdir from a directory.
1368	*/
1369	static void afs_dir_remove_subdir(struct dentry *dentry)
1370	{
1371	if (d_really_is_positive(dentry)) {
1372	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry));
1373
1374	clear_nlink(inode: &vnode->netfs.inode);
1375	set_bit(AFS_VNODE_DELETED, addr: &vnode->flags);
1376	clear_bit(AFS_VNODE_CB_PROMISED, addr: &vnode->flags);
1377	clear_bit(AFS_VNODE_DIR_VALID, addr: &vnode->flags);
1378	}
1379	}
1380
1381	static void afs_rmdir_success(struct afs_operation *op)
1382	{
1383	_enter("op=%08x", op->debug_id);
1384	op->ctime = op->file[0].scb.status.mtime_client;
1385	afs_vnode_commit_status(op, &op->file[0]);
1386	afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry);
1387	}
1388
1389	static void afs_rmdir_edit_dir(struct afs_operation *op)
1390	{
1391	struct afs_vnode_param *dvp = &op->file[0];
1392	struct afs_vnode *dvnode = dvp->vnode;
1393
1394	_enter("op=%08x", op->debug_id);
1395	afs_dir_remove_subdir(dentry: op->dentry);
1396
1397	down_write(sem: &dvnode->validate_lock);
1398	if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
1399	dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
1400	afs_edit_dir_remove(dvnode, &op->dentry->d_name,
1401	afs_edit_dir_for_rmdir);
1402	up_write(sem: &dvnode->validate_lock);
1403	}
1404
1405	static void afs_rmdir_put(struct afs_operation *op)
1406	{
1407	_enter("op=%08x", op->debug_id);
1408	if (op->file[1].vnode)
1409	up_write(sem: &op->file[1].vnode->rmdir_lock);
1410	}
1411
1412	static const struct afs_operation_ops afs_rmdir_operation = {
1413	.issue_afs_rpc = afs_fs_remove_dir,
1414	.issue_yfs_rpc = yfs_fs_remove_dir,
1415	.success = afs_rmdir_success,
1416	.aborted = afs_check_for_remote_deletion,
1417	.edit_dir = afs_rmdir_edit_dir,
1418	.put = afs_rmdir_put,
1419	};
1420
1421	/*
1422	* remove a directory from an AFS filesystem
1423	*/
1424	static int afs_rmdir(struct inode *dir, struct dentry *dentry)
1425	{
1426	struct afs_operation *op;
1427	struct afs_vnode *dvnode = AFS_FS_I(inode: dir), *vnode = NULL;
1428	int ret;
1429
1430	_enter("{%llx:%llu},{%pd}",
1431	dvnode->fid.vid, dvnode->fid.vnode, dentry);
1432
1433	op = afs_alloc_operation(NULL, dvnode->volume);
1434	if (IS_ERR(ptr: op))
1435	return PTR_ERR(ptr: op);
1436
1437	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1438	op->file[0].dv_delta = 1;
1439	op->file[0].modification = true;
1440	op->file[0].update_ctime = true;
1441
1442	op->dentry = dentry;
1443	op->ops = &afs_rmdir_operation;
1444
1445	/* Try to make sure we have a callback promise on the victim. */
1446	if (d_really_is_positive(dentry)) {
1447	vnode = AFS_FS_I(inode: d_inode(dentry));
1448	ret = afs_validate(vnode, op->key);
1449	if (ret < 0)
1450	goto error;
1451	}
1452
1453	if (vnode) {
1454	ret = down_write_killable(sem: &vnode->rmdir_lock);
1455	if (ret < 0)
1456	goto error;
1457	op->file[1].vnode = vnode;
1458	}
1459
1460	return afs_do_sync_operation(op);
1461
1462	error:
1463	return afs_put_operation(op);
1464	}
1465
1466	/*
1467	* Remove a link to a file or symlink from a directory.
1468	*
1469	* If the file was not deleted due to excess hard links, the fileserver will
1470	* break the callback promise on the file - if it had one - before it returns
1471	* to us, and if it was deleted, it won't
1472	*
1473	* However, if we didn't have a callback promise outstanding, or it was
1474	* outstanding on a different server, then it won't break it either...
1475	*/
1476	static void afs_dir_remove_link(struct afs_operation *op)
1477	{
1478	struct afs_vnode *dvnode = op->file[0].vnode;
1479	struct afs_vnode *vnode = op->file[1].vnode;
1480	struct dentry *dentry = op->dentry;
1481	int ret;
1482
1483	if (op->error != 0 ||
1484	(op->file[1].scb.have_status && op->file[1].scb.have_error))
1485	return;
1486	if (d_really_is_positive(dentry))
1487	return;
1488
1489	if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) {
1490	/* Already done */
1491	} else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {
1492	write_seqlock(sl: &vnode->cb_lock);
1493	drop_nlink(inode: &vnode->netfs.inode);
1494	if (vnode->netfs.inode.i_nlink == 0) {
1495	set_bit(AFS_VNODE_DELETED, addr: &vnode->flags);
1496	__afs_break_callback(vnode, afs_cb_break_for_unlink);
1497	}
1498	write_sequnlock(sl: &vnode->cb_lock);
1499	} else {
1500	afs_break_callback(vnode, afs_cb_break_for_unlink);
1501
1502	if (test_bit(AFS_VNODE_DELETED, &vnode->flags))
1503	_debug("AFS_VNODE_DELETED");
1504
1505	ret = afs_validate(vnode, op->key);
1506	if (ret != -ESTALE)
1507	op->error = ret;
1508	}
1509
1510	_debug("nlink %d [val %d]", vnode->netfs.inode.i_nlink, op->error);
1511	}
1512
1513	static void afs_unlink_success(struct afs_operation *op)
1514	{
1515	_enter("op=%08x", op->debug_id);
1516	op->ctime = op->file[0].scb.status.mtime_client;
1517	afs_check_dir_conflict(op, dvp: &op->file[0]);
1518	afs_vnode_commit_status(op, &op->file[0]);
1519	afs_vnode_commit_status(op, &op->file[1]);
1520	afs_update_dentry_version(op, dir_vp: &op->file[0], dentry: op->dentry);
1521	afs_dir_remove_link(op);
1522	}
1523
1524	static void afs_unlink_edit_dir(struct afs_operation *op)
1525	{
1526	struct afs_vnode_param *dvp = &op->file[0];
1527	struct afs_vnode *dvnode = dvp->vnode;
1528
1529	_enter("op=%08x", op->debug_id);
1530	down_write(sem: &dvnode->validate_lock);
1531	if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags) &&
1532	dvnode->status.data_version == dvp->dv_before + dvp->dv_delta)
1533	afs_edit_dir_remove(dvnode, &op->dentry->d_name,
1534	afs_edit_dir_for_unlink);
1535	up_write(sem: &dvnode->validate_lock);
1536	}
1537
1538	static void afs_unlink_put(struct afs_operation *op)
1539	{
1540	_enter("op=%08x", op->debug_id);
1541	if (op->unlink.need_rehash && op->error < 0 && op->error != -ENOENT)
1542	d_rehash(op->dentry);
1543	}
1544
1545	static const struct afs_operation_ops afs_unlink_operation = {
1546	.issue_afs_rpc = afs_fs_remove_file,
1547	.issue_yfs_rpc = yfs_fs_remove_file,
1548	.success = afs_unlink_success,
1549	.aborted = afs_check_for_remote_deletion,
1550	.edit_dir = afs_unlink_edit_dir,
1551	.put = afs_unlink_put,
1552	};
1553
1554	/*
1555	* Remove a file or symlink from an AFS filesystem.
1556	*/
1557	static int afs_unlink(struct inode *dir, struct dentry *dentry)
1558	{
1559	struct afs_operation *op;
1560	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1561	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry));
1562	int ret;
1563
1564	_enter("{%llx:%llu},{%pd}",
1565	dvnode->fid.vid, dvnode->fid.vnode, dentry);
1566
1567	if (dentry->d_name.len >= AFSNAMEMAX)
1568	return -ENAMETOOLONG;
1569
1570	op = afs_alloc_operation(NULL, dvnode->volume);
1571	if (IS_ERR(ptr: op))
1572	return PTR_ERR(ptr: op);
1573
1574	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1575	op->file[0].dv_delta = 1;
1576	op->file[0].modification = true;
1577	op->file[0].update_ctime = true;
1578
1579	/* Try to make sure we have a callback promise on the victim. */
1580	ret = afs_validate(vnode, op->key);
1581	if (ret < 0) {
1582	op->error = ret;
1583	goto error;
1584	}
1585
1586	spin_lock(lock: &dentry->d_lock);
1587	if (d_count(dentry) > 1) {
1588	spin_unlock(lock: &dentry->d_lock);
1589	/* Start asynchronous writeout of the inode */
1590	write_inode_now(d_inode(dentry), sync: 0);
1591	op->error = afs_sillyrename(dvnode, vnode, dentry, op->key);
1592	goto error;
1593	}
1594	if (!d_unhashed(dentry)) {
1595	/* Prevent a race with RCU lookup. */
1596	__d_drop(dentry);
1597	op->unlink.need_rehash = true;
1598	}
1599	spin_unlock(lock: &dentry->d_lock);
1600
1601	op->file[1].vnode = vnode;
1602	op->file[1].update_ctime = true;
1603	op->file[1].op_unlinked = true;
1604	op->dentry = dentry;
1605	op->ops = &afs_unlink_operation;
1606	afs_begin_vnode_operation(op);
1607	afs_wait_for_operation(op);
1608
1609	/* If there was a conflict with a third party, check the status of the
1610	* unlinked vnode.
1611	*/
1612	if (op->error == 0 && (op->flags & AFS_OPERATION_DIR_CONFLICT)) {
1613	op->file[1].update_ctime = false;
1614	op->fetch_status.which = 1;
1615	op->ops = &afs_fetch_status_operation;
1616	afs_begin_vnode_operation(op);
1617	afs_wait_for_operation(op);
1618	}
1619
1620	return afs_put_operation(op);
1621
1622	error:
1623	return afs_put_operation(op);
1624	}
1625
1626	static const struct afs_operation_ops afs_create_operation = {
1627	.issue_afs_rpc = afs_fs_create_file,
1628	.issue_yfs_rpc = yfs_fs_create_file,
1629	.success = afs_create_success,
1630	.aborted = afs_check_for_remote_deletion,
1631	.edit_dir = afs_create_edit_dir,
1632	.put = afs_create_put,
1633	};
1634
1635	/*
1636	* create a regular file on an AFS filesystem
1637	*/
1638	static int afs_create(struct mnt_idmap *idmap, struct inode *dir,
1639	struct dentry *dentry, umode_t mode, bool excl)
1640	{
1641	struct afs_operation *op;
1642	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1643	int ret = -ENAMETOOLONG;
1644
1645	_enter("{%llx:%llu},{%pd},%ho",
1646	dvnode->fid.vid, dvnode->fid.vnode, dentry, mode);
1647
1648	if (dentry->d_name.len >= AFSNAMEMAX)
1649	goto error;
1650
1651	op = afs_alloc_operation(NULL, dvnode->volume);
1652	if (IS_ERR(ptr: op)) {
1653	ret = PTR_ERR(ptr: op);
1654	goto error;
1655	}
1656
1657	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1658	op->file[0].dv_delta = 1;
1659	op->file[0].modification = true;
1660	op->file[0].update_ctime = true;
1661
1662	op->dentry = dentry;
1663	op->create.mode = S_IFREG | mode;
1664	op->create.reason = afs_edit_dir_for_create;
1665	op->mtime = current_time(inode: dir);
1666	op->ops = &afs_create_operation;
1667	return afs_do_sync_operation(op);
1668
1669	error:
1670	d_drop(dentry);
1671	_leave(" = %d", ret);
1672	return ret;
1673	}
1674
1675	static void afs_link_success(struct afs_operation *op)
1676	{
1677	struct afs_vnode_param *dvp = &op->file[0];
1678	struct afs_vnode_param *vp = &op->file[1];
1679
1680	_enter("op=%08x", op->debug_id);
1681	op->ctime = dvp->scb.status.mtime_client;
1682	afs_vnode_commit_status(op, dvp);
1683	afs_vnode_commit_status(op, vp);
1684	afs_update_dentry_version(op, dir_vp: dvp, dentry: op->dentry);
1685	if (op->dentry_2->d_parent == op->dentry->d_parent)
1686	afs_update_dentry_version(op, dir_vp: dvp, dentry: op->dentry_2);
1687	ihold(inode: &vp->vnode->netfs.inode);
1688	d_instantiate(op->dentry, &vp->vnode->netfs.inode);
1689	}
1690
1691	static void afs_link_put(struct afs_operation *op)
1692	{
1693	_enter("op=%08x", op->debug_id);
1694	if (op->error)
1695	d_drop(dentry: op->dentry);
1696	}
1697
1698	static const struct afs_operation_ops afs_link_operation = {
1699	.issue_afs_rpc = afs_fs_link,
1700	.issue_yfs_rpc = yfs_fs_link,
1701	.success = afs_link_success,
1702	.aborted = afs_check_for_remote_deletion,
1703	.edit_dir = afs_create_edit_dir,
1704	.put = afs_link_put,
1705	};
1706
1707	/*
1708	* create a hard link between files in an AFS filesystem
1709	*/
1710	static int afs_link(struct dentry *from, struct inode *dir,
1711	struct dentry *dentry)
1712	{
1713	struct afs_operation *op;
1714	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1715	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry: from));
1716	int ret = -ENAMETOOLONG;
1717
1718	_enter("{%llx:%llu},{%llx:%llu},{%pd}",
1719	vnode->fid.vid, vnode->fid.vnode,
1720	dvnode->fid.vid, dvnode->fid.vnode,
1721	dentry);
1722
1723	if (dentry->d_name.len >= AFSNAMEMAX)
1724	goto error;
1725
1726	op = afs_alloc_operation(NULL, dvnode->volume);
1727	if (IS_ERR(ptr: op)) {
1728	ret = PTR_ERR(ptr: op);
1729	goto error;
1730	}
1731
1732	ret = afs_validate(vnode, op->key);
1733	if (ret < 0)
1734	goto error_op;
1735
1736	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1737	afs_op_set_vnode(op, n: 1, vnode);
1738	op->file[0].dv_delta = 1;
1739	op->file[0].modification = true;
1740	op->file[0].update_ctime = true;
1741	op->file[1].update_ctime = true;
1742
1743	op->dentry = dentry;
1744	op->dentry_2 = from;
1745	op->ops = &afs_link_operation;
1746	op->create.reason = afs_edit_dir_for_link;
1747	return afs_do_sync_operation(op);
1748
1749	error_op:
1750	afs_put_operation(op);
1751	error:
1752	d_drop(dentry);
1753	_leave(" = %d", ret);
1754	return ret;
1755	}
1756
1757	static const struct afs_operation_ops afs_symlink_operation = {
1758	.issue_afs_rpc = afs_fs_symlink,
1759	.issue_yfs_rpc = yfs_fs_symlink,
1760	.success = afs_create_success,
1761	.aborted = afs_check_for_remote_deletion,
1762	.edit_dir = afs_create_edit_dir,
1763	.put = afs_create_put,
1764	};
1765
1766	/*
1767	* create a symlink in an AFS filesystem
1768	*/
1769	static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,
1770	struct dentry *dentry, const char *content)
1771	{
1772	struct afs_operation *op;
1773	struct afs_vnode *dvnode = AFS_FS_I(inode: dir);
1774	int ret;
1775
1776	_enter("{%llx:%llu},{%pd},%s",
1777	dvnode->fid.vid, dvnode->fid.vnode, dentry,
1778	content);
1779
1780	ret = -ENAMETOOLONG;
1781	if (dentry->d_name.len >= AFSNAMEMAX)
1782	goto error;
1783
1784	ret = -EINVAL;
1785	if (strlen(content) >= AFSPATHMAX)
1786	goto error;
1787
1788	op = afs_alloc_operation(NULL, dvnode->volume);
1789	if (IS_ERR(ptr: op)) {
1790	ret = PTR_ERR(ptr: op);
1791	goto error;
1792	}
1793
1794	afs_op_set_vnode(op, n: 0, vnode: dvnode);
1795	op->file[0].dv_delta = 1;
1796
1797	op->dentry = dentry;
1798	op->ops = &afs_symlink_operation;
1799	op->create.reason = afs_edit_dir_for_symlink;
1800	op->create.symlink = content;
1801	op->mtime = current_time(inode: dir);
1802	return afs_do_sync_operation(op);
1803
1804	error:
1805	d_drop(dentry);
1806	_leave(" = %d", ret);
1807	return ret;
1808	}
1809
1810	static void afs_rename_success(struct afs_operation *op)
1811	{
1812	_enter("op=%08x", op->debug_id);
1813
1814	op->ctime = op->file[0].scb.status.mtime_client;
1815	afs_check_dir_conflict(op, dvp: &op->file[1]);
1816	afs_vnode_commit_status(op, &op->file[0]);
1817	if (op->file[1].vnode != op->file[0].vnode) {
1818	op->ctime = op->file[1].scb.status.mtime_client;
1819	afs_vnode_commit_status(op, &op->file[1]);
1820	}
1821	}
1822
1823	static void afs_rename_edit_dir(struct afs_operation *op)
1824	{
1825	struct afs_vnode_param *orig_dvp = &op->file[0];
1826	struct afs_vnode_param *new_dvp = &op->file[1];
1827	struct afs_vnode *orig_dvnode = orig_dvp->vnode;
1828	struct afs_vnode *new_dvnode = new_dvp->vnode;
1829	struct afs_vnode *vnode = AFS_FS_I(inode: d_inode(dentry: op->dentry));
1830	struct dentry *old_dentry = op->dentry;
1831	struct dentry *new_dentry = op->dentry_2;
1832	struct inode *new_inode;
1833
1834	_enter("op=%08x", op->debug_id);
1835
1836	if (op->rename.rehash) {
1837	d_rehash(op->rename.rehash);
1838	op->rename.rehash = NULL;
1839	}
1840
1841	down_write(sem: &orig_dvnode->validate_lock);
1842	if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags) &&
1843	orig_dvnode->status.data_version == orig_dvp->dv_before + orig_dvp->dv_delta)
1844	afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name,
1845	afs_edit_dir_for_rename_0);
1846
1847	if (new_dvnode != orig_dvnode) {
1848	up_write(sem: &orig_dvnode->validate_lock);
1849	down_write(sem: &new_dvnode->validate_lock);
1850	}
1851
1852	if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags) &&
1853	new_dvnode->status.data_version == new_dvp->dv_before + new_dvp->dv_delta) {
1854	if (!op->rename.new_negative)
1855	afs_edit_dir_remove(new_dvnode, &new_dentry->d_name,
1856	afs_edit_dir_for_rename_1);
1857
1858	afs_edit_dir_add(new_dvnode, &new_dentry->d_name,
1859	&vnode->fid, afs_edit_dir_for_rename_2);
1860	}
1861
1862	new_inode = d_inode(dentry: new_dentry);
1863	if (new_inode) {
1864	spin_lock(lock: &new_inode->i_lock);
1865	if (S_ISDIR(new_inode->i_mode))
1866	clear_nlink(inode: new_inode);
1867	else if (new_inode->i_nlink > 0)
1868	drop_nlink(inode: new_inode);
1869	spin_unlock(lock: &new_inode->i_lock);
1870	}
1871
1872	/* Now we can update d_fsdata on the dentries to reflect their
1873	* new parent's data_version.
1874	*
1875	* Note that if we ever implement RENAME_EXCHANGE, we'll have
1876	* to update both dentries with opposing dir versions.
1877	*/
1878	afs_update_dentry_version(op, dir_vp: new_dvp, dentry: op->dentry);
1879	afs_update_dentry_version(op, dir_vp: new_dvp, dentry: op->dentry_2);
1880
1881	d_move(old_dentry, new_dentry);
1882
1883	up_write(sem: &new_dvnode->validate_lock);
1884	}
1885
1886	static void afs_rename_put(struct afs_operation *op)
1887	{
1888	_enter("op=%08x", op->debug_id);
1889	if (op->rename.rehash)
1890	d_rehash(op->rename.rehash);
1891	dput(op->rename.tmp);
1892	if (op->error)
1893	d_rehash(op->dentry);
1894	}
1895
1896	static const struct afs_operation_ops afs_rename_operation = {
1897	.issue_afs_rpc = afs_fs_rename,
1898	.issue_yfs_rpc = yfs_fs_rename,
1899	.success = afs_rename_success,
1900	.edit_dir = afs_rename_edit_dir,
1901	.put = afs_rename_put,
1902	};
1903
1904	/*
1905	* rename a file in an AFS filesystem and/or move it between directories
1906	*/
1907	static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
1908	struct dentry *old_dentry, struct inode *new_dir,
1909	struct dentry *new_dentry, unsigned int flags)
1910	{
1911	struct afs_operation *op;
1912	struct afs_vnode *orig_dvnode, *new_dvnode, *vnode;
1913	int ret;
1914
1915	if (flags)
1916	return -EINVAL;
1917
1918	/* Don't allow silly-rename files be moved around. */
1919	if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED)
1920	return -EINVAL;
1921
1922	vnode = AFS_FS_I(inode: d_inode(dentry: old_dentry));
1923	orig_dvnode = AFS_FS_I(inode: old_dir);
1924	new_dvnode = AFS_FS_I(inode: new_dir);
1925
1926	_enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}",
1927	orig_dvnode->fid.vid, orig_dvnode->fid.vnode,
1928	vnode->fid.vid, vnode->fid.vnode,
1929	new_dvnode->fid.vid, new_dvnode->fid.vnode,
1930	new_dentry);
1931
1932	op = afs_alloc_operation(NULL, orig_dvnode->volume);
1933	if (IS_ERR(ptr: op))
1934	return PTR_ERR(ptr: op);
1935
1936	ret = afs_validate(vnode, op->key);
1937	op->error = ret;
1938	if (ret < 0)
1939	goto error;
1940
1941	afs_op_set_vnode(op, n: 0, vnode: orig_dvnode);
1942	afs_op_set_vnode(op, n: 1, vnode: new_dvnode); /* May be same as orig_dvnode */
1943	op->file[0].dv_delta = 1;
1944	op->file[1].dv_delta = 1;
1945	op->file[0].modification = true;
1946	op->file[1].modification = true;
1947	op->file[0].update_ctime = true;
1948	op->file[1].update_ctime = true;
1949
1950	op->dentry = old_dentry;
1951	op->dentry_2 = new_dentry;
1952	op->rename.new_negative = d_is_negative(dentry: new_dentry);
1953	op->ops = &afs_rename_operation;
1954
1955	/* For non-directories, check whether the target is busy and if so,
1956	* make a copy of the dentry and then do a silly-rename. If the
1957	* silly-rename succeeds, the copied dentry is hashed and becomes the
1958	* new target.
1959	*/
1960	if (d_is_positive(dentry: new_dentry) && !d_is_dir(dentry: new_dentry)) {
1961	/* To prevent any new references to the target during the
1962	* rename, we unhash the dentry in advance.
1963	*/
1964	if (!d_unhashed(dentry: new_dentry)) {
1965	d_drop(dentry: new_dentry);
1966	op->rename.rehash = new_dentry;
1967	}
1968
1969	if (d_count(dentry: new_dentry) > 2) {
1970	/* copy the target dentry's name */
1971	op->rename.tmp = d_alloc(new_dentry->d_parent,
1972	&new_dentry->d_name);
1973	if (!op->rename.tmp) {
1974	op->error = -ENOMEM;
1975	goto error;
1976	}
1977
1978	ret = afs_sillyrename(new_dvnode,
1979	AFS_FS_I(inode: d_inode(dentry: new_dentry)),
1980	new_dentry, op->key);
1981	if (ret) {
1982	op->error = ret;
1983	goto error;
1984	}
1985
1986	op->dentry_2 = op->rename.tmp;
1987	op->rename.rehash = NULL;
1988	op->rename.new_negative = true;
1989	}
1990	}
1991
1992	/* This bit is potentially nasty as there's a potential race with
1993	* afs_d_revalidate{,_rcu}(). We have to change d_fsdata on the dentry
1994	* to reflect it's new parent's new data_version after the op, but
1995	* d_revalidate may see old_dentry between the op having taken place
1996	* and the version being updated.
1997	*
1998	* So drop the old_dentry for now to make other threads go through
1999	* lookup instead - which we hold a lock against.
2000	*/
2001	d_drop(dentry: old_dentry);
2002
2003	return afs_do_sync_operation(op);
2004
2005	error:
2006	return afs_put_operation(op);
2007	}
2008
2009	/*
2010	* Release a directory folio and clean up its private state if it's not busy
2011	* - return true if the folio can now be released, false if not
2012	*/
2013	static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags)
2014	{
2015	struct afs_vnode *dvnode = AFS_FS_I(inode: folio_inode(folio));
2016
2017	_enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, folio_index(folio));
2018
2019	folio_detach_private(folio);
2020
2021	/* The directory will need reloading. */
2022	if (test_and_clear_bit(AFS_VNODE_DIR_VALID, addr: &dvnode->flags))
2023	afs_stat_v(dvnode, n_relpg);
2024	return true;
2025	}
2026
2027	/*
2028	* Invalidate part or all of a folio.
2029	*/
2030	static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,
2031	size_t length)
2032	{
2033	struct afs_vnode *dvnode = AFS_FS_I(inode: folio_inode(folio));
2034
2035	_enter("{%lu},%zu,%zu", folio->index, offset, length);
2036
2037	BUG_ON(!folio_test_locked(folio));
2038
2039	/* The directory will need reloading. */
2040	if (test_and_clear_bit(AFS_VNODE_DIR_VALID, addr: &dvnode->flags))
2041	afs_stat_v(dvnode, n_inval);
2042
2043	/* we clean up only if the entire folio is being invalidated */
2044	if (offset == 0 && length == folio_size(folio))
2045	folio_detach_private(folio);
2046	}
2047