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