Merge tag 'vfs-6.15-rc1.afs' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs

+50

fs/afs/addr_list.c

··· 362 362 alist->nr_addrs++; 363 363 return 0; 364 364 } 365 + 366 + /* 367 + * Set the app data on the rxrpc peers an address list points to 368 + */ 369 + void afs_set_peer_appdata(struct afs_server *server, 370 + struct afs_addr_list *old_alist, 371 + struct afs_addr_list *new_alist) 372 + { 373 + unsigned long data = (unsigned long)server; 374 + int n = 0, o = 0; 375 + 376 + if (!old_alist) { 377 + /* New server. Just set all. */ 378 + for (; n < new_alist->nr_addrs; n++) 379 + rxrpc_kernel_set_peer_data(new_alist->addrs[n].peer, data); 380 + return; 381 + } 382 + if (!new_alist) { 383 + /* Dead server. Just remove all. */ 384 + for (; o < old_alist->nr_addrs; o++) 385 + rxrpc_kernel_set_peer_data(old_alist->addrs[o].peer, 0); 386 + return; 387 + } 388 + 389 + /* Walk through the two lists simultaneously, setting new peers and 390 + * clearing old ones. The two lists are ordered by pointer to peer 391 + * record. 392 + */ 393 + while (n < new_alist->nr_addrs && o < old_alist->nr_addrs) { 394 + struct rxrpc_peer *pn = new_alist->addrs[n].peer; 395 + struct rxrpc_peer *po = old_alist->addrs[o].peer; 396 + 397 + if (pn == po) 398 + continue; 399 + if (pn < po) { 400 + rxrpc_kernel_set_peer_data(pn, data); 401 + n++; 402 + } else { 403 + rxrpc_kernel_set_peer_data(po, 0); 404 + o++; 405 + } 406 + } 407 + 408 + if (n < new_alist->nr_addrs) 409 + for (; n < new_alist->nr_addrs; n++) 410 + rxrpc_kernel_set_peer_data(new_alist->addrs[n].peer, data); 411 + if (o < old_alist->nr_addrs) 412 + for (; o < old_alist->nr_addrs; o++) 413 + rxrpc_kernel_set_peer_data(old_alist->addrs[o].peer, 0); 414 + }

+186 -255

fs/afs/cell.c

