1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* dir.c: AFS filesystem directory handling
3 *
4 * Copyright (C) 2002, 2018 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/fs.h>
10 #include <linux/namei.h>
11 #include <linux/pagemap.h>
12 #include <linux/swap.h>
13 #include <linux/ctype.h>
14 #include <linux/sched.h>
15 #include <linux/task_io_accounting_ops.h>
16 #include "internal.h"
17 #include "afs_fs.h"
18 #include "xdr_fs.h"
19
20 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry,
21 unsigned int flags);
22 static int afs_dir_open(struct inode *inode, struct file *file);
23 static int afs_readdir(struct file *file, struct dir_context *ctx);
24 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags);
25 static int afs_d_delete(const struct dentry *dentry);
26 static void afs_d_iput(struct dentry *dentry, struct inode *inode);
27 static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name, int nlen,
28 loff_t fpos, u64 ino, unsigned dtype);
29 static bool afs_lookup_filldir(struct dir_context *ctx, const char *name, int nlen,
30 loff_t fpos, u64 ino, unsigned dtype);
31 static int afs_create(struct mnt_idmap *idmap, struct inode *dir,
32 struct dentry *dentry, umode_t mode, bool excl);
33 static int afs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
34 struct dentry *dentry, umode_t mode);
35 static int afs_rmdir(struct inode *dir, struct dentry *dentry);
36 static int afs_unlink(struct inode *dir, struct dentry *dentry);
37 static int afs_link(struct dentry *from, struct inode *dir,
38 struct dentry *dentry);
39 static int afs_symlink(struct mnt_idmap *idmap, struct inode *dir,
40 struct dentry *dentry, const char *content);
41 static int afs_rename(struct mnt_idmap *idmap, struct inode *old_dir,
42 struct dentry *old_dentry, struct inode *new_dir,
43 struct dentry *new_dentry, unsigned int flags);
44 static bool afs_dir_release_folio(struct folio *folio, gfp_t gfp_flags);
45 static void afs_dir_invalidate_folio(struct folio *folio, size_t offset,
46 size_t length);
47
48 static bool afs_dir_dirty_folio(struct address_space *mapping,
49 struct folio *folio)
50 {
51 BUG(); /* This should never happen. */
52 }
53
54 const struct file_operations afs_dir_file_operations = {
55 .open = afs_dir_open,
56 .release = afs_release,
57 .iterate_shared = afs_readdir,
58 .lock = afs_lock,
59 .llseek = generic_file_llseek,
60 };
61
62 const struct inode_operations afs_dir_inode_operations = {
63 .create = afs_create,
64 .lookup = afs_lookup,
65 .link = afs_link,
66 .unlink = afs_unlink,
67 .symlink = afs_symlink,
68 .mkdir = afs_mkdir,
69 .rmdir = afs_rmdir,
70 .rename = afs_rename,
71 .permission = afs_permission,
72 .getattr = afs_getattr,
73 .setattr = afs_setattr,
74 };
75
76 const struct address_space_operations afs_dir_aops = {
77 .dirty_folio = afs_dir_dirty_folio,
78 .release_folio = afs_dir_release_folio,
79 .invalidate_folio = afs_dir_invalidate_folio,
80 .migrate_folio = filemap_migrate_folio,
81 };
82
83 const struct dentry_operations afs_fs_dentry_operations = {
84 .d_revalidate = afs_d_revalidate,
85 .d_delete = afs_d_delete,
86 .d_release = afs_d_release,
87 .d_automount = afs_d_automount,
88 .d_iput = afs_d_iput,
89 };
90
91 struct afs_lookup_one_cookie {
92 struct dir_context ctx;
93 struct qstr name;
94 bool found;
95 struct afs_fid fid;
96 };
97
98 struct afs_lookup_cookie {
99 struct dir_context ctx;
100 struct qstr name;
101 bool found;
102 bool one_only;
103 unsigned short nr_fids;
104 struct afs_fid fids[50];
105 };
106
107 /*
108 * Drop the refs that we're holding on the folios we were reading into. We've
109 * got refs on the first nr_pages pages.
110 */
111 static void afs_dir_read_cleanup(struct afs_read *req)
112 {
113 struct address_space *mapping = req->vnode->netfs.inode.i_mapping;
114 struct folio *folio;
115 pgoff_t last = req->nr_pages - 1;
116
117 XA_STATE(xas, &mapping->i_pages, 0);
118
119 if (unlikely(!req->nr_pages))
120 return;
121
122 rcu_read_lock();
123 xas_for_each(&xas, folio, last) {
124 if (xas_retry(&xas, folio))
125 continue;
126 BUG_ON(xa_is_value(folio));
127 ASSERTCMP(folio->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(dvnode, pos + offset, i_size);
160 kunmap_local(block);
161 trace_afs_file_error(dvnode, -EIO, afs_file_error_dir_bad_magic);
162 goto error;
163 }
164
165 /* Make sure each block is NUL terminated so we can reasonably
166 * use string functions on it. The filenames in the folio
167 * *should* be NUL-terminated anyway.
168 */
169 ((u8 *)block)[AFS_DIR_BLOCK_SIZE - 1] = 0;
170
171 kunmap_local(block);
172 }
173 checked:
174 afs_stat_v(dvnode, n_read_dir);
175 return true;
176
177 error:
178 return false;
179 }
180
181 /*
182 * Dump the contents of a directory.
183 */
184 static void afs_dir_dump(struct afs_vnode *dvnode, struct afs_read *req)
185 {
186 union afs_xdr_dir_block *block;
187 struct address_space *mapping = dvnode->netfs.inode.i_mapping;
188 struct folio *folio;
189 pgoff_t last = req->nr_pages - 1;
190 size_t offset, size;
191
192 XA_STATE(xas, &mapping->i_pages, 0);
193
194 pr_warn("DIR %llx:%llx f=%llx l=%llx al=%llx\n",
195 dvnode->fid.vid, dvnode->fid.vnode,
196 req->file_size, req->len, req->actual_len);
197 pr_warn("DIR %llx %x %zx %zx\n",
198 req->pos, req->nr_pages,
199 req->iter->iov_offset, iov_iter_count(req->iter));
200
201 xas_for_each(&xas, folio, last) {
202 if (xas_retry(&xas, folio))
203 continue;
204
205 BUG_ON(folio->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, folio))
234 continue;
235
236 BUG_ON(folio->mapping != mapping);
237
238 if (!afs_dir_check_folio(dvnode, folio, req->actual_len)) {
239 afs_dir_dump(dvnode, req);
240 ret = -EIO;
241 break;
242 }
243 }
244
245 rcu_read_unlock();
246 return ret;
247 }
248
249 /*
250 * open an AFS directory file
251 */
252 static int afs_dir_open(struct inode *inode, struct file *file)
253 {
254 _enter("{%lu}", inode->i_ino);
255
256 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);
257 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);
258
259 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(inode)->flags))
260 return -ENOENT;
261
262 return afs_open(inode, file);
263 }
264
265 /*
266 * Read the directory into the pagecache in one go, scrubbing the previous
267 * contents. The list of folios is returned, pinning them so that they don't
268 * get reclaimed during the iteration.
269 */
270 static struct afs_read *afs_read_dir(struct afs_vnode *dvnode, struct key *key)
271 __acquires(&dvnode->validate_lock)
272 {
273 struct address_space *mapping = dvnode->netfs.inode.i_mapping;
274 struct afs_read *req;
275 loff_t i_size;
276 int nr_pages, i;
277 int ret;
278 loff_t remote_size = 0;
279
280 _enter("");
281
282 req = kzalloc(sizeof(*req), GFP_KERNEL);
283 if (!req)
284 return ERR_PTR(-ENOMEM);
285
286 refcount_set(&req->usage, 1);
287 req->vnode = dvnode;
288 req->key = key_get(key);
289 req->cleanup = afs_dir_read_cleanup;
290
291 expand:
292 i_size = i_size_read(&dvnode->netfs.inode);
293 if (i_size < remote_size)
294 i_size = remote_size;
295 if (i_size < 2048) {
296 ret = afs_bad(dvnode, afs_file_error_dir_small);
297 goto error;
298 }
299 if (i_size > 2048 * 1024) {
300 trace_afs_file_error(dvnode, -EFBIG, afs_file_error_dir_big);
301 ret = -EFBIG;
302 goto error;
303 }
304
305 _enter("%llu", i_size);
306
307 nr_pages = (i_size + PAGE_SIZE - 1) / PAGE_SIZE;
308
309 req->actual_len = i_size; /* May change */
310 req->len = nr_pages * PAGE_SIZE; /* We can ask for more than there is */
311 req->data_version = dvnode->status.data_version; /* May change */
312 iov_iter_xarray(&req->def_iter, ITER_DEST, &dvnode->netfs.inode.i_mapping->i_pages,
313 0, i_size);
314 req->iter = &req->def_iter;
315
316 /* Fill in any gaps that we might find where the memory reclaimer has
317 * been at work and pin all the folios. If there are any gaps, we will
318 * need to reread the entire directory contents.
319 */
320 i = req->nr_pages;
321 while (i < nr_pages) {
322 struct folio *folio;
323
324 folio = filemap_get_folio(mapping, i);
325 if (IS_ERR(folio)) {
326 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))
327 afs_stat_v(dvnode, n_inval);
328 folio = __filemap_get_folio(mapping,
329 i, FGP_LOCK | FGP_CREAT,
330 mapping->gfp_mask);
331 if (IS_ERR(folio)) {
332 ret = PTR_ERR(folio);
333 goto error;
334 }
335 folio_attach_private(folio, (void *)1);
336 folio_unlock(folio);
337 }
338
339 req->nr_pages += folio_nr_pages(folio);
340 i += folio_nr_pages(folio);
341 }
342
343 /* If we're going to reload, we need to lock all the pages to prevent
344 * races.
345 */
346 ret = -ERESTARTSYS;
347 if (down_read_killable(&dvnode->validate_lock) < 0)
348 goto error;
349
350 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags))
351 goto success;
352
353 up_read(&dvnode->validate_lock);
354 if (down_write_killable(&dvnode->validate_lock) < 0)
355 goto error;
356
357 if (!test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) {
358 trace_afs_reload_dir(dvnode);
359 ret = afs_fetch_data(dvnode, req);
360 if (ret < 0)
361 goto error_unlock;
362
363 task_io_account_read(PAGE_SIZE * req->nr_pages);
364
365 if (req->len < req->file_size) {
366 /* The content has grown, so we need to expand the
367 * buffer.
368 */
369 up_write(&dvnode->validate_lock);
370 remote_size = req->file_size;
371 goto expand;
372 }
373
374 /* Validate the data we just read. */
375 ret = afs_dir_check(dvnode, req);
376 if (ret < 0)
377 goto error_unlock;
378
379 // TODO: Trim excess pages
380
381 set_bit(AFS_VNODE_DIR_VALID, &dvnode->flags);
382 }
383
384 downgrade_write(&dvnode->validate_lock);
385 success:
386 return req;
387
388 error_unlock:
389 up_write(&dvnode->validate_lock);
390 error:
391 afs_put_read(req);
392 _leave(" = %d", ret);
393 return ERR_PTR(ret);
394 }
395
396 /*
397 * deal with one block in an AFS directory
398 */
399 static int afs_dir_iterate_block(struct afs_vnode *dvnode,
400 struct dir_context *ctx,
401 union afs_xdr_dir_block *block,
402 unsigned blkoff)
403 {
404 union afs_xdr_dirent *dire;
405 unsigned offset, next, curr, nr_slots;
406 size_t nlen;
407 int tmp;
408
409 _enter("%llx,%x", ctx->pos, blkoff);
410
411 curr = (ctx->pos - blkoff) / sizeof(union afs_xdr_dirent);
412
413 /* walk through the block, an entry at a time */
414 for (offset = (blkoff == 0 ? AFS_DIR_RESV_BLOCKS0 : AFS_DIR_RESV_BLOCKS);
415 offset < AFS_DIR_SLOTS_PER_BLOCK;
416 offset = next
417 ) {
418 /* skip entries marked unused in the bitmap */
419 if (!(block->hdr.bitmap[offset / 8] &
420 (1 << (offset % 8)))) {
421 _debug("ENT[%zu.%u]: unused",
422 blkoff / sizeof(union afs_xdr_dir_block), offset);
423 next = offset + 1;
424 if (offset >= curr)
425 ctx->pos = blkoff +
426 next * sizeof(union afs_xdr_dirent);
427 continue;
428 }
429
430 /* got a valid entry */
431 dire = &block->dirents[offset];
432 nlen = strnlen(dire->u.name,
433 sizeof(*block) -
434 offset * sizeof(union afs_xdr_dirent));
435 if (nlen > AFSNAMEMAX - 1) {
436 _debug("ENT[%zu]: name too long (len %u/%zu)",
437 blkoff / sizeof(union afs_xdr_dir_block),
438 offset, nlen);
439 return afs_bad(dvnode, afs_file_error_dir_name_too_long);
440 }
441
442 _debug("ENT[%zu.%u]: %s %zu \"%s\"",
443 blkoff / sizeof(union afs_xdr_dir_block), offset,
444 (offset < curr ? "skip" : "fill"),
445 nlen, dire->u.name);
446
447 nr_slots = afs_dir_calc_slots(nlen);
448 next = offset + nr_slots;
449 if (next > AFS_DIR_SLOTS_PER_BLOCK) {
450 _debug("ENT[%zu.%u]:"
451 " %u extends beyond end dir block"
452 " (len %zu)",
453 blkoff / sizeof(union afs_xdr_dir_block),
454 offset, next, nlen);
455 return afs_bad(dvnode, afs_file_error_dir_over_end);
456 }
457
458 /* Check that the name-extension dirents are all allocated */
459 for (tmp = 1; tmp < nr_slots; tmp++) {
460 unsigned int ix = offset + tmp;
461 if (!(block->hdr.bitmap[ix / 8] & (1 << (ix % 8)))) {
462 _debug("ENT[%zu.u]:"
463 " %u unmarked extension (%u/%u)",
464 blkoff / sizeof(union afs_xdr_dir_block),
465 offset, tmp, nr_slots);
466 return afs_bad(dvnode, afs_file_error_dir_unmarked_ext);
467 }
468 }
469
470 /* skip if starts before the current position */
471 if (offset < curr) {
472 if (next > curr)
473 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);
474 continue;
475 }
476
477 /* found the next entry */
478 if (!dir_emit(ctx, dire->u.name, nlen,
479 ntohl(dire->u.vnode),
480 (ctx->actor == afs_lookup_filldir ||
481 ctx->actor == afs_lookup_one_filldir)?
482 ntohl(dire->u.unique) : DT_UNKNOWN)) {
483 _leave(" = 0 [full]");
484 return 0;
485 }
486
487 ctx->pos = blkoff + next * sizeof(union afs_xdr_dirent);
488 }
489
490 _leave(" = 1 [more]");
491 return 1;
492 }
493
494 /*
495 * iterate through the data blob that lists the contents of an AFS directory
496 */
497 static int afs_dir_iterate(struct inode *dir, struct dir_context *ctx,
498 struct key *key, afs_dataversion_t *_dir_version)
499 {
500 struct afs_vnode *dvnode = AFS_FS_I(dir);
501 union afs_xdr_dir_block *dblock;
502 struct afs_read *req;
503 struct folio *folio;
504 unsigned offset, size;
505 int ret;
506
507 _enter("{%lu},%u,,", dir->i_ino, (unsigned)ctx->pos);
508
509 if (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dir)->flags)) {
510 _leave(" = -ESTALE");
511 return -ESTALE;
512 }
513
514 req = afs_read_dir(dvnode, key);
515 if (IS_ERR(req))
516 return PTR_ERR(req);
517 *_dir_version = req->data_version;
518
519 /* round the file position up to the next entry boundary */
520 ctx->pos += sizeof(union afs_xdr_dirent) - 1;
521 ctx->pos &= ~(sizeof(union afs_xdr_dirent) - 1);
522
523 /* walk through the blocks in sequence */
524 ret = 0;
525 while (ctx->pos < req->actual_len) {
526 /* Fetch the appropriate folio from the directory and re-add it
527 * to the LRU. We have all the pages pinned with an extra ref.
528 */
529 folio = __filemap_get_folio(dir->i_mapping, ctx->pos / PAGE_SIZE,
530 FGP_ACCESSED, 0);
531 if (IS_ERR(folio)) {
532 ret = afs_bad(dvnode, afs_file_error_dir_missing_page);
533 break;
534 }
535
536 offset = round_down(ctx->pos, sizeof(*dblock)) - folio_pos(folio);
537 size = min_t(loff_t, folio_size(folio),
538 req->actual_len - folio_pos(folio));
539
540 do {
541 dblock = kmap_local_folio(folio, offset);
542 ret = afs_dir_iterate_block(dvnode, ctx, dblock,
543 folio_pos(folio) + offset);
544 kunmap_local(dblock);
545 if (ret != 1)
546 goto out;
547
548 } while (offset += sizeof(*dblock), offset < size);
549
550 ret = 0;
551 }
552
553 out:
554 up_read(&dvnode->validate_lock);
555 afs_put_read(req);
556 _leave(" = %d", ret);
557 return ret;
558 }
559
560 /*
561 * read an AFS directory
562 */
563 static int afs_readdir(struct file *file, struct dir_context *ctx)
564 {
565 afs_dataversion_t dir_version;
566
567 return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file),
568 &dir_version);
569 }
570
571 /*
572 * Search the directory for a single name
573 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
574 * uniquifier through dtype
575 */
576 static bool afs_lookup_one_filldir(struct dir_context *ctx, const char *name,
577 int nlen, loff_t fpos, u64 ino, unsigned dtype)
578 {
579 struct afs_lookup_one_cookie *cookie =
580 container_of(ctx, struct afs_lookup_one_cookie, ctx);
581
582 _enter("{%s,%u},%s,%u,,%llu,%u",
583 cookie->name.name, cookie->name.len, name, nlen,
584 (unsigned long long) ino, dtype);
585
586 /* insanity checks first */
587 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);
588 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);
589
590 if (cookie->name.len != nlen ||
591 memcmp(cookie->name.name, name, nlen) != 0) {
592 _leave(" = true [keep looking]");
593 return true;
594 }
595
596 cookie->fid.vnode = ino;
597 cookie->fid.unique = dtype;
598 cookie->found = 1;
599
600 _leave(" = false [found]");
601 return false;
602 }
603
604 /*
605 * Do a lookup of a single name in a directory
606 * - just returns the FID the dentry name maps to if found
607 */
608 static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry,
609 struct afs_fid *fid, struct key *key,
610 afs_dataversion_t *_dir_version)
611 {
612 struct afs_super_info *as = dir->i_sb->s_fs_info;
613 struct afs_lookup_one_cookie cookie = {
614 .ctx.actor = afs_lookup_one_filldir,
615 .name = dentry->d_name,
616 .fid.vid = as->volume->vid
617 };
618 int ret;
619
620 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
621
622 /* search the directory */
623 ret = afs_dir_iterate(dir, &cookie.ctx, key, _dir_version);
624 if (ret < 0) {
625 _leave(" = %d [iter]", ret);
626 return ret;
627 }
628
629 if (!cookie.found) {
630 _leave(" = -ENOENT [not found]");
631 return -ENOENT;
632 }
633
634 *fid = cookie.fid;
635 _leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique);
636 return 0;
637 }
638
639 /*
640 * search the directory for a name
641 * - if afs_dir_iterate_block() spots this function, it'll pass the FID
642 * uniquifier through dtype
643 */
644 static bool afs_lookup_filldir(struct dir_context *ctx, const char *name,
645 int nlen, loff_t fpos, u64 ino, unsigned dtype)
646 {
647 struct afs_lookup_cookie *cookie =
648 container_of(ctx, struct afs_lookup_cookie, ctx);
649
650 _enter("{%s,%u},%s,%u,,%llu,%u",
651 cookie->name.name, cookie->name.len, name, nlen,
652 (unsigned long long) ino, dtype);
653
654 /* insanity checks first */
655 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);
656 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);
657
658 if (cookie->found) {
659 if (cookie->nr_fids < 50) {
660 cookie->fids[cookie->nr_fids].vnode = ino;
661 cookie->fids[cookie->nr_fids].unique = dtype;
662 cookie->nr_fids++;
663 }
664 } else if (cookie->name.len == nlen &&
665 memcmp(cookie->name.name, name, nlen) == 0) {
666 cookie->fids[1].vnode = ino;
667 cookie->fids[1].unique = dtype;
668 cookie->found = 1;
669 if (cookie->one_only)
670 return false;
671 }
672
673 return cookie->nr_fids < 50;
674 }
675
676 /*
677 * Deal with the result of a successful lookup operation. Turn all the files
678 * into inodes and save the first one - which is the one we actually want.
679 */
680 static void afs_do_lookup_success(struct afs_operation *op)
681 {
682 struct afs_vnode_param *vp;
683 struct afs_vnode *vnode;
684 struct inode *inode;
685 u32 abort_code;
686 int i;
687
688 _enter("");
689
690 for (i = 0; i < op->nr_files; i++) {
691 switch (i) {
692 case 0:
693 vp = &op->file[0];
694 abort_code = vp->scb.status.abort_code;
695 if (abort_code != 0) {
696 op->call_abort_code = abort_code;
697 afs_op_set_error(op, 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, &vp->fid, i, 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(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(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(sizeof(struct afs_lookup_cookie), GFP_KERNEL);
805 if (!cookie)
806 return ERR_PTR(-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, &cookie->ctx, key, &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(dir->i_sb, cookie->fids[1].vnode,
831 afs_ilookup5_test_by_fid, &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(op)) {
841 ret = PTR_ERR(op);
842 goto out;
843 }
844
845 afs_op_set_vnode(op, 0, dvnode);
846 afs_op_set_fid(op, 1, &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(op->nr_files - 2,
854 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(dir->i_sb, vp->fid.vnode,
869 afs_ilookup5_test_by_fid, &vp->fid);
870 if (!IS_ERR_OR_NULL(ti)) {
871 vnode = AFS_FS_I(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, -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, -ECONNABORTED,
907 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(cookie);
921 _leave("");
922 return inode ?: ERR_PTR(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(dir);
933 struct dentry *ret;
934 char *buf, *p, *name;
935 int len, i;
936
937 _enter("");
938
939 ret = ERR_PTR(-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(&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(-ENAMETOOLONG);
959 goto out_s;
960 }
961
962 strcpy(p, name);
963 ret = lookup_one_len(buf, dentry->d_parent, len);
964 if (IS_ERR(ret) || d_is_positive(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(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(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(-ENAMETOOLONG);
1002 }
1003
1004 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) {
1005 _leave(" = -ESTALE");
1006 return ERR_PTR(-ESTALE);
1007 }
1008
1009 key = afs_request_key(dvnode->volume->cell);
1010 if (IS_ERR(key)) {
1011 _leave(" = %ld [key]", PTR_ERR(key));
1012 return ERR_CAST(key);
1013 }
1014
1015 ret = afs_validate(dvnode, key);
1016 if (ret < 0) {
1017 key_put(key);
1018 _leave(" = %d [val]", ret);
1019 return ERR_PTR(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(-ENOENT))
1033 inode = afs_try_auto_mntpt(dentry, dir);
1034
1035 if (!IS_ERR_OR_NULL(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(d)) {
1041 d->d_fsdata = dentry->d_fsdata;
1042 trace_afs_lookup(dvnode, &d->d_name, &fid);
1043 } else {
1044 trace_afs_lookup(dvnode, &dentry->d_name, &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(parent);
1065 if (!dir)
1066 return -ECHILD;
1067 dvnode = AFS_FS_I(dir);
1068 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags))
1069 return -ECHILD;
1070
1071 if (!afs_check_validity(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(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(dentry->d_sb)->volume->cell);
1119 if (IS_ERR(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(d_inode(parent));
1125
1126 /* validate the parent directory */
1127 ret = afs_validate(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->netfs.inode, dentry, &fid, key, &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, &vnode->flags);
1274 clear_nlink(&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(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, PTR_ERR(inode), 0);
1298 return;
1299 }
1300
1301 vnode = AFS_FS_I(inode);
1302 set_bit(AFS_VNODE_NEW_CONTENT, &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, &op->file[0], 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(&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(&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(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(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(op)) {
1364 d_drop(dentry);
1365 return PTR_ERR(op);
1366 }
1367
1368 afs_op_set_vnode(op, 0, 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(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(d_inode(dentry));
1387
1388 clear_nlink(&vnode->netfs.inode);
1389 set_bit(AFS_VNODE_DELETED, &vnode->flags);
1390 atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE);
1391 clear_bit(AFS_VNODE_DIR_VALID, &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, &op->file[0], 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(op->dentry);
1410
1411 down_write(&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(&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(&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(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(op))
1449 return PTR_ERR(op);
1450
1451 afs_op_set_vnode(op, 0, 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(d_inode(dentry));
1462 ret = afs_validate(vnode, op->key);
1463 if (ret < 0)
1464 goto error;
1465 }
1466
1467 if (vnode) {
1468 ret = down_write_killable(&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(&vnode->cb_lock);
1507 drop_nlink(&vnode->netfs.inode);
1508 if (vnode->netfs.inode.i_nlink == 0) {
1509 set_bit(AFS_VNODE_DELETED, &vnode->flags);
1510 __afs_break_callback(vnode, afs_cb_break_for_unlink);
1511 }
1512 write_sequnlock(&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, op->key);
1520 if (ret != -ESTALE)
1521 afs_op_set_error(op, 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, &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, &op->file[0], 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(&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(&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(dir);
1575 struct afs_vnode *vnode = AFS_FS_I(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(op))
1586 return PTR_ERR(op);
1587
1588 afs_op_set_vnode(op, 0, 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, op->key);
1595 if (ret < 0) {
1596 afs_op_set_error(op, ret);
1597 goto error;
1598 }
1599
1600 spin_lock(&dentry->d_lock);
1601 if (d_count(dentry) > 1) {
1602 spin_unlock(&dentry->d_lock);
1603 /* Start asynchronous writeout of the inode */
1604 write_inode_now(d_inode(dentry), 0);
1605 afs_op_set_error(op, 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(&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(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(op)) {
1667 ret = PTR_ERR(op);
1668 goto error;
1669 }
1670
1671 afs_op_set_vnode(op, 0, 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(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, dvp, op->dentry);
1699 if (op->dentry_2->d_parent == op->dentry->d_parent)
1700 afs_update_dentry_version(op, dvp, op->dentry_2);
1701 ihold(&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(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(dir);
1729 struct afs_vnode *vnode = AFS_FS_I(d_inode(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(op)) {
1742 ret = PTR_ERR(op);
1743 goto error;
1744 }
1745
1746 ret = afs_validate(vnode, op->key);
1747 if (ret < 0)
1748 goto error_op;
1749
1750 afs_op_set_vnode(op, 0, dvnode);
1751 afs_op_set_vnode(op, 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(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(op)) {
1804 ret = PTR_ERR(op);
1805 goto error;
1806 }
1807
1808 afs_op_set_vnode(op, 0, 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(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, &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(d_inode(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(&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(&orig_dvnode->validate_lock);
1863 down_write(&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(new_dentry);
1877 if (new_inode) {
1878 spin_lock(&new_inode->i_lock);
1879 if (S_ISDIR(new_inode->i_mode))
1880 clear_nlink(new_inode);
1881 else if (new_inode->i_nlink > 0)
1882 drop_nlink(new_inode);
1883 spin_unlock(&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, new_dvp, op->dentry);
1893 afs_update_dentry_version(op, new_dvp, op->dentry_2);
1894
1895 d_move(old_dentry, new_dentry);
1896
1897 up_write(&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(d_inode(old_dentry));
1937 orig_dvnode = AFS_FS_I(old_dir);
1938 new_dvnode = AFS_FS_I(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(op))
1948 return PTR_ERR(op);
1949
1950 ret = afs_validate(vnode, op->key);
1951 afs_op_set_error(op, ret);
1952 if (ret < 0)
1953 goto error;
1954
1955 afs_op_set_vnode(op, 0, orig_dvnode);
1956 afs_op_set_vnode(op, 1, 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(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(new_dentry) && !d_is_dir(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(new_dentry)) {
1979 d_drop(new_dentry);
1980 op->rename.rehash = new_dentry;
1981 }
1982
1983 if (d_count(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(d_inode(new_dentry)),
1994 new_dentry, op->key);
1995 if (ret) {
1996 afs_op_set_error(op, 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(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(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, &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(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, &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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.