1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* AFS server record management 3 * 4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/sched.h> 9 #include <linux/slab.h> 10 #include "afs_fs.h" 11 #include "internal.h" 12 #include "protocol_yfs.h" 13 14 static unsigned afs_server_gc_delay = 10; /* Server record timeout in seconds */ 15 static atomic_t afs_server_debug_id; 16 17 static struct afs_server *afs_maybe_use_server(struct afs_server *, 18 enum afs_server_trace); 19 static void __afs_put_server(struct afs_net *, struct afs_server *); 20 21 /* 22 * Find a server by one of its addresses. 23 */ 24 struct afs_server *afs_find_server(struct afs_net *net, 25 const struct sockaddr_rxrpc *srx) 26 { 27 const struct afs_addr_list *alist; 28 struct afs_server *server = NULL; 29 unsigned int i; 30 int seq = 0, diff; 31 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 read_seqbegin_or_lock(&net->fs_addr_lock, &seq); 39 40 if (srx->transport.family == AF_INET6) { 41 const struct sockaddr_in6 *a = &srx->transport.sin6, *b; 42 hlist_for_each_entry_rcu(server, &net->fs_addresses6, addr6_link) { 43 alist = rcu_dereference(server->addresses); 44 for (i = alist->nr_ipv4; i < alist->nr_addrs; i++) { 45 b = &alist->addrs[i].transport.sin6; 46 diff = ((u16 __force)a->sin6_port - 47 (u16 __force)b->sin6_port); 48 if (diff == 0) 49 diff = memcmp(&a->sin6_addr, 50 &b->sin6_addr, 51 sizeof(struct in6_addr)); 52 if (diff == 0) 53 goto found; 54 } 55 } 56 } else { 57 const struct sockaddr_in *a = &srx->transport.sin, *b; 58 hlist_for_each_entry_rcu(server, &net->fs_addresses4, addr4_link) { 59 alist = rcu_dereference(server->addresses); 60 for (i = 0; i < alist->nr_ipv4; i++) { 61 b = &alist->addrs[i].transport.sin; 62 diff = ((u16 __force)a->sin_port - 63 (u16 __force)b->sin_port); 64 if (diff == 0) 65 diff = ((u32 __force)a->sin_addr.s_addr - 66 (u32 __force)b->sin_addr.s_addr); 67 if (diff == 0) 68 goto found; 69 } 70 } 71 } 72 73 server = NULL; 74 continue; 75 found: 76 server = afs_maybe_use_server(server, afs_server_trace_get_by_addr); 77 78 } while (need_seqretry(&net->fs_addr_lock, seq)); 79 80 done_seqretry(&net->fs_addr_lock, seq); 81 82 rcu_read_unlock(); 83 return server; 84 } 85 86 /* 87 * Look up a server by its UUID and mark it active. 88 */ 89 struct afs_server *afs_find_server_by_uuid(struct afs_net *net, const uuid_t *uuid) 90 { 91 struct afs_server *server = NULL; 92 struct rb_node *p; 93 int diff, seq = 0; 94 95 _enter("%pU", uuid); 96 97 do { 98 /* Unfortunately, rbtree walking doesn't give reliable results 99 * under just the RCU read lock, so we have to check for 100 * changes. 101 */ 102 if (server) 103 afs_unuse_server(net, server, afs_server_trace_put_uuid_rsq); 104 server = NULL; 105 106 read_seqbegin_or_lock(&net->fs_lock, &seq); 107 108 p = net->fs_servers.rb_node; 109 while (p) { 110 server = rb_entry(p, struct afs_server, uuid_rb); 111 112 diff = memcmp(uuid, &server->uuid, sizeof(*uuid)); 113 if (diff < 0) { 114 p = p->rb_left; 115 } else if (diff > 0) { 116 p = p->rb_right; 117 } else { 118 afs_use_server(server, afs_server_trace_get_by_uuid); 119 break; 120 } 121 122 server = NULL; 123 } 124 } while (need_seqretry(&net->fs_lock, seq)); 125 126 done_seqretry(&net->fs_lock, seq); 127 128 _leave(" = %p", server); 129 return server; 130 } 131 132 /* 133 * Install a server record in the namespace tree. If there's a clash, we stick 134 * it into a list anchored on whichever afs_server struct is actually in the 135 * tree. 136 */ 137 static struct afs_server *afs_install_server(struct afs_cell *cell, 138 struct afs_server *candidate) 139 { 140 const struct afs_addr_list *alist; 141 struct afs_server *server, *next; 142 struct afs_net *net = cell->net; 143 struct rb_node **pp, *p; 144 int diff; 145 146 _enter("%p", candidate); 147 148 write_seqlock(&net->fs_lock); 149 150 /* Firstly install the server in the UUID lookup tree */ 151 pp = &net->fs_servers.rb_node; 152 p = NULL; 153 while (*pp) { 154 p = *pp; 155 _debug("- consider %p", p); 156 server = rb_entry(p, struct afs_server, uuid_rb); 157 diff = memcmp(&candidate->uuid, &server->uuid, sizeof(uuid_t)); 158 if (diff < 0) { 159 pp = &(*pp)->rb_left; 160 } else if (diff > 0) { 161 pp = &(*pp)->rb_right; 162 } else { 163 if (server->cell == cell) 164 goto exists; 165 166 /* We have the same UUID representing servers in 167 * different cells. Append the new server to the list. 168 */ 169 for (;;) { 170 next = rcu_dereference_protected( 171 server->uuid_next, 172 lockdep_is_held(&net->fs_lock.lock)); 173 if (!next) 174 break; 175 server = next; 176 } 177 rcu_assign_pointer(server->uuid_next, candidate); 178 candidate->uuid_prev = server; 179 server = candidate; 180 goto added_dup; 181 } 182 } 183 184 server = candidate; 185 rb_link_node(&server->uuid_rb, p, pp); 186 rb_insert_color(&server->uuid_rb, &net->fs_servers); 187 hlist_add_head_rcu(&server->proc_link, &net->fs_proc); 188 189 added_dup: 190 write_seqlock(&net->fs_addr_lock); 191 alist = rcu_dereference_protected(server->addresses, 192 lockdep_is_held(&net->fs_addr_lock.lock)); 193 194 /* Secondly, if the server has any IPv4 and/or IPv6 addresses, install 195 * it in the IPv4 and/or IPv6 reverse-map lists. 196 * 197 * TODO: For speed we want to use something other than a flat list 198 * here; even sorting the list in terms of lowest address would help a 199 * bit, but anything we might want to do gets messy and memory 200 * intensive. 201 */ 202 if (alist->nr_ipv4 > 0) 203 hlist_add_head_rcu(&server->addr4_link, &net->fs_addresses4); 204 if (alist->nr_addrs > alist->nr_ipv4) 205 hlist_add_head_rcu(&server->addr6_link, &net->fs_addresses6); 206 207 write_sequnlock(&net->fs_addr_lock); 208 209 exists: 210 afs_get_server(server, afs_server_trace_get_install); 211 write_sequnlock(&net->fs_lock); 212 return server; 213 } 214 215 /* 216 * Allocate a new server record and mark it active. 217 */ 218 static struct afs_server *afs_alloc_server(struct afs_cell *cell, 219 const uuid_t *uuid, 220 struct afs_addr_list *alist) 221 { 222 struct afs_server *server; 223 struct afs_net *net = cell->net; 224 225 _enter(""); 226 227 server = kzalloc(sizeof(struct afs_server), GFP_KERNEL); 228 if (!server) 229 goto enomem; 230 231 refcount_set(&server->ref, 1); 232 atomic_set(&server->active, 1); 233 server->debug_id = atomic_inc_return(&afs_server_debug_id); 234 RCU_INIT_POINTER(server->addresses, alist); 235 server->addr_version = alist->version; 236 server->uuid = *uuid; 237 rwlock_init(&server->fs_lock); 238 INIT_WORK(&server->initcb_work, afs_server_init_callback_work); 239 init_waitqueue_head(&server->probe_wq); 240 INIT_LIST_HEAD(&server->probe_link); 241 spin_lock_init(&server->probe_lock); 242 server->cell = cell; 243 server->rtt = UINT_MAX; 244 245 afs_inc_servers_outstanding(net); 246 trace_afs_server(server, 1, 1, afs_server_trace_alloc); 247 _leave(" = %p", server); 248 return server; 249 250 enomem: 251 _leave(" = NULL [nomem]"); 252 return NULL; 253 } 254 255 /* 256 * Look up an address record for a server 257 */ 258 static struct afs_addr_list *afs_vl_lookup_addrs(struct afs_cell *cell, 259 struct key *key, const uuid_t *uuid) 260 { 261 struct afs_vl_cursor vc; 262 struct afs_addr_list *alist = NULL; 263 int ret; 264 265 ret = -ERESTARTSYS; 266 if (afs_begin_vlserver_operation(&vc, cell, key)) { 267 while (afs_select_vlserver(&vc)) { 268 if (test_bit(AFS_VLSERVER_FL_IS_YFS, &vc.server->flags)) 269 alist = afs_yfsvl_get_endpoints(&vc, uuid); 270 else 271 alist = afs_vl_get_addrs_u(&vc, uuid); 272 } 273 274 ret = afs_end_vlserver_operation(&vc); 275 } 276 277 return ret < 0 ? ERR_PTR(ret) : alist; 278 } 279 280 /* 281 * Get or create a fileserver record. 282 */ 283 struct afs_server *afs_lookup_server(struct afs_cell *cell, struct key *key, 284 const uuid_t *uuid, u32 addr_version) 285 { 286 struct afs_addr_list *alist; 287 struct afs_server *server, *candidate; 288 289 _enter("%p,%pU", cell->net, uuid); 290 291 server = afs_find_server_by_uuid(cell->net, uuid); 292 if (server) { 293 if (server->addr_version != addr_version) 294 set_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); 295 return server; 296 } 297 298 alist = afs_vl_lookup_addrs(cell, key, uuid); 299 if (IS_ERR(alist)) 300 return ERR_CAST(alist); 301 302 candidate = afs_alloc_server(cell, uuid, alist); 303 if (!candidate) { 304 afs_put_addrlist(alist); 305 return ERR_PTR(-ENOMEM); 306 } 307 308 server = afs_install_server(cell, candidate); 309 if (server != candidate) { 310 afs_put_addrlist(alist); 311 kfree(candidate); 312 } else { 313 /* Immediately dispatch an asynchronous probe to each interface 314 * on the fileserver. This will make sure the repeat-probing 315 * service is started. 316 */ 317 afs_fs_probe_fileserver(cell->net, server, key, true); 318 } 319 320 return server; 321 } 322 323 /* 324 * Set the server timer to fire after a given delay, assuming it's not already 325 * set for an earlier time. 326 */ 327 static void afs_set_server_timer(struct afs_net *net, time64_t delay) 328 { 329 if (net->live) { 330 afs_inc_servers_outstanding(net); 331 if (timer_reduce(&net->fs_timer, jiffies + delay * HZ)) 332 afs_dec_servers_outstanding(net); 333 } 334 } 335 336 /* 337 * Server management timer. We have an increment on fs_outstanding that we 338 * need to pass along to the work item. 339 */ 340 void afs_servers_timer(struct timer_list *timer) 341 { 342 struct afs_net *net = container_of(timer, struct afs_net, fs_timer); 343 344 _enter(""); 345 if (!queue_work(afs_wq, &net->fs_manager)) 346 afs_dec_servers_outstanding(net); 347 } 348 349 /* 350 * Get a reference on a server object. 351 */ 352 struct afs_server *afs_get_server(struct afs_server *server, 353 enum afs_server_trace reason) 354 { 355 int r; 356 357 __refcount_inc(&server->ref, &r); 358 trace_afs_server(server, r + 1, atomic_read(&server->active), reason); 359 return server; 360 } 361 362 /* 363 * Try to get a reference on a server object. 364 */ 365 static struct afs_server *afs_maybe_use_server(struct afs_server *server, 366 enum afs_server_trace reason) 367 { 368 unsigned int a; 369 int r; 370 371 if (!__refcount_inc_not_zero(&server->ref, &r)) 372 return NULL; 373 374 a = atomic_inc_return(&server->active); 375 trace_afs_server(server, r + 1, a, reason); 376 return server; 377 } 378 379 /* 380 * Get an active count on a server object. 381 */ 382 struct afs_server *afs_use_server(struct afs_server *server, enum afs_server_trace reason) 383 { 384 unsigned int a; 385 int r; 386 387 __refcount_inc(&server->ref, &r); 388 a = atomic_inc_return(&server->active); 389 390 trace_afs_server(server, r + 1, a, reason); 391 return server; 392 } 393 394 /* 395 * Release a reference on a server record. 396 */ 397 void afs_put_server(struct afs_net *net, struct afs_server *server, 398 enum afs_server_trace reason) 399 { 400 bool zero; 401 int r; 402 403 if (!server) 404 return; 405 406 zero = __refcount_dec_and_test(&server->ref, &r); 407 trace_afs_server(server, r - 1, atomic_read(&server->active), reason); 408 if (unlikely(zero)) 409 __afs_put_server(net, server); 410 } 411 412 /* 413 * Drop an active count on a server object without updating the last-unused 414 * time. 415 */ 416 void afs_unuse_server_notime(struct afs_net *net, struct afs_server *server, 417 enum afs_server_trace reason) 418 { 419 if (server) { 420 unsigned int active = atomic_dec_return(&server->active); 421 422 if (active == 0) 423 afs_set_server_timer(net, afs_server_gc_delay); 424 afs_put_server(net, server, reason); 425 } 426 } 427 428 /* 429 * Drop an active count on a server object. 430 */ 431 void afs_unuse_server(struct afs_net *net, struct afs_server *server, 432 enum afs_server_trace reason) 433 { 434 if (server) { 435 server->unuse_time = ktime_get_real_seconds(); 436 afs_unuse_server_notime(net, server, reason); 437 } 438 } 439 440 static void afs_server_rcu(struct rcu_head *rcu) 441 { 442 struct afs_server *server = container_of(rcu, struct afs_server, rcu); 443 444 trace_afs_server(server, refcount_read(&server->ref), 445 atomic_read(&server->active), afs_server_trace_free); 446 afs_put_addrlist(rcu_access_pointer(server->addresses)); 447 kfree(server); 448 } 449 450 static void __afs_put_server(struct afs_net *net, struct afs_server *server) 451 { 452 call_rcu(&server->rcu, afs_server_rcu); 453 afs_dec_servers_outstanding(net); 454 } 455 456 static void afs_give_up_callbacks(struct afs_net *net, struct afs_server *server) 457 { 458 struct afs_addr_list *alist = rcu_access_pointer(server->addresses); 459 struct afs_addr_cursor ac = { 460 .alist = alist, 461 .index = alist->preferred, 462 .error = 0, 463 }; 464 465 afs_fs_give_up_all_callbacks(net, server, &ac, NULL); 466 } 467 468 /* 469 * destroy a dead server 470 */ 471 static void afs_destroy_server(struct afs_net *net, struct afs_server *server) 472 { 473 if (test_bit(AFS_SERVER_FL_MAY_HAVE_CB, &server->flags)) 474 afs_give_up_callbacks(net, server); 475 476 flush_work(&server->initcb_work); 477 afs_put_server(net, server, afs_server_trace_destroy); 478 } 479 480 /* 481 * Garbage collect any expired servers. 482 */ 483 static void afs_gc_servers(struct afs_net *net, struct afs_server *gc_list) 484 { 485 struct afs_server *server, *next, *prev; 486 int active; 487 488 while ((server = gc_list)) { 489 gc_list = server->gc_next; 490 491 write_seqlock(&net->fs_lock); 492 493 active = atomic_read(&server->active); 494 if (active == 0) { 495 trace_afs_server(server, refcount_read(&server->ref), 496 active, afs_server_trace_gc); 497 next = rcu_dereference_protected( 498 server->uuid_next, lockdep_is_held(&net->fs_lock.lock)); 499 prev = server->uuid_prev; 500 if (!prev) { 501 /* The one at the front is in the tree */ 502 if (!next) { 503 rb_erase(&server->uuid_rb, &net->fs_servers); 504 } else { 505 rb_replace_node_rcu(&server->uuid_rb, 506 &next->uuid_rb, 507 &net->fs_servers); 508 next->uuid_prev = NULL; 509 } 510 } else { 511 /* This server is not at the front */ 512 rcu_assign_pointer(prev->uuid_next, next); 513 if (next) 514 next->uuid_prev = prev; 515 } 516 517 list_del(&server->probe_link); 518 hlist_del_rcu(&server->proc_link); 519 if (!hlist_unhashed(&server->addr4_link)) 520 hlist_del_rcu(&server->addr4_link); 521 if (!hlist_unhashed(&server->addr6_link)) 522 hlist_del_rcu(&server->addr6_link); 523 } 524 write_sequnlock(&net->fs_lock); 525 526 if (active == 0) 527 afs_destroy_server(net, server); 528 } 529 } 530 531 /* 532 * Manage the records of servers known to be within a network namespace. This 533 * includes garbage collecting unused servers. 534 * 535 * Note also that we were given an increment on net->servers_outstanding by 536 * whoever queued us that we need to deal with before returning. 537 */ 538 void afs_manage_servers(struct work_struct *work) 539 { 540 struct afs_net *net = container_of(work, struct afs_net, fs_manager); 541 struct afs_server *gc_list = NULL; 542 struct rb_node *cursor; 543 time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX; 544 bool purging = !net->live; 545 546 _enter(""); 547 548 /* Trawl the server list looking for servers that have expired from 549 * lack of use. 550 */ 551 read_seqlock_excl(&net->fs_lock); 552 553 for (cursor = rb_first(&net->fs_servers); cursor; cursor = rb_next(cursor)) { 554 struct afs_server *server = 555 rb_entry(cursor, struct afs_server, uuid_rb); 556 int active = atomic_read(&server->active); 557 558 _debug("manage %pU %u", &server->uuid, active); 559 560 if (purging) { 561 trace_afs_server(server, refcount_read(&server->ref), 562 active, afs_server_trace_purging); 563 if (active != 0) 564 pr_notice("Can't purge s=%08x\n", server->debug_id); 565 } 566 567 if (active == 0) { 568 time64_t expire_at = server->unuse_time; 569 570 if (!test_bit(AFS_SERVER_FL_VL_FAIL, &server->flags) && 571 !test_bit(AFS_SERVER_FL_NOT_FOUND, &server->flags)) 572 expire_at += afs_server_gc_delay; 573 if (purging || expire_at <= now) { 574 server->gc_next = gc_list; 575 gc_list = server; 576 } else if (expire_at < next_manage) { 577 next_manage = expire_at; 578 } 579 } 580 } 581 582 read_sequnlock_excl(&net->fs_lock); 583 584 /* Update the timer on the way out. We have to pass an increment on 585 * servers_outstanding in the namespace that we are in to the timer or 586 * the work scheduler. 587 */ 588 if (!purging && next_manage < TIME64_MAX) { 589 now = ktime_get_real_seconds(); 590 591 if (next_manage - now <= 0) { 592 if (queue_work(afs_wq, &net->fs_manager)) 593 afs_inc_servers_outstanding(net); 594 } else { 595 afs_set_server_timer(net, next_manage - now); 596 } 597 } 598 599 afs_gc_servers(net, gc_list); 600 601 afs_dec_servers_outstanding(net); 602 _leave(" [%d]", atomic_read(&net->servers_outstanding)); 603 } 604 605 static void afs_queue_server_manager(struct afs_net *net) 606 { 607 afs_inc_servers_outstanding(net); 608 if (!queue_work(afs_wq, &net->fs_manager)) 609 afs_dec_servers_outstanding(net); 610 } 611 612 /* 613 * Purge list of servers. 614 */ 615 void afs_purge_servers(struct afs_net *net) 616 { 617 _enter(""); 618 619 if (del_timer_sync(&net->fs_timer)) 620 afs_dec_servers_outstanding(net); 621 622 afs_queue_server_manager(net); 623 624 _debug("wait"); 625 atomic_dec(&net->servers_outstanding); 626 wait_var_event(&net->servers_outstanding, 627 !atomic_read(&net->servers_outstanding)); 628 _leave(""); 629 } 630 631 /* 632 * Get an update for a server's address list. 633 */ 634 static noinline bool afs_update_server_record(struct afs_operation *op, 635 struct afs_server *server) 636 { 637 struct afs_addr_list *alist, *discard; 638 639 _enter(""); 640 641 trace_afs_server(server, refcount_read(&server->ref), 642 atomic_read(&server->active), 643 afs_server_trace_update); 644 645 alist = afs_vl_lookup_addrs(op->volume->cell, op->key, &server->uuid); 646 if (IS_ERR(alist)) { 647 if ((PTR_ERR(alist) == -ERESTARTSYS || 648 PTR_ERR(alist) == -EINTR) && 649 (op->flags & AFS_OPERATION_UNINTR) && 650 server->addresses) { 651 _leave(" = t [intr]"); 652 return true; 653 } 654 op->error = PTR_ERR(alist); 655 _leave(" = f [%d]", op->error); 656 return false; 657 } 658 659 discard = alist; 660 if (server->addr_version != alist->version) { 661 write_lock(&server->fs_lock); 662 discard = rcu_dereference_protected(server->addresses, 663 lockdep_is_held(&server->fs_lock)); 664 rcu_assign_pointer(server->addresses, alist); 665 server->addr_version = alist->version; 666 write_unlock(&server->fs_lock); 667 } 668 669 afs_put_addrlist(discard); 670 _leave(" = t"); 671 return true; 672 } 673 674 /* 675 * See if a server's address list needs updating. 676 */ 677 bool afs_check_server_record(struct afs_operation *op, struct afs_server *server) 678 { 679 bool success; 680 int ret, retries = 0; 681 682 _enter(""); 683 684 ASSERT(server); 685 686 retry: 687 if (test_bit(AFS_SERVER_FL_UPDATING, &server->flags)) 688 goto wait; 689 if (test_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags)) 690 goto update; 691 _leave(" = t [good]"); 692 return true; 693 694 update: 695 if (!test_and_set_bit_lock(AFS_SERVER_FL_UPDATING, &server->flags)) { 696 clear_bit(AFS_SERVER_FL_NEEDS_UPDATE, &server->flags); 697 success = afs_update_server_record(op, server); 698 clear_bit_unlock(AFS_SERVER_FL_UPDATING, &server->flags); 699 wake_up_bit(&server->flags, AFS_SERVER_FL_UPDATING); 700 _leave(" = %d", success); 701 return success; 702 } 703 704 wait: 705 ret = wait_on_bit(&server->flags, AFS_SERVER_FL_UPDATING, 706 (op->flags & AFS_OPERATION_UNINTR) ? 707 TASK_UNINTERRUPTIBLE : TASK_INTERRUPTIBLE); 708 if (ret == -ERESTARTSYS) { 709 op->error = ret; 710 _leave(" = f [intr]"); 711 return false; 712 } 713 714 retries++; 715 if (retries == 4) { 716 _leave(" = f [stale]"); 717 ret = -ESTALE; 718 return false; 719 } 720 goto retry; 721 } 722