··· 20 20 static unsigned __read_mostly afs_cell_max_ttl = 24 * 60 * 60; 21 21 static atomic_t cell_debug_id; 22 22 23 - static void afs_queue_cell_manager(struct afs_net *); 24 - static void afs_manage_cell_work(struct work_struct *); 23 + static void afs_cell_timer(struct timer_list *timer); 24 + static void afs_destroy_cell_work(struct work_struct *work); 25 + static void afs_manage_cell_work(struct work_struct *work); 25 26 26 27 static void afs_dec_cells_outstanding(struct afs_net *net) 27 28 { ··· 30 29 wake_up_var(&net->cells_outstanding); 31 30 } 32 31 33 - /* 34 - * Set the cell timer to fire after a given delay, assuming it's not already 35 - * set for an earlier time. 36 - */ 37 - static void afs_set_cell_timer(struct afs_net *net, time64_t delay) 32 + static void afs_set_cell_state(struct afs_cell *cell, enum afs_cell_state state) 38 33 { 39 - if (net->live) { 40 - atomic_inc(&net->cells_outstanding); 41 - if (timer_reduce(&net->cells_timer, jiffies + delay * HZ)) 42 - afs_dec_cells_outstanding(net); 43 - } else { 44 - afs_queue_cell_manager(net); 45 - } 34 + smp_store_release(&cell->state, state); /* Commit cell changes before state */ 35 + smp_wmb(); /* Set cell state before task state */ 36 + wake_up_var(&cell->state); 46 37 } 47 38 48 39 /* ··· 109 116 const char *name, unsigned int namelen, 110 117 const char *addresses) 111 118 { 112 - struct afs_vlserver_list *vllist; 119 + struct afs_vlserver_list *vllist = NULL; 113 120 struct afs_cell *cell; 114 121 int i, ret; 115 122 ··· 156 163 cell->net = net; 157 164 refcount_set(&cell->ref, 1); 158 165 atomic_set(&cell->active, 0); 166 + INIT_WORK(&cell->destroyer, afs_destroy_cell_work); 159 167 INIT_WORK(&cell->manager, afs_manage_cell_work); 168 + timer_setup(&cell->management_timer, afs_cell_timer, 0); 160 169 init_rwsem(&cell->vs_lock); 161 170 cell->volumes = RB_ROOT; 162 171 INIT_HLIST_HEAD(&cell->proc_volumes); 163 172 seqlock_init(&cell->volume_lock); 164 173 cell->fs_servers = RB_ROOT; 165 - seqlock_init(&cell->fs_lock); 174 + init_rwsem(&cell->fs_lock); 166 175 rwlock_init(&cell->vl_servers_lock); 167 176 cell->flags = (1 << AFS_CELL_FL_CHECK_ALIAS); 168 177 ··· 199 204 cell->dns_status = vllist->status; 200 205 smp_store_release(&cell->dns_lookup_count, 1); /* vs source/status */ 201 206 atomic_inc(&net->cells_outstanding); 207 + ret = idr_alloc_cyclic(&net->cells_dyn_ino, cell, 208 + 2, INT_MAX / 2, GFP_KERNEL); 209 + if (ret < 0) 210 + goto error; 211 + cell->dynroot_ino = ret; 202 212 cell->debug_id = atomic_inc_return(&cell_debug_id); 213 + 203 214 trace_afs_cell(cell->debug_id, 1, 0, afs_cell_trace_alloc); 204 215 205 216 _leave(" = %p", cell); ··· 215 214 if (ret == -EINVAL) 216 215 printk(KERN_ERR "kAFS: bad VL server IP address\n"); 217 216 error: 217 + afs_put_vlserverlist(cell->net, vllist); 218 218 kfree(cell->name - 1); 219 219 kfree(cell); 220 220 _leave(" = %d", ret); ··· 229 227 * @namesz: The strlen of the cell name. 230 228 * @vllist: A colon/comma separated list of numeric IP addresses or NULL. 231 229 * @excl: T if an error should be given if the cell name already exists. 230 + * @trace: The reason to be logged if the lookup is successful. 232 231 * 233 232 * Look up a cell record by name and query the DNS for VL server addresses if 234 233 * needed. Note that that actual DNS query is punted off to the manager thread ··· 238 235 */ 239 236 struct afs_cell *afs_lookup_cell(struct afs_net *net, 240 237 const char *name, unsigned int namesz, 241 - const char *vllist, bool excl) 238 + const char *vllist, bool excl, 239 + enum afs_cell_trace trace) 242 240 { 243 241 struct afs_cell *cell, *candidate, *cursor; 244 242 struct rb_node *parent, **pp; ··· 249 245 _enter("%s,%s", name, vllist); 250 246 251 247 if (!excl) { 252 - cell = afs_find_cell(net, name, namesz, afs_cell_trace_use_lookup); 248 + cell = afs_find_cell(net, name, namesz, trace); 253 249 if (!IS_ERR(cell)) 254 250 goto wait_for_cell; 255 251 } ··· 292 288 293 289 cell = candidate; 294 290 candidate = NULL; 295 - atomic_set(&cell->active, 2); 296 - trace_afs_cell(cell->debug_id, refcount_read(&cell->ref), 2, afs_cell_trace_insert); 291 + afs_use_cell(cell, trace); 297 292 rb_link_node_rcu(&cell->net_node, parent, pp); 298 293 rb_insert_color(&cell->net_node, &net->cells); 299 294 up_write(&net->cells_lock); 300 295 301 - afs_queue_cell(cell, afs_cell_trace_get_queue_new); 296 + afs_queue_cell(cell, afs_cell_trace_queue_new); 302 297 303 298 wait_for_cell: 304 - trace_afs_cell(cell->debug_id, refcount_read(&cell->ref), atomic_read(&cell->active), 305 - afs_cell_trace_wait); 306 299 _debug("wait_for_cell"); 307 - wait_var_event(&cell->state, 308 - ({ 309 - state = smp_load_acquire(&cell->state); /* vs error */ 310 - state == AFS_CELL_ACTIVE || state == AFS_CELL_REMOVED; 311 - })); 300 + state = smp_load_acquire(&cell->state); /* vs error */ 301 + if (state != AFS_CELL_ACTIVE && 302 + state != AFS_CELL_DEAD) { 303 + afs_see_cell(cell, afs_cell_trace_wait); 304 + wait_var_event(&cell->state, 305 + ({ 306 + state = smp_load_acquire(&cell->state); /* vs error */ 307 + state == AFS_CELL_ACTIVE || state == AFS_CELL_DEAD; 308 + })); 309 + } 312 310 313 311 /* Check the state obtained from the wait check. */ 314 - if (state == AFS_CELL_REMOVED) { 312 + if (state == AFS_CELL_DEAD) { 315 313 ret = cell->error; 316 314 goto error; 317 315 } ··· 327 321 if (excl) { 328 322 ret = -EEXIST; 329 323 } else { 330 - afs_use_cell(cursor, afs_cell_trace_use_lookup); 324 + afs_use_cell(cursor, trace); 331 325 ret = 0; 332 326 } 333 327 up_write(&net->cells_lock); ··· 337 331 goto wait_for_cell; 338 332 goto error_noput; 339 333 error: 340 - afs_unuse_cell(net, cell, afs_cell_trace_unuse_lookup); 334 + afs_unuse_cell(cell, afs_cell_trace_unuse_lookup_error); 341 335 error_noput: 342 336 _leave(" = %d [error]", ret); 343 337 return ERR_PTR(ret); ··· 382 376 if (cp && cp < rootcell + len) 383 377 return -EINVAL; 384 378 385 - /* allocate a cell record for the root cell */ 386 - new_root = afs_lookup_cell(net, rootcell, len, vllist, false); 379 + /* allocate a cell record for the root/workstation cell */ 380 + new_root = afs_lookup_cell(net, rootcell, len, vllist, false, 381 + afs_cell_trace_use_lookup_ws); 387 382 if (IS_ERR(new_root)) { 388 383 _leave(" = %ld", PTR_ERR(new_root)); 389 384 return PTR_ERR(new_root); ··· 395 388 396 389 /* install the new cell */ 397 390 down_write(&net->cells_lock); 398 - afs_see_cell(new_root, afs_cell_trace_see_ws); 399 391 old_root = rcu_replace_pointer(net->ws_cell, new_root, 400 392 lockdep_is_held(&net->cells_lock)); 401 393 up_write(&net->cells_lock); 402 394 403 - afs_unuse_cell(net, old_root, afs_cell_trace_unuse_ws); 395 + afs_unuse_cell(old_root, afs_cell_trace_unuse_ws); 404 396 _leave(" = 0"); 405 397 return 0; 406 398 } ··· 517 511 trace_afs_cell(cell->debug_id, r, atomic_read(&cell->active), afs_cell_trace_free); 518 512 519 513 afs_put_vlserverlist(net, rcu_access_pointer(cell->vl_servers)); 520 - afs_unuse_cell(net, cell->alias_of, afs_cell_trace_unuse_alias); 514 + afs_unuse_cell(cell->alias_of, afs_cell_trace_unuse_alias); 521 515 key_put(cell->anonymous_key); 516 + idr_remove(&net->cells_dyn_ino, cell->dynroot_ino); 522 517 kfree(cell->name - 1); 523 518 kfree(cell); 524 519 ··· 527 520 _leave(" [destroyed]"); 528 521 } 529 522 530 - /* 531 - * Queue the cell manager. 532 - */ 533 - static void afs_queue_cell_manager(struct afs_net *net) 523 + static void afs_destroy_cell_work(struct work_struct *work) 534 524 { 535 - int outstanding = atomic_inc_return(&net->cells_outstanding); 525 + struct afs_cell *cell = container_of(work, struct afs_cell, destroyer); 536 526 537 - _enter("%d", outstanding); 538 - 539 - if (!queue_work(afs_wq, &net->cells_manager)) 540 - afs_dec_cells_outstanding(net); 541 - } 542 - 543 - /* 544 - * Cell management timer. We have an increment on cells_outstanding that we 545 - * need to pass along to the work item. 546 - */ 547 - void afs_cells_timer(struct timer_list *timer) 548 - { 549 - struct afs_net *net = container_of(timer, struct afs_net, cells_timer); 550 - 551 - _enter(""); 552 - if (!queue_work(afs_wq, &net->cells_manager)) 553 - afs_dec_cells_outstanding(net); 527 + afs_see_cell(cell, afs_cell_trace_destroy); 528 + timer_delete_sync(&cell->management_timer); 529 + cancel_work_sync(&cell->manager); 530 + call_rcu(&cell->rcu, afs_cell_destroy); 554 531 } 555 532 556 533 /* ··· 566 575 if (zero) { 567 576 a = atomic_read(&cell->active); 568 577 WARN(a != 0, "Cell active count %u > 0\n", a); 569 - call_rcu(&cell->rcu, afs_cell_destroy); 578 + WARN_ON(!queue_work(afs_wq, &cell->destroyer)); 570 579 } 571 580 } 572 581 } ··· 578 587 { 579 588 int r, a; 580 589 581 - r = refcount_read(&cell->ref); 582 - WARN_ON(r == 0); 590 + __refcount_inc(&cell->ref, &r); 583 591 a = atomic_inc_return(&cell->active); 584 - trace_afs_cell(cell->debug_id, r, a, reason); 592 + trace_afs_cell(cell->debug_id, r + 1, a, reason); 585 593 return cell; 586 594 } 587 595 ··· 588 598 * Record a cell becoming less active. When the active counter reaches 1, it 589 599 * is scheduled for destruction, but may get reactivated. 590 600 */ 591 - void afs_unuse_cell(struct afs_net *net, struct afs_cell *cell, enum afs_cell_trace reason) 601 + void afs_unuse_cell(struct afs_cell *cell, enum afs_cell_trace reason) 592 602 { 593 603 unsigned int debug_id; 594 604 time64_t now, expire_delay; 605 + bool zero; 595 606 int r, a; 596 607 597 608 if (!cell) ··· 607 616 expire_delay = afs_cell_gc_delay; 608 617 609 618 debug_id = cell->debug_id; 610 - r = refcount_read(&cell->ref); 611 619 a = atomic_dec_return(&cell->active); 612 - trace_afs_cell(debug_id, r, a, reason); 613 - WARN_ON(a == 0); 614 - if (a == 1) 620 + if (!a) 615 621 /* 'cell' may now be garbage collected. */ 616 - afs_set_cell_timer(net, expire_delay); 622 + afs_set_cell_timer(cell, expire_delay); 623 + 624 + zero = __refcount_dec_and_test(&cell->ref, &r); 625 + trace_afs_cell(debug_id, r - 1, a, reason); 626 + if (zero) 627 + WARN_ON(!queue_work(afs_wq, &cell->destroyer)); 617 628 } 618 629 619 630 /* ··· 635 642 */ 636 643 void afs_queue_cell(struct afs_cell *cell, enum afs_cell_trace reason) 637 644 { 638 - afs_get_cell(cell, reason); 639 - if (!queue_work(afs_wq, &cell->manager)) 640 - afs_put_cell(cell, afs_cell_trace_put_queue_fail); 645 + queue_work(afs_wq, &cell->manager); 646 + } 647 + 648 + /* 649 + * Cell-specific management timer. 650 + */ 651 + static void afs_cell_timer(struct timer_list *timer) 652 + { 653 + struct afs_cell *cell = container_of(timer, struct afs_cell, management_timer); 654 + 655 + afs_see_cell(cell, afs_cell_trace_see_mgmt_timer); 656 + if (refcount_read(&cell->ref) > 0 && cell->net->live) 657 + queue_work(afs_wq, &cell->manager); 658 + } 659 + 660 + /* 661 + * Set/reduce the cell timer. 662 + */ 663 + void afs_set_cell_timer(struct afs_cell *cell, unsigned int delay_secs) 664 + { 665 + timer_reduce(&cell->management_timer, jiffies + delay_secs * HZ); 641 666 } 642 667 643 668 /* ··· 717 706 if (cell->proc_link.next) 718 707 cell->proc_link.next->pprev = &cell->proc_link.next; 719 708 720 - afs_dynroot_mkdir(net, cell); 721 709 mutex_unlock(&net->proc_cells_lock); 722 710 return 0; 723 711 } ··· 733 723 mutex_lock(&net->proc_cells_lock); 734 724 if (!hlist_unhashed(&cell->proc_link)) 735 725 hlist_del_rcu(&cell->proc_link); 736 - afs_dynroot_rmdir(net, cell); 737 726 mutex_unlock(&net->proc_cells_lock); 738 727 739 728 _leave(""); 729 + } 730 + 731 + static bool afs_has_cell_expired(struct afs_cell *cell, time64_t *_next_manage) 732 + { 733 + const struct afs_vlserver_list *vllist; 734 + time64_t expire_at = cell->last_inactive; 735 + time64_t now = ktime_get_real_seconds(); 736 + 737 + if (atomic_read(&cell->active)) 738 + return false; 739 + if (!cell->net->live) 740 + return true; 741 + 742 + vllist = rcu_dereference_protected(cell->vl_servers, true); 743 + if (vllist && vllist->nr_servers > 0) 744 + expire_at += afs_cell_gc_delay; 745 + 746 + if (expire_at <= now) 747 + return true; 748 + if (expire_at < *_next_manage) 749 + *_next_manage = expire_at; 750 + return false; 740 751 } 741 752 742 753 /* 743 754 * Manage a cell record, initialising and destroying it, maintaining its DNS 744 755 * records. 745 756 */ 746 - static void afs_manage_cell(struct afs_cell *cell) 757 + static bool afs_manage_cell(struct afs_cell *cell) 747 758 { 748 759 struct afs_net *net = cell->net; 749 - int ret, active; 760 + time64_t next_manage = TIME64_MAX; 761 + int ret; 750 762 751 763 _enter("%s", cell->name); 752 764 753 - again: 754 765 _debug("state %u", cell->state); 755 766 switch (cell->state) { 756 - case AFS_CELL_INACTIVE: 757 - case AFS_CELL_FAILED: 758 - down_write(&net->cells_lock); 759 - active = 1; 760 - if (atomic_try_cmpxchg_relaxed(&cell->active, &active, 0)) { 761 - rb_erase(&cell->net_node, &net->cells); 762 - trace_afs_cell(cell->debug_id, refcount_read(&cell->ref), 0, 763 - afs_cell_trace_unuse_delete); 764 - smp_store_release(&cell->state, AFS_CELL_REMOVED); 765 - } 766 - up_write(&net->cells_lock); 767 - if (cell->state == AFS_CELL_REMOVED) { 768 - wake_up_var(&cell->state); 769 - goto final_destruction; 770 - } 771 - if (cell->state == AFS_CELL_FAILED) 772 - goto done; 773 - smp_store_release(&cell->state, AFS_CELL_UNSET); 774 - wake_up_var(&cell->state); 775 - goto again; 776 - 777 - case AFS_CELL_UNSET: 778 - smp_store_release(&cell->state, AFS_CELL_ACTIVATING); 779 - wake_up_var(&cell->state); 780 - goto again; 781 - 782 - case AFS_CELL_ACTIVATING: 783 - ret = afs_activate_cell(net, cell); 784 - if (ret < 0) 785 - goto activation_failed; 786 - 787 - smp_store_release(&cell->state, AFS_CELL_ACTIVE); 788 - wake_up_var(&cell->state); 789 - goto again; 790 - 767 + case AFS_CELL_SETTING_UP: 768 + goto set_up_cell; 791 769 case AFS_CELL_ACTIVE: 792 - if (atomic_read(&cell->active) > 1) { 793 - if (test_and_clear_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags)) { 794 - ret = afs_update_cell(cell); 795 - if (ret < 0) 796 - cell->error = ret; 797 - } 798 - goto done; 799 - } 800 - smp_store_release(&cell->state, AFS_CELL_DEACTIVATING); 801 - wake_up_var(&cell->state); 802 - goto again; 803 - 804 - case AFS_CELL_DEACTIVATING: 805 - if (atomic_read(&cell->active) > 1) 806 - goto reverse_deactivation; 807 - afs_deactivate_cell(net, cell); 808 - smp_store_release(&cell->state, AFS_CELL_INACTIVE); 809 - wake_up_var(&cell->state); 810 - goto again; 811 - 812 - case AFS_CELL_REMOVED: 813 - goto done; 814 - 770 + goto cell_is_active; 771 + case AFS_CELL_REMOVING: 772 + WARN_ON_ONCE(1); 773 + return false; 774 + case AFS_CELL_DEAD: 775 + return false; 815 776 default: 816 - break; 777 + _debug("bad state %u", cell->state); 778 + WARN_ON_ONCE(1); /* Unhandled state */ 779 + return false; 817 780 } 818 - _debug("bad state %u", cell->state); 819 - BUG(); /* Unhandled state */ 820 781 821 - activation_failed: 822 - cell->error = ret; 823 - afs_deactivate_cell(net, cell); 782 + set_up_cell: 783 + ret = afs_activate_cell(net, cell); 784 + if (ret < 0) { 785 + cell->error = ret; 786 + goto remove_cell; 787 + } 824 788 825 - smp_store_release(&cell->state, AFS_CELL_FAILED); /* vs error */ 826 - wake_up_var(&cell->state); 827 - goto again; 789 + afs_set_cell_state(cell, AFS_CELL_ACTIVE); 828 790 829 - reverse_deactivation: 830 - smp_store_release(&cell->state, AFS_CELL_ACTIVE); 831 - wake_up_var(&cell->state); 832 - _leave(" [deact->act]"); 833 - return; 791 + cell_is_active: 792 + if (afs_has_cell_expired(cell, &next_manage)) 793 + goto remove_cell; 834 794 835 - done: 795 + if (test_and_clear_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags)) { 796 + ret = afs_update_cell(cell); 797 + if (ret < 0) 798 + cell->error = ret; 799 + } 800 + 801 + if (next_manage < TIME64_MAX && cell->net->live) { 802 + time64_t now = ktime_get_real_seconds(); 803 + 804 + if (next_manage - now <= 0) 805 + afs_queue_cell(cell, afs_cell_trace_queue_again); 806 + else 807 + afs_set_cell_timer(cell, next_manage - now); 808 + } 836 809 _leave(" [done %u]", cell->state); 837 - return; 810 + return false; 838 811 839 - final_destruction: 812 + remove_cell: 813 + down_write(&net->cells_lock); 814 + 815 + if (atomic_read(&cell->active)) { 816 + up_write(&net->cells_lock); 817 + goto cell_is_active; 818 + } 819 + 820 + /* Make sure that the expiring server records are going to see the fact 821 + * that the cell is caput. 822 + */ 823 + afs_set_cell_state(cell, AFS_CELL_REMOVING); 824 + 825 + afs_deactivate_cell(net, cell); 826 + afs_purge_servers(cell); 827 + 828 + rb_erase(&cell->net_node, &net->cells); 829 + afs_see_cell(cell, afs_cell_trace_unuse_delete); 830 + up_write(&net->cells_lock); 831 + 840 832 /* The root volume is pinning the cell */ 841 833 afs_put_volume(cell->root_volume, afs_volume_trace_put_cell_root); 842 834 cell->root_volume = NULL; 843 - afs_put_cell(cell, afs_cell_trace_put_destroy); 835 + 836 + afs_set_cell_state(cell, AFS_CELL_DEAD); 837 + return true; 844 838 } 845 839 846 840 static void afs_manage_cell_work(struct work_struct *work) 847 841 { 848 842 struct afs_cell *cell = container_of(work, struct afs_cell, manager); 843 + bool final_put; 849 844 850 - afs_manage_cell(cell); 851 - afs_put_cell(cell, afs_cell_trace_put_queue_work); 852 - } 853 - 854 - /* 855 - * Manage the records of cells known to a network namespace. This includes 856 - * updating the DNS records and garbage collecting unused cells that were 857 - * automatically added. 858 - * 859 - * Note that constructed cell records may only be removed from net->cells by 860 - * this work item, so it is safe for this work item to stash a cursor pointing 861 - * into the tree and then return to caller (provided it skips cells that are 862 - * still under construction). 863 - * 864 - * Note also that we were given an increment on net->cells_outstanding by 865 - * whoever queued us that we need to deal with before returning. 866 - */ 867 - void afs_manage_cells(struct work_struct *work) 868 - { 869 - struct afs_net *net = container_of(work, struct afs_net, cells_manager); 870 - struct rb_node *cursor; 871 - time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX; 872 - bool purging = !net->live; 873 - 874 - _enter(""); 875 - 876 - /* Trawl the cell database looking for cells that have expired from 877 - * lack of use and cells whose DNS results have expired and dispatch 878 - * their managers. 879 - */ 880 - down_read(&net->cells_lock); 881 - 882 - for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) { 883 - struct afs_cell *cell = 884 - rb_entry(cursor, struct afs_cell, net_node); 885 - unsigned active; 886 - bool sched_cell = false; 887 - 888 - active = atomic_read(&cell->active); 889 - trace_afs_cell(cell->debug_id, refcount_read(&cell->ref), 890 - active, afs_cell_trace_manage); 891 - 892 - ASSERTCMP(active, >=, 1); 893 - 894 - if (purging) { 895 - if (test_and_clear_bit(AFS_CELL_FL_NO_GC, &cell->flags)) { 896 - active = atomic_dec_return(&cell->active); 897 - trace_afs_cell(cell->debug_id, refcount_read(&cell->ref), 898 - active, afs_cell_trace_unuse_pin); 899 - } 900 - } 901 - 902 - if (active == 1) { 903 - struct afs_vlserver_list *vllist; 904 - time64_t expire_at = cell->last_inactive; 905 - 906 - read_lock(&cell->vl_servers_lock); 907 - vllist = rcu_dereference_protected( 908 - cell->vl_servers, 909 - lockdep_is_held(&cell->vl_servers_lock)); 910 - if (vllist->nr_servers > 0) 911 - expire_at += afs_cell_gc_delay; 912 - read_unlock(&cell->vl_servers_lock); 913 - if (purging || expire_at <= now) 914 - sched_cell = true; 915 - else if (expire_at < next_manage) 916 - next_manage = expire_at; 917 - } 918 - 919 - if (!purging) { 920 - if (test_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags)) 921 - sched_cell = true; 922 - } 923 - 924 - if (sched_cell) 925 - afs_queue_cell(cell, afs_cell_trace_get_queue_manage); 926 - } 927 - 928 - up_read(&net->cells_lock); 929 - 930 - /* Update the timer on the way out. We have to pass an increment on 931 - * cells_outstanding in the namespace that we are in to the timer or 932 - * the work scheduler. 933 - */ 934 - if (!purging && next_manage < TIME64_MAX) { 935 - now = ktime_get_real_seconds(); 936 - 937 - if (next_manage - now <= 0) { 938 - if (queue_work(afs_wq, &net->cells_manager)) 939 - atomic_inc(&net->cells_outstanding); 940 - } else { 941 - afs_set_cell_timer(net, next_manage - now); 942 - } 943 - } 944 - 945 - afs_dec_cells_outstanding(net); 946 - _leave(" [%d]", atomic_read(&net->cells_outstanding)); 845 + afs_see_cell(cell, afs_cell_trace_manage); 846 + final_put = afs_manage_cell(cell); 847 + afs_see_cell(cell, afs_cell_trace_managed); 848 + if (final_put) 849 + afs_put_cell(cell, afs_cell_trace_put_final); 947 850 } 948 851 949 852 /* ··· 865 942 void afs_cell_purge(struct afs_net *net) 866 943 { 867 944 struct afs_cell *ws; 945 + struct rb_node *cursor; 868 946 869 947 _enter(""); 870 948 ··· 873 949 ws = rcu_replace_pointer(net->ws_cell, NULL, 874 950 lockdep_is_held(&net->cells_lock)); 875 951 up_write(&net->cells_lock); 876 - afs_unuse_cell(net, ws, afs_cell_trace_unuse_ws); 952 + afs_unuse_cell(ws, afs_cell_trace_unuse_ws); 877 953 878 - _debug("del timer"); 879 - if (del_timer_sync(&net->cells_timer)) 880 - atomic_dec(&net->cells_outstanding); 954 + _debug("kick cells"); 955 + down_read(&net->cells_lock); 956 + for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) { 957 + struct afs_cell *cell = rb_entry(cursor, struct afs_cell, net_node); 881 958 882 - _debug("kick mgr"); 883 - afs_queue_cell_manager(net); 959 + afs_see_cell(cell, afs_cell_trace_purge); 960 + 961 + if (test_and_clear_bit(AFS_CELL_FL_NO_GC, &cell->flags)) 962 + afs_unuse_cell(cell, afs_cell_trace_unuse_pin); 963 + 964 + afs_queue_cell(cell, afs_cell_trace_queue_purge); 965 + } 966 + up_read(&net->cells_lock); 884 967 885 968 _debug("wait"); 886 969 wait_var_event(&net->cells_outstanding,

+13 -69

fs/afs/cmservice.c

··· 139 139 } 140 140 141 141 /* 142 - * Find the server record by peer address and record a probe to the cache 143 - * manager from a server. 144 - */ 145 - static int afs_find_cm_server_by_peer(struct afs_call *call) 146 - { 147 - struct sockaddr_rxrpc srx; 148 - struct afs_server *server; 149 - struct rxrpc_peer *peer; 150 - 151 - peer = rxrpc_kernel_get_call_peer(call->net->socket, call->rxcall); 152 - 153 - server = afs_find_server(call->net, peer); 154 - if (!server) { 155 - trace_afs_cm_no_server(call, &srx); 156 - return 0; 157 - } 158 - 159 - call->server = server; 160 - return 0; 161 - } 162 - 163 - /* 164 - * Find the server record by server UUID and record a probe to the cache 165 - * manager from a server. 166 - */ 167 - static int afs_find_cm_server_by_uuid(struct afs_call *call, 168 - struct afs_uuid *uuid) 169 - { 170 - struct afs_server *server; 171 - 172 - rcu_read_lock(); 173 - server = afs_find_server_by_uuid(call->net, call->request); 174 - rcu_read_unlock(); 175 - if (!server) { 176 - trace_afs_cm_no_server_u(call, call->request); 177 - return 0; 178 - } 179 - 180 - call->server = server; 181 - return 0; 182 - } 183 - 184 - /* 185 142 * Clean up a cache manager call. 186 143 */ 187 144 static void afs_cm_destructor(struct afs_call *call) ··· 279 322 280 323 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 281 324 return afs_io_error(call, afs_io_error_cm_reply); 282 - 283 - /* we'll need the file server record as that tells us which set of 284 - * vnodes to operate upon */ 285 - return afs_find_cm_server_by_peer(call); 325 + return 0; 286 326 } 287 327 288 328 /* ··· 303 349 */ 304 350 static int afs_deliver_cb_init_call_back_state(struct afs_call *call) 305 351 { 306 - int ret; 307 - 308 352 _enter(""); 309 353 310 354 afs_extract_discard(call, 0); 311 - ret = afs_extract_data(call, false); 312 - if (ret < 0) 313 - return ret; 314 - 315 - /* we'll need the file server record as that tells us which set of 316 - * vnodes to operate upon */ 317 - return afs_find_cm_server_by_peer(call); 355 + return afs_extract_data(call, false); 318 356 } 319 357 320 358 /* ··· 318 372 unsigned loop; 319 373 __be32 *b; 320 374 int ret; 321 - 322 - _enter(""); 323 375 324 376 _enter("{%u}", call->unmarshall); 325 377 ··· 365 421 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 366 422 return afs_io_error(call, afs_io_error_cm_reply); 367 423 368 - /* we'll need the file server record as that tells us which set of 369 - * vnodes to operate upon */ 370 - return afs_find_cm_server_by_uuid(call, call->request); 424 + if (memcmp(call->request, &call->server->_uuid, sizeof(call->server->_uuid)) != 0) { 425 + pr_notice("Callback UUID does not match fileserver UUID\n"); 426 + trace_afs_cm_no_server_u(call, call->request); 427 + return 0; 428 + } 429 + 430 + return 0; 371 431 } 372 432 373 433 /* ··· 403 455 404 456 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 405 457 return afs_io_error(call, afs_io_error_cm_reply); 406 - return afs_find_cm_server_by_peer(call); 458 + return 0; 407 459 } 408 460 409 461 /* ··· 481 533 482 534 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 483 535 return afs_io_error(call, afs_io_error_cm_reply); 484 - return afs_find_cm_server_by_peer(call); 536 + return 0; 485 537 } 486 538 487 539 /* ··· 541 593 542 594 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 543 595 return afs_io_error(call, afs_io_error_cm_reply); 544 - return afs_find_cm_server_by_peer(call); 596 + return 0; 545 597 } 546 598 547 599 /* ··· 615 667 616 668 if (!afs_check_call_state(call, AFS_CALL_SV_REPLYING)) 617 669 return afs_io_error(call, afs_io_error_cm_reply); 618 - 619 - /* We'll need the file server record as that tells us which set of 620 - * vnodes to operate upon. 621 - */ 622 - return afs_find_cm_server_by_peer(call); 670 + return 0; 623 671 }

+2 -3

fs/afs/dir.c

··· 1004 1004 afs_stat_v(dvnode, n_lookup); 1005 1005 inode = afs_do_lookup(dir, dentry); 1006 1006 if (inode == ERR_PTR(-ENOENT)) 1007 - inode = afs_try_auto_mntpt(dentry, dir); 1008 - 1009 - if (!IS_ERR_OR_NULL(inode)) 1007 + inode = NULL; 1008 + else if (!IS_ERR_OR_NULL(inode)) 1010 1009 fid = AFS_FS_I(inode)->fid; 1011 1010 1012 1011 _debug("splice %p", dentry->d_inode);

+225 -315

fs/afs/dynroot.c

