fs/afs/server.c

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