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