··· 10 10 #include <linux/dns_resolver.h> 11 11 #include "internal.h" 12 12 13 - static atomic_t afs_autocell_ino; 13 + #define AFS_MIN_DYNROOT_CELL_INO 4 /* Allow for ., .., @cell, .@cell */ 14 + #define AFS_MAX_DYNROOT_CELL_INO ((unsigned int)INT_MAX) 15 + 16 + static struct dentry *afs_lookup_atcell(struct inode *dir, struct dentry *dentry, ino_t ino); 14 17 15 18 /* 16 19 * iget5() comparator for inode created by autocell operations 17 - * 18 - * These pseudo inodes don't match anything. 19 20 */ 20 21 static int afs_iget5_pseudo_test(struct inode *inode, void *opaque) 21 22 { 22 - return 0; 23 + struct afs_fid *fid = opaque; 24 + 25 + return inode->i_ino == fid->vnode; 23 26 } 24 27 25 28 /* ··· 42 39 } 43 40 44 41 /* 45 - * Create an inode for a dynamic root directory or an autocell dynamic 46 - * automount dir. 42 + * Create an inode for an autocell dynamic automount dir. 47 43 */ 48 - struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root) 44 + static struct inode *afs_iget_pseudo_dir(struct super_block *sb, ino_t ino) 49 45 { 50 - struct afs_super_info *as = AFS_FS_S(sb); 51 46 struct afs_vnode *vnode; 52 47 struct inode *inode; 53 - struct afs_fid fid = {}; 48 + struct afs_fid fid = { .vnode = ino, .unique = 1, }; 54 49 55 50 _enter(""); 56 - 57 - if (as->volume) 58 - fid.vid = as->volume->vid; 59 - if (root) { 60 - fid.vnode = 1; 61 - fid.unique = 1; 62 - } else { 63 - fid.vnode = atomic_inc_return(&afs_autocell_ino); 64 - fid.unique = 0; 65 - } 66 51 67 52 inode = iget5_locked(sb, fid.vnode, 68 53 afs_iget5_pseudo_test, afs_iget5_pseudo_set, &fid); ··· 64 73 65 74 vnode = AFS_FS_I(inode); 66 75 67 - /* there shouldn't be an existing inode */ 68 - BUG_ON(!(inode->i_state & I_NEW)); 76 + if (inode->i_state & I_NEW) { 77 + netfs_inode_init(&vnode->netfs, NULL, false); 78 + simple_inode_init_ts(inode); 79 + set_nlink(inode, 2); 80 + inode->i_size = 0; 81 + inode->i_mode = S_IFDIR | 0555; 82 + inode->i_op = &afs_autocell_inode_operations; 83 + inode->i_uid = GLOBAL_ROOT_UID; 84 + inode->i_gid = GLOBAL_ROOT_GID; 85 + inode->i_blocks = 0; 86 + inode->i_generation = 0; 87 + inode->i_flags |= S_AUTOMOUNT | S_NOATIME; 69 88 70 - netfs_inode_init(&vnode->netfs, NULL, false); 71 - inode->i_size = 0; 72 - inode->i_mode = S_IFDIR | S_IRUGO | S_IXUGO; 73 - if (root) { 74 - inode->i_op = &afs_dynroot_inode_operations; 75 - inode->i_fop = &simple_dir_operations; 76 - } else { 77 - inode->i_op = &afs_autocell_inode_operations; 78 - } 79 - set_nlink(inode, 2); 80 - inode->i_uid = GLOBAL_ROOT_UID; 81 - inode->i_gid = GLOBAL_ROOT_GID; 82 - simple_inode_init_ts(inode); 83 - inode->i_blocks = 0; 84 - inode->i_generation = 0; 85 - 86 - set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags); 87 - if (!root) { 89 + set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags); 88 90 set_bit(AFS_VNODE_MOUNTPOINT, &vnode->flags); 89 - inode->i_flags |= S_AUTOMOUNT; 90 - } 91 91 92 - inode->i_flags |= S_NOATIME; 93 - unlock_new_inode(inode); 92 + unlock_new_inode(inode); 93 + } 94 94 _leave(" = %p", inode); 95 95 return inode; 96 96 } 97 97 98 98 /* 99 - * Probe to see if a cell may exist. This prevents positive dentries from 100 - * being created unnecessarily. 99 + * Try to automount the mountpoint with pseudo directory, if the autocell 100 + * option is set. 101 101 */ 102 - static int afs_probe_cell_name(struct dentry *dentry) 102 + static struct dentry *afs_dynroot_lookup_cell(struct inode *dir, struct dentry *dentry, 103 + unsigned int flags) 103 104 { 104 - struct afs_cell *cell; 105 + struct afs_cell *cell = NULL; 105 106 struct afs_net *net = afs_d2net(dentry); 107 + struct inode *inode = NULL; 106 108 const char *name = dentry->d_name.name; 107 109 size_t len = dentry->d_name.len; 108 - char *result = NULL; 109 - int ret; 110 + bool dotted = false; 111 + int ret = -ENOENT; 110 112 111 113 /* Names prefixed with a dot are R/W mounts. */ 112 114 if (name[0] == '.') { 113 - if (len == 1) 114 - return -EINVAL; 115 115 name++; 116 116 len--; 117 + dotted = true; 117 118 } 118 119 119 - cell = afs_find_cell(net, name, len, afs_cell_trace_use_probe); 120 - if (!IS_ERR(cell)) { 121 - afs_unuse_cell(net, cell, afs_cell_trace_unuse_probe); 122 - return 0; 120 + cell = afs_lookup_cell(net, name, len, NULL, false, 121 + afs_cell_trace_use_lookup_dynroot); 122 + if (IS_ERR(cell)) { 123 + ret = PTR_ERR(cell); 124 + goto out_no_cell; 123 125 } 124 126 125 - ret = dns_query(net->net, "afsdb", name, len, "srv=1", 126 - &result, NULL, false); 127 - if (ret == -ENODATA || ret == -ENOKEY || ret == 0) 128 - ret = -ENOENT; 129 - if (ret > 0 && ret >= sizeof(struct dns_server_list_v1_header)) { 130 - struct dns_server_list_v1_header *v1 = (void *)result; 131 - 132 - if (v1->hdr.zero == 0 && 133 - v1->hdr.content == DNS_PAYLOAD_IS_SERVER_LIST && 134 - v1->hdr.version == 1 && 135 - (v1->status != DNS_LOOKUP_GOOD && 136 - v1->status != DNS_LOOKUP_GOOD_WITH_BAD)) 137 - return -ENOENT; 138 - 139 - } 140 - 141 - kfree(result); 142 - return ret; 143 - } 144 - 145 - /* 146 - * Try to auto mount the mountpoint with pseudo directory, if the autocell 147 - * operation is setted. 148 - */ 149 - struct inode *afs_try_auto_mntpt(struct dentry *dentry, struct inode *dir) 150 - { 151 - struct afs_vnode *vnode = AFS_FS_I(dir); 152 - struct inode *inode; 153 - int ret = -ENOENT; 154 - 155 - _enter("%p{%pd}, {%llx:%llu}", 156 - dentry, dentry, vnode->fid.vid, vnode->fid.vnode); 157 - 158 - if (!test_bit(AFS_VNODE_AUTOCELL, &vnode->flags)) 159 - goto out; 160 - 161 - ret = afs_probe_cell_name(dentry); 162 - if (ret < 0) 163 - goto out; 164 - 165 - inode = afs_iget_pseudo_dir(dir->i_sb, false); 127 + inode = afs_iget_pseudo_dir(dir->i_sb, cell->dynroot_ino * 2 + dotted); 166 128 if (IS_ERR(inode)) { 167 129 ret = PTR_ERR(inode); 168 130 goto out; 169 131 } 170 132 171 - _leave("= %p", inode); 172 - return inode; 133 + dentry->d_fsdata = cell; 134 + return d_splice_alias(inode, dentry); 173 135 174 136 out: 175 - _leave("= %d", ret); 137 + afs_unuse_cell(cell, afs_cell_trace_unuse_lookup_dynroot); 138 + out_no_cell: 139 + if (!inode) 140 + return d_splice_alias(inode, dentry); 176 141 return ret == -ENOENT ? NULL : ERR_PTR(ret); 177 142 } 178 143 ··· 140 193 { 141 194 _enter("%pd", dentry); 142 195 143 - ASSERTCMP(d_inode(dentry), ==, NULL); 144 - 145 196 if (flags & LOOKUP_CREATE) 146 197 return ERR_PTR(-EOPNOTSUPP); 147 198 ··· 148 203 return ERR_PTR(-ENAMETOOLONG); 149 204 } 150 205 151 - return d_splice_alias(afs_try_auto_mntpt(dentry, dir), dentry); 206 + if (dentry->d_name.len == 5 && 207 + memcmp(dentry->d_name.name, "@cell", 5) == 0) 208 + return afs_lookup_atcell(dir, dentry, 2); 209 + 210 + if (dentry->d_name.len == 6 && 211 + memcmp(dentry->d_name.name, ".@cell", 6) == 0) 212 + return afs_lookup_atcell(dir, dentry, 3); 213 + 214 + return afs_dynroot_lookup_cell(dir, dentry, flags); 152 215 } 153 216 154 217 const struct inode_operations afs_dynroot_inode_operations = { 155 218 .lookup = afs_dynroot_lookup, 156 219 }; 157 220 221 + static void afs_dynroot_d_release(struct dentry *dentry) 222 + { 223 + struct afs_cell *cell = dentry->d_fsdata; 224 + 225 + afs_unuse_cell(cell, afs_cell_trace_unuse_dynroot_mntpt); 226 + } 227 + 228 + /* 229 + * Keep @cell symlink dentries around, but only keep cell autodirs when they're 230 + * being used. 231 + */ 232 + static int afs_dynroot_delete_dentry(const struct dentry *dentry) 233 + { 234 + const struct qstr *name = &dentry->d_name; 235 + 236 + if (name->len == 5 && memcmp(name->name, "@cell", 5) == 0) 237 + return 0; 238 + if (name->len == 6 && memcmp(name->name, ".@cell", 6) == 0) 239 + return 0; 240 + return 1; 241 + } 242 + 158 243 const struct dentry_operations afs_dynroot_dentry_operations = { 159 - .d_delete = always_delete_dentry, 160 - .d_release = afs_d_release, 244 + .d_delete = afs_dynroot_delete_dentry, 245 + .d_release = afs_dynroot_d_release, 161 246 .d_automount = afs_d_automount, 162 247 }; 163 - 164 - /* 165 - * Create a manually added cell mount directory. 166 - * - The caller must hold net->proc_cells_lock 167 - */ 168 - int afs_dynroot_mkdir(struct afs_net *net, struct afs_cell *cell) 169 - { 170 - struct super_block *sb = net->dynroot_sb; 171 - struct dentry *root, *subdir, *dsubdir; 172 - char *dotname = cell->name - 1; 173 - int ret; 174 - 175 - if (!sb || atomic_read(&sb->s_active) == 0) 176 - return 0; 177 - 178 - /* Let the ->lookup op do the creation */ 179 - root = sb->s_root; 180 - inode_lock(root->d_inode); 181 - subdir = lookup_one_len(cell->name, root, cell->name_len); 182 - if (IS_ERR(subdir)) { 183 - ret = PTR_ERR(subdir); 184 - goto unlock; 185 - } 186 - 187 - dsubdir = lookup_one_len(dotname, root, cell->name_len + 1); 188 - if (IS_ERR(dsubdir)) { 189 - ret = PTR_ERR(dsubdir); 190 - dput(subdir); 191 - goto unlock; 192 - } 193 - 194 - /* Note that we're retaining extra refs on the dentries. */ 195 - subdir->d_fsdata = (void *)1UL; 196 - dsubdir->d_fsdata = (void *)1UL; 197 - ret = 0; 198 - unlock: 199 - inode_unlock(root->d_inode); 200 - return ret; 201 - } 202 - 203 - static void afs_dynroot_rm_one_dir(struct dentry *root, const char *name, size_t name_len) 204 - { 205 - struct dentry *subdir; 206 - 207 - /* Don't want to trigger a lookup call, which will re-add the cell */ 208 - subdir = try_lookup_one_len(name, root, name_len); 209 - if (IS_ERR_OR_NULL(subdir)) { 210 - _debug("lookup %ld", PTR_ERR(subdir)); 211 - return; 212 - } 213 - 214 - _debug("rmdir %pd %u", subdir, d_count(subdir)); 215 - 216 - if (subdir->d_fsdata) { 217 - _debug("unpin %u", d_count(subdir)); 218 - subdir->d_fsdata = NULL; 219 - dput(subdir); 220 - } 221 - dput(subdir); 222 - } 223 - 224 - /* 225 - * Remove a manually added cell mount directory. 226 - * - The caller must hold net->proc_cells_lock 227 - */ 228 - void afs_dynroot_rmdir(struct afs_net *net, struct afs_cell *cell) 229 - { 230 - struct super_block *sb = net->dynroot_sb; 231 - char *dotname = cell->name - 1; 232 - 233 - if (!sb || atomic_read(&sb->s_active) == 0) 234 - return; 235 - 236 - inode_lock(sb->s_root->d_inode); 237 - afs_dynroot_rm_one_dir(sb->s_root, cell->name, cell->name_len); 238 - afs_dynroot_rm_one_dir(sb->s_root, dotname, cell->name_len + 1); 239 - inode_unlock(sb->s_root->d_inode); 240 - _leave(""); 241 - } 242 248 243 249 static void afs_atcell_delayed_put_cell(void *arg) 244 250 { ··· 243 347 }; 244 348 245 349 /* 246 - * Look up @cell or .@cell in a dynroot directory. This is a substitution for 247 - * the local cell name for the net namespace. 350 + * Create an inode for the @cell or .@cell symlinks. 248 351 */ 249 - static struct dentry *afs_dynroot_create_symlink(struct dentry *root, const char *name) 352 + static struct dentry *afs_lookup_atcell(struct inode *dir, struct dentry *dentry, ino_t ino) 250 353 { 251 354 struct afs_vnode *vnode; 252 - struct afs_fid fid = { .vnode = 2, .unique = 1, }; 253 - struct dentry *dentry; 254 355 struct inode *inode; 356 + struct afs_fid fid = { .vnode = ino, .unique = 1, }; 255 357 256 - if (name[0] == '.') 257 - fid.vnode = 3; 258 - 259 - dentry = d_alloc_name(root, name); 260 - if (!dentry) 261 - return ERR_PTR(-ENOMEM); 262 - 263 - inode = iget5_locked(dentry->d_sb, fid.vnode, 358 + inode = iget5_locked(dir->i_sb, fid.vnode, 264 359 afs_iget5_pseudo_test, afs_iget5_pseudo_set, &fid); 265 - if (!inode) { 266 - dput(dentry); 360 + if (!inode) 267 361 return ERR_PTR(-ENOMEM); 362 + 363 + vnode = AFS_FS_I(inode); 364 + 365 + if (inode->i_state & I_NEW) { 366 + netfs_inode_init(&vnode->netfs, NULL, false); 367 + simple_inode_init_ts(inode); 368 + set_nlink(inode, 1); 369 + inode->i_size = 0; 370 + inode->i_mode = S_IFLNK | 0555; 371 + inode->i_op = &afs_atcell_inode_operations; 372 + inode->i_uid = GLOBAL_ROOT_UID; 373 + inode->i_gid = GLOBAL_ROOT_GID; 374 + inode->i_blocks = 0; 375 + inode->i_generation = 0; 376 + inode->i_flags |= S_NOATIME; 377 + 378 + unlock_new_inode(inode); 268 379 } 380 + return d_splice_alias(inode, dentry); 381 + } 382 + 383 + /* 384 + * Transcribe the cell database into readdir content under the RCU read lock. 385 + * Each cell produces two entries, one prefixed with a dot and one not. 386 + */ 387 + static int afs_dynroot_readdir_cells(struct afs_net *net, struct dir_context *ctx) 388 + { 389 + const struct afs_cell *cell; 390 + loff_t newpos; 391 + 392 + _enter("%llu", ctx->pos); 393 + 394 + for (;;) { 395 + unsigned int ix = ctx->pos >> 1; 396 + 397 + cell = idr_get_next(&net->cells_dyn_ino, &ix); 398 + if (!cell) 399 + return 0; 400 + if (READ_ONCE(cell->state) == AFS_CELL_REMOVING || 401 + READ_ONCE(cell->state) == AFS_CELL_DEAD) { 402 + ctx->pos += 2; 403 + ctx->pos &= ~1; 404 + continue; 405 + } 406 + 407 + newpos = ix << 1; 408 + if (newpos > ctx->pos) 409 + ctx->pos = newpos; 410 + 411 + _debug("pos %llu -> cell %u", ctx->pos, cell->dynroot_ino); 412 + 413 + if ((ctx->pos & 1) == 0) { 414 + if (!dir_emit(ctx, cell->name, cell->name_len, 415 + cell->dynroot_ino, DT_DIR)) 416 + return 0; 417 + ctx->pos++; 418 + } 419 + if ((ctx->pos & 1) == 1) { 420 + if (!dir_emit(ctx, cell->name - 1, cell->name_len + 1, 421 + cell->dynroot_ino + 1, DT_DIR)) 422 + return 0; 423 + ctx->pos++; 424 + } 425 + } 426 + return 0; 427 + } 428 + 429 + /* 430 + * Read the AFS dynamic root directory. This produces a list of cellnames, 431 + * dotted and undotted, along with @cell and .@cell links if configured. 432 + */ 433 + static int afs_dynroot_readdir(struct file *file, struct dir_context *ctx) 434 + { 435 + struct afs_net *net = afs_d2net(file->f_path.dentry); 436 + int ret = 0; 437 + 438 + if (!dir_emit_dots(file, ctx)) 439 + return 0; 440 + 441 + if (ctx->pos == 2) { 442 + if (rcu_access_pointer(net->ws_cell) && 443 + !dir_emit(ctx, "@cell", 5, 2, DT_LNK)) 444 + return 0; 445 + ctx->pos = 3; 446 + } 447 + if (ctx->pos == 3) { 448 + if (rcu_access_pointer(net->ws_cell) && 449 + !dir_emit(ctx, ".@cell", 6, 3, DT_LNK)) 450 + return 0; 451 + ctx->pos = 4; 452 + } 453 + 454 + if ((unsigned long long)ctx->pos <= AFS_MAX_DYNROOT_CELL_INO) { 455 + rcu_read_lock(); 456 + ret = afs_dynroot_readdir_cells(net, ctx); 457 + rcu_read_unlock(); 458 + } 459 + return ret; 460 + } 461 + 462 + static const struct file_operations afs_dynroot_file_operations = { 463 + .llseek = generic_file_llseek, 464 + .read = generic_read_dir, 465 + .iterate_shared = afs_dynroot_readdir, 466 + .fsync = noop_fsync, 467 + }; 468 + 469 + /* 470 + * Create an inode for a dynamic root directory. 471 + */ 472 + struct inode *afs_dynroot_iget_root(struct super_block *sb) 473 + { 474 + struct afs_super_info *as = AFS_FS_S(sb); 475 + struct afs_vnode *vnode; 476 + struct inode *inode; 477 + struct afs_fid fid = { .vid = 0, .vnode = 1, .unique = 1,}; 478 + 479 + if (as->volume) 480 + fid.vid = as->volume->vid; 481 + 482 + inode = iget5_locked(sb, fid.vnode, 483 + afs_iget5_pseudo_test, afs_iget5_pseudo_set, &fid); 484 + if (!inode) 485 + return ERR_PTR(-ENOMEM); 269 486 270 487 vnode = AFS_FS_I(inode); 271 488 272 489 /* there shouldn't be an existing inode */ 273 - if (WARN_ON_ONCE(!(inode->i_state & I_NEW))) { 274 - iput(inode); 275 - dput(dentry); 276 - return ERR_PTR(-EIO); 490 + if (inode->i_state & I_NEW) { 491 + netfs_inode_init(&vnode->netfs, NULL, false); 492 + simple_inode_init_ts(inode); 493 + set_nlink(inode, 2); 494 + inode->i_size = 0; 495 + inode->i_mode = S_IFDIR | 0555; 496 + inode->i_op = &afs_dynroot_inode_operations; 497 + inode->i_fop = &afs_dynroot_file_operations; 498 + inode->i_uid = GLOBAL_ROOT_UID; 499 + inode->i_gid = GLOBAL_ROOT_GID; 500 + inode->i_blocks = 0; 501 + inode->i_generation = 0; 502 + inode->i_flags |= S_NOATIME; 503 + 504 + set_bit(AFS_VNODE_PSEUDODIR, &vnode->flags); 505 + unlock_new_inode(inode); 277 506 } 278 - 279 - netfs_inode_init(&vnode->netfs, NULL, false); 280 - simple_inode_init_ts(inode); 281 - set_nlink(inode, 1); 282 - inode->i_size = 0; 283 - inode->i_mode = S_IFLNK | 0555; 284 - inode->i_op = &afs_atcell_inode_operations; 285 - inode->i_uid = GLOBAL_ROOT_UID; 286 - inode->i_gid = GLOBAL_ROOT_GID; 287 - inode->i_blocks = 0; 288 - inode->i_generation = 0; 289 - inode->i_flags |= S_NOATIME; 290 - 291 - unlock_new_inode(inode); 292 - d_splice_alias(inode, dentry); 293 - return dentry; 294 - } 295 - 296 - /* 297 - * Create @cell and .@cell symlinks. 298 - */ 299 - static int afs_dynroot_symlink(struct afs_net *net) 300 - { 301 - struct super_block *sb = net->dynroot_sb; 302 - struct dentry *root, *symlink, *dsymlink; 303 - int ret; 304 - 305 - /* Let the ->lookup op do the creation */ 306 - root = sb->s_root; 307 - inode_lock(root->d_inode); 308 - symlink = afs_dynroot_create_symlink(root, "@cell"); 309 - if (IS_ERR(symlink)) { 310 - ret = PTR_ERR(symlink); 311 - goto unlock; 312 - } 313 - 314 - dsymlink = afs_dynroot_create_symlink(root, ".@cell"); 315 - if (IS_ERR(dsymlink)) { 316 - ret = PTR_ERR(dsymlink); 317 - dput(symlink); 318 - goto unlock; 319 - } 320 - 321 - /* Note that we're retaining extra refs on the dentries. */ 322 - symlink->d_fsdata = (void *)1UL; 323 - dsymlink->d_fsdata = (void *)1UL; 324 - ret = 0; 325 - unlock: 326 - inode_unlock(root->d_inode); 327 - return ret; 328 - } 329 - 330 - /* 331 - * Populate a newly created dynamic root with cell names. 332 - */ 333 - int afs_dynroot_populate(struct super_block *sb) 334 - { 335 - struct afs_cell *cell; 336 - struct afs_net *net = afs_sb2net(sb); 337 - int ret; 338 - 339 - mutex_lock(&net->proc_cells_lock); 340 - 341 - net->dynroot_sb = sb; 342 - ret = afs_dynroot_symlink(net); 343 - if (ret < 0) 344 - goto error; 345 - 346 - hlist_for_each_entry(cell, &net->proc_cells, proc_link) { 347 - ret = afs_dynroot_mkdir(net, cell); 348 - if (ret < 0) 349 - goto error; 350 - } 351 - 352 - ret = 0; 353 - out: 354 - mutex_unlock(&net->proc_cells_lock); 355 - return ret; 356 - 357 - error: 358 - net->dynroot_sb = NULL; 359 - goto out; 360 - } 361 - 362 - /* 363 - * When a dynamic root that's in the process of being destroyed, depopulate it 364 - * of pinned directories. 365 - */ 366 - void afs_dynroot_depopulate(struct super_block *sb) 367 - { 368 - struct afs_net *net = afs_sb2net(sb); 369 - struct dentry *root = sb->s_root, *subdir; 370 - 371 - /* Prevent more subdirs from being created */ 372 - mutex_lock(&net->proc_cells_lock); 373 - if (net->dynroot_sb == sb) 374 - net->dynroot_sb = NULL; 375 - mutex_unlock(&net->proc_cells_lock); 376 - 377 - if (root) { 378 - struct hlist_node *n; 379 - inode_lock(root->d_inode); 380 - 381 - /* Remove all the pins for dirs created for manually added cells */ 382 - hlist_for_each_entry_safe(subdir, n, &root->d_children, d_sib) { 383 - if (subdir->d_fsdata) { 384 - subdir->d_fsdata = NULL; 385 - dput(subdir); 386 - } 387 - } 388 - 389 - inode_unlock(root->d_inode); 390 - } 507 + _leave(" = %p", inode); 508 + return inode; 391 509 }

