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) 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 464 /* round the file position up to the next entry boundary */ 465 ctx->pos += sizeof(union afs_xdr_dirent) - 1; 466 ctx->pos &= ~(sizeof(union afs_xdr_dirent) - 1); 467 468 /* walk through the blocks in sequence */ 469 ret = 0; 470 while (ctx->pos < req->actual_len) { 471 blkoff = ctx->pos & ~(sizeof(union afs_xdr_dir_block) - 1); 472 473 /* Fetch the appropriate page from the directory and re-add it 474 * to the LRU. 475 */ 476 page = req->pages[blkoff / PAGE_SIZE]; 477 if (!page) { 478 ret = afs_bad(dvnode, afs_file_error_dir_missing_page); 479 break; 480 } 481 mark_page_accessed(page); 482 483 limit = blkoff & ~(PAGE_SIZE - 1); 484 485 dbuf = kmap(page); 486 487 /* deal with the individual blocks stashed on this page */ 488 do { 489 dblock = &dbuf->blocks[(blkoff % PAGE_SIZE) / 490 sizeof(union afs_xdr_dir_block)]; 491 ret = afs_dir_iterate_block(dvnode, ctx, dblock, blkoff); 492 if (ret != 1) { 493 kunmap(page); 494 goto out; 495 } 496 497 blkoff += sizeof(union afs_xdr_dir_block); 498 499 } while (ctx->pos < dir->i_size && blkoff < limit); 500 501 kunmap(page); 502 ret = 0; 503 } 504 505 out: 506 up_read(&dvnode->validate_lock); 507 afs_put_read(req); 508 _leave(" = %d", ret); 509 return ret; 510 } 511 512 /* 513 * read an AFS directory 514 */ 515 static int afs_readdir(struct file *file, struct dir_context *ctx) 516 { 517 return afs_dir_iterate(file_inode(file), ctx, afs_file_key(file)); 518 } 519 520 /* 521 * Search the directory for a single name 522 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 523 * uniquifier through dtype 524 */ 525 static int afs_lookup_one_filldir(struct dir_context *ctx, const char *name, 526 int nlen, loff_t fpos, u64 ino, unsigned dtype) 527 { 528 struct afs_lookup_one_cookie *cookie = 529 container_of(ctx, struct afs_lookup_one_cookie, ctx); 530 531 _enter("{%s,%u},%s,%u,,%llu,%u", 532 cookie->name.name, cookie->name.len, name, nlen, 533 (unsigned long long) ino, dtype); 534 535 /* insanity checks first */ 536 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048); 537 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32); 538 539 if (cookie->name.len != nlen || 540 memcmp(cookie->name.name, name, nlen) != 0) { 541 _leave(" = 0 [no]"); 542 return 0; 543 } 544 545 cookie->fid.vnode = ino; 546 cookie->fid.unique = dtype; 547 cookie->found = 1; 548 549 _leave(" = -1 [found]"); 550 return -1; 551 } 552 553 /* 554 * Do a lookup of a single name in a directory 555 * - just returns the FID the dentry name maps to if found 556 */ 557 static int afs_do_lookup_one(struct inode *dir, struct dentry *dentry, 558 struct afs_fid *fid, struct key *key) 559 { 560 struct afs_super_info *as = dir->i_sb->s_fs_info; 561 struct afs_lookup_one_cookie cookie = { 562 .ctx.actor = afs_lookup_one_filldir, 563 .name = dentry->d_name, 564 .fid.vid = as->volume->vid 565 }; 566 int ret; 567 568 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry); 569 570 /* search the directory */ 571 ret = afs_dir_iterate(dir, &cookie.ctx, key); 572 if (ret < 0) { 573 _leave(" = %d [iter]", ret); 574 return ret; 575 } 576 577 ret = -ENOENT; 578 if (!cookie.found) { 579 _leave(" = -ENOENT [not found]"); 580 return -ENOENT; 581 } 582 583 *fid = cookie.fid; 584 _leave(" = 0 { vn=%llu u=%u }", fid->vnode, fid->unique); 585 return 0; 586 } 587 588 /* 589 * search the directory for a name 590 * - if afs_dir_iterate_block() spots this function, it'll pass the FID 591 * uniquifier through dtype 592 */ 593 static int afs_lookup_filldir(struct dir_context *ctx, const char *name, 594 int nlen, loff_t fpos, u64 ino, unsigned dtype) 595 { 596 struct afs_lookup_cookie *cookie = 597 container_of(ctx, struct afs_lookup_cookie, ctx); 598 int ret; 599 600 _enter("{%s,%u},%s,%u,,%llu,%u", 601 cookie->name.name, cookie->name.len, name, nlen, 602 (unsigned long long) ino, dtype); 603 604 /* insanity checks first */ 605 BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048); 606 BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32); 607 608 if (cookie->found) { 609 if (cookie->nr_fids < 50) { 610 cookie->fids[cookie->nr_fids].vnode = ino; 611 cookie->fids[cookie->nr_fids].unique = dtype; 612 cookie->nr_fids++; 613 } 614 } else if (cookie->name.len == nlen && 615 memcmp(cookie->name.name, name, nlen) == 0) { 616 cookie->fids[0].vnode = ino; 617 cookie->fids[0].unique = dtype; 618 cookie->found = 1; 619 if (cookie->one_only) 620 return -1; 621 } 622 623 ret = cookie->nr_fids >= 50 ? -1 : 0; 624 _leave(" = %d", ret); 625 return ret; 626 } 627 628 /* 629 * Do a lookup in a directory. We make use of bulk lookup to query a slew of 630 * files in one go and create inodes for them. The inode of the file we were 631 * asked for is returned. 632 */ 633 static struct inode *afs_do_lookup(struct inode *dir, struct dentry *dentry, 634 struct key *key) 635 { 636 struct afs_lookup_cookie *cookie; 637 struct afs_cb_interest *dcbi, *cbi = NULL; 638 struct afs_super_info *as = dir->i_sb->s_fs_info; 639 struct afs_status_cb *scb; 640 struct afs_iget_data iget_data; 641 struct afs_fs_cursor fc; 642 struct afs_server *server; 643 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode; 644 struct inode *inode = NULL, *ti; 645 int ret, i; 646 647 _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry); 648 649 cookie = kzalloc(sizeof(struct afs_lookup_cookie), GFP_KERNEL); 650 if (!cookie) 651 return ERR_PTR(-ENOMEM); 652 653 cookie->ctx.actor = afs_lookup_filldir; 654 cookie->name = dentry->d_name; 655 cookie->nr_fids = 1; /* slot 0 is saved for the fid we actually want */ 656 657 read_seqlock_excl(&dvnode->cb_lock); 658 dcbi = rcu_dereference_protected(dvnode->cb_interest, 659 lockdep_is_held(&dvnode->cb_lock.lock)); 660 if (dcbi) { 661 server = dcbi->server; 662 if (server && 663 test_bit(AFS_SERVER_FL_NO_IBULK, &server->flags)) 664 cookie->one_only = true; 665 } 666 read_sequnlock_excl(&dvnode->cb_lock); 667 668 for (i = 0; i < 50; i++) 669 cookie->fids[i].vid = as->volume->vid; 670 671 /* search the directory */ 672 ret = afs_dir_iterate(dir, &cookie->ctx, key); 673 if (ret < 0) { 674 inode = ERR_PTR(ret); 675 goto out; 676 } 677 678 inode = ERR_PTR(-ENOENT); 679 if (!cookie->found) 680 goto out; 681 682 /* Check to see if we already have an inode for the primary fid. */ 683 iget_data.fid = cookie->fids[0]; 684 iget_data.volume = dvnode->volume; 685 iget_data.cb_v_break = dvnode->volume->cb_v_break; 686 iget_data.cb_s_break = 0; 687 inode = ilookup5(dir->i_sb, cookie->fids[0].vnode, 688 afs_iget5_test, &iget_data); 689 if (inode) 690 goto out; 691 692 /* Need space for examining all the selected files */ 693 inode = ERR_PTR(-ENOMEM); 694 cookie->statuses = kvcalloc(cookie->nr_fids, sizeof(struct afs_status_cb), 695 GFP_KERNEL); 696 if (!cookie->statuses) 697 goto out; 698 699 cookie->inodes = kcalloc(cookie->nr_fids, sizeof(struct inode *), 700 GFP_KERNEL); 701 if (!cookie->inodes) 702 goto out_s; 703 704 for (i = 1; i < cookie->nr_fids; i++) { 705 scb = &cookie->statuses[i]; 706 707 /* Find any inodes that already exist and get their 708 * callback counters. 709 */ 710 iget_data.fid = cookie->fids[i]; 711 ti = ilookup5_nowait(dir->i_sb, iget_data.fid.vnode, 712 afs_iget5_test, &iget_data); 713 if (!IS_ERR_OR_NULL(ti)) { 714 vnode = AFS_FS_I(ti); 715 scb->cb_break = afs_calc_vnode_cb_break(vnode); 716 cookie->inodes[i] = ti; 717 } 718 } 719 720 /* Try FS.InlineBulkStatus first. Abort codes for the individual 721 * lookups contained therein are stored in the reply without aborting 722 * the whole operation. 723 */ 724 if (cookie->one_only) 725 goto no_inline_bulk_status; 726 727 inode = ERR_PTR(-ERESTARTSYS); 728 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 729 while (afs_select_fileserver(&fc)) { 730 if (test_bit(AFS_SERVER_FL_NO_IBULK, 731 &fc.cbi->server->flags)) { 732 fc.ac.abort_code = RX_INVALID_OPERATION; 733 fc.ac.error = -ECONNABORTED; 734 break; 735 } 736 iget_data.cb_v_break = dvnode->volume->cb_v_break; 737 iget_data.cb_s_break = fc.cbi->server->cb_s_break; 738 afs_fs_inline_bulk_status(&fc, 739 afs_v2net(dvnode), 740 cookie->fids, 741 cookie->statuses, 742 cookie->nr_fids, NULL); 743 } 744 745 if (fc.ac.error == 0) 746 cbi = afs_get_cb_interest(fc.cbi); 747 if (fc.ac.abort_code == RX_INVALID_OPERATION) 748 set_bit(AFS_SERVER_FL_NO_IBULK, &fc.cbi->server->flags); 749 inode = ERR_PTR(afs_end_vnode_operation(&fc)); 750 } 751 752 if (!IS_ERR(inode)) 753 goto success; 754 if (fc.ac.abort_code != RX_INVALID_OPERATION) 755 goto out_c; 756 757 no_inline_bulk_status: 758 /* We could try FS.BulkStatus next, but this aborts the entire op if 759 * any of the lookups fails - so, for the moment, revert to 760 * FS.FetchStatus for just the primary fid. 761 */ 762 inode = ERR_PTR(-ERESTARTSYS); 763 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 764 while (afs_select_fileserver(&fc)) { 765 iget_data.cb_v_break = dvnode->volume->cb_v_break; 766 iget_data.cb_s_break = fc.cbi->server->cb_s_break; 767 scb = &cookie->statuses[0]; 768 afs_fs_fetch_status(&fc, 769 afs_v2net(dvnode), 770 cookie->fids, 771 scb, 772 NULL); 773 } 774 775 if (fc.ac.error == 0) 776 cbi = afs_get_cb_interest(fc.cbi); 777 inode = ERR_PTR(afs_end_vnode_operation(&fc)); 778 } 779 780 if (IS_ERR(inode)) 781 goto out_c; 782 783 success: 784 /* Turn all the files into inodes and save the first one - which is the 785 * one we actually want. 786 */ 787 scb = &cookie->statuses[0]; 788 if (scb->status.abort_code != 0) 789 inode = ERR_PTR(afs_abort_to_error(scb->status.abort_code)); 790 791 for (i = 0; i < cookie->nr_fids; i++) { 792 struct afs_status_cb *scb = &cookie->statuses[i]; 793 794 if (!scb->have_status && !scb->have_error) 795 continue; 796 797 if (cookie->inodes[i]) { 798 afs_vnode_commit_status(&fc, AFS_FS_I(cookie->inodes[i]), 799 scb->cb_break, NULL, scb); 800 continue; 801 } 802 803 if (scb->status.abort_code != 0) 804 continue; 805 806 iget_data.fid = cookie->fids[i]; 807 ti = afs_iget(dir->i_sb, key, &iget_data, scb, cbi, dvnode); 808 if (!IS_ERR(ti)) 809 afs_cache_permit(AFS_FS_I(ti), key, 810 0 /* Assume vnode->cb_break is 0 */ + 811 iget_data.cb_v_break, 812 scb); 813 if (i == 0) { 814 inode = ti; 815 } else { 816 if (!IS_ERR(ti)) 817 iput(ti); 818 } 819 } 820 821 out_c: 822 afs_put_cb_interest(afs_v2net(dvnode), cbi); 823 if (cookie->inodes) { 824 for (i = 0; i < cookie->nr_fids; i++) 825 iput(cookie->inodes[i]); 826 kfree(cookie->inodes); 827 } 828 out_s: 829 kvfree(cookie->statuses); 830 out: 831 kfree(cookie); 832 return inode; 833 } 834 835 /* 836 * Look up an entry in a directory with @sys substitution. 837 */ 838 static struct dentry *afs_lookup_atsys(struct inode *dir, struct dentry *dentry, 839 struct key *key) 840 { 841 struct afs_sysnames *subs; 842 struct afs_net *net = afs_i2net(dir); 843 struct dentry *ret; 844 char *buf, *p, *name; 845 int len, i; 846 847 _enter(""); 848 849 ret = ERR_PTR(-ENOMEM); 850 p = buf = kmalloc(AFSNAMEMAX, GFP_KERNEL); 851 if (!buf) 852 goto out_p; 853 if (dentry->d_name.len > 4) { 854 memcpy(p, dentry->d_name.name, dentry->d_name.len - 4); 855 p += dentry->d_name.len - 4; 856 } 857 858 /* There is an ordered list of substitutes that we have to try. */ 859 read_lock(&net->sysnames_lock); 860 subs = net->sysnames; 861 refcount_inc(&subs->usage); 862 read_unlock(&net->sysnames_lock); 863 864 for (i = 0; i < subs->nr; i++) { 865 name = subs->subs[i]; 866 len = dentry->d_name.len - 4 + strlen(name); 867 if (len >= AFSNAMEMAX) { 868 ret = ERR_PTR(-ENAMETOOLONG); 869 goto out_s; 870 } 871 872 strcpy(p, name); 873 ret = lookup_one_len(buf, dentry->d_parent, len); 874 if (IS_ERR(ret) || d_is_positive(ret)) 875 goto out_s; 876 dput(ret); 877 } 878 879 /* We don't want to d_add() the @sys dentry here as we don't want to 880 * the cached dentry to hide changes to the sysnames list. 881 */ 882 ret = NULL; 883 out_s: 884 afs_put_sysnames(subs); 885 kfree(buf); 886 out_p: 887 key_put(key); 888 return ret; 889 } 890 891 /* 892 * look up an entry in a directory 893 */ 894 static struct dentry *afs_lookup(struct inode *dir, struct dentry *dentry, 895 unsigned int flags) 896 { 897 struct afs_vnode *dvnode = AFS_FS_I(dir); 898 struct inode *inode; 899 struct dentry *d; 900 struct key *key; 901 int ret; 902 903 _enter("{%llx:%llu},%p{%pd},", 904 dvnode->fid.vid, dvnode->fid.vnode, dentry, dentry); 905 906 ASSERTCMP(d_inode(dentry), ==, NULL); 907 908 if (dentry->d_name.len >= AFSNAMEMAX) { 909 _leave(" = -ENAMETOOLONG"); 910 return ERR_PTR(-ENAMETOOLONG); 911 } 912 913 if (test_bit(AFS_VNODE_DELETED, &dvnode->flags)) { 914 _leave(" = -ESTALE"); 915 return ERR_PTR(-ESTALE); 916 } 917 918 key = afs_request_key(dvnode->volume->cell); 919 if (IS_ERR(key)) { 920 _leave(" = %ld [key]", PTR_ERR(key)); 921 return ERR_CAST(key); 922 } 923 924 ret = afs_validate(dvnode, key); 925 if (ret < 0) { 926 key_put(key); 927 _leave(" = %d [val]", ret); 928 return ERR_PTR(ret); 929 } 930 931 if (dentry->d_name.len >= 4 && 932 dentry->d_name.name[dentry->d_name.len - 4] == '@' && 933 dentry->d_name.name[dentry->d_name.len - 3] == 's' && 934 dentry->d_name.name[dentry->d_name.len - 2] == 'y' && 935 dentry->d_name.name[dentry->d_name.len - 1] == 's') 936 return afs_lookup_atsys(dir, dentry, key); 937 938 afs_stat_v(dvnode, n_lookup); 939 inode = afs_do_lookup(dir, dentry, key); 940 key_put(key); 941 if (inode == ERR_PTR(-ENOENT)) { 942 inode = afs_try_auto_mntpt(dentry, dir); 943 } else { 944 dentry->d_fsdata = 945 (void *)(unsigned long)dvnode->status.data_version; 946 } 947 d = d_splice_alias(inode, dentry); 948 if (!IS_ERR_OR_NULL(d)) { 949 d->d_fsdata = dentry->d_fsdata; 950 trace_afs_lookup(dvnode, &d->d_name, 951 inode ? AFS_FS_I(inode) : NULL); 952 } else { 953 trace_afs_lookup(dvnode, &dentry->d_name, 954 inode ? AFS_FS_I(inode) : NULL); 955 } 956 return d; 957 } 958 959 /* 960 * check that a dentry lookup hit has found a valid entry 961 * - NOTE! the hit can be a negative hit too, so we can't assume we have an 962 * inode 963 */ 964 static int afs_d_revalidate(struct dentry *dentry, unsigned int flags) 965 { 966 struct afs_vnode *vnode, *dir; 967 struct afs_fid uninitialized_var(fid); 968 struct dentry *parent; 969 struct inode *inode; 970 struct key *key; 971 long dir_version, de_version; 972 int ret; 973 974 if (flags & LOOKUP_RCU) 975 return -ECHILD; 976 977 if (d_really_is_positive(dentry)) { 978 vnode = AFS_FS_I(d_inode(dentry)); 979 _enter("{v={%llx:%llu} n=%pd fl=%lx},", 980 vnode->fid.vid, vnode->fid.vnode, dentry, 981 vnode->flags); 982 } else { 983 _enter("{neg n=%pd}", dentry); 984 } 985 986 key = afs_request_key(AFS_FS_S(dentry->d_sb)->volume->cell); 987 if (IS_ERR(key)) 988 key = NULL; 989 990 if (d_really_is_positive(dentry)) { 991 inode = d_inode(dentry); 992 if (inode) { 993 vnode = AFS_FS_I(inode); 994 afs_validate(vnode, key); 995 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 996 goto out_bad; 997 } 998 } 999 1000 /* lock down the parent dentry so we can peer at it */ 1001 parent = dget_parent(dentry); 1002 dir = AFS_FS_I(d_inode(parent)); 1003 1004 /* validate the parent directory */ 1005 afs_validate(dir, key); 1006 1007 if (test_bit(AFS_VNODE_DELETED, &dir->flags)) { 1008 _debug("%pd: parent dir deleted", dentry); 1009 goto out_bad_parent; 1010 } 1011 1012 /* We only need to invalidate a dentry if the server's copy changed 1013 * behind our back. If we made the change, it's no problem. Note that 1014 * on a 32-bit system, we only have 32 bits in the dentry to store the 1015 * version. 1016 */ 1017 dir_version = (long)dir->status.data_version; 1018 de_version = (long)dentry->d_fsdata; 1019 if (de_version == dir_version) 1020 goto out_valid_noupdate; 1021 1022 dir_version = (long)dir->invalid_before; 1023 if (de_version - dir_version >= 0) 1024 goto out_valid; 1025 1026 _debug("dir modified"); 1027 afs_stat_v(dir, n_reval); 1028 1029 /* search the directory for this vnode */ 1030 ret = afs_do_lookup_one(&dir->vfs_inode, dentry, &fid, key); 1031 switch (ret) { 1032 case 0: 1033 /* the filename maps to something */ 1034 if (d_really_is_negative(dentry)) 1035 goto out_bad_parent; 1036 inode = d_inode(dentry); 1037 if (is_bad_inode(inode)) { 1038 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n", 1039 dentry); 1040 goto out_bad_parent; 1041 } 1042 1043 vnode = AFS_FS_I(inode); 1044 1045 /* if the vnode ID has changed, then the dirent points to a 1046 * different file */ 1047 if (fid.vnode != vnode->fid.vnode) { 1048 _debug("%pd: dirent changed [%llu != %llu]", 1049 dentry, fid.vnode, 1050 vnode->fid.vnode); 1051 goto not_found; 1052 } 1053 1054 /* if the vnode ID uniqifier has changed, then the file has 1055 * been deleted and replaced, and the original vnode ID has 1056 * been reused */ 1057 if (fid.unique != vnode->fid.unique) { 1058 _debug("%pd: file deleted (uq %u -> %u I:%u)", 1059 dentry, fid.unique, 1060 vnode->fid.unique, 1061 vnode->vfs_inode.i_generation); 1062 write_seqlock(&vnode->cb_lock); 1063 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1064 write_sequnlock(&vnode->cb_lock); 1065 goto not_found; 1066 } 1067 goto out_valid; 1068 1069 case -ENOENT: 1070 /* the filename is unknown */ 1071 _debug("%pd: dirent not found", dentry); 1072 if (d_really_is_positive(dentry)) 1073 goto not_found; 1074 goto out_valid; 1075 1076 default: 1077 _debug("failed to iterate dir %pd: %d", 1078 parent, ret); 1079 goto out_bad_parent; 1080 } 1081 1082 out_valid: 1083 dentry->d_fsdata = (void *)dir_version; 1084 out_valid_noupdate: 1085 dput(parent); 1086 key_put(key); 1087 _leave(" = 1 [valid]"); 1088 return 1; 1089 1090 /* the dirent, if it exists, now points to a different vnode */ 1091 not_found: 1092 spin_lock(&dentry->d_lock); 1093 dentry->d_flags |= DCACHE_NFSFS_RENAMED; 1094 spin_unlock(&dentry->d_lock); 1095 1096 out_bad_parent: 1097 _debug("dropping dentry %pd2", dentry); 1098 dput(parent); 1099 out_bad: 1100 key_put(key); 1101 1102 _leave(" = 0 [bad]"); 1103 return 0; 1104 } 1105 1106 /* 1107 * allow the VFS to enquire as to whether a dentry should be unhashed (mustn't 1108 * sleep) 1109 * - called from dput() when d_count is going to 0. 1110 * - return 1 to request dentry be unhashed, 0 otherwise 1111 */ 1112 static int afs_d_delete(const struct dentry *dentry) 1113 { 1114 _enter("%pd", dentry); 1115 1116 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1117 goto zap; 1118 1119 if (d_really_is_positive(dentry) && 1120 (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) || 1121 test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags))) 1122 goto zap; 1123 1124 _leave(" = 0 [keep]"); 1125 return 0; 1126 1127 zap: 1128 _leave(" = 1 [zap]"); 1129 return 1; 1130 } 1131 1132 /* 1133 * Clean up sillyrename files on dentry removal. 1134 */ 1135 static void afs_d_iput(struct dentry *dentry, struct inode *inode) 1136 { 1137 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 1138 afs_silly_iput(dentry, inode); 1139 iput(inode); 1140 } 1141 1142 /* 1143 * handle dentry release 1144 */ 1145 void afs_d_release(struct dentry *dentry) 1146 { 1147 _enter("%pd", dentry); 1148 } 1149 1150 /* 1151 * Create a new inode for create/mkdir/symlink 1152 */ 1153 static void afs_vnode_new_inode(struct afs_fs_cursor *fc, 1154 struct dentry *new_dentry, 1155 struct afs_iget_data *new_data, 1156 struct afs_status_cb *new_scb) 1157 { 1158 struct afs_vnode *vnode; 1159 struct inode *inode; 1160 1161 if (fc->ac.error < 0) 1162 return; 1163 1164 inode = afs_iget(fc->vnode->vfs_inode.i_sb, fc->key, 1165 new_data, new_scb, fc->cbi, fc->vnode); 1166 if (IS_ERR(inode)) { 1167 /* ENOMEM or EINTR at a really inconvenient time - just abandon 1168 * the new directory on the server. 1169 */ 1170 fc->ac.error = PTR_ERR(inode); 1171 return; 1172 } 1173 1174 vnode = AFS_FS_I(inode); 1175 set_bit(AFS_VNODE_NEW_CONTENT, &vnode->flags); 1176 if (fc->ac.error == 0) 1177 afs_cache_permit(vnode, fc->key, vnode->cb_break, new_scb); 1178 d_instantiate(new_dentry, inode); 1179 } 1180 1181 static void afs_prep_for_new_inode(struct afs_fs_cursor *fc, 1182 struct afs_iget_data *iget_data) 1183 { 1184 iget_data->volume = fc->vnode->volume; 1185 iget_data->cb_v_break = fc->vnode->volume->cb_v_break; 1186 iget_data->cb_s_break = fc->cbi->server->cb_s_break; 1187 } 1188 1189 /* 1190 * create a directory on an AFS filesystem 1191 */ 1192 static int afs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 1193 { 1194 struct afs_iget_data iget_data; 1195 struct afs_status_cb *scb; 1196 struct afs_fs_cursor fc; 1197 struct afs_vnode *dvnode = AFS_FS_I(dir); 1198 struct key *key; 1199 int ret; 1200 1201 mode |= S_IFDIR; 1202 1203 _enter("{%llx:%llu},{%pd},%ho", 1204 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode); 1205 1206 ret = -ENOMEM; 1207 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1208 if (!scb) 1209 goto error; 1210 1211 key = afs_request_key(dvnode->volume->cell); 1212 if (IS_ERR(key)) { 1213 ret = PTR_ERR(key); 1214 goto error_scb; 1215 } 1216 1217 ret = -ERESTARTSYS; 1218 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1219 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1220 1221 while (afs_select_fileserver(&fc)) { 1222 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1223 afs_prep_for_new_inode(&fc, &iget_data); 1224 afs_fs_create(&fc, dentry->d_name.name, mode, 1225 &scb[0], &iget_data.fid, &scb[1]); 1226 } 1227 1228 afs_check_for_remote_deletion(&fc, dvnode); 1229 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1230 &data_version, &scb[0]); 1231 afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]); 1232 ret = afs_end_vnode_operation(&fc); 1233 if (ret < 0) 1234 goto error_key; 1235 } else { 1236 goto error_key; 1237 } 1238 1239 if (ret == 0 && 1240 test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1241 afs_edit_dir_add(dvnode, &dentry->d_name, &iget_data.fid, 1242 afs_edit_dir_for_create); 1243 1244 key_put(key); 1245 kfree(scb); 1246 _leave(" = 0"); 1247 return 0; 1248 1249 error_key: 1250 key_put(key); 1251 error_scb: 1252 kfree(scb); 1253 error: 1254 d_drop(dentry); 1255 _leave(" = %d", ret); 1256 return ret; 1257 } 1258 1259 /* 1260 * Remove a subdir from a directory. 1261 */ 1262 static void afs_dir_remove_subdir(struct dentry *dentry) 1263 { 1264 if (d_really_is_positive(dentry)) { 1265 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 1266 1267 clear_nlink(&vnode->vfs_inode); 1268 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1269 clear_bit(AFS_VNODE_CB_PROMISED, &vnode->flags); 1270 clear_bit(AFS_VNODE_DIR_VALID, &vnode->flags); 1271 } 1272 } 1273 1274 /* 1275 * remove a directory from an AFS filesystem 1276 */ 1277 static int afs_rmdir(struct inode *dir, struct dentry *dentry) 1278 { 1279 struct afs_status_cb *scb; 1280 struct afs_fs_cursor fc; 1281 struct afs_vnode *dvnode = AFS_FS_I(dir), *vnode = NULL; 1282 struct key *key; 1283 int ret; 1284 1285 _enter("{%llx:%llu},{%pd}", 1286 dvnode->fid.vid, dvnode->fid.vnode, dentry); 1287 1288 scb = kzalloc(sizeof(struct afs_status_cb), GFP_KERNEL); 1289 if (!scb) 1290 return -ENOMEM; 1291 1292 key = afs_request_key(dvnode->volume->cell); 1293 if (IS_ERR(key)) { 1294 ret = PTR_ERR(key); 1295 goto error; 1296 } 1297 1298 /* Try to make sure we have a callback promise on the victim. */ 1299 if (d_really_is_positive(dentry)) { 1300 vnode = AFS_FS_I(d_inode(dentry)); 1301 ret = afs_validate(vnode, key); 1302 if (ret < 0) 1303 goto error_key; 1304 } 1305 1306 if (vnode) { 1307 ret = down_write_killable(&vnode->rmdir_lock); 1308 if (ret < 0) 1309 goto error_key; 1310 } 1311 1312 ret = -ERESTARTSYS; 1313 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1314 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1315 1316 while (afs_select_fileserver(&fc)) { 1317 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1318 afs_fs_remove(&fc, vnode, dentry->d_name.name, true, scb); 1319 } 1320 1321 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1322 &data_version, scb); 1323 ret = afs_end_vnode_operation(&fc); 1324 if (ret == 0) { 1325 afs_dir_remove_subdir(dentry); 1326 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1327 afs_edit_dir_remove(dvnode, &dentry->d_name, 1328 afs_edit_dir_for_rmdir); 1329 } 1330 } 1331 1332 if (vnode) 1333 up_write(&vnode->rmdir_lock); 1334 error_key: 1335 key_put(key); 1336 error: 1337 kfree(scb); 1338 return ret; 1339 } 1340 1341 /* 1342 * Remove a link to a file or symlink from a directory. 1343 * 1344 * If the file was not deleted due to excess hard links, the fileserver will 1345 * break the callback promise on the file - if it had one - before it returns 1346 * to us, and if it was deleted, it won't 1347 * 1348 * However, if we didn't have a callback promise outstanding, or it was 1349 * outstanding on a different server, then it won't break it either... 1350 */ 1351 static int afs_dir_remove_link(struct afs_vnode *dvnode, struct dentry *dentry, 1352 struct key *key) 1353 { 1354 int ret = 0; 1355 1356 if (d_really_is_positive(dentry)) { 1357 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 1358 1359 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) { 1360 /* Already done */ 1361 } else if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) { 1362 write_seqlock(&vnode->cb_lock); 1363 drop_nlink(&vnode->vfs_inode); 1364 if (vnode->vfs_inode.i_nlink == 0) { 1365 set_bit(AFS_VNODE_DELETED, &vnode->flags); 1366 __afs_break_callback(vnode, afs_cb_break_for_unlink); 1367 } 1368 write_sequnlock(&vnode->cb_lock); 1369 ret = 0; 1370 } else { 1371 afs_break_callback(vnode, afs_cb_break_for_unlink); 1372 1373 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 1374 kdebug("AFS_VNODE_DELETED"); 1375 1376 ret = afs_validate(vnode, key); 1377 if (ret == -ESTALE) 1378 ret = 0; 1379 } 1380 _debug("nlink %d [val %d]", vnode->vfs_inode.i_nlink, ret); 1381 } 1382 1383 return ret; 1384 } 1385 1386 /* 1387 * Remove a file or symlink from an AFS filesystem. 1388 */ 1389 static int afs_unlink(struct inode *dir, struct dentry *dentry) 1390 { 1391 struct afs_fs_cursor fc; 1392 struct afs_status_cb *scb; 1393 struct afs_vnode *dvnode = AFS_FS_I(dir); 1394 struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 1395 struct key *key; 1396 bool need_rehash = false; 1397 int ret; 1398 1399 _enter("{%llx:%llu},{%pd}", 1400 dvnode->fid.vid, dvnode->fid.vnode, dentry); 1401 1402 if (dentry->d_name.len >= AFSNAMEMAX) 1403 return -ENAMETOOLONG; 1404 1405 ret = -ENOMEM; 1406 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1407 if (!scb) 1408 goto error; 1409 1410 key = afs_request_key(dvnode->volume->cell); 1411 if (IS_ERR(key)) { 1412 ret = PTR_ERR(key); 1413 goto error_scb; 1414 } 1415 1416 /* Try to make sure we have a callback promise on the victim. */ 1417 ret = afs_validate(vnode, key); 1418 if (ret < 0) 1419 goto error_key; 1420 1421 spin_lock(&dentry->d_lock); 1422 if (d_count(dentry) > 1) { 1423 spin_unlock(&dentry->d_lock); 1424 /* Start asynchronous writeout of the inode */ 1425 write_inode_now(d_inode(dentry), 0); 1426 ret = afs_sillyrename(dvnode, vnode, dentry, key); 1427 goto error_key; 1428 } 1429 if (!d_unhashed(dentry)) { 1430 /* Prevent a race with RCU lookup. */ 1431 __d_drop(dentry); 1432 need_rehash = true; 1433 } 1434 spin_unlock(&dentry->d_lock); 1435 1436 ret = -ERESTARTSYS; 1437 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1438 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1439 afs_dataversion_t data_version_2 = vnode->status.data_version; 1440 1441 while (afs_select_fileserver(&fc)) { 1442 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1443 fc.cb_break_2 = afs_calc_vnode_cb_break(vnode); 1444 1445 if (test_bit(AFS_SERVER_FL_IS_YFS, &fc.cbi->server->flags) && 1446 !test_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags)) { 1447 yfs_fs_remove_file2(&fc, vnode, dentry->d_name.name, 1448 &scb[0], &scb[1]); 1449 if (fc.ac.error != -ECONNABORTED || 1450 fc.ac.abort_code != RXGEN_OPCODE) 1451 continue; 1452 set_bit(AFS_SERVER_FL_NO_RM2, &fc.cbi->server->flags); 1453 } 1454 1455 afs_fs_remove(&fc, vnode, dentry->d_name.name, false, &scb[0]); 1456 } 1457 1458 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1459 &data_version, &scb[0]); 1460 afs_vnode_commit_status(&fc, vnode, fc.cb_break_2, 1461 &data_version_2, &scb[1]); 1462 ret = afs_end_vnode_operation(&fc); 1463 if (ret == 0 && !(scb[1].have_status || scb[1].have_error)) 1464 ret = afs_dir_remove_link(dvnode, dentry, key); 1465 if (ret == 0 && 1466 test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1467 afs_edit_dir_remove(dvnode, &dentry->d_name, 1468 afs_edit_dir_for_unlink); 1469 } 1470 1471 if (need_rehash && ret < 0 && ret != -ENOENT) 1472 d_rehash(dentry); 1473 1474 error_key: 1475 key_put(key); 1476 error_scb: 1477 kfree(scb); 1478 error: 1479 _leave(" = %d", ret); 1480 return ret; 1481 } 1482 1483 /* 1484 * create a regular file on an AFS filesystem 1485 */ 1486 static int afs_create(struct inode *dir, struct dentry *dentry, umode_t mode, 1487 bool excl) 1488 { 1489 struct afs_iget_data iget_data; 1490 struct afs_fs_cursor fc; 1491 struct afs_status_cb *scb; 1492 struct afs_vnode *dvnode = AFS_FS_I(dir); 1493 struct key *key; 1494 int ret; 1495 1496 mode |= S_IFREG; 1497 1498 _enter("{%llx:%llu},{%pd},%ho,", 1499 dvnode->fid.vid, dvnode->fid.vnode, dentry, mode); 1500 1501 ret = -ENAMETOOLONG; 1502 if (dentry->d_name.len >= AFSNAMEMAX) 1503 goto error; 1504 1505 key = afs_request_key(dvnode->volume->cell); 1506 if (IS_ERR(key)) { 1507 ret = PTR_ERR(key); 1508 goto error; 1509 } 1510 1511 ret = -ENOMEM; 1512 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1513 if (!scb) 1514 goto error_scb; 1515 1516 ret = -ERESTARTSYS; 1517 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1518 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1519 1520 while (afs_select_fileserver(&fc)) { 1521 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1522 afs_prep_for_new_inode(&fc, &iget_data); 1523 afs_fs_create(&fc, dentry->d_name.name, mode, 1524 &scb[0], &iget_data.fid, &scb[1]); 1525 } 1526 1527 afs_check_for_remote_deletion(&fc, dvnode); 1528 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1529 &data_version, &scb[0]); 1530 afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]); 1531 ret = afs_end_vnode_operation(&fc); 1532 if (ret < 0) 1533 goto error_key; 1534 } else { 1535 goto error_key; 1536 } 1537 1538 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1539 afs_edit_dir_add(dvnode, &dentry->d_name, &iget_data.fid, 1540 afs_edit_dir_for_create); 1541 1542 kfree(scb); 1543 key_put(key); 1544 _leave(" = 0"); 1545 return 0; 1546 1547 error_scb: 1548 kfree(scb); 1549 error_key: 1550 key_put(key); 1551 error: 1552 d_drop(dentry); 1553 _leave(" = %d", ret); 1554 return ret; 1555 } 1556 1557 /* 1558 * create a hard link between files in an AFS filesystem 1559 */ 1560 static int afs_link(struct dentry *from, struct inode *dir, 1561 struct dentry *dentry) 1562 { 1563 struct afs_fs_cursor fc; 1564 struct afs_status_cb *scb; 1565 struct afs_vnode *dvnode = AFS_FS_I(dir); 1566 struct afs_vnode *vnode = AFS_FS_I(d_inode(from)); 1567 struct key *key; 1568 int ret; 1569 1570 _enter("{%llx:%llu},{%llx:%llu},{%pd}", 1571 vnode->fid.vid, vnode->fid.vnode, 1572 dvnode->fid.vid, dvnode->fid.vnode, 1573 dentry); 1574 1575 ret = -ENAMETOOLONG; 1576 if (dentry->d_name.len >= AFSNAMEMAX) 1577 goto error; 1578 1579 ret = -ENOMEM; 1580 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1581 if (!scb) 1582 goto error; 1583 1584 key = afs_request_key(dvnode->volume->cell); 1585 if (IS_ERR(key)) { 1586 ret = PTR_ERR(key); 1587 goto error_scb; 1588 } 1589 1590 ret = -ERESTARTSYS; 1591 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1592 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1593 1594 if (mutex_lock_interruptible_nested(&vnode->io_lock, 1) < 0) { 1595 afs_end_vnode_operation(&fc); 1596 goto error_key; 1597 } 1598 1599 while (afs_select_fileserver(&fc)) { 1600 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1601 fc.cb_break_2 = afs_calc_vnode_cb_break(vnode); 1602 afs_fs_link(&fc, vnode, dentry->d_name.name, 1603 &scb[0], &scb[1]); 1604 } 1605 1606 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1607 &data_version, &scb[0]); 1608 afs_vnode_commit_status(&fc, vnode, fc.cb_break_2, 1609 NULL, &scb[1]); 1610 ihold(&vnode->vfs_inode); 1611 d_instantiate(dentry, &vnode->vfs_inode); 1612 1613 mutex_unlock(&vnode->io_lock); 1614 ret = afs_end_vnode_operation(&fc); 1615 if (ret < 0) 1616 goto error_key; 1617 } else { 1618 goto error_key; 1619 } 1620 1621 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1622 afs_edit_dir_add(dvnode, &dentry->d_name, &vnode->fid, 1623 afs_edit_dir_for_link); 1624 1625 key_put(key); 1626 kfree(scb); 1627 _leave(" = 0"); 1628 return 0; 1629 1630 error_key: 1631 key_put(key); 1632 error_scb: 1633 kfree(scb); 1634 error: 1635 d_drop(dentry); 1636 _leave(" = %d", ret); 1637 return ret; 1638 } 1639 1640 /* 1641 * create a symlink in an AFS filesystem 1642 */ 1643 static int afs_symlink(struct inode *dir, struct dentry *dentry, 1644 const char *content) 1645 { 1646 struct afs_iget_data iget_data; 1647 struct afs_fs_cursor fc; 1648 struct afs_status_cb *scb; 1649 struct afs_vnode *dvnode = AFS_FS_I(dir); 1650 struct key *key; 1651 int ret; 1652 1653 _enter("{%llx:%llu},{%pd},%s", 1654 dvnode->fid.vid, dvnode->fid.vnode, dentry, 1655 content); 1656 1657 ret = -ENAMETOOLONG; 1658 if (dentry->d_name.len >= AFSNAMEMAX) 1659 goto error; 1660 1661 ret = -EINVAL; 1662 if (strlen(content) >= AFSPATHMAX) 1663 goto error; 1664 1665 ret = -ENOMEM; 1666 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1667 if (!scb) 1668 goto error; 1669 1670 key = afs_request_key(dvnode->volume->cell); 1671 if (IS_ERR(key)) { 1672 ret = PTR_ERR(key); 1673 goto error_scb; 1674 } 1675 1676 ret = -ERESTARTSYS; 1677 if (afs_begin_vnode_operation(&fc, dvnode, key, true)) { 1678 afs_dataversion_t data_version = dvnode->status.data_version + 1; 1679 1680 while (afs_select_fileserver(&fc)) { 1681 fc.cb_break = afs_calc_vnode_cb_break(dvnode); 1682 afs_prep_for_new_inode(&fc, &iget_data); 1683 afs_fs_symlink(&fc, dentry->d_name.name, content, 1684 &scb[0], &iget_data.fid, &scb[1]); 1685 } 1686 1687 afs_check_for_remote_deletion(&fc, dvnode); 1688 afs_vnode_commit_status(&fc, dvnode, fc.cb_break, 1689 &data_version, &scb[0]); 1690 afs_vnode_new_inode(&fc, dentry, &iget_data, &scb[1]); 1691 ret = afs_end_vnode_operation(&fc); 1692 if (ret < 0) 1693 goto error_key; 1694 } else { 1695 goto error_key; 1696 } 1697 1698 if (test_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1699 afs_edit_dir_add(dvnode, &dentry->d_name, &iget_data.fid, 1700 afs_edit_dir_for_symlink); 1701 1702 key_put(key); 1703 kfree(scb); 1704 _leave(" = 0"); 1705 return 0; 1706 1707 error_key: 1708 key_put(key); 1709 error_scb: 1710 kfree(scb); 1711 error: 1712 d_drop(dentry); 1713 _leave(" = %d", ret); 1714 return ret; 1715 } 1716 1717 /* 1718 * rename a file in an AFS filesystem and/or move it between directories 1719 */ 1720 static int afs_rename(struct inode *old_dir, struct dentry *old_dentry, 1721 struct inode *new_dir, struct dentry *new_dentry, 1722 unsigned int flags) 1723 { 1724 struct afs_fs_cursor fc; 1725 struct afs_status_cb *scb; 1726 struct afs_vnode *orig_dvnode, *new_dvnode, *vnode; 1727 struct dentry *tmp = NULL, *rehash = NULL; 1728 struct inode *new_inode; 1729 struct key *key; 1730 bool new_negative = d_is_negative(new_dentry); 1731 int ret; 1732 1733 if (flags) 1734 return -EINVAL; 1735 1736 /* Don't allow silly-rename files be moved around. */ 1737 if (old_dentry->d_flags & DCACHE_NFSFS_RENAMED) 1738 return -EINVAL; 1739 1740 vnode = AFS_FS_I(d_inode(old_dentry)); 1741 orig_dvnode = AFS_FS_I(old_dir); 1742 new_dvnode = AFS_FS_I(new_dir); 1743 1744 _enter("{%llx:%llu},{%llx:%llu},{%llx:%llu},{%pd}", 1745 orig_dvnode->fid.vid, orig_dvnode->fid.vnode, 1746 vnode->fid.vid, vnode->fid.vnode, 1747 new_dvnode->fid.vid, new_dvnode->fid.vnode, 1748 new_dentry); 1749 1750 ret = -ENOMEM; 1751 scb = kcalloc(2, sizeof(struct afs_status_cb), GFP_KERNEL); 1752 if (!scb) 1753 goto error; 1754 1755 key = afs_request_key(orig_dvnode->volume->cell); 1756 if (IS_ERR(key)) { 1757 ret = PTR_ERR(key); 1758 goto error_scb; 1759 } 1760 1761 /* For non-directories, check whether the target is busy and if so, 1762 * make a copy of the dentry and then do a silly-rename. If the 1763 * silly-rename succeeds, the copied dentry is hashed and becomes the 1764 * new target. 1765 */ 1766 if (d_is_positive(new_dentry) && !d_is_dir(new_dentry)) { 1767 /* To prevent any new references to the target during the 1768 * rename, we unhash the dentry in advance. 1769 */ 1770 if (!d_unhashed(new_dentry)) { 1771 d_drop(new_dentry); 1772 rehash = new_dentry; 1773 } 1774 1775 if (d_count(new_dentry) > 2) { 1776 /* copy the target dentry's name */ 1777 ret = -ENOMEM; 1778 tmp = d_alloc(new_dentry->d_parent, 1779 &new_dentry->d_name); 1780 if (!tmp) 1781 goto error_rehash; 1782 1783 ret = afs_sillyrename(new_dvnode, 1784 AFS_FS_I(d_inode(new_dentry)), 1785 new_dentry, key); 1786 if (ret) 1787 goto error_rehash; 1788 1789 new_dentry = tmp; 1790 rehash = NULL; 1791 new_negative = true; 1792 } 1793 } 1794 1795 ret = -ERESTARTSYS; 1796 if (afs_begin_vnode_operation(&fc, orig_dvnode, key, true)) { 1797 afs_dataversion_t orig_data_version; 1798 afs_dataversion_t new_data_version; 1799 struct afs_status_cb *new_scb = &scb[1]; 1800 1801 orig_data_version = orig_dvnode->status.data_version + 1; 1802 1803 if (orig_dvnode != new_dvnode) { 1804 if (mutex_lock_interruptible_nested(&new_dvnode->io_lock, 1) < 0) { 1805 afs_end_vnode_operation(&fc); 1806 goto error_rehash; 1807 } 1808 new_data_version = new_dvnode->status.data_version + 1; 1809 } else { 1810 new_data_version = orig_data_version; 1811 new_scb = &scb[0]; 1812 } 1813 1814 while (afs_select_fileserver(&fc)) { 1815 fc.cb_break = afs_calc_vnode_cb_break(orig_dvnode); 1816 fc.cb_break_2 = afs_calc_vnode_cb_break(new_dvnode); 1817 afs_fs_rename(&fc, old_dentry->d_name.name, 1818 new_dvnode, new_dentry->d_name.name, 1819 &scb[0], new_scb); 1820 } 1821 1822 afs_vnode_commit_status(&fc, orig_dvnode, fc.cb_break, 1823 &orig_data_version, &scb[0]); 1824 if (new_dvnode != orig_dvnode) { 1825 afs_vnode_commit_status(&fc, new_dvnode, fc.cb_break_2, 1826 &new_data_version, &scb[1]); 1827 mutex_unlock(&new_dvnode->io_lock); 1828 } 1829 ret = afs_end_vnode_operation(&fc); 1830 if (ret < 0) 1831 goto error_rehash; 1832 } 1833 1834 if (ret == 0) { 1835 if (rehash) 1836 d_rehash(rehash); 1837 if (test_bit(AFS_VNODE_DIR_VALID, &orig_dvnode->flags)) 1838 afs_edit_dir_remove(orig_dvnode, &old_dentry->d_name, 1839 afs_edit_dir_for_rename_0); 1840 1841 if (!new_negative && 1842 test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags)) 1843 afs_edit_dir_remove(new_dvnode, &new_dentry->d_name, 1844 afs_edit_dir_for_rename_1); 1845 1846 if (test_bit(AFS_VNODE_DIR_VALID, &new_dvnode->flags)) 1847 afs_edit_dir_add(new_dvnode, &new_dentry->d_name, 1848 &vnode->fid, afs_edit_dir_for_rename_2); 1849 1850 new_inode = d_inode(new_dentry); 1851 if (new_inode) { 1852 spin_lock(&new_inode->i_lock); 1853 if (new_inode->i_nlink > 0) 1854 drop_nlink(new_inode); 1855 spin_unlock(&new_inode->i_lock); 1856 } 1857 d_move(old_dentry, new_dentry); 1858 goto error_tmp; 1859 } 1860 1861 error_rehash: 1862 if (rehash) 1863 d_rehash(rehash); 1864 error_tmp: 1865 if (tmp) 1866 dput(tmp); 1867 key_put(key); 1868 error_scb: 1869 kfree(scb); 1870 error: 1871 _leave(" = %d", ret); 1872 return ret; 1873 } 1874 1875 /* 1876 * Release a directory page and clean up its private state if it's not busy 1877 * - return true if the page can now be released, false if not 1878 */ 1879 static int afs_dir_releasepage(struct page *page, gfp_t gfp_flags) 1880 { 1881 struct afs_vnode *dvnode = AFS_FS_I(page->mapping->host); 1882 1883 _enter("{{%llx:%llu}[%lu]}", dvnode->fid.vid, dvnode->fid.vnode, page->index); 1884 1885 set_page_private(page, 0); 1886 ClearPagePrivate(page); 1887 1888 /* The directory will need reloading. */ 1889 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1890 afs_stat_v(dvnode, n_relpg); 1891 return 1; 1892 } 1893 1894 /* 1895 * invalidate part or all of a page 1896 * - release a page and clean up its private data if offset is 0 (indicating 1897 * the entire page) 1898 */ 1899 static void afs_dir_invalidatepage(struct page *page, unsigned int offset, 1900 unsigned int length) 1901 { 1902 struct afs_vnode *dvnode = AFS_FS_I(page->mapping->host); 1903 1904 _enter("{%lu},%u,%u", page->index, offset, length); 1905 1906 BUG_ON(!PageLocked(page)); 1907 1908 /* The directory will need reloading. */ 1909 if (test_and_clear_bit(AFS_VNODE_DIR_VALID, &dvnode->flags)) 1910 afs_stat_v(dvnode, n_inval); 1911 1912 /* we clean up only if the entire page is being invalidated */ 1913 if (offset == 0 && length == PAGE_SIZE) { 1914 set_page_private(page, 0); 1915 ClearPagePrivate(page); 1916 } 1917 } 1918