1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* Handle fileserver selection and rotation. 3 * 4 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved. 5 * Written by David Howells (dhowells@redhat.com) 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/slab.h> 10 #include <linux/fs.h> 11 #include <linux/sched.h> 12 #include <linux/delay.h> 13 #include <linux/sched/signal.h> 14 #include "internal.h" 15 #include "afs_fs.h" 16 #include "protocol_uae.h" 17 18 void afs_clear_server_states(struct afs_operation *op) 19 { 20 unsigned int i; 21 22 if (op->server_states) { 23 for (i = 0; i < op->server_list->nr_servers; i++) 24 afs_put_endpoint_state(op->server_states[i].endpoint_state, 25 afs_estate_trace_put_server_state); 26 kfree(op->server_states); 27 } 28 } 29 30 /* 31 * Begin iteration through a server list, starting with the vnode's last used 32 * server if possible, or the last recorded good server if not. 33 */ 34 static bool afs_start_fs_iteration(struct afs_operation *op, 35 struct afs_vnode *vnode) 36 { 37 struct afs_server *server; 38 void *cb_server; 39 int i; 40 41 trace_afs_rotate(op, afs_rotate_trace_start, 0); 42 43 read_lock(&op->volume->servers_lock); 44 op->server_list = afs_get_serverlist( 45 rcu_dereference_protected(op->volume->servers, 46 lockdep_is_held(&op->volume->servers_lock))); 47 read_unlock(&op->volume->servers_lock); 48 49 op->server_states = kcalloc(op->server_list->nr_servers, sizeof(op->server_states[0]), 50 GFP_KERNEL); 51 if (!op->server_states) { 52 afs_op_nomem(op); 53 trace_afs_rotate(op, afs_rotate_trace_nomem, 0); 54 return false; 55 } 56 57 rcu_read_lock(); 58 for (i = 0; i < op->server_list->nr_servers; i++) { 59 struct afs_endpoint_state *estate; 60 struct afs_server_state *s = &op->server_states[i]; 61 62 server = op->server_list->servers[i].server; 63 estate = rcu_dereference(server->endpoint_state); 64 s->endpoint_state = afs_get_endpoint_state(estate, 65 afs_estate_trace_get_server_state); 66 s->probe_seq = estate->probe_seq; 67 s->untried_addrs = (1UL << estate->addresses->nr_addrs) - 1; 68 init_waitqueue_entry(&s->probe_waiter, current); 69 afs_get_address_preferences(op->net, estate->addresses); 70 } 71 rcu_read_unlock(); 72 73 74 op->untried_servers = (1UL << op->server_list->nr_servers) - 1; 75 op->server_index = -1; 76 77 cb_server = vnode->cb_server; 78 if (cb_server) { 79 /* See if the vnode's preferred record is still available */ 80 for (i = 0; i < op->server_list->nr_servers; i++) { 81 server = op->server_list->servers[i].server; 82 if (server == cb_server) { 83 op->server_index = i; 84 goto found_interest; 85 } 86 } 87 88 /* If we have a lock outstanding on a server that's no longer 89 * serving this vnode, then we can't switch to another server 90 * and have to return an error. 91 */ 92 if (op->flags & AFS_OPERATION_CUR_ONLY) { 93 afs_op_set_error(op, -ESTALE); 94 trace_afs_rotate(op, afs_rotate_trace_stale_lock, 0); 95 return false; 96 } 97 98 /* Note that the callback promise is effectively broken */ 99 write_seqlock(&vnode->cb_lock); 100 ASSERTCMP(cb_server, ==, vnode->cb_server); 101 vnode->cb_server = NULL; 102 if (atomic64_xchg(&vnode->cb_expires_at, AFS_NO_CB_PROMISE) != AFS_NO_CB_PROMISE) 103 vnode->cb_break++; 104 write_sequnlock(&vnode->cb_lock); 105 } 106 107 found_interest: 108 return true; 109 } 110 111 /* 112 * Post volume busy note. 113 */ 114 static void afs_busy(struct afs_operation *op, u32 abort_code) 115 { 116 const char *m; 117 118 switch (abort_code) { 119 case VOFFLINE: m = "offline"; break; 120 case VRESTARTING: m = "restarting"; break; 121 case VSALVAGING: m = "being salvaged"; break; 122 default: m = "busy"; break; 123 } 124 125 pr_notice("kAFS: Volume %llu '%s' on server %pU is %s\n", 126 op->volume->vid, op->volume->name, &op->server->uuid, m); 127 } 128 129 /* 130 * Sleep and retry the operation to the same fileserver. 131 */ 132 static bool afs_sleep_and_retry(struct afs_operation *op) 133 { 134 trace_afs_rotate(op, afs_rotate_trace_busy_sleep, 0); 135 if (!(op->flags & AFS_OPERATION_UNINTR)) { 136 msleep_interruptible(1000); 137 if (signal_pending(current)) { 138 afs_op_set_error(op, -ERESTARTSYS); 139 return false; 140 } 141 } else { 142 msleep(1000); 143 } 144 145 return true; 146 } 147 148 /* 149 * Select the fileserver to use. May be called multiple times to rotate 150 * through the fileservers. 151 */ 152 bool afs_select_fileserver(struct afs_operation *op) 153 { 154 struct afs_addr_list *alist; 155 struct afs_server *server; 156 struct afs_vnode *vnode = op->file[0].vnode; 157 unsigned long set, failed; 158 s32 abort_code = op->call_abort_code; 159 int best_prio = 0; 160 int error = op->call_error, addr_index, i, j; 161 162 op->nr_iterations++; 163 164 _enter("OP=%x+%x,%llx,%u{%lx},%u{%lx},%d,%d", 165 op->debug_id, op->nr_iterations, op->volume->vid, 166 op->server_index, op->untried_servers, 167 op->addr_index, op->addr_tried, 168 error, abort_code); 169 170 if (op->flags & AFS_OPERATION_STOP) { 171 trace_afs_rotate(op, afs_rotate_trace_stopped, 0); 172 _leave(" = f [stopped]"); 173 return false; 174 } 175 176 if (op->nr_iterations == 0) 177 goto start; 178 179 WRITE_ONCE(op->estate->addresses->addrs[op->addr_index].last_error, error); 180 trace_afs_rotate(op, afs_rotate_trace_iter, op->call_error); 181 182 /* Evaluate the result of the previous operation, if there was one. */ 183 switch (op->call_error) { 184 case 0: 185 clear_bit(AFS_SE_VOLUME_OFFLINE, 186 &op->server_list->servers[op->server_index].flags); 187 clear_bit(AFS_SE_VOLUME_BUSY, 188 &op->server_list->servers[op->server_index].flags); 189 op->cumul_error.responded = true; 190 191 /* We succeeded, but we may need to redo the op from another 192 * server if we're looking at a set of RO volumes where some of 193 * the servers have not yet been brought up to date lest we 194 * regress the data. We only switch to the new version once 195 * >=50% of the servers are updated. 196 */ 197 error = afs_update_volume_state(op); 198 if (error != 0) { 199 if (error == 1) { 200 afs_sleep_and_retry(op); 201 goto restart_from_beginning; 202 } 203 afs_op_set_error(op, error); 204 goto failed; 205 } 206 fallthrough; 207 default: 208 /* Success or local failure. Stop. */ 209 afs_op_set_error(op, error); 210 op->flags |= AFS_OPERATION_STOP; 211 trace_afs_rotate(op, afs_rotate_trace_stop, error); 212 _leave(" = f [okay/local %d]", error); 213 return false; 214 215 case -ECONNABORTED: 216 /* The far side rejected the operation on some grounds. This 217 * might involve the server being busy or the volume having been moved. 218 * 219 * Note that various V* errors should not be sent to a cache manager 220 * by a fileserver as they should be translated to more modern UAE* 221 * errors instead. IBM AFS and OpenAFS fileservers, however, do leak 222 * these abort codes. 223 */ 224 trace_afs_rotate(op, afs_rotate_trace_aborted, abort_code); 225 op->cumul_error.responded = true; 226 switch (abort_code) { 227 case VNOVOL: 228 /* This fileserver doesn't know about the volume. 229 * - May indicate that the VL is wrong - retry once and compare 230 * the results. 231 * - May indicate that the fileserver couldn't attach to the vol. 232 * - The volume might have been temporarily removed so that it can 233 * be replaced by a volume restore. "vos" might have ended one 234 * transaction and has yet to create the next. 235 * - The volume might not be blessed or might not be in-service 236 * (administrative action). 237 */ 238 if (op->flags & AFS_OPERATION_VNOVOL) { 239 afs_op_accumulate_error(op, -EREMOTEIO, abort_code); 240 goto next_server; 241 } 242 243 write_lock(&op->volume->servers_lock); 244 op->server_list->vnovol_mask |= 1 << op->server_index; 245 write_unlock(&op->volume->servers_lock); 246 247 set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags); 248 error = afs_check_volume_status(op->volume, op); 249 if (error < 0) { 250 afs_op_set_error(op, error); 251 goto failed; 252 } 253 254 if (test_bit(AFS_VOLUME_DELETED, &op->volume->flags)) { 255 afs_op_set_error(op, -ENOMEDIUM); 256 goto failed; 257 } 258 259 /* If the server list didn't change, then assume that 260 * it's the fileserver having trouble. 261 */ 262 if (rcu_access_pointer(op->volume->servers) == op->server_list) { 263 afs_op_accumulate_error(op, -EREMOTEIO, abort_code); 264 goto next_server; 265 } 266 267 /* Try again */ 268 op->flags |= AFS_OPERATION_VNOVOL; 269 _leave(" = t [vnovol]"); 270 return true; 271 272 case VVOLEXISTS: 273 case VONLINE: 274 /* These should not be returned from the fileserver. */ 275 pr_warn("Fileserver returned unexpected abort %d\n", 276 abort_code); 277 afs_op_accumulate_error(op, -EREMOTEIO, abort_code); 278 goto next_server; 279 280 case VNOSERVICE: 281 /* Prior to AFS 3.2 VNOSERVICE was returned from the fileserver 282 * if the volume was neither in-service nor administratively 283 * blessed. All usage was replaced by VNOVOL because AFS 3.1 and 284 * earlier cache managers did not handle VNOSERVICE and assumed 285 * it was the client OSes errno 105. 286 * 287 * Starting with OpenAFS 1.4.8 VNOSERVICE was repurposed as the 288 * fileserver idle dead time error which was sent in place of 289 * RX_CALL_TIMEOUT (-3). The error was intended to be sent if the 290 * fileserver took too long to send a reply to the client. 291 * RX_CALL_TIMEOUT would have caused the cache manager to mark the 292 * server down whereas VNOSERVICE since AFS 3.2 would cause cache 293 * manager to temporarily (up to 15 minutes) mark the volume 294 * instance as unusable. 295 * 296 * The idle dead logic resulted in cache inconsistency since a 297 * state changing call that the cache manager assumed was dead 298 * could still be processed to completion by the fileserver. This 299 * logic was removed in OpenAFS 1.8.0 and VNOSERVICE is no longer 300 * returned. However, many 1.4.8 through 1.6.24 fileservers are 301 * still in existence. 302 * 303 * AuriStorFS fileservers have never returned VNOSERVICE. 304 * 305 * VNOSERVICE should be treated as an alias for RX_CALL_TIMEOUT. 306 */ 307 case RX_CALL_TIMEOUT: 308 afs_op_accumulate_error(op, -ETIMEDOUT, abort_code); 309 goto next_server; 310 311 case VSALVAGING: /* This error should not be leaked to cache managers 312 * but is from OpenAFS demand attach fileservers. 313 * It should be treated as an alias for VOFFLINE. 314 */ 315 case VSALVAGE: /* VSALVAGE should be treated as a synonym of VOFFLINE */ 316 case VOFFLINE: 317 /* The volume is in use by the volserver or another volume utility 318 * for an operation that might alter the contents. The volume is 319 * expected to come back but it might take a long time (could be 320 * days). 321 */ 322 if (!test_and_set_bit(AFS_SE_VOLUME_OFFLINE, 323 &op->server_list->servers[op->server_index].flags)) { 324 afs_busy(op, abort_code); 325 clear_bit(AFS_SE_VOLUME_BUSY, 326 &op->server_list->servers[op->server_index].flags); 327 } 328 if (op->flags & AFS_OPERATION_NO_VSLEEP) { 329 afs_op_set_error(op, -EADV); 330 goto failed; 331 } 332 goto busy; 333 334 case VRESTARTING: /* The fileserver is either shutting down or starting up. */ 335 case VBUSY: 336 /* The volume is in use by the volserver or another volume 337 * utility for an operation that is not expected to alter the 338 * contents of the volume. VBUSY does not need to be returned 339 * for a ROVOL or BACKVOL bound to an ITBusy volserver 340 * transaction. The fileserver is permitted to continue serving 341 * content from ROVOLs and BACKVOLs during an ITBusy transaction 342 * because the content will not change. However, many fileserver 343 * releases do return VBUSY for ROVOL and BACKVOL instances under 344 * many circumstances. 345 * 346 * Retry after going round all the servers unless we have a file 347 * lock we need to maintain. 348 */ 349 if (op->flags & AFS_OPERATION_NO_VSLEEP) { 350 afs_op_set_error(op, -EBUSY); 351 goto failed; 352 } 353 if (!test_and_set_bit(AFS_SE_VOLUME_BUSY, 354 &op->server_list->servers[op->server_index].flags)) { 355 afs_busy(op, abort_code); 356 clear_bit(AFS_SE_VOLUME_OFFLINE, 357 &op->server_list->servers[op->server_index].flags); 358 } 359 busy: 360 if (op->flags & AFS_OPERATION_CUR_ONLY) { 361 if (!afs_sleep_and_retry(op)) 362 goto failed; 363 364 /* Retry with same server & address */ 365 _leave(" = t [vbusy]"); 366 return true; 367 } 368 369 op->flags |= AFS_OPERATION_VBUSY; 370 goto next_server; 371 372 case VMOVED: 373 /* The volume migrated to another server. We consider 374 * consider all locks and callbacks broken and request 375 * an update from the VLDB. 376 * 377 * We also limit the number of VMOVED hops we will 378 * honour, just in case someone sets up a loop. 379 */ 380 if (op->flags & AFS_OPERATION_VMOVED) { 381 afs_op_set_error(op, -EREMOTEIO); 382 goto failed; 383 } 384 op->flags |= AFS_OPERATION_VMOVED; 385 386 set_bit(AFS_VOLUME_WAIT, &op->volume->flags); 387 set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags); 388 error = afs_check_volume_status(op->volume, op); 389 if (error < 0) { 390 afs_op_set_error(op, error); 391 goto failed; 392 } 393 394 /* If the server list didn't change, then the VLDB is 395 * out of sync with the fileservers. This is hopefully 396 * a temporary condition, however, so we don't want to 397 * permanently block access to the file. 398 * 399 * TODO: Try other fileservers if we can. 400 * 401 * TODO: Retry a few times with sleeps. 402 */ 403 if (rcu_access_pointer(op->volume->servers) == op->server_list) { 404 afs_op_accumulate_error(op, -ENOMEDIUM, abort_code); 405 goto failed; 406 } 407 408 goto restart_from_beginning; 409 410 case UAEIO: 411 case VIO: 412 afs_op_accumulate_error(op, -EREMOTEIO, abort_code); 413 if (op->volume->type != AFSVL_RWVOL) 414 goto next_server; 415 goto failed; 416 417 case VDISKFULL: 418 case UAENOSPC: 419 /* The partition is full. Only applies to RWVOLs. 420 * Translate locally and return ENOSPC. 421 * No replicas to failover to. 422 */ 423 afs_op_set_error(op, -ENOSPC); 424 goto failed_but_online; 425 426 case VOVERQUOTA: 427 case UAEDQUOT: 428 /* Volume is full. Only applies to RWVOLs. 429 * Translate locally and return EDQUOT. 430 * No replicas to failover to. 431 */ 432 afs_op_set_error(op, -EDQUOT); 433 goto failed_but_online; 434 435 default: 436 afs_op_accumulate_error(op, error, abort_code); 437 failed_but_online: 438 clear_bit(AFS_SE_VOLUME_OFFLINE, 439 &op->server_list->servers[op->server_index].flags); 440 clear_bit(AFS_SE_VOLUME_BUSY, 441 &op->server_list->servers[op->server_index].flags); 442 goto failed; 443 } 444 445 case -ETIMEDOUT: 446 case -ETIME: 447 if (afs_op_error(op) != -EDESTADDRREQ) 448 goto iterate_address; 449 fallthrough; 450 case -ERFKILL: 451 case -EADDRNOTAVAIL: 452 case -ENETUNREACH: 453 case -EHOSTUNREACH: 454 case -EHOSTDOWN: 455 case -ECONNREFUSED: 456 _debug("no conn"); 457 afs_op_accumulate_error(op, error, 0); 458 goto iterate_address; 459 460 case -ENETRESET: 461 pr_warn("kAFS: Peer reset %s (op=%x)\n", 462 op->type ? op->type->name : "???", op->debug_id); 463 fallthrough; 464 case -ECONNRESET: 465 _debug("call reset"); 466 afs_op_set_error(op, error); 467 goto failed; 468 } 469 470 restart_from_beginning: 471 trace_afs_rotate(op, afs_rotate_trace_restart, 0); 472 _debug("restart"); 473 op->estate = NULL; 474 op->server = NULL; 475 afs_clear_server_states(op); 476 op->server_states = NULL; 477 afs_put_serverlist(op->net, op->server_list); 478 op->server_list = NULL; 479 start: 480 _debug("start"); 481 ASSERTCMP(op->estate, ==, NULL); 482 /* See if we need to do an update of the volume record. Note that the 483 * volume may have moved or even have been deleted. 484 */ 485 error = afs_check_volume_status(op->volume, op); 486 trace_afs_rotate(op, afs_rotate_trace_check_vol_status, error); 487 if (error < 0) { 488 afs_op_set_error(op, error); 489 goto failed; 490 } 491 492 if (!afs_start_fs_iteration(op, vnode)) 493 goto failed; 494 495 _debug("__ VOL %llx __", op->volume->vid); 496 497 pick_server: 498 _debug("pick [%lx]", op->untried_servers); 499 ASSERTCMP(op->estate, ==, NULL); 500 501 error = afs_wait_for_fs_probes(op, op->server_states, 502 !(op->flags & AFS_OPERATION_UNINTR)); 503 switch (error) { 504 case 0: /* No untried responsive servers and no outstanding probes */ 505 trace_afs_rotate(op, afs_rotate_trace_probe_none, 0); 506 goto no_more_servers; 507 case 1: /* Got a response */ 508 trace_afs_rotate(op, afs_rotate_trace_probe_response, 0); 509 break; 510 case 2: /* Probe data superseded */ 511 trace_afs_rotate(op, afs_rotate_trace_probe_superseded, 0); 512 goto restart_from_beginning; 513 default: 514 trace_afs_rotate(op, afs_rotate_trace_probe_error, error); 515 afs_op_set_error(op, error); 516 goto failed; 517 } 518 519 /* Pick the untried server with the highest priority untried endpoint. 520 * If we have outstanding callbacks, we stick with the server we're 521 * already using if we can. 522 */ 523 if (op->server) { 524 _debug("server %u", op->server_index); 525 if (test_bit(op->server_index, &op->untried_servers)) 526 goto selected_server; 527 op->server = NULL; 528 _debug("no server"); 529 } 530 531 rcu_read_lock(); 532 op->server_index = -1; 533 best_prio = -1; 534 for (i = 0; i < op->server_list->nr_servers; i++) { 535 struct afs_endpoint_state *es; 536 struct afs_server_entry *se = &op->server_list->servers[i]; 537 struct afs_addr_list *sal; 538 struct afs_server *s = se->server; 539 540 if (!test_bit(i, &op->untried_servers) || 541 test_bit(AFS_SE_EXCLUDED, &se->flags) || 542 !test_bit(AFS_SERVER_FL_RESPONDING, &s->flags)) 543 continue; 544 es = op->server_states[i].endpoint_state; 545 sal = es->addresses; 546 547 afs_get_address_preferences_rcu(op->net, sal); 548 for (j = 0; j < sal->nr_addrs; j++) { 549 if (es->failed_set & (1 << j)) 550 continue; 551 if (!sal->addrs[j].peer) 552 continue; 553 if (sal->addrs[j].prio > best_prio) { 554 op->server_index = i; 555 best_prio = sal->addrs[j].prio; 556 } 557 } 558 } 559 rcu_read_unlock(); 560 561 if (op->server_index == -1) 562 goto no_more_servers; 563 564 selected_server: 565 trace_afs_rotate(op, afs_rotate_trace_selected_server, best_prio); 566 _debug("use %d prio %u", op->server_index, best_prio); 567 __clear_bit(op->server_index, &op->untried_servers); 568 569 /* We're starting on a different fileserver from the list. We need to 570 * check it, create a callback intercept, find its address list and 571 * probe its capabilities before we use it. 572 */ 573 ASSERTCMP(op->estate, ==, NULL); 574 server = op->server_list->servers[op->server_index].server; 575 576 if (!afs_check_server_record(op, server, op->key)) 577 goto failed; 578 579 _debug("USING SERVER: %pU", &server->uuid); 580 581 op->flags |= AFS_OPERATION_RETRY_SERVER; 582 op->server = server; 583 if (vnode->cb_server != server) { 584 vnode->cb_server = server; 585 vnode->cb_v_check = atomic_read(&vnode->volume->cb_v_break); 586 atomic64_set(&vnode->cb_expires_at, AFS_NO_CB_PROMISE); 587 } 588 589 retry_server: 590 op->addr_tried = 0; 591 op->addr_index = -1; 592 593 iterate_address: 594 /* Iterate over the current server's address list to try and find an 595 * address on which it will respond to us. 596 */ 597 op->estate = op->server_states[op->server_index].endpoint_state; 598 set = READ_ONCE(op->estate->responsive_set); 599 failed = READ_ONCE(op->estate->failed_set); 600 _debug("iterate ES=%x rs=%lx fs=%lx", op->estate->probe_seq, set, failed); 601 set &= ~(failed | op->addr_tried); 602 trace_afs_rotate(op, afs_rotate_trace_iterate_addr, set); 603 if (!set) 604 goto wait_for_more_probe_results; 605 606 alist = op->estate->addresses; 607 best_prio = -1; 608 addr_index = 0; 609 for (i = 0; i < alist->nr_addrs; i++) { 610 if (!(set & (1 << i))) 611 continue; 612 if (alist->addrs[i].prio > best_prio) { 613 addr_index = i; 614 best_prio = alist->addrs[i].prio; 615 } 616 } 617 618 alist->preferred = addr_index; 619 620 op->addr_index = addr_index; 621 set_bit(addr_index, &op->addr_tried); 622 623 op->volsync.creation = TIME64_MIN; 624 op->volsync.update = TIME64_MIN; 625 op->call_responded = false; 626 _debug("address [%u] %u/%u %pISp", 627 op->server_index, addr_index, alist->nr_addrs, 628 rxrpc_kernel_remote_addr(alist->addrs[op->addr_index].peer)); 629 _leave(" = t"); 630 return true; 631 632 wait_for_more_probe_results: 633 error = afs_wait_for_one_fs_probe(op->server, op->estate, op->addr_tried, 634 !(op->flags & AFS_OPERATION_UNINTR)); 635 if (!error) 636 goto iterate_address; 637 638 /* We've now had a failure to respond on all of a server's addresses - 639 * immediately probe them again and consider retrying the server. 640 */ 641 trace_afs_rotate(op, afs_rotate_trace_probe_fileserver, 0); 642 afs_probe_fileserver(op->net, op->server); 643 if (op->flags & AFS_OPERATION_RETRY_SERVER) { 644 error = afs_wait_for_one_fs_probe(op->server, op->estate, op->addr_tried, 645 !(op->flags & AFS_OPERATION_UNINTR)); 646 switch (error) { 647 case 0: 648 op->flags &= ~AFS_OPERATION_RETRY_SERVER; 649 trace_afs_rotate(op, afs_rotate_trace_retry_server, 0); 650 goto retry_server; 651 case -ERESTARTSYS: 652 afs_op_set_error(op, error); 653 goto failed; 654 case -ETIME: 655 case -EDESTADDRREQ: 656 goto next_server; 657 } 658 } 659 660 next_server: 661 trace_afs_rotate(op, afs_rotate_trace_next_server, 0); 662 _debug("next"); 663 op->estate = NULL; 664 goto pick_server; 665 666 no_more_servers: 667 /* That's all the servers poked to no good effect. Try again if some 668 * of them were busy. 669 */ 670 trace_afs_rotate(op, afs_rotate_trace_no_more_servers, 0); 671 if (op->flags & AFS_OPERATION_VBUSY) { 672 afs_sleep_and_retry(op); 673 op->flags &= ~AFS_OPERATION_VBUSY; 674 goto restart_from_beginning; 675 } 676 677 rcu_read_lock(); 678 for (i = 0; i < op->server_list->nr_servers; i++) { 679 struct afs_endpoint_state *estate; 680 681 estate = op->server_states[i].endpoint_state; 682 error = READ_ONCE(estate->error); 683 if (error < 0) 684 afs_op_accumulate_error(op, error, estate->abort_code); 685 } 686 rcu_read_unlock(); 687 688 failed: 689 trace_afs_rotate(op, afs_rotate_trace_failed, 0); 690 op->flags |= AFS_OPERATION_STOP; 691 op->estate = NULL; 692 _leave(" = f [failed %d]", afs_op_error(op)); 693 return false; 694 } 695 696 /* 697 * Dump cursor state in the case of the error being EDESTADDRREQ. 698 */ 699 void afs_dump_edestaddrreq(const struct afs_operation *op) 700 { 701 static int count; 702 int i; 703 704 if (!IS_ENABLED(CONFIG_AFS_DEBUG_CURSOR) || count > 3) 705 return; 706 count++; 707 708 rcu_read_lock(); 709 710 pr_notice("EDESTADDR occurred\n"); 711 pr_notice("OP: cbb=%x cbb2=%x fl=%x err=%hd\n", 712 op->file[0].cb_break_before, 713 op->file[1].cb_break_before, op->flags, op->cumul_error.error); 714 pr_notice("OP: ut=%lx ix=%d ni=%u\n", 715 op->untried_servers, op->server_index, op->nr_iterations); 716 pr_notice("OP: call er=%d ac=%d r=%u\n", 717 op->call_error, op->call_abort_code, op->call_responded); 718 719 if (op->server_list) { 720 const struct afs_server_list *sl = op->server_list; 721 722 pr_notice("FC: SL nr=%u vnov=%hx\n", 723 sl->nr_servers, sl->vnovol_mask); 724 for (i = 0; i < sl->nr_servers; i++) { 725 const struct afs_server *s = sl->servers[i].server; 726 const struct afs_endpoint_state *e = 727 rcu_dereference(s->endpoint_state); 728 const struct afs_addr_list *a = e->addresses; 729 730 pr_notice("FC: server fl=%lx av=%u %pU\n", 731 s->flags, s->addr_version, &s->uuid); 732 pr_notice("FC: - pq=%x R=%lx F=%lx\n", 733 e->probe_seq, e->responsive_set, e->failed_set); 734 if (a) { 735 pr_notice("FC: - av=%u nr=%u/%u/%u pr=%u\n", 736 a->version, 737 a->nr_ipv4, a->nr_addrs, a->max_addrs, 738 a->preferred); 739 if (a == e->addresses) 740 pr_notice("FC: - current\n"); 741 } 742 } 743 } 744 745 pr_notice("AC: t=%lx ax=%d\n", op->addr_tried, op->addr_index); 746 rcu_read_unlock(); 747 } 748