+22 -10

fs/afs/fs_probe.c

··· 235 235 * Probe all of a fileserver's addresses to find out the best route and to 236 236 * query its capabilities. 237 237 */ 238 - void afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server, 239 - struct afs_addr_list *new_alist, struct key *key) 238 + int afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server, 239 + struct afs_addr_list *new_alist, struct key *key) 240 240 { 241 241 struct afs_endpoint_state *estate, *old; 242 - struct afs_addr_list *alist; 242 + struct afs_addr_list *old_alist = NULL, *alist; 243 243 unsigned long unprobed; 244 244 245 245 _enter("%pU", &server->uuid); 246 246 247 247 estate = kzalloc(sizeof(*estate), GFP_KERNEL); 248 248 if (!estate) 249 - return; 249 + return -ENOMEM; 250 250 251 - refcount_set(&estate->ref, 1); 251 + refcount_set(&estate->ref, 2); 252 252 estate->server_id = server->debug_id; 253 253 estate->rtt = UINT_MAX; 254 254 ··· 256 256 257 257 old = rcu_dereference_protected(server->endpoint_state, 258 258 lockdep_is_held(&server->fs_lock)); 259 - estate->responsive_set = old->responsive_set; 260 - estate->addresses = afs_get_addrlist(new_alist ?: old->addresses, 261 - afs_alist_trace_get_estate); 259 + if (old) { 260 + estate->responsive_set = old->responsive_set; 261 + if (!new_alist) 262 + new_alist = old->addresses; 263 + } 264 + 265 + if (old_alist != new_alist) 266 + afs_set_peer_appdata(server, old_alist, new_alist); 267 + 268 + estate->addresses = afs_get_addrlist(new_alist, afs_alist_trace_get_estate); 262 269 alist = estate->addresses; 263 270 estate->probe_seq = ++server->probe_counter; 264 271 atomic_set(&estate->nr_probing, alist->nr_addrs); 265 272 273 + if (new_alist) 274 + server->addr_version = new_alist->version; 266 275 rcu_assign_pointer(server->endpoint_state, estate); 267 - set_bit(AFS_ESTATE_SUPERSEDED, &old->flags); 268 276 write_unlock(&server->fs_lock); 277 + if (old) 278 + set_bit(AFS_ESTATE_SUPERSEDED, &old->flags); 269 279 270 280 trace_afs_estate(estate->server_id, estate->probe_seq, refcount_read(&estate->ref), 271 281 afs_estate_trace_alloc_probe); 272 282 273 - afs_get_address_preferences(net, alist); 283 + afs_get_address_preferences(net, new_alist); 274 284 275 285 server->probed_at = jiffies; 276 286 unprobed = (1UL << alist->nr_addrs) - 1; ··· 303 293 } 304 294 305 295 afs_put_endpoint_state(old, afs_estate_trace_put_probe); 296 + afs_put_endpoint_state(estate, afs_estate_trace_put_probe); 297 + return 0; 306 298 } 307 299 308 300 /*

+2 -2

fs/afs/fsclient.c

··· 1653 1653 bp = call->request; 1654 1654 *bp++ = htonl(FSGIVEUPALLCALLBACKS); 1655 1655 1656 - call->server = afs_use_server(server, afs_server_trace_give_up_cb); 1656 + call->server = afs_use_server(server, false, afs_server_trace_use_give_up_cb); 1657 1657 afs_make_call(call, GFP_NOFS); 1658 1658 afs_wait_for_call_to_complete(call); 1659 1659 ret = call->error; ··· 1760 1760 return false; 1761 1761 1762 1762 call->key = key; 1763 - call->server = afs_use_server(server, afs_server_trace_get_caps); 1763 + call->server = afs_use_server(server, false, afs_server_trace_use_get_caps); 1764 1764 call->peer = rxrpc_kernel_get_peer(estate->addresses->addrs[addr_index].peer); 1765 1765 call->probe = afs_get_endpoint_state(estate, afs_estate_trace_get_getcaps); 1766 1766 call->probe_index = addr_index;

+50 -48

fs/afs/internal.h

