fs/afs/server.c

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