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