··· 287 287 288 288 /* Cell database */ 289 289 struct rb_root cells; 290 + struct idr cells_dyn_ino; /* cell->dynroot_ino mapping */ 290 291 struct afs_cell __rcu *ws_cell; 291 - struct work_struct cells_manager; 292 - struct timer_list cells_timer; 293 292 atomic_t cells_outstanding; 294 293 struct rw_semaphore cells_lock; 295 294 struct mutex cells_alias_lock; ··· 300 301 * cell, but in practice, people create aliases and subsets and there's 301 302 * no easy way to distinguish them. 302 303 */ 303 - seqlock_t fs_lock; /* For fs_servers, fs_probe_*, fs_proc */ 304 - struct rb_root fs_servers; /* afs_server (by server UUID or address) */ 304 + seqlock_t fs_lock; /* For fs_probe_*, fs_proc */ 305 305 struct list_head fs_probe_fast; /* List of afs_server to probe at 30s intervals */ 306 306 struct list_head fs_probe_slow; /* List of afs_server to probe at 5m intervals */ 307 307 struct hlist_head fs_proc; /* procfs servers list */ 308 - 309 - struct hlist_head fs_addresses; /* afs_server (by lowest IPv6 addr) */ 310 - seqlock_t fs_addr_lock; /* For fs_addresses[46] */ 311 - 312 - struct work_struct fs_manager; 313 - struct timer_list fs_timer; 314 308 315 309 struct work_struct fs_prober; 316 310 struct timer_list fs_probe_timer; ··· 337 345 extern const char afs_init_sysname[]; 338 346 339 347 enum afs_cell_state { 340 - AFS_CELL_UNSET, 341 - AFS_CELL_ACTIVATING, 348 + AFS_CELL_SETTING_UP, 342 349 AFS_CELL_ACTIVE, 343 - AFS_CELL_DEACTIVATING, 344 - AFS_CELL_INACTIVE, 345 - AFS_CELL_FAILED, 346 - AFS_CELL_REMOVED, 350 + AFS_CELL_REMOVING, 351 + AFS_CELL_DEAD, 347 352 }; 348 353 349 354 /* ··· 371 382 struct afs_cell *alias_of; /* The cell this is an alias of */ 372 383 struct afs_volume *root_volume; /* The root.cell volume if there is one */ 373 384 struct key *anonymous_key; /* anonymous user key for this cell */ 385 + struct work_struct destroyer; /* Destroyer for cell */ 374 386 struct work_struct manager; /* Manager for init/deinit/dns */ 387 + struct timer_list management_timer; /* General management timer */ 375 388 struct hlist_node proc_link; /* /proc cell list link */ 376 389 time64_t dns_expiry; /* Time AFSDB/SRV record expires */ 377 390 time64_t last_inactive; /* Time of last drop of usage count */ ··· 389 398 enum dns_lookup_status dns_status:8; /* Latest status of data from lookup */ 390 399 unsigned int dns_lookup_count; /* Counter of DNS lookups */ 391 400 unsigned int debug_id; 401 + unsigned int dynroot_ino; /* Inode numbers for dynroot (a pair) */ 392 402 393 403 /* The volumes belonging to this cell */ 394 404 struct rw_semaphore vs_lock; /* Lock for server->volumes */ ··· 399 407 400 408 /* Active fileserver interaction state. */ 401 409 struct rb_root fs_servers; /* afs_server (by server UUID) */ 402 - seqlock_t fs_lock; /* For fs_servers */ 410 + struct rw_semaphore fs_lock; /* For fs_servers */ 403 411 404 412 /* VL server list. */ 405 413 rwlock_t vl_servers_lock; /* Lock on vl_servers */ ··· 534 542 }; 535 543 536 544 struct afs_cell *cell; /* Cell to which belongs (pins ref) */ 537 - struct rb_node uuid_rb; /* Link in net->fs_servers */ 538 - struct afs_server __rcu *uuid_next; /* Next server with same UUID */ 539 - struct afs_server *uuid_prev; /* Previous server with same UUID */ 540 - struct list_head probe_link; /* Link in net->fs_probe_list */ 541 - struct hlist_node addr_link; /* Link in net->fs_addresses6 */ 545 + struct rb_node uuid_rb; /* Link in cell->fs_servers */ 546 + struct list_head probe_link; /* Link in net->fs_probe_* */ 542 547 struct hlist_node proc_link; /* Link in net->fs_proc */ 543 548 struct list_head volumes; /* RCU list of afs_server_entry objects */ 544 - struct afs_server *gc_next; /* Next server in manager's list */ 549 + struct work_struct destroyer; /* Work item to try and destroy a server */ 550 + struct timer_list timer; /* Management timer */ 545 551 time64_t unuse_time; /* Time at which last unused */ 546 552 unsigned long flags; 547 553 #define AFS_SERVER_FL_RESPONDING 0 /* The server is responding */ 548 554 #define AFS_SERVER_FL_UPDATING 1 549 555 #define AFS_SERVER_FL_NEEDS_UPDATE 2 /* Fileserver address list is out of date */ 550 - #define AFS_SERVER_FL_NOT_READY 4 /* The record is not ready for use */ 551 - #define AFS_SERVER_FL_NOT_FOUND 5 /* VL server says no such server */ 552 - #define AFS_SERVER_FL_VL_FAIL 6 /* Failed to access VL server */ 556 + #define AFS_SERVER_FL_UNCREATED 3 /* The record needs creating */ 557 + #define AFS_SERVER_FL_CREATING 4 /* The record is being created */ 558 + #define AFS_SERVER_FL_EXPIRED 5 /* The record has expired */ 559 + #define AFS_SERVER_FL_NOT_FOUND 6 /* VL server says no such server */ 560 + #define AFS_SERVER_FL_VL_FAIL 7 /* Failed to access VL server */ 553 561 #define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */ 554 562 #define AFS_SERVER_FL_IS_YFS 16 /* Server is YFS not AFS */ 555 563 #define AFS_SERVER_FL_NO_IBULK 17 /* Fileserver doesn't support FS.InlineBulkStatus */ ··· 559 567 atomic_t active; /* Active user count */ 560 568 u32 addr_version; /* Address list version */ 561 569 u16 service_id; /* Service ID we're using. */ 570 + short create_error; /* Creation error */ 562 571 unsigned int rtt; /* Server's current RTT in uS */ 563 572 unsigned int debug_id; /* Debugging ID for traces */ 564 573 ··· 614 621 afs_volid_t vid; /* The volume ID of this volume */ 615 622 afs_volid_t vids[AFS_MAXTYPES]; /* All associated volume IDs */ 616 623 refcount_t ref; 624 + unsigned int debug_id; /* Debugging ID for traces */ 617 625 time64_t update_at; /* Time at which to next update */ 618 626 struct afs_cell *cell; /* Cell to which belongs (pins ref) */ 619 627 struct rb_node cell_node; /* Link in cell->volumes */ ··· 694 700 #define AFS_VNODE_ZAP_DATA 3 /* set if vnode's data should be invalidated */ 695 701 #define AFS_VNODE_DELETED 4 /* set if vnode deleted on server */ 696 702 #define AFS_VNODE_MOUNTPOINT 5 /* set if vnode is a mountpoint symlink */ 697 - #define AFS_VNODE_AUTOCELL 6 /* set if Vnode is an auto mount point */ 698 703 #define AFS_VNODE_PSEUDODIR 7 /* set if Vnode is a pseudo directory */ 699 704 #define AFS_VNODE_NEW_CONTENT 8 /* Set if file has new content (create/trunc-0) */ 700 705 #define AFS_VNODE_SILLY_DELETED 9 /* Set if file has been silly-deleted */ ··· 1001 1008 __be32 xdr, u16 port); 1002 1009 extern int afs_merge_fs_addr6(struct afs_net *net, struct afs_addr_list *addr, 1003 1010 __be32 *xdr, u16 port); 1011 + void afs_set_peer_appdata(struct afs_server *server, 1012 + struct afs_addr_list *old_alist, 1013 + struct afs_addr_list *new_alist); 1004 1014 1005 1015 /* 1006 1016 * addr_prefs.c ··· 1040 1044 extern int afs_cell_init(struct afs_net *, const char *); 1041 1045 extern struct afs_cell *afs_find_cell(struct afs_net *, const char *, unsigned, 1042 1046 enum afs_cell_trace); 1043 - extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned, 1044 - const char *, bool); 1047 + struct afs_cell *afs_lookup_cell(struct afs_net *net, 1048 + const char *name, unsigned int namesz, 1049 + const char *vllist, bool excl, 1050 + enum afs_cell_trace trace); 1045 1051 extern struct afs_cell *afs_use_cell(struct afs_cell *, enum afs_cell_trace); 1046 - extern void afs_unuse_cell(struct afs_net *, struct afs_cell *, enum afs_cell_trace); 1052 + void afs_unuse_cell(struct afs_cell *cell, enum afs_cell_trace reason); 1047 1053 extern struct afs_cell *afs_get_cell(struct afs_cell *, enum afs_cell_trace); 1048 1054 extern void afs_see_cell(struct afs_cell *, enum afs_cell_trace); 1049 1055 extern void afs_put_cell(struct afs_cell *, enum afs_cell_trace); 1050 1056 extern void afs_queue_cell(struct afs_cell *, enum afs_cell_trace); 1051 - extern void afs_manage_cells(struct work_struct *); 1052 - extern void afs_cells_timer(struct timer_list *); 1057 + void afs_set_cell_timer(struct afs_cell *cell, unsigned int delay_secs); 1053 1058 extern void __net_exit afs_cell_purge(struct afs_net *); 1054 1059 1055 1060 /* ··· 1108 1111 extern const struct inode_operations afs_dynroot_inode_operations; 1109 1112 extern const struct dentry_operations afs_dynroot_dentry_operations; 1110 1113 1111 - extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *); 1112 - extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *); 1113 - extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *); 1114 - extern int afs_dynroot_populate(struct super_block *); 1115 - extern void afs_dynroot_depopulate(struct super_block *); 1114 + struct inode *afs_dynroot_iget_root(struct super_block *sb); 1116 1115 1117 1116 /* 1118 1117 * file.c ··· 1200 1207 enum afs_estate_trace where); 1201 1208 void afs_put_endpoint_state(struct afs_endpoint_state *estate, enum afs_estate_trace where); 1202 1209 extern void afs_fileserver_probe_result(struct afs_call *); 1203 - void afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server, 1204 - struct afs_addr_list *new_addrs, struct key *key); 1210 + int afs_fs_probe_fileserver(struct afs_net *net, struct afs_server *server, 1211 + struct afs_addr_list *new_alist, struct key *key); 1205 1212 int afs_wait_for_fs_probes(struct afs_operation *op, struct afs_server_state *states, bool intr); 1206 1213 extern void afs_probe_fileserver(struct afs_net *, struct afs_server *); 1207 1214 extern void afs_fs_probe_dispatcher(struct work_struct *); ··· 1221 1228 extern void afs_vnode_commit_status(struct afs_operation *, struct afs_vnode_param *); 1222 1229 extern int afs_fetch_status(struct afs_vnode *, struct key *, bool, afs_access_t *); 1223 1230 extern int afs_ilookup5_test_by_fid(struct inode *, void *); 1224 - extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool); 1225 1231 extern struct inode *afs_iget(struct afs_operation *, struct afs_vnode_param *); 1226 1232 extern struct inode *afs_root_iget(struct super_block *, struct key *); 1227 1233 extern int afs_getattr(struct mnt_idmap *idmap, const struct path *, ··· 1502 1510 */ 1503 1511 extern spinlock_t afs_server_peer_lock; 1504 1512 1505 - extern struct afs_server *afs_find_server(struct afs_net *, const struct rxrpc_peer *); 1506 - extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *); 1513 + struct afs_server *afs_find_server(const struct rxrpc_peer *peer); 1507 1514 extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *, u32); 1508 1515 extern struct afs_server *afs_get_server(struct afs_server *, enum afs_server_trace); 1509 - extern struct afs_server *afs_use_server(struct afs_server *, enum afs_server_trace); 1510 - extern void afs_unuse_server(struct afs_net *, struct afs_server *, enum afs_server_trace); 1511 - extern void afs_unuse_server_notime(struct afs_net *, struct afs_server *, enum afs_server_trace); 1516 + struct afs_server *afs_use_server(struct afs_server *server, bool activate, 1517 + enum afs_server_trace reason); 1518 + void afs_unuse_server(struct afs_net *net, struct afs_server *server, 1519 + enum afs_server_trace reason); 1520 + void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server, 1521 + enum afs_server_trace reason); 1512 1522 extern void afs_put_server(struct afs_net *, struct afs_server *, enum afs_server_trace); 1513 - extern void afs_manage_servers(struct work_struct *); 1514 - extern void afs_servers_timer(struct timer_list *); 1523 + void afs_purge_servers(struct afs_cell *cell); 1515 1524 extern void afs_fs_probe_timer(struct timer_list *); 1516 - extern void __net_exit afs_purge_servers(struct afs_net *); 1525 + void __net_exit afs_wait_for_servers(struct afs_net *net); 1517 1526 bool afs_check_server_record(struct afs_operation *op, struct afs_server *server, struct key *key); 1527 + 1528 + static inline void afs_see_server(struct afs_server *server, enum afs_server_trace trace) 1529 + { 1530 + int r = refcount_read(&server->ref); 1531 + int a = atomic_read(&server->active); 1532 + 1533 + trace_afs_server(server->debug_id, r, a, trace); 1534 + 1535 + } 1518 1536 1519 1537 static inline void afs_inc_servers_outstanding(struct afs_net *net) 1520 1538 {

+5 -11

fs/afs/main.c

··· 76 76 mutex_init(&net->socket_mutex); 77 77 78 78 net->cells = RB_ROOT; 79 + idr_init(&net->cells_dyn_ino); 79 80 init_rwsem(&net->cells_lock); 80 - INIT_WORK(&net->cells_manager, afs_manage_cells); 81 - timer_setup(&net->cells_timer, afs_cells_timer, 0); 82 - 83 81 mutex_init(&net->cells_alias_lock); 84 82 mutex_init(&net->proc_cells_lock); 85 83 INIT_HLIST_HEAD(&net->proc_cells); 86 84 87 85 seqlock_init(&net->fs_lock); 88 - net->fs_servers = RB_ROOT; 89 86 INIT_LIST_HEAD(&net->fs_probe_fast); 90 87 INIT_LIST_HEAD(&net->fs_probe_slow); 91 88 INIT_HLIST_HEAD(&net->fs_proc); 92 89 93 - INIT_HLIST_HEAD(&net->fs_addresses); 94 - seqlock_init(&net->fs_addr_lock); 95 - 96 - INIT_WORK(&net->fs_manager, afs_manage_servers); 97 - timer_setup(&net->fs_timer, afs_servers_timer, 0); 98 90 INIT_WORK(&net->fs_prober, afs_fs_probe_dispatcher); 99 91 timer_setup(&net->fs_probe_timer, afs_fs_probe_timer, 0); 100 92 atomic_set(&net->servers_outstanding, 1); ··· 122 130 net->live = false; 123 131 afs_fs_probe_cleanup(net); 124 132 afs_cell_purge(net); 125 - afs_purge_servers(net); 133 + afs_wait_for_servers(net); 126 134 error_cell_init: 127 135 net->live = false; 128 136 afs_proc_cleanup(net); 129 137 error_proc: 130 138 afs_put_sysnames(net->sysnames); 131 139 error_sysnames: 140 + idr_destroy(&net->cells_dyn_ino); 132 141 net->live = false; 133 142 return ret; 134 143 } ··· 144 151 net->live = false; 145 152 afs_fs_probe_cleanup(net); 146 153 afs_cell_purge(net); 147 - afs_purge_servers(net); 154 + afs_wait_for_servers(net); 148 155 afs_close_socket(net); 149 156 afs_proc_cleanup(net); 150 157 afs_put_sysnames(net->sysnames); 158 + idr_destroy(&net->cells_dyn_ino); 151 159 kfree_rcu(rcu_access_pointer(net->address_prefs), rcu); 152 160 } 153 161

+3 -2

fs/afs/mntpt.c

··· 87 87 ctx->force = true; 88 88 } 89 89 if (ctx->cell) { 90 - afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_mntpt); 90 + afs_unuse_cell(ctx->cell, afs_cell_trace_unuse_mntpt); 91 91 ctx->cell = NULL; 92 92 } 93 93 if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) { ··· 107 107 if (size > AFS_MAXCELLNAME) 108 108 return -ENAMETOOLONG; 109 109 110 - cell = afs_lookup_cell(ctx->net, p, size, NULL, false); 110 + cell = afs_lookup_cell(ctx->net, p, size, NULL, false, 111 + afs_cell_trace_use_lookup_mntpt); 111 112 if (IS_ERR(cell)) { 112 113 pr_err("kAFS: unable to lookup cell '%pd'\n", mntpt); 113 114 return PTR_ERR(cell);

+11 -4

fs/afs/proc.c

··· 122 122 if (strcmp(buf, "add") == 0) { 123 123 struct afs_cell *cell; 124 124 125 - cell = afs_lookup_cell(net, name, strlen(name), args, true); 125 + cell = afs_lookup_cell(net, name, strlen(name), args, true, 126 + afs_cell_trace_use_lookup_add); 126 127 if (IS_ERR(cell)) { 127 128 ret = PTR_ERR(cell); 128 129 goto done; 129 130 } 130 131 131 132 if (test_and_set_bit(AFS_CELL_FL_NO_GC, &cell->flags)) 132 - afs_unuse_cell(net, cell, afs_cell_trace_unuse_no_pin); 133 + afs_unuse_cell(cell, afs_cell_trace_unuse_no_pin); 133 134 } else { 134 135 goto inval; 135 136 } ··· 444 443 } 445 444 446 445 server = list_entry(v, struct afs_server, proc_link); 447 - estate = rcu_dereference(server->endpoint_state); 448 - alist = estate->addresses; 449 446 seq_printf(m, "%pU %3d %3d %s\n", 450 447 &server->uuid, 451 448 refcount_read(&server->ref), ··· 453 454 server->flags, server->rtt); 454 455 seq_printf(m, " - probe: last=%d\n", 455 456 (int)(jiffies - server->probed_at) / HZ); 457 + 458 + estate = rcu_dereference(server->endpoint_state); 459 + if (!estate) 460 + goto out; 456 461 failed = estate->failed_set; 457 462 seq_printf(m, " - ESTATE pq=%x np=%u rsp=%lx f=%lx\n", 458 463 estate->probe_seq, atomic_read(&estate->nr_probing), 459 464 estate->responsive_set, estate->failed_set); 465 + 466 + alist = estate->addresses; 460 467 seq_printf(m, " - ALIST v=%u ap=%u\n", 461 468 alist->version, alist->addr_pref_version); 462 469 for (i = 0; i < alist->nr_addrs; i++) { ··· 475 470 rxrpc_kernel_get_srtt(addr->peer), 476 471 addr->last_error, addr->prio); 477 472 } 473 + 474 + out: 478 475 return 0; 479 476 } 480 477

+7 -1

fs/afs/rxrpc.c

··· 179 179 if (call->type->destructor) 180 180 call->type->destructor(call); 181 181 182 - afs_unuse_server_notime(call->net, call->server, afs_server_trace_put_call); 182 + afs_unuse_server_notime(call->net, call->server, afs_server_trace_unuse_call); 183 183 kfree(call->request); 184 184 185 185 o = atomic_read(&net->nr_outstanding_calls); ··· 766 766 static void afs_rx_new_call(struct sock *sk, struct rxrpc_call *rxcall, 767 767 unsigned long user_call_ID) 768 768 { 769 + struct afs_call *call = (struct afs_call *)user_call_ID; 769 770 struct afs_net *net = afs_sock2net(sk); 771 + 772 + call->peer = rxrpc_kernel_get_call_peer(sk->sk_socket, call->rxcall); 773 + call->server = afs_find_server(call->peer); 774 + if (!call->server) 775 + trace_afs_cm_no_server(call, rxrpc_kernel_remote_srx(call->peer)); 770 776 771 777 queue_work(afs_wq, &net->charge_preallocation_work); 772 778 }

+266 -355

fs/afs/server.c

··· 14 14 static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */ 15 15 static atomic_t afs_server_debug_id; 16 16 17 - static struct afs_server *afs_maybe_use_server(struct afs_server *, 18 - enum afs_server_trace); 19 17 static void __afs_put_server(struct afs_net *, struct afs_server *); 18 + static void afs_server_timer(struct timer_list *timer); 19 + static void afs_server_destroyer(struct work_struct *work); 20 20 21 21 /* 22 22 * Find a server by one of its addresses. 23 23 */ 24 - struct afs_server *afs_find_server(struct afs_net *net, const struct rxrpc_peer *peer) 24 + struct afs_server *afs_find_server(const struct rxrpc_peer *peer) 25 25 { 26 - const struct afs_endpoint_state *estate; 27 - const struct afs_addr_list *alist; 28 - struct afs_server *server = NULL; 29 - unsigned int i; 30 - int seq = 1; 26 + struct afs_server *server = (struct afs_server *)rxrpc_kernel_get_peer_data(peer); 31 27 32 - rcu_read_lock(); 33 - 34 - do { 35 - if (server) 36 - afs_unuse_server_notime(net, server, afs_server_trace_put_find_rsq); 37 - server = NULL; 38 - seq++; /* 2 on the 1st/lockless path, otherwise odd */ 39 - read_seqbegin_or_lock(&net->fs_addr_lock, &seq); 40 - 41 - hlist_for_each_entry_rcu(server, &net->fs_addresses, addr_link) { 42 - estate = rcu_dereference(server->endpoint_state); 43 - alist = estate->addresses; 44 - for (i = 0; i < alist->nr_addrs; i++) 45 - if (alist->addrs[i].peer == peer) 46 - goto found; 47 - } 48 - 49 - server = NULL; 50 - continue; 51 - found: 52 - server = afs_maybe_use_server(server, afs_server_trace_get_by_addr); 53 - 54 - } while (need_seqretry(&net->fs_addr_lock, seq)); 55 - 56 - done_seqretry(&net->fs_addr_lock, seq); 57 - 58 - rcu_read_unlock(); 59 - return server; 28 + if (!server) 29 + return NULL; 30 + return afs_use_server(server, false, afs_server_trace_use_cm_call); 60 31 } 61 32 62 33 /* 63 - * Look up a server by its UUID and mark it active. 34 + * Look up a server by its UUID and mark it active. The caller must hold 35 + * cell->fs_lock. 64 36 */ 65 - struct afs_server *afs_find_server_by_uuid(struct afs_net *net, const uuid_t *uuid) 37 + static struct afs_server *afs_find_server_by_uuid(struct afs_cell *cell, const uuid_t *uuid) 66 38 { 67 - struct afs_server *server = NULL; 39 + struct afs_server *server; 68 40 struct rb_node *p; 69 - int diff, seq = 1; 41 + int diff; 70 42 71 43 _enter("%pU", uuid); 72 44 73 - do { 74 - /* Unfortunately, rbtree walking doesn't give reliable results 75 - * under just the RCU read lock, so we have to check for 76 - * changes. 77 - */ 78 - if (server) 79 - afs_unuse_server(net, server, afs_server_trace_put_uuid_rsq); 80 - server = NULL; 81 - seq++; /* 2 on the 1st/lockless path, otherwise odd */ 82 - read_seqbegin_or_lock(&net->fs_lock, &seq); 45 + p = cell->fs_servers.rb_node; 46 + while (p) { 47 + server = rb_entry(p, struct afs_server, uuid_rb); 83 48 84 - p = net->fs_servers.rb_node; 85 - while (p) { 86 - server = rb_entry(p, struct afs_server, uuid_rb); 87 - 88 - diff = memcmp(uuid, &server->uuid, sizeof(*uuid)); 89 - if (diff < 0) { 90 - p = p->rb_left; 91 - } else if (diff > 0) { 92 - p = p->rb_right; 93 - } else { 94 - afs_use_server(server, afs_server_trace_get_by_uuid); 95 - break; 96 - } 97 - 98 - server = NULL; 49 + diff = memcmp(uuid, &server->uuid, sizeof(*uuid)); 50 + if (diff < 0) { 51 + p = p->rb_left; 52 + } else if (diff > 0) { 53 + p = p->rb_right; 54 + } else { 55 + if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) 56 + return NULL; /* Need a write lock */ 57 + afs_use_server(server, true, afs_server_trace_use_by_uuid); 58 + return server; 99 59 } 100 - } while (need_seqretry(&net->fs_lock, seq)); 60 + } 101 61 102 - done_seqretry(&net->fs_lock, seq); 103 - 104 - _leave(" = %p", server); 105 - return server; 62 + return NULL; 106 63 } 107 64 108 65 /* 109 - * Install a server record in the namespace tree. If there's a clash, we stick 110 - * it into a list anchored on whichever afs_server struct is actually in the 111 - * tree. 66 + * Install a server record in the cell tree. The caller must hold an exclusive 67 + * lock on cell->fs_lock. 112 68 */ 113 69 static struct afs_server *afs_install_server(struct afs_cell *cell, 114 - struct afs_server *candidate) 70 + struct afs_server **candidate) 115 71 { 116 - const struct afs_endpoint_state *estate; 117 - const struct afs_addr_list *alist; 118 - struct afs_server *server, *next; 72 + struct afs_server *server; 119 73 struct afs_net *net = cell->net; 120 74 struct rb_node **pp, *p; 121 75 int diff; 122 76 123 77 _enter("%p", candidate); 124 78 125 - write_seqlock(&net->fs_lock); 126 - 127 79 /* Firstly install the server in the UUID lookup tree */ 128 - pp = &net->fs_servers.rb_node; 80 + pp = &cell->fs_servers.rb_node; 129 81 p = NULL; 130 82 while (*pp) { 131 83 p = *pp; 132 84 _debug("- consider %p", p); 133 85 server = rb_entry(p, struct afs_server, uuid_rb); 134 - diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t)); 135 - if (diff < 0) { 86 + diff = memcmp(&(*candidate)->uuid, &server->uuid, sizeof(uuid_t)); 87 + if (diff < 0) 136 88 pp = &(*pp)->rb_left; 137 - } else if (diff > 0) { 89 + else if (diff > 0) 138 90 pp = &(*pp)->rb_right; 139 - } else { 140 - if (server->cell == cell) 141 - goto exists; 142 - 143 - /* We have the same UUID representing servers in 144 - * different cells. Append the new server to the list. 145 - */ 146 - for (;;) { 147 - next = rcu_dereference_protected( 148 - server->uuid_next, 149 - lockdep_is_held(&net->fs_lock.lock)); 150 - if (!next) 151 - break; 152 - server = next; 153 - } 154 - rcu_assign_pointer(server->uuid_next, candidate); 155 - candidate->uuid_prev = server; 156 - server = candidate; 157 - goto added_dup; 158 - } 91 + else 92 + goto exists; 159 93 } 160 94 161 - server = candidate; 95 + server = *candidate; 96 + *candidate = NULL; 162 97 rb_link_node(&server->uuid_rb, p, pp); 163 - rb_insert_color(&server->uuid_rb, &net->fs_servers); 98 + rb_insert_color(&server->uuid_rb, &cell->fs_servers); 99 + write_seqlock(&net->fs_lock); 164 100 hlist_add_head_rcu(&server->proc_link, &net->fs_proc); 101 + write_sequnlock(&net->fs_lock); 165 102 166 103 afs_get_cell(cell, afs_cell_trace_get_server); 167 104 168 - added_dup: 169 - write_seqlock(&net->fs_addr_lock); 170 - estate = rcu_dereference_protected(server->endpoint_state, 171 - lockdep_is_held(&net->fs_addr_lock.lock)); 172 - alist = estate->addresses; 173 - 174 - /* Secondly, if the server has any IPv4 and/or IPv6 addresses, install 175 - * it in the IPv4 and/or IPv6 reverse-map lists. 176 - * 177 - * TODO: For speed we want to use something other than a flat list 178 - * here; even sorting the list in terms of lowest address would help a 179 - * bit, but anything we might want to do gets messy and memory 180 - * intensive. 181 - */ 182 - if (alist->nr_addrs > 0) 183 - hlist_add_head_rcu(&server->addr_link, &net->fs_addresses); 184 - 185 - write_sequnlock(&net->fs_addr_lock); 186 - 187 105 exists: 188 - afs_get_server(server, afs_server_trace_get_install); 189 - write_sequnlock(&net->fs_lock); 106 + afs_use_server(server, true, afs_server_trace_use_install); 190 107 return server; 191 108 } 192 109 193 110 /* 194 - * Allocate a new server record and mark it active. 111 + * Allocate a new server record and mark it as active but uncreated. 195 112 */ 196 - static struct afs_server *afs_alloc_server(struct afs_cell *cell, 197 - const uuid_t *uuid, 198 - struct afs_addr_list *alist) 113 + static struct afs_server *afs_alloc_server(struct afs_cell *cell, const uuid_t *uuid) 199 114 { 200 - struct afs_endpoint_state *estate; 201 115 struct afs_server *server; 202 116 struct afs_net *net = cell->net; 203 117 ··· 119 205 120 206 server = kzalloc(sizeof(struct afs_server), GFP_KERNEL); 121 207 if (!server) 122 - goto enomem; 123 - 124 - estate = kzalloc(sizeof(struct afs_endpoint_state), GFP_KERNEL); 125 - if (!estate) 126 - goto enomem_server; 208 + return NULL; 127 209 128 210 refcount_set(&server->ref, 1); 129 - atomic_set(&server->active, 1); 211 + atomic_set(&server->active, 0); 212 + __set_bit(AFS_SERVER_FL_UNCREATED, &server->flags); 130 213 server->debug_id = atomic_inc_return(&afs_server_debug_id); 131 - server->addr_version = alist->version; 132 214 server->uuid = *uuid; 133 215 rwlock_init(&server->fs_lock); 216 + INIT_WORK(&server->destroyer, &afs_server_destroyer); 217 + timer_setup(&server->timer, afs_server_timer, 0); 134 218 INIT_LIST_HEAD(&server->volumes); 135 219 init_waitqueue_head(&server->probe_wq); 136 220 INIT_LIST_HEAD(&server->probe_link); 221 + INIT_HLIST_NODE(&server->proc_link); 137 222 spin_lock_init(&server->probe_lock); 138 223 server->cell = cell; 139 224 server->rtt = UINT_MAX; 140 225 server->service_id = FS_SERVICE; 141 - 142 226 server->probe_counter = 1; 143 227 server->probed_at = jiffies - LONG_MAX / 2; 144 - refcount_set(&estate->ref, 1); 145 - estate->addresses = alist; 146 - estate->server_id = server->debug_id; 147 - estate->probe_seq = 1; 148 - rcu_assign_pointer(server->endpoint_state, estate); 149 228 150 229 afs_inc_servers_outstanding(net); 151 - trace_afs_server(server->debug_id, 1, 1, afs_server_trace_alloc); 152 - trace_afs_estate(estate->server_id, estate->probe_seq, refcount_read(&estate->ref), 153 - afs_estate_trace_alloc_server); 154 230 _leave(" = %p", server); 155 231 return server; 156 - 157 - enomem_server: 158 - kfree(server); 159 - enomem: 160 - _leave(" = NULL [nomem]"); 161 - return NULL; 162 232 } 163 233 164 234 /* 165 235 * Look up an address record for a server 166 236 */ 167 - static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell, 168 - struct key *key, const uuid_t *uuid) 237 + static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_server *server, 238 + struct key *key) 169 239 { 170 240 struct afs_vl_cursor vc; 171 241 struct afs_addr_list *alist = NULL; 172 242 int ret; 173 243 174 244 ret = -ERESTARTSYS; 175 - if (afs_begin_vlserver_operation(&vc, cell, key)) { 245 + if (afs_begin_vlserver_operation(&vc, server->cell, key)) { 176 246 while (afs_select_vlserver(&vc)) { 177 247 if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) 178 - alist = afs_yfsvl_get_endpoints(&vc, uuid); 248 + alist = afs_yfsvl_get_endpoints(&vc, &server->uuid); 179 249 else 180 - alist = afs_vl_get_addrs_u(&vc, uuid); 250 + alist = afs_vl_get_addrs_u(&vc, &server->uuid); 181 251 } 182 252 183 253 ret = afs_end_vlserver_operation(&vc); ··· 171 273 } 172 274 173 275 /* 174 - * Get or create a fileserver record. 276 + * Get or create a fileserver record and return it with an active-use count on 277 + * it. 175 278 */ 176 279 struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key, 177 280 const uuid_t *uuid, u32 addr_version) 178 281 { 179 - struct afs_addr_list *alist; 180 - struct afs_server *server, *candidate; 282 + struct afs_addr_list *alist = NULL; 283 + struct afs_server *server, *candidate = NULL; 284 + bool creating = false; 285 + int ret; 181 286 182 287 _enter("%p,%pU", cell->net, uuid); 183 288 184 - server = afs_find_server_by_uuid(cell->net, uuid); 289 + down_read(&cell->fs_lock); 290 + server = afs_find_server_by_uuid(cell, uuid); 291 + /* Won't see servers marked uncreated. */ 292 + up_read(&cell->fs_lock); 293 + 185 294 if (server) { 295 + timer_delete_sync(&server->timer); 296 + if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) 297 + goto wait_for_creation; 186 298 if (server->addr_version != addr_version) 187 299 set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); 188 300 return server; 189 301 } 190 302 191 - alist = afs_vl_lookup_addrs(cell, key, uuid); 192 - if (IS_ERR(alist)) 193 - return ERR_CAST(alist); 194 - 195 - candidate = afs_alloc_server(cell, uuid, alist); 303 + candidate = afs_alloc_server(cell, uuid); 196 304 if (!candidate) { 197 305 afs_put_addrlist(alist, afs_alist_trace_put_server_oom); 198 306 return ERR_PTR(-ENOMEM); 199 307 } 200 308 201 - server = afs_install_server(cell, candidate); 202 - if (server != candidate) { 203 - afs_put_addrlist(alist, afs_alist_trace_put_server_dup); 309 + down_write(&cell->fs_lock); 310 + server = afs_install_server(cell, &candidate); 311 + if (test_bit(AFS_SERVER_FL_CREATING, &server->flags)) { 312 + /* We need to wait for creation to complete. */ 313 + up_write(&cell->fs_lock); 314 + goto wait_for_creation; 315 + } 316 + if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) { 317 + set_bit(AFS_SERVER_FL_CREATING, &server->flags); 318 + clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags); 319 + creating = true; 320 + } 321 + up_write(&cell->fs_lock); 322 + timer_delete_sync(&server->timer); 323 + 324 + /* If we get to create the server, we look up the addresses and then 325 + * immediately dispatch an asynchronous probe to each interface on the 326 + * fileserver. This will make sure the repeat-probing service is 327 + * started. 328 + */ 329 + if (creating) { 330 + alist = afs_vl_lookup_addrs(server, key); 331 + if (IS_ERR(alist)) { 332 + ret = PTR_ERR(alist); 333 + goto create_failed; 334 + } 335 + 336 + ret = afs_fs_probe_fileserver(cell->net, server, alist, key); 337 + if (ret) 338 + goto create_failed; 339 + 340 + clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags); 341 + } 342 + 343 + out: 344 + afs_put_addrlist(alist, afs_alist_trace_put_server_create); 345 + if (candidate) { 346 + kfree(rcu_access_pointer(server->endpoint_state)); 204 347 kfree(candidate); 205 - } else { 206 - /* Immediately dispatch an asynchronous probe to each interface 207 - * on the fileserver. This will make sure the repeat-probing 208 - * service is started. 209 - */ 210 - afs_fs_probe_fileserver(cell->net, server, alist, key); 348 + afs_dec_servers_outstanding(cell->net); 349 + } 350 + return server ?: ERR_PTR(ret); 351 + 352 + wait_for_creation: 353 + afs_see_server(server, afs_server_trace_wait_create); 354 + wait_on_bit(&server->flags, AFS_SERVER_FL_CREATING, TASK_UNINTERRUPTIBLE); 355 + if (test_bit_acquire(AFS_SERVER_FL_UNCREATED, &server->flags)) { 356 + /* Barrier: read flag before error */ 357 + ret = READ_ONCE(server->create_error); 358 + afs_put_server(cell->net, server, afs_server_trace_unuse_create_fail); 359 + server = NULL; 360 + goto out; 211 361 } 212 362 213 - return server; 363 + ret = 0; 364 + goto out; 365 + 366 + create_failed: 367 + down_write(&cell->fs_lock); 368 + 369 + WRITE_ONCE(server->create_error, ret); 370 + smp_wmb(); /* Barrier: set error before flag. */ 371 + set_bit(AFS_SERVER_FL_UNCREATED, &server->flags); 372 + 373 + clear_and_wake_up_bit(AFS_SERVER_FL_CREATING, &server->flags); 374 + 375 + if (test_bit(AFS_SERVER_FL_UNCREATED, &server->flags)) { 376 + clear_bit(AFS_SERVER_FL_UNCREATED, &server->flags); 377 + creating = true; 378 + } 379 + afs_unuse_server(cell->net, server, afs_server_trace_unuse_create_fail); 380 + server = NULL; 381 + 382 + up_write(&cell->fs_lock); 383 + goto out; 214 384 } 215 385 216 386 /* 217 - * Set the server timer to fire after a given delay, assuming it's not already 218 - * set for an earlier time. 387 + * Set/reduce a server's timer. 219 388 */ 220 - static void afs_set_server_timer(struct afs_net *net, time64_t delay) 389 + static void afs_set_server_timer(struct afs_server *server, unsigned int delay_secs) 221 390 { 222 - if (net->live) { 223 - afs_inc_servers_outstanding(net); 224 - if (timer_reduce(&net->fs_timer, jiffies + delay * HZ)) 225 - afs_dec_servers_outstanding(net); 226 - } 227 - } 228 - 229 - /* 230 - * Server management timer. We have an increment on fs_outstanding that we 231 - * need to pass along to the work item. 232 - */ 233 - void afs_servers_timer(struct timer_list *timer) 234 - { 235 - struct afs_net *net = container_of(timer, struct afs_net, fs_timer); 236 - 237 - _enter(""); 238 - if (!queue_work(afs_wq, &net->fs_manager)) 239 - afs_dec_servers_outstanding(net); 391 + mod_timer(&server->timer, jiffies + delay_secs * HZ); 240 392 } 241 393 242 394 /* ··· 305 357 } 306 358 307 359 /* 308 - * Try to get a reference on a server object. 360 + * Get an active count on a server object and maybe remove from the inactive 361 + * list. 309 362 */ 310 - static struct afs_server *afs_maybe_use_server(struct afs_server *server, 311 - enum afs_server_trace reason) 312 - { 313 - unsigned int a; 314 - int r; 315 - 316 - if (!__refcount_inc_not_zero(&server->ref, &r)) 317 - return NULL; 318 - 319 - a = atomic_inc_return(&server->active); 320 - trace_afs_server(server->debug_id, r + 1, a, reason); 321 - return server; 322 - } 323 - 324 - /* 325 - * Get an active count on a server object. 326 - */ 327 - struct afs_server *afs_use_server(struct afs_server *server, enum afs_server_trace reason) 363 + struct afs_server *afs_use_server(struct afs_server *server, bool activate, 364 + enum afs_server_trace reason) 328 365 { 329 366 unsigned int a; 330 367 int r; 331 368 332 369 __refcount_inc(&server->ref, &r); 333 370 a = atomic_inc_return(&server->active); 371 + if (a == 1 && activate && 372 + !test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) 373 + del_timer(&server->timer); 334 374 335 375 trace_afs_server(server->debug_id, r + 1, a, reason); 336 376 return server; ··· 351 415 void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server, 352 416 enum afs_server_trace reason) 353 417 { 354 - if (server) { 355 - unsigned int active = atomic_dec_return(&server->active); 418 + if (!server) 419 + return; 356 420 357 - if (active == 0) 358 - afs_set_server_timer(net, afs_server_gc_delay); 359 - afs_put_server(net, server, reason); 421 + if (atomic_dec_and_test(&server->active)) { 422 + if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) || 423 + READ_ONCE(server->cell->state) >= AFS_CELL_REMOVING) 424 + schedule_work(&server->destroyer); 360 425 } 426 + 427 + afs_put_server(net, server, reason); 361 428 } 362 429 363 430 /* ··· 369 430 void afs_unuse_server(struct afs_net *net, struct afs_server *server, 370 431 enum afs_server_trace reason) 371 432 { 372 - if (server) { 373 - server->unuse_time = ktime_get_real_seconds(); 374 - afs_unuse_server_notime(net, server, reason); 433 + if (!server) 434 + return; 435 + 436 + if (atomic_dec_and_test(&server->active)) { 437 + if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags) && 438 + READ_ONCE(server->cell->state) < AFS_CELL_REMOVING) { 439 + time64_t unuse_time = ktime_get_real_seconds(); 440 + 441 + server->unuse_time = unuse_time; 442 + afs_set_server_timer(server, afs_server_gc_delay); 443 + } else { 444 + schedule_work(&server->destroyer); 445 + } 375 446 } 447 + 448 + afs_put_server(net, server, reason); 376 449 } 377 450 378 451 static void afs_server_rcu(struct rcu_head *rcu) ··· 414 463 } 415 464 416 465 /* 417 - * destroy a dead server 466 + * Check to see if the server record has expired. 418 467 */ 419 - static void afs_destroy_server(struct afs_net *net, struct afs_server *server) 468 + static bool afs_has_server_expired(const struct afs_server *server) 420 469 { 470 + time64_t expires_at; 471 + 472 + if (atomic_read(&server->active)) 473 + return false; 474 + 475 + if (server->cell->net->live || 476 + server->cell->state >= AFS_CELL_REMOVING) { 477 + trace_afs_server(server->debug_id, refcount_read(&server->ref), 478 + 0, afs_server_trace_purging); 479 + return true; 480 + } 481 + 482 + expires_at = server->unuse_time; 483 + if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) && 484 + !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags)) 485 + expires_at += afs_server_gc_delay; 486 + 487 + return ktime_get_real_seconds() > expires_at; 488 + } 489 + 490 + /* 491 + * Remove a server record from it's parent cell's database. 492 + */ 493 + static bool afs_remove_server_from_cell(struct afs_server *server) 494 + { 495 + struct afs_cell *cell = server->cell; 496 + 497 + down_write(&cell->fs_lock); 498 + 499 + if (!afs_has_server_expired(server)) { 500 + up_write(&cell->fs_lock); 501 + return false; 502 + } 503 + 504 + set_bit(AFS_SERVER_FL_EXPIRED, &server->flags); 505 + _debug("expire %pU %u", &server->uuid, atomic_read(&server->active)); 506 + afs_see_server(server, afs_server_trace_see_expired); 507 + rb_erase(&server->uuid_rb, &cell->fs_servers); 508 + up_write(&cell->fs_lock); 509 + return true; 510 + } 511 + 512 + static void afs_server_destroyer(struct work_struct *work) 513 + { 514 + struct afs_endpoint_state *estate; 515 + struct afs_server *server = container_of(work, struct afs_server, destroyer); 516 + struct afs_net *net = server->cell->net; 517 + 518 + afs_see_server(server, afs_server_trace_see_destroyer); 519 + 520 + if (test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) 521 + return; 522 + 523 + if (!afs_remove_server_from_cell(server)) 524 + return; 525 + 526 + timer_shutdown_sync(&server->timer); 527 + cancel_work(&server->destroyer); 528 + 421 529 if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags)) 422 530 afs_give_up_callbacks(net, server); 531 + 532 + /* Unbind the rxrpc_peer records from the server. */ 533 + estate = rcu_access_pointer(server->endpoint_state); 534 + if (estate) 535 + afs_set_peer_appdata(server, estate->addresses, NULL); 536 + 537 + write_seqlock(&net->fs_lock); 538 + list_del_init(&server->probe_link); 539 + if (!hlist_unhashed(&server->proc_link)) 540 + hlist_del_rcu(&server->proc_link); 541 + write_sequnlock(&net->fs_lock); 423 542 424 543 afs_put_server(net, server, afs_server_trace_destroy); 425 544 } 426 545 427 - /* 428 - * Garbage collect any expired servers. 429 - */ 430 - static void afs_gc_servers(struct afs_net *net, struct afs_server *gc_list) 546 + static void afs_server_timer(struct timer_list *timer) 431 547 { 432 - struct afs_server *server, *next, *prev; 433 - int active; 548 + struct afs_server *server = container_of(timer, struct afs_server, timer); 434 549 435 - while ((server = gc_list)) { 436 - gc_list = server->gc_next; 437 - 438 - write_seqlock(&net->fs_lock); 439 - 440 - active = atomic_read(&server->active); 441 - if (active == 0) { 442 - trace_afs_server(server->debug_id, refcount_read(&server->ref), 443 - active, afs_server_trace_gc); 444 - next = rcu_dereference_protected( 445 - server->uuid_next, lockdep_is_held(&net->fs_lock.lock)); 446 - prev = server->uuid_prev; 447 - if (!prev) { 448 - /* The one at the front is in the tree */ 449 - if (!next) { 450 - rb_erase(&server->uuid_rb, &net->fs_servers); 451 - } else { 452 - rb_replace_node_rcu(&server->uuid_rb, 453 - &next->uuid_rb, 454 - &net->fs_servers); 455 - next->uuid_prev = NULL; 456 - } 457 - } else { 458 - /* This server is not at the front */ 459 - rcu_assign_pointer(prev->uuid_next, next); 460 - if (next) 461 - next->uuid_prev = prev; 462 - } 463 - 464 - list_del(&server->probe_link); 465 - hlist_del_rcu(&server->proc_link); 466 - if (!hlist_unhashed(&server->addr_link)) 467 - hlist_del_rcu(&server->addr_link); 468 - } 469 - write_sequnlock(&net->fs_lock); 470 - 471 - if (active == 0) 472 - afs_destroy_server(net, server); 473 - } 550 + afs_see_server(server, afs_server_trace_see_timer); 551 + if (!test_bit(AFS_SERVER_FL_EXPIRED, &server->flags)) 552 + schedule_work(&server->destroyer); 474 553 } 475 554 476 555 /* 477 - * Manage the records of servers known to be within a network namespace. This 478 - * includes garbage collecting unused servers. 479 - * 480 - * Note also that we were given an increment on net->servers_outstanding by 481 - * whoever queued us that we need to deal with before returning. 556 + * Wake up all the servers in a cell so that they can purge themselves. 482 557 */ 483 - void afs_manage_servers(struct work_struct *work) 558 + void afs_purge_servers(struct afs_cell *cell) 484 559 { 485 - struct afs_net *net = container_of(work, struct afs_net, fs_manager); 486 - struct afs_server *gc_list = NULL; 487 - struct rb_node *cursor; 488 - time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX; 489 - bool purging = !net->live; 560 + struct afs_server *server; 561 + struct rb_node *rb; 490 562 491 - _enter(""); 492 - 493 - /* Trawl the server list looking for servers that have expired from 494 - * lack of use. 495 - */ 496 - read_seqlock_excl(&net->fs_lock); 497 - 498 - for (cursor = rb_first(&net->fs_servers); cursor; cursor = rb_next(cursor)) { 499 - struct afs_server *server = 500 - rb_entry(cursor, struct afs_server, uuid_rb); 501 - int active = atomic_read(&server->active); 502 - 503 - _debug("manage %pU %u", &server->uuid, active); 504 - 505 - if (purging) { 506 - trace_afs_server(server->debug_id, refcount_read(&server->ref), 507 - active, afs_server_trace_purging); 508 - if (active != 0) 509 - pr_notice("Can't purge s=%08x\n", server->debug_id); 510 - } 511 - 512 - if (active == 0) { 513 - time64_t expire_at = server->unuse_time; 514 - 515 - if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) && 516 - !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags)) 517 - expire_at += afs_server_gc_delay; 518 - if (purging || expire_at <= now) { 519 - server->gc_next = gc_list; 520 - gc_list = server; 521 - } else if (expire_at < next_manage) { 522 - next_manage = expire_at; 523 - } 524 - } 563 + down_read(&cell->fs_lock); 564 + for (rb = rb_first(&cell->fs_servers); rb; rb = rb_next(rb)) { 565 + server = rb_entry(rb, struct afs_server, uuid_rb); 566 + afs_see_server(server, afs_server_trace_see_purge); 567 + schedule_work(&server->destroyer); 525 568 } 526 - 527 - read_sequnlock_excl(&net->fs_lock); 528 - 529 - /* Update the timer on the way out. We have to pass an increment on 530 - * servers_outstanding in the namespace that we are in to the timer or 531 - * the work scheduler. 532 - */ 533 - if (!purging && next_manage < TIME64_MAX) { 534 - now = ktime_get_real_seconds(); 535 - 536 - if (next_manage - now <= 0) { 537 - if (queue_work(afs_wq, &net->fs_manager)) 538 - afs_inc_servers_outstanding(net); 539 - } else { 540 - afs_set_server_timer(net, next_manage - now); 541 - } 542 - } 543 - 544 - afs_gc_servers(net, gc_list); 545 - 546 - afs_dec_servers_outstanding(net); 547 - _leave(" [%d]", atomic_read(&net->servers_outstanding)); 548 - } 549 - 550 - static void afs_queue_server_manager(struct afs_net *net) 551 - { 552 - afs_inc_servers_outstanding(net); 553 - if (!queue_work(afs_wq, &net->fs_manager)) 554 - afs_dec_servers_outstanding(net); 569 + up_read(&cell->fs_lock); 555 570 } 556 571 557 572 /* 558 - * Purge list of servers. 573 + * Wait for outstanding servers. 559 574 */ 560 - void afs_purge_servers(struct afs_net *net) 575 + void afs_wait_for_servers(struct afs_net *net) 561 576 { 562 577 _enter(""); 563 578 564 - if (del_timer_sync(&net->fs_timer)) 565 - afs_dec_servers_outstanding(net); 566 - 567 - afs_queue_server_manager(net); 568 - 569 - _debug("wait"); 570 579 atomic_dec(&net->servers_outstanding); 571 580 wait_var_event(&net->servers_outstanding, 572 581 !atomic_read(&net->servers_outstanding)); ··· 550 639 atomic_read(&server->active), 551 640 afs_server_trace_update); 552 641 553 - alist = afs_vl_lookup_addrs(op->volume->cell, op->key, &server->uuid); 642 + alist = afs_vl_lookup_addrs(server, op->key); 554 643 if (IS_ERR(alist)) { 555 644 rcu_read_lock(); 556 645 estate = rcu_dereference(server->endpoint_state);

+3 -3

fs/afs/server_list.c

··· 16 16 if (slist && refcount_dec_and_test(&slist->usage)) { 17 17 for (i = 0; i < slist->nr_servers; i++) 18 18 afs_unuse_server(net, slist->servers[i].server, 19 - afs_server_trace_put_slist); 19 + afs_server_trace_unuse_slist); 20 20 kfree_rcu(slist, rcu); 21 21 } 22 22 } ··· 97 97 break; 98 98 if (j < slist->nr_servers) { 99 99 if (slist->servers[j].server == server) { 100 - afs_unuse_server(volume->cell->net, server, 101 - afs_server_trace_put_slist_isort); 100 + afs_unuse_server_notime(volume->cell->net, server, 101 + afs_server_trace_unuse_slist_isort); 102 102 continue; 103 103 } 104 104

+7 -18

fs/afs/super.c

··· 194 194 195 195 if (as->dyn_root) 196 196 seq_puts(m, ",dyn"); 197 - if (test_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(d_inode(root))->flags)) 198 - seq_puts(m, ",autocell"); 199 197 switch (as->flock_mode) { 200 198 case afs_flock_mode_unset: break; 201 199 case afs_flock_mode_local: p = "local"; break; ··· 290 292 /* lookup the cell record */ 291 293 if (cellname) { 292 294 cell = afs_lookup_cell(ctx->net, cellname, cellnamesz, 293 - NULL, false); 295 + NULL, false, 296 + afs_cell_trace_use_lookup_mount); 294 297 if (IS_ERR(cell)) { 295 298 pr_err("kAFS: unable to lookup cell '%*.*s'\n", 296 299 cellnamesz, cellnamesz, cellname ?: ""); 297 300 return PTR_ERR(cell); 298 301 } 299 - afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_parse); 302 + afs_unuse_cell(ctx->cell, afs_cell_trace_unuse_parse); 300 303 afs_see_cell(cell, afs_cell_trace_see_source); 301 304 ctx->cell = cell; 302 305 } ··· 394 395 ctx->key = NULL; 395 396 cell = afs_use_cell(ctx->cell->alias_of, 396 397 afs_cell_trace_use_fc_alias); 397 - afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_fc); 398 + afs_unuse_cell(ctx->cell, afs_cell_trace_unuse_fc); 398 399 ctx->cell = cell; 399 400 goto reget_key; 400 401 } ··· 467 468 468 469 /* allocate the root inode and dentry */ 469 470 if (as->dyn_root) { 470 - inode = afs_iget_pseudo_dir(sb, true); 471 + inode = afs_dynroot_iget_root(sb); 471 472 } else { 472 473 sprintf(sb->s_id, "%llu", as->volume->vid); 473 474 afs_activate_volume(as->volume); ··· 477 478 if (IS_ERR(inode)) 478 479 return PTR_ERR(inode); 479 480 480 - if (ctx->autocell || as->dyn_root) 481 - set_bit(AFS_VNODE_AUTOCELL, &AFS_FS_I(inode)->flags); 482 - 483 481 ret = -ENOMEM; 484 482 sb->s_root = d_make_root(inode); 485 483 if (!sb->s_root) ··· 484 488 485 489 if (as->dyn_root) { 486 490 sb->s_d_op = &afs_dynroot_dentry_operations; 487 - ret = afs_dynroot_populate(sb); 488 - if (ret < 0) 489 - goto error; 490 491 } else { 491 492 sb->s_d_op = &afs_fs_dentry_operations; 492 493 rcu_assign_pointer(as->volume->sb, sb); ··· 520 527 static void afs_destroy_sbi(struct afs_super_info *as) 521 528 { 522 529 if (as) { 523 - struct afs_net *net = afs_net(as->net_ns); 524 530 afs_put_volume(as->volume, afs_volume_trace_put_destroy_sbi); 525 - afs_unuse_cell(net, as->cell, afs_cell_trace_unuse_sbi); 531 + afs_unuse_cell(as->cell, afs_cell_trace_unuse_sbi); 526 532 put_net(as->net_ns); 527 533 kfree(as); 528 534 } ··· 530 538 static void afs_kill_super(struct super_block *sb) 531 539 { 532 540 struct afs_super_info *as = AFS_FS_S(sb); 533 - 534 - if (as->dyn_root) 535 - afs_dynroot_depopulate(sb); 536 541 537 542 /* Clear the callback interests (which will do ilookup5) before 538 543 * deactivating the superblock. ··· 604 615 605 616 afs_destroy_sbi(fc->s_fs_info); 606 617 afs_put_volume(ctx->volume, afs_volume_trace_put_free_fc); 607 - afs_unuse_cell(ctx->net, ctx->cell, afs_cell_trace_unuse_fc); 618 + afs_unuse_cell(ctx->cell, afs_cell_trace_unuse_fc); 608 619 key_put(ctx->key); 609 620 kfree(ctx); 610 621 }

+4 -3

fs/afs/vl_alias.c

··· 205 205 goto is_alias; 206 206 207 207 if (mutex_lock_interruptible(&cell->net->proc_cells_lock) < 0) { 208 - afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias); 208 + afs_unuse_cell(p, afs_cell_trace_unuse_check_alias); 209 209 return -ERESTARTSYS; 210 210 } 211 211 212 - afs_unuse_cell(cell->net, p, afs_cell_trace_unuse_check_alias); 212 + afs_unuse_cell(p, afs_cell_trace_unuse_check_alias); 213 213 } 214 214 215 215 mutex_unlock(&cell->net->proc_cells_lock); ··· 269 269 if (!name_len || name_len > AFS_MAXCELLNAME) 270 270 master = ERR_PTR(-EOPNOTSUPP); 271 271 else 272 - master = afs_lookup_cell(cell->net, cell_name, name_len, NULL, false); 272 + master = afs_lookup_cell(cell->net, cell_name, name_len, NULL, false, 273 + afs_cell_trace_use_lookup_canonical); 273 274 kfree(cell_name); 274 275 if (IS_ERR(master)) 275 276 return PTR_ERR(master);

+1 -1

fs/afs/vl_rotate.c

··· 48 48 cell->dns_expiry <= ktime_get_real_seconds()) { 49 49 dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count); 50 50 set_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags); 51 - afs_queue_cell(cell, afs_cell_trace_get_queue_dns); 51 + afs_queue_cell(cell, afs_cell_trace_queue_dns); 52 52 53 53 if (cell->dns_source == DNS_RECORD_UNAVAILABLE) { 54 54 if (wait_var_event_interruptible(

+9 -6

fs/afs/volume.c

··· 10 10 #include "internal.h" 11 11 12 12 static unsigned __read_mostly afs_volume_record_life = 60 * 60; 13 + static atomic_t afs_volume_debug_id; 13 14 14 15 static void afs_destroy_volume(struct work_struct *work); 15 16 ··· 60 59 struct afs_cell *cell = volume->cell; 61 60 62 61 if (!hlist_unhashed(&volume->proc_link)) { 63 - trace_afs_volume(volume->vid, refcount_read(&cell->ref), 62 + trace_afs_volume(volume->debug_id, volume->vid, refcount_read(&volume->ref), 64 63 afs_volume_trace_remove); 65 64 write_seqlock(&cell->volume_lock); 66 65 hlist_del_rcu(&volume->proc_link); ··· 85 84 if (!volume) 86 85 goto error_0; 87 86 87 + volume->debug_id = atomic_inc_return(&afs_volume_debug_id); 88 88 volume->vid = vldb->vid[params->type]; 89 89 volume->update_at = ktime_get_real_seconds() + afs_volume_record_life; 90 90 volume->cell = afs_get_cell(params->cell, afs_cell_trace_get_vol); ··· 117 115 118 116 *_slist = slist; 119 117 rcu_assign_pointer(volume->servers, slist); 120 - trace_afs_volume(volume->vid, 1, afs_volume_trace_alloc); 118 + trace_afs_volume(volume->debug_id, volume->vid, 1, afs_volume_trace_alloc); 121 119 return volume; 122 120 123 121 error_1: ··· 249 247 afs_remove_volume_from_cell(volume); 250 248 afs_put_serverlist(volume->cell->net, slist); 251 249 afs_put_cell(volume->cell, afs_cell_trace_put_vol); 252 - trace_afs_volume(volume->vid, refcount_read(&volume->ref), 250 + trace_afs_volume(volume->debug_id, volume->vid, refcount_read(&volume->ref), 253 251 afs_volume_trace_free); 254 252 kfree_rcu(volume, rcu); 255 253 ··· 264 262 int r; 265 263 266 264 if (__refcount_inc_not_zero(&volume->ref, &r)) { 267 - trace_afs_volume(volume->vid, r + 1, reason); 265 + trace_afs_volume(volume->debug_id, volume->vid, r + 1, reason); 268 266 return true; 269 267 } 270 268 return false; ··· 280 278 int r; 281 279 282 280 __refcount_inc(&volume->ref, &r); 283 - trace_afs_volume(volume->vid, r + 1, reason); 281 + trace_afs_volume(volume->debug_id, volume->vid, r + 1, reason); 284 282 } 285 283 return volume; 286 284 } ··· 292 290 void afs_put_volume(struct afs_volume *volume, enum afs_volume_trace reason) 293 291 { 294 292 if (volume) { 293 + unsigned int debug_id = volume->debug_id; 295 294 afs_volid_t vid = volume->vid; 296 295 bool zero; 297 296 int r; 298 297 299 298 zero = __refcount_dec_and_test(&volume->ref, &r); 300 - trace_afs_volume(vid, r - 1, reason); 299 + trace_afs_volume(debug_id, vid, r - 1, reason); 301 300 if (zero) 302 301 schedule_work(&volume->destructor); 303 302 }

+2

include/net/af_rxrpc.h

··· 69 69 struct rxrpc_peer *rxrpc_kernel_get_call_peer(struct socket *sock, struct rxrpc_call *call); 70 70 const struct sockaddr_rxrpc *rxrpc_kernel_remote_srx(const struct rxrpc_peer *peer); 71 71 const struct sockaddr *rxrpc_kernel_remote_addr(const struct rxrpc_peer *peer); 72 + unsigned long rxrpc_kernel_set_peer_data(struct rxrpc_peer *peer, unsigned long app_data); 73 + unsigned long rxrpc_kernel_get_peer_data(const struct rxrpc_peer *peer); 72 74 unsigned int rxrpc_kernel_get_srtt(const struct rxrpc_peer *); 73 75 int rxrpc_kernel_charge_accept(struct socket *, rxrpc_notify_rx_t, 74 76 rxrpc_user_attach_call_t, unsigned long, gfp_t,

+48 -35

include/trace/events/afs.h

··· 127 127 E_(afs_call_trace_work, "QUEUE") 128 128 129 129 #define afs_server_traces \ 130 - EM(afs_server_trace_alloc, "ALLOC ") \ 131 130 EM(afs_server_trace_callback, "CALLBACK ") \ 132 131 EM(afs_server_trace_destroy, "DESTROY ") \ 133 132 EM(afs_server_trace_free, "FREE ") \ 134 133 EM(afs_server_trace_gc, "GC ") \ 135 - EM(afs_server_trace_get_by_addr, "GET addr ") \ 136 - EM(afs_server_trace_get_by_uuid, "GET uuid ") \ 137 - EM(afs_server_trace_get_caps, "GET caps ") \ 138 - EM(afs_server_trace_get_install, "GET inst ") \ 139 - EM(afs_server_trace_get_new_cbi, "GET cbi ") \ 140 134 EM(afs_server_trace_get_probe, "GET probe") \ 141 - EM(afs_server_trace_give_up_cb, "giveup-cb") \ 142 135 EM(afs_server_trace_purging, "PURGE ") \ 143 - EM(afs_server_trace_put_call, "PUT call ") \ 144 136 EM(afs_server_trace_put_cbi, "PUT cbi ") \ 145 - EM(afs_server_trace_put_find_rsq, "PUT f-rsq") \ 146 137 EM(afs_server_trace_put_probe, "PUT probe") \ 147 - EM(afs_server_trace_put_slist, "PUT slist") \ 148 - EM(afs_server_trace_put_slist_isort, "PUT isort") \ 149 - EM(afs_server_trace_put_uuid_rsq, "PUT u-req") \ 150 - E_(afs_server_trace_update, "UPDATE") 138 + EM(afs_server_trace_see_destroyer, "SEE destr") \ 139 + EM(afs_server_trace_see_expired, "SEE expd ") \ 140 + EM(afs_server_trace_see_purge, "SEE purge") \ 141 + EM(afs_server_trace_see_timer, "SEE timer") \ 142 + EM(afs_server_trace_unuse_call, "UNU call ") \ 143 + EM(afs_server_trace_unuse_create_fail, "UNU cfail") \ 144 + EM(afs_server_trace_unuse_slist, "UNU slist") \ 145 + EM(afs_server_trace_unuse_slist_isort, "UNU isort") \ 146 + EM(afs_server_trace_update, "UPDATE ") \ 147 + EM(afs_server_trace_use_by_uuid, "USE uuid ") \ 148 + EM(afs_server_trace_use_cm_call, "USE cm-cl") \ 149 + EM(afs_server_trace_use_get_caps, "USE gcaps") \ 150 + EM(afs_server_trace_use_give_up_cb, "USE gvupc") \ 151 + EM(afs_server_trace_use_install, "USE inst ") \ 152 + E_(afs_server_trace_wait_create, "WAIT crt ") 151 153 152 154 #define afs_volume_traces \ 153 155 EM(afs_volume_trace_alloc, "ALLOC ") \ ··· 171 169 172 170 #define afs_cell_traces \ 173 171 EM(afs_cell_trace_alloc, "ALLOC ") \ 172 + EM(afs_cell_trace_destroy, "DESTROY ") \ 174 173 EM(afs_cell_trace_free, "FREE ") \ 175 174 EM(afs_cell_trace_get_atcell, "GET atcell") \ 176 - EM(afs_cell_trace_get_queue_dns, "GET q-dns ") \ 177 - EM(afs_cell_trace_get_queue_manage, "GET q-mng ") \ 178 - EM(afs_cell_trace_get_queue_new, "GET q-new ") \ 179 175 EM(afs_cell_trace_get_server, "GET server") \ 180 176 EM(afs_cell_trace_get_vol, "GET vol ") \ 181 - EM(afs_cell_trace_insert, "INSERT ") \ 182 - EM(afs_cell_trace_manage, "MANAGE ") \ 177 + EM(afs_cell_trace_purge, "PURGE ") \ 183 178 EM(afs_cell_trace_put_atcell, "PUT atcell") \ 184 179 EM(afs_cell_trace_put_candidate, "PUT candid") \ 185 - EM(afs_cell_trace_put_destroy, "PUT destry") \ 186 - EM(afs_cell_trace_put_queue_work, "PUT q-work") \ 187 - EM(afs_cell_trace_put_queue_fail, "PUT q-fail") \ 180 + EM(afs_cell_trace_put_final, "PUT final ") \ 188 181 EM(afs_cell_trace_put_server, "PUT server") \ 189 182 EM(afs_cell_trace_put_vol, "PUT vol ") \ 183 + EM(afs_cell_trace_queue_again, "QUE again ") \ 184 + EM(afs_cell_trace_queue_dns, "QUE dns ") \ 185 + EM(afs_cell_trace_queue_new, "QUE new ") \ 186 + EM(afs_cell_trace_queue_purge, "QUE purge ") \ 187 + EM(afs_cell_trace_manage, "MANAGE ") \ 188 + EM(afs_cell_trace_managed, "MANAGED ") \ 190 189 EM(afs_cell_trace_see_source, "SEE source") \ 191 - EM(afs_cell_trace_see_ws, "SEE ws ") \ 190 + EM(afs_cell_trace_see_mgmt_timer, "SEE mtimer") \ 192 191 EM(afs_cell_trace_unuse_alias, "UNU alias ") \ 193 192 EM(afs_cell_trace_unuse_check_alias, "UNU chk-al") \ 194 193 EM(afs_cell_trace_unuse_delete, "UNU delete") \ 194 + EM(afs_cell_trace_unuse_dynroot_mntpt, "UNU dyn-mp") \ 195 195 EM(afs_cell_trace_unuse_fc, "UNU fc ") \ 196 - EM(afs_cell_trace_unuse_lookup, "UNU lookup") \ 196 + EM(afs_cell_trace_unuse_lookup_dynroot, "UNU lu-dyn") \ 197 + EM(afs_cell_trace_unuse_lookup_error, "UNU lu-err") \ 197 198 EM(afs_cell_trace_unuse_mntpt, "UNU mntpt ") \ 198 199 EM(afs_cell_trace_unuse_no_pin, "UNU no-pin") \ 199 200 EM(afs_cell_trace_unuse_parse, "UNU parse ") \ 200 201 EM(afs_cell_trace_unuse_pin, "UNU pin ") \ 201 - EM(afs_cell_trace_unuse_probe, "UNU probe ") \ 202 202 EM(afs_cell_trace_unuse_sbi, "UNU sbi ") \ 203 203 EM(afs_cell_trace_unuse_ws, "UNU ws ") \ 204 204 EM(afs_cell_trace_use_alias, "USE alias ") \ 205 205 EM(afs_cell_trace_use_check_alias, "USE chk-al") \ 206 206 EM(afs_cell_trace_use_fc, "USE fc ") \ 207 207 EM(afs_cell_trace_use_fc_alias, "USE fc-al ") \ 208 - EM(afs_cell_trace_use_lookup, "USE lookup") \ 208 + EM(afs_cell_trace_use_lookup_add, "USE lu-add") \ 209 + EM(afs_cell_trace_use_lookup_canonical, "USE lu-can") \ 210 + EM(afs_cell_trace_use_lookup_dynroot, "USE lu-dyn") \ 211 + EM(afs_cell_trace_use_lookup_mntpt, "USE lu-mpt") \ 212 + EM(afs_cell_trace_use_lookup_mount, "USE lu-mnt") \ 213 + EM(afs_cell_trace_use_lookup_ws, "USE lu-ws ") \ 209 214 EM(afs_cell_trace_use_mntpt, "USE mntpt ") \ 210 215 EM(afs_cell_trace_use_pin, "USE pin ") \ 211 216 EM(afs_cell_trace_use_probe, "USE probe ") \ ··· 229 220 EM(afs_alist_trace_put_getaddru, "PUT GtAdrU") \ 230 221 EM(afs_alist_trace_put_parse_empty, "PUT p-empt") \ 231 222 EM(afs_alist_trace_put_parse_error, "PUT p-err ") \ 232 - EM(afs_alist_trace_put_server_dup, "PUT sv-dup") \ 223 + EM(afs_alist_trace_put_server_create, "PUT sv-crt") \ 233 224 EM(afs_alist_trace_put_server_oom, "PUT sv-oom") \ 234 225 EM(afs_alist_trace_put_server_update, "PUT sv-upd") \ 235 226 EM(afs_alist_trace_put_vlgetcaps, "PUT vgtcap") \ ··· 1279 1270 ); 1280 1271 1281 1272 TRACE_EVENT(afs_cm_no_server, 1282 - TP_PROTO(struct afs_call *call, struct sockaddr_rxrpc *srx), 1273 + TP_PROTO(struct afs_call *call, const struct sockaddr_rxrpc *srx), 1283 1274 1284 1275 TP_ARGS(call, srx), 1285 1276 ··· 1538 1529 __entry->reason = reason; 1539 1530 ), 1540 1531 1541 - TP_printk("s=%08x %s u=%d a=%d", 1532 + TP_printk("s=%08x %s r=%d a=%d", 1542 1533 __entry->server, 1543 1534 __print_symbolic(__entry->reason, afs_server_traces), 1544 1535 __entry->ref, ··· 1546 1537 ); 1547 1538 1548 1539 TRACE_EVENT(afs_volume, 1549 - TP_PROTO(afs_volid_t vid, int ref, enum afs_volume_trace reason), 1540 + TP_PROTO(unsigned int debug_id, afs_volid_t vid, int ref, 1541 + enum afs_volume_trace reason), 1550 1542 1551 - TP_ARGS(vid, ref, reason), 1543 + TP_ARGS(debug_id, vid, ref, reason), 1552 1544 1553 1545 TP_STRUCT__entry( 1546 + __field(unsigned int, debug_id) 1554 1547 __field(afs_volid_t, vid) 1555 1548 __field(int, ref) 1556 1549 __field(enum afs_volume_trace, reason) 1557 1550 ), 1558 1551 1559 1552 TP_fast_assign( 1560 - __entry->vid = vid; 1561 - __entry->ref = ref; 1562 - __entry->reason = reason; 1553 + __entry->debug_id = debug_id; 1554 + __entry->vid = vid; 1555 + __entry->ref = ref; 1556 + __entry->reason = reason; 1563 1557 ), 1564 1558 1565 - TP_printk("V=%llx %s ur=%d", 1566 - __entry->vid, 1559 + TP_printk("V=%08x %s vid=%llx r=%d", 1560 + __entry->debug_id, 1567 1561 __print_symbolic(__entry->reason, afs_volume_traces), 1562 + __entry->vid, 1568 1563 __entry->ref) 1569 1564 ); 1570 1565

+1

net/rxrpc/ar-internal.h

··· 344 344 struct hlist_head error_targets; /* targets for net error distribution */ 345 345 struct rb_root service_conns; /* Service connections */ 346 346 struct list_head keepalive_link; /* Link in net->peer_keepalive[] */ 347 + unsigned long app_data; /* Application data (e.g. afs_server) */ 347 348 time64_t last_tx_at; /* Last time packet sent here */ 348 349 seqlock_t service_conn_lock; 349 350 spinlock_t lock; /* access lock */

+28 -2

net/rxrpc/peer_object.c

··· 461 461 continue; 462 462 463 463 hlist_for_each_entry(peer, &rxnet->peer_hash[i], hash_link) { 464 - pr_err("Leaked peer %u {%u} %pISp\n", 464 + pr_err("Leaked peer %x {%u} %pISp\n", 465 465 peer->debug_id, 466 466 refcount_read(&peer->ref), 467 467 &peer->srx.transport); ··· 478 478 */ 479 479 struct rxrpc_peer *rxrpc_kernel_get_call_peer(struct socket *sock, struct rxrpc_call *call) 480 480 { 481 - return call->peer; 481 + return rxrpc_get_peer(call->peer, rxrpc_peer_get_application); 482 482 } 483 483 EXPORT_SYMBOL(rxrpc_kernel_get_call_peer); 484 484 ··· 520 520 (peer ? &peer->srx.transport : &rxrpc_null_addr.transport); 521 521 } 522 522 EXPORT_SYMBOL(rxrpc_kernel_remote_addr); 523 + 524 + /** 525 + * rxrpc_kernel_set_peer_data - Set app-specific data on a peer. 526 + * @peer: The peer to alter 527 + * @app_data: The data to set 528 + * 529 + * Set the app-specific data on a peer. AF_RXRPC makes no effort to retain 530 + * anything the data might refer to. The previous app_data is returned. 531 + */ 532 + unsigned long rxrpc_kernel_set_peer_data(struct rxrpc_peer *peer, unsigned long app_data) 533 + { 534 + return xchg(&peer->app_data, app_data); 535 + } 536 + EXPORT_SYMBOL(rxrpc_kernel_set_peer_data); 537 + 538 + /** 539 + * rxrpc_kernel_get_peer_data - Get app-specific data from a peer. 540 + * @peer: The peer to query 541 + * 542 + * Retrieve the app-specific data from a peer. 543 + */ 544 + unsigned long rxrpc_kernel_get_peer_data(const struct rxrpc_peer *peer) 545 + { 546 + return peer->app_data; 547 + } 548 + EXPORT_SYMBOL(rxrpc_kernel_get_peer_data);

Configure Feed

Configure Feed