fs/afs/cell.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* AFS cell and server record management
   3  *
   4  * Copyright (C) 2002, 2017 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7
   8 #include <linux/slab.h>
   9 #include <linux/key.h>
  10 #include <linux/ctype.h>
  11 #include <linux/dns_resolver.h>
  12 #include <linux/sched.h>
  13 #include <linux/inet.h>
  14 #include <linux/namei.h>
  15 #include <keys/rxrpc-type.h>
  16 #include "internal.h"
  17
  18 static unsigned __read_mostly afs_cell_gc_delay = 10;
  19 static unsigned __read_mostly afs_cell_min_ttl = 10 * 60;
  20 static unsigned __read_mostly afs_cell_max_ttl = 24 * 60 * 60;
  21 static atomic_t cell_debug_id;
  22
  23 static void afs_queue_cell_manager(struct afs_net *);
  24 static void afs_manage_cell_work(struct work_struct *);
  25
  26 static void afs_dec_cells_outstanding(struct afs_net *net)
  27 {
  28         if (atomic_dec_and_test(&net->cells_outstanding))
  29                 wake_up_var(&net->cells_outstanding);
  30 }
  31
  32 /*
  33  * Set the cell timer to fire after a given delay, assuming it's not already
  34  * set for an earlier time.
  35  */
  36 static void afs_set_cell_timer(struct afs_net *net, time64_t delay)
  37 {
  38         if (net->live) {
  39                 atomic_inc(&net->cells_outstanding);
  40                 if (timer_reduce(&net->cells_timer, jiffies + delay * HZ))
  41                         afs_dec_cells_outstanding(net);
  42         } else {
  43                 afs_queue_cell_manager(net);
  44         }
  45 }
  46
  47 /*
  48  * Look up and get an activation reference on a cell record.  The caller must
  49  * hold net->cells_lock at least read-locked.
  50  */
  51 static struct afs_cell *afs_find_cell_locked(struct afs_net *net,
  52                                              const char *name, unsigned int namesz,
  53                                              enum afs_cell_trace reason)
  54 {
  55         struct afs_cell *cell = NULL;
  56         struct rb_node *p;
  57         int n;
  58
  59         _enter("%*.*s", namesz, namesz, name);
  60
  61         if (name && namesz == 0)
  62                 return ERR_PTR(-EINVAL);
  63         if (namesz > AFS_MAXCELLNAME)
  64                 return ERR_PTR(-ENAMETOOLONG);
  65
  66         if (!name) {
  67                 cell = net->ws_cell;
  68                 if (!cell)
  69                         return ERR_PTR(-EDESTADDRREQ);
  70                 goto found;
  71         }
  72
  73         p = net->cells.rb_node;
  74         while (p) {
  75                 cell = rb_entry(p, struct afs_cell, net_node);
  76
  77                 n = strncasecmp(cell->name, name,
  78                                 min_t(size_t, cell->name_len, namesz));
  79                 if (n == 0)
  80                         n = cell->name_len - namesz;
  81                 if (n < 0)
  82                         p = p->rb_left;
  83                 else if (n > 0)
  84                         p = p->rb_right;
  85                 else
  86                         goto found;
  87         }
  88
  89         return ERR_PTR(-ENOENT);
  90
  91 found:
  92         return afs_use_cell(cell, reason);
  93 }
  94
  95 /*
  96  * Look up and get an activation reference on a cell record.
  97  */
  98 struct afs_cell *afs_find_cell(struct afs_net *net,
  99                                const char *name, unsigned int namesz,
 100                                enum afs_cell_trace reason)
 101 {
 102         struct afs_cell *cell;
 103
 104         down_read(&net->cells_lock);
 105         cell = afs_find_cell_locked(net, name, namesz, reason);
 106         up_read(&net->cells_lock);
 107         return cell;
 108 }
 109
 110 /*
 111  * Set up a cell record and fill in its name, VL server address list and
 112  * allocate an anonymous key
 113  */
 114 static struct afs_cell *afs_alloc_cell(struct afs_net *net,
 115                                        const char *name, unsigned int namelen,
 116                                        const char *addresses)
 117 {
 118         struct afs_vlserver_list *vllist;
 119         struct afs_cell *cell;
 120         int i, ret;
 121
 122         ASSERT(name);
 123         if (namelen == 0)
 124                 return ERR_PTR(-EINVAL);
 125         if (namelen > AFS_MAXCELLNAME) {
 126                 _leave(" = -ENAMETOOLONG");
 127                 return ERR_PTR(-ENAMETOOLONG);
 128         }
 129
 130         /* Prohibit cell names that contain unprintable chars, '/' and '@' or
 131          * that begin with a dot.  This also precludes "@cell".
 132          */
 133         if (name[0] == '.')
 134                 return ERR_PTR(-EINVAL);
 135         for (i = 0; i < namelen; i++) {
 136                 char ch = name[i];
 137                 if (!isprint(ch) || ch == '/' || ch == '@')
 138                         return ERR_PTR(-EINVAL);
 139         }
 140
 141         _enter("%*.*s,%s", namelen, namelen, name, addresses);
 142
 143         cell = kzalloc(sizeof(struct afs_cell), GFP_KERNEL);
 144         if (!cell) {
 145                 _leave(" = -ENOMEM");
 146                 return ERR_PTR(-ENOMEM);
 147         }
 148
 149         cell->name = kmalloc(namelen + 1, GFP_KERNEL);
 150         if (!cell->name) {
 151                 kfree(cell);
 152                 return ERR_PTR(-ENOMEM);
 153         }
 154
 155         cell->net = net;
 156         cell->name_len = namelen;
 157         for (i = 0; i < namelen; i++)
 158                 cell->name[i] = tolower(name[i]);
 159         cell->name[i] = 0;
 160
 161         atomic_set(&cell->ref, 1);
 162         atomic_set(&cell->active, 0);
 163         INIT_WORK(&cell->manager, afs_manage_cell_work);
 164         cell->volumes = RB_ROOT;
 165         INIT_HLIST_HEAD(&cell->proc_volumes);
 166         seqlock_init(&cell->volume_lock);
 167         cell->fs_servers = RB_ROOT;
 168         seqlock_init(&cell->fs_lock);
 169         rwlock_init(&cell->vl_servers_lock);
 170         cell->flags = (1 << AFS_CELL_FL_CHECK_ALIAS);
 171
 172         /* Provide a VL server list, filling it in if we were given a list of
 173          * addresses to use.
 174          */
 175         if (addresses) {
 176                 vllist = afs_parse_text_addrs(net,
 177                                               addresses, strlen(addresses), ':',
 178                                               VL_SERVICE, AFS_VL_PORT);
 179                 if (IS_ERR(vllist)) {
 180                         ret = PTR_ERR(vllist);
 181                         goto parse_failed;
 182                 }
 183
 184                 vllist->source = DNS_RECORD_FROM_CONFIG;
 185                 vllist->status = DNS_LOOKUP_NOT_DONE;
 186                 cell->dns_expiry = TIME64_MAX;
 187         } else {
 188                 ret = -ENOMEM;
 189                 vllist = afs_alloc_vlserver_list(0);
 190                 if (!vllist)
 191                         goto error;
 192                 vllist->source = DNS_RECORD_UNAVAILABLE;
 193                 vllist->status = DNS_LOOKUP_NOT_DONE;
 194                 cell->dns_expiry = ktime_get_real_seconds();
 195         }
 196
 197         rcu_assign_pointer(cell->vl_servers, vllist);
 198
 199         cell->dns_source = vllist->source;
 200         cell->dns_status = vllist->status;
 201         smp_store_release(&cell->dns_lookup_count, 1); /* vs source/status */
 202         atomic_inc(&net->cells_outstanding);
 203         cell->debug_id = atomic_inc_return(&cell_debug_id);
 204         trace_afs_cell(cell->debug_id, 1, 0, afs_cell_trace_alloc);
 205
 206         _leave(" = %p", cell);
 207         return cell;
 208
 209 parse_failed:
 210         if (ret == -EINVAL)
 211                 printk(KERN_ERR "kAFS: bad VL server IP address\n");
 212 error:
 213         kfree(cell->name);
 214         kfree(cell);
 215         _leave(" = %d", ret);
 216         return ERR_PTR(ret);
 217 }
 218
 219 /*
 220  * afs_lookup_cell - Look up or create a cell record.
 221  * @net:        The network namespace
 222  * @name:       The name of the cell.
 223  * @namesz:     The strlen of the cell name.
 224  * @vllist:     A colon/comma separated list of numeric IP addresses or NULL.
 225  * @excl:       T if an error should be given if the cell name already exists.
 226  *
 227  * Look up a cell record by name and query the DNS for VL server addresses if
 228  * needed.  Note that that actual DNS query is punted off to the manager thread
 229  * so that this function can return immediately if interrupted whilst allowing
 230  * cell records to be shared even if not yet fully constructed.
 231  */
 232 struct afs_cell *afs_lookup_cell(struct afs_net *net,
 233                                  const char *name, unsigned int namesz,
 234                                  const char *vllist, bool excl)
 235 {
 236         struct afs_cell *cell, *candidate, *cursor;
 237         struct rb_node *parent, **pp;
 238         enum afs_cell_state state;
 239         int ret, n;
 240
 241         _enter("%s,%s", name, vllist);
 242
 243         if (!excl) {
 244                 cell = afs_find_cell(net, name, namesz, afs_cell_trace_use_lookup);
 245                 if (!IS_ERR(cell))
 246                         goto wait_for_cell;
 247         }
 248
 249         /* Assume we're probably going to create a cell and preallocate and
 250          * mostly set up a candidate record.  We can then use this to stash the
 251          * name, the net namespace and VL server addresses.
 252          *
 253          * We also want to do this before we hold any locks as it may involve
 254          * upcalling to userspace to make DNS queries.
 255          */
 256         candidate = afs_alloc_cell(net, name, namesz, vllist);
 257         if (IS_ERR(candidate)) {
 258                 _leave(" = %ld", PTR_ERR(candidate));
 259                 return candidate;
 260         }
 261
 262         /* Find the insertion point and check to see if someone else added a
 263          * cell whilst we were allocating.
 264          */
 265         down_write(&net->cells_lock);
 266
 267         pp = &net->cells.rb_node;
 268         parent = NULL;
 269         while (*pp) {
 270                 parent = *pp;
 271                 cursor = rb_entry(parent, struct afs_cell, net_node);
 272
 273                 n = strncasecmp(cursor->name, name,
 274                                 min_t(size_t, cursor->name_len, namesz));
 275                 if (n == 0)
 276                         n = cursor->name_len - namesz;
 277                 if (n < 0)
 278                         pp = &(*pp)->rb_left;
 279                 else if (n > 0)
 280                         pp = &(*pp)->rb_right;
 281                 else
 282                         goto cell_already_exists;
 283         }
 284
 285         cell = candidate;
 286         candidate = NULL;
 287         atomic_set(&cell->active, 2);
 288         trace_afs_cell(cell->debug_id, atomic_read(&cell->ref), 2, afs_cell_trace_insert);
 289         rb_link_node_rcu(&cell->net_node, parent, pp);
 290         rb_insert_color(&cell->net_node, &net->cells);
 291         up_write(&net->cells_lock);
 292
 293         afs_queue_cell(cell, afs_cell_trace_get_queue_new);
 294
 295 wait_for_cell:
 296         trace_afs_cell(cell->debug_id, atomic_read(&cell->ref), atomic_read(&cell->active),
 297                        afs_cell_trace_wait);
 298         _debug("wait_for_cell");
 299         wait_var_event(&cell->state,
 300                        ({
 301                                state = smp_load_acquire(&cell->state); /* vs error */
 302                                state == AFS_CELL_ACTIVE || state == AFS_CELL_REMOVED;
 303                        }));
 304
 305         /* Check the state obtained from the wait check. */
 306         if (state == AFS_CELL_REMOVED) {
 307                 ret = cell->error;
 308                 goto error;
 309         }
 310
 311         _leave(" = %p [cell]", cell);
 312         return cell;
 313
 314 cell_already_exists:
 315         _debug("cell exists");
 316         cell = cursor;
 317         if (excl) {
 318                 ret = -EEXIST;
 319         } else {
 320                 afs_use_cell(cursor, afs_cell_trace_use_lookup);
 321                 ret = 0;
 322         }
 323         up_write(&net->cells_lock);
 324         if (candidate)
 325                 afs_put_cell(candidate, afs_cell_trace_put_candidate);
 326         if (ret == 0)
 327                 goto wait_for_cell;
 328         goto error_noput;
 329 error:
 330         afs_unuse_cell(net, cell, afs_cell_trace_unuse_lookup);
 331 error_noput:
 332         _leave(" = %d [error]", ret);
 333         return ERR_PTR(ret);
 334 }
 335
 336 /*
 337  * set the root cell information
 338  * - can be called with a module parameter string
 339  * - can be called from a write to /proc/fs/afs/rootcell
 340  */
 341 int afs_cell_init(struct afs_net *net, const char *rootcell)
 342 {
 343         struct afs_cell *old_root, *new_root;
 344         const char *cp, *vllist;
 345         size_t len;
 346
 347         _enter("");
 348
 349         if (!rootcell) {
 350                 /* module is loaded with no parameters, or built statically.
 351                  * - in the future we might initialize cell DB here.
 352                  */
 353                 _leave(" = 0 [no root]");
 354                 return 0;
 355         }
 356
 357         cp = strchr(rootcell, ':');
 358         if (!cp) {
 359                 _debug("kAFS: no VL server IP addresses specified");
 360                 vllist = NULL;
 361                 len = strlen(rootcell);
 362         } else {
 363                 vllist = cp + 1;
 364                 len = cp - rootcell;
 365         }
 366
 367         /* allocate a cell record for the root cell */
 368         new_root = afs_lookup_cell(net, rootcell, len, vllist, false);
 369         if (IS_ERR(new_root)) {
 370                 _leave(" = %ld", PTR_ERR(new_root));
 371                 return PTR_ERR(new_root);
 372         }
 373
 374         if (!test_and_set_bit(AFS_CELL_FL_NO_GC, &new_root->flags))
 375                 afs_use_cell(new_root, afs_cell_trace_use_pin);
 376
 377         /* install the new cell */
 378         down_write(&net->cells_lock);
 379         afs_see_cell(new_root, afs_cell_trace_see_ws);
 380         old_root = net->ws_cell;
 381         net->ws_cell = new_root;
 382         up_write(&net->cells_lock);
 383
 384         afs_unuse_cell(net, old_root, afs_cell_trace_unuse_ws);
 385         _leave(" = 0");
 386         return 0;
 387 }
 388
 389 /*
 390  * Update a cell's VL server address list from the DNS.
 391  */
 392 static int afs_update_cell(struct afs_cell *cell)
 393 {
 394         struct afs_vlserver_list *vllist, *old = NULL, *p;
 395         unsigned int min_ttl = READ_ONCE(afs_cell_min_ttl);
 396         unsigned int max_ttl = READ_ONCE(afs_cell_max_ttl);
 397         time64_t now, expiry = 0;
 398         int ret = 0;
 399
 400         _enter("%s", cell->name);
 401
 402         vllist = afs_dns_query(cell, &expiry);
 403         if (IS_ERR(vllist)) {
 404                 ret = PTR_ERR(vllist);
 405
 406                 _debug("%s: fail %d", cell->name, ret);
 407                 if (ret == -ENOMEM)
 408                         goto out_wake;
 409
 410                 ret = -ENOMEM;
 411                 vllist = afs_alloc_vlserver_list(0);
 412                 if (!vllist)
 413                         goto out_wake;
 414
 415                 switch (ret) {
 416                 case -ENODATA:
 417                 case -EDESTADDRREQ:
 418                         vllist->status = DNS_LOOKUP_GOT_NOT_FOUND;
 419                         break;
 420                 case -EAGAIN:
 421                 case -ECONNREFUSED:
 422                         vllist->status = DNS_LOOKUP_GOT_TEMP_FAILURE;
 423                         break;
 424                 default:
 425                         vllist->status = DNS_LOOKUP_GOT_LOCAL_FAILURE;
 426                         break;
 427                 }
 428         }
 429
 430         _debug("%s: got list %d %d", cell->name, vllist->source, vllist->status);
 431         cell->dns_status = vllist->status;
 432
 433         now = ktime_get_real_seconds();
 434         if (min_ttl > max_ttl)
 435                 max_ttl = min_ttl;
 436         if (expiry < now + min_ttl)
 437                 expiry = now + min_ttl;
 438         else if (expiry > now + max_ttl)
 439                 expiry = now + max_ttl;
 440
 441         _debug("%s: status %d", cell->name, vllist->status);
 442         if (vllist->source == DNS_RECORD_UNAVAILABLE) {
 443                 switch (vllist->status) {
 444                 case DNS_LOOKUP_GOT_NOT_FOUND:
 445                         /* The DNS said that the cell does not exist or there
 446                          * weren't any addresses to be had.
 447                          */
 448                         cell->dns_expiry = expiry;
 449                         break;
 450
 451                 case DNS_LOOKUP_BAD:
 452                 case DNS_LOOKUP_GOT_LOCAL_FAILURE:
 453                 case DNS_LOOKUP_GOT_TEMP_FAILURE:
 454                 case DNS_LOOKUP_GOT_NS_FAILURE:
 455                 default:
 456                         cell->dns_expiry = now + 10;
 457                         break;
 458                 }
 459         } else {
 460                 cell->dns_expiry = expiry;
 461         }
 462
 463         /* Replace the VL server list if the new record has servers or the old
 464          * record doesn't.
 465          */
 466         write_lock(&cell->vl_servers_lock);
 467         p = rcu_dereference_protected(cell->vl_servers, true);
 468         if (vllist->nr_servers > 0 || p->nr_servers == 0) {
 469                 rcu_assign_pointer(cell->vl_servers, vllist);
 470                 cell->dns_source = vllist->source;
 471                 old = p;
 472         }
 473         write_unlock(&cell->vl_servers_lock);
 474         afs_put_vlserverlist(cell->net, old);
 475
 476 out_wake:
 477         smp_store_release(&cell->dns_lookup_count,
 478                           cell->dns_lookup_count + 1); /* vs source/status */
 479         wake_up_var(&cell->dns_lookup_count);
 480         _leave(" = %d", ret);
 481         return ret;
 482 }
 483
 484 /*
 485  * Destroy a cell record
 486  */
 487 static void afs_cell_destroy(struct rcu_head *rcu)
 488 {
 489         struct afs_cell *cell = container_of(rcu, struct afs_cell, rcu);
 490         struct afs_net *net = cell->net;
 491         int u;
 492
 493         _enter("%p{%s}", cell, cell->name);
 494
 495         u = atomic_read(&cell->ref);
 496         ASSERTCMP(u, ==, 0);
 497         trace_afs_cell(cell->debug_id, u, atomic_read(&cell->active), afs_cell_trace_free);
 498
 499         afs_put_vlserverlist(net, rcu_access_pointer(cell->vl_servers));
 500         afs_unuse_cell(net, cell->alias_of, afs_cell_trace_unuse_alias);
 501         key_put(cell->anonymous_key);
 502         kfree(cell->name);
 503         kfree(cell);
 504
 505         afs_dec_cells_outstanding(net);
 506         _leave(" [destroyed]");
 507 }
 508
 509 /*
 510  * Queue the cell manager.
 511  */
 512 static void afs_queue_cell_manager(struct afs_net *net)
 513 {
 514         int outstanding = atomic_inc_return(&net->cells_outstanding);
 515
 516         _enter("%d", outstanding);
 517
 518         if (!queue_work(afs_wq, &net->cells_manager))
 519                 afs_dec_cells_outstanding(net);
 520 }
 521
 522 /*
 523  * Cell management timer.  We have an increment on cells_outstanding that we
 524  * need to pass along to the work item.
 525  */
 526 void afs_cells_timer(struct timer_list *timer)
 527 {
 528         struct afs_net *net = container_of(timer, struct afs_net, cells_timer);
 529
 530         _enter("");
 531         if (!queue_work(afs_wq, &net->cells_manager))
 532                 afs_dec_cells_outstanding(net);
 533 }
 534
 535 /*
 536  * Get a reference on a cell record.
 537  */
 538 struct afs_cell *afs_get_cell(struct afs_cell *cell, enum afs_cell_trace reason)
 539 {
 540         int u;
 541
 542         if (atomic_read(&cell->ref) <= 0)
 543                 BUG();
 544
 545         u = atomic_inc_return(&cell->ref);
 546         trace_afs_cell(cell->debug_id, u, atomic_read(&cell->active), reason);
 547         return cell;
 548 }
 549
 550 /*
 551  * Drop a reference on a cell record.
 552  */
 553 void afs_put_cell(struct afs_cell *cell, enum afs_cell_trace reason)
 554 {
 555         if (cell) {
 556                 unsigned int debug_id = cell->debug_id;
 557                 unsigned int u, a;
 558
 559                 a = atomic_read(&cell->active);
 560                 u = atomic_dec_return(&cell->ref);
 561                 trace_afs_cell(debug_id, u, a, reason);
 562                 if (u == 0) {
 563                         a = atomic_read(&cell->active);
 564                         WARN(a != 0, "Cell active count %u > 0\n", a);
 565                         call_rcu(&cell->rcu, afs_cell_destroy);
 566                 }
 567         }
 568 }
 569
 570 /*
 571  * Note a cell becoming more active.
 572  */
 573 struct afs_cell *afs_use_cell(struct afs_cell *cell, enum afs_cell_trace reason)
 574 {
 575         int u, a;
 576
 577         if (atomic_read(&cell->ref) <= 0)
 578                 BUG();
 579
 580         u = atomic_read(&cell->ref);
 581         a = atomic_inc_return(&cell->active);
 582         trace_afs_cell(cell->debug_id, u, a, reason);
 583         return cell;
 584 }
 585
 586 /*
 587  * Record a cell becoming less active.  When the active counter reaches 1, it
 588  * is scheduled for destruction, but may get reactivated.
 589  */
 590 void afs_unuse_cell(struct afs_net *net, struct afs_cell *cell, enum afs_cell_trace reason)
 591 {
 592         unsigned int debug_id = cell->debug_id;
 593         time64_t now, expire_delay;
 594         int u, a;
 595
 596         if (!cell)
 597                 return;
 598
 599         _enter("%s", cell->name);
 600
 601         now = ktime_get_real_seconds();
 602         cell->last_inactive = now;
 603         expire_delay = 0;
 604         if (cell->vl_servers->nr_servers)
 605                 expire_delay = afs_cell_gc_delay;
 606
 607         u = atomic_read(&cell->ref);
 608         a = atomic_dec_return(&cell->active);
 609         trace_afs_cell(debug_id, u, a, reason);
 610         WARN_ON(a == 0);
 611         if (a == 1)
 612                 /* 'cell' may now be garbage collected. */
 613                 afs_set_cell_timer(net, expire_delay);
 614 }
 615
 616 /*
 617  * Note that a cell has been seen.
 618  */
 619 void afs_see_cell(struct afs_cell *cell, enum afs_cell_trace reason)
 620 {
 621         int u, a;
 622
 623         u = atomic_read(&cell->ref);
 624         a = atomic_read(&cell->active);
 625         trace_afs_cell(cell->debug_id, u, a, reason);
 626 }
 627
 628 /*
 629  * Queue a cell for management, giving the workqueue a ref to hold.
 630  */
 631 void afs_queue_cell(struct afs_cell *cell, enum afs_cell_trace reason)
 632 {
 633         afs_get_cell(cell, reason);
 634         if (!queue_work(afs_wq, &cell->manager))
 635                 afs_put_cell(cell, afs_cell_trace_put_queue_fail);
 636 }
 637
 638 /*
 639  * Allocate a key to use as a placeholder for anonymous user security.
 640  */
 641 static int afs_alloc_anon_key(struct afs_cell *cell)
 642 {
 643         struct key *key;
 644         char keyname[4 + AFS_MAXCELLNAME + 1], *cp, *dp;
 645
 646         /* Create a key to represent an anonymous user. */
 647         memcpy(keyname, "afs@", 4);
 648         dp = keyname + 4;
 649         cp = cell->name;
 650         do {
 651                 *dp++ = tolower(*cp);
 652         } while (*cp++);
 653
 654         key = rxrpc_get_null_key(keyname);
 655         if (IS_ERR(key))
 656                 return PTR_ERR(key);
 657
 658         cell->anonymous_key = key;
 659
 660         _debug("anon key %p{%x}",
 661                cell->anonymous_key, key_serial(cell->anonymous_key));
 662         return 0;
 663 }
 664
 665 /*
 666  * Activate a cell.
 667  */
 668 static int afs_activate_cell(struct afs_net *net, struct afs_cell *cell)
 669 {
 670         struct hlist_node **p;
 671         struct afs_cell *pcell;
 672         int ret;
 673
 674         if (!cell->anonymous_key) {
 675                 ret = afs_alloc_anon_key(cell);
 676                 if (ret < 0)
 677                         return ret;
 678         }
 679
 680 #ifdef CONFIG_AFS_FSCACHE
 681         cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,
 682                                              &afs_cell_cache_index_def,
 683                                              cell->name, strlen(cell->name),
 684                                              NULL, 0,
 685                                              cell, 0, true);
 686 #endif
 687         ret = afs_proc_cell_setup(cell);
 688         if (ret < 0)
 689                 return ret;
 690
 691         mutex_lock(&net->proc_cells_lock);
 692         for (p = &net->proc_cells.first; *p; p = &(*p)->next) {
 693                 pcell = hlist_entry(*p, struct afs_cell, proc_link);
 694                 if (strcmp(cell->name, pcell->name) < 0)
 695                         break;
 696         }
 697
 698         cell->proc_link.pprev = p;
 699         cell->proc_link.next = *p;
 700         rcu_assign_pointer(*p, &cell->proc_link.next);
 701         if (cell->proc_link.next)
 702                 cell->proc_link.next->pprev = &cell->proc_link.next;
 703
 704         afs_dynroot_mkdir(net, cell);
 705         mutex_unlock(&net->proc_cells_lock);
 706         return 0;
 707 }
 708
 709 /*
 710  * Deactivate a cell.
 711  */
 712 static void afs_deactivate_cell(struct afs_net *net, struct afs_cell *cell)
 713 {
 714         _enter("%s", cell->name);
 715
 716         afs_proc_cell_remove(cell);
 717
 718         mutex_lock(&net->proc_cells_lock);
 719         hlist_del_rcu(&cell->proc_link);
 720         afs_dynroot_rmdir(net, cell);
 721         mutex_unlock(&net->proc_cells_lock);
 722
 723 #ifdef CONFIG_AFS_FSCACHE
 724         fscache_relinquish_cookie(cell->cache, NULL, false);
 725         cell->cache = NULL;
 726 #endif
 727
 728         _leave("");
 729 }
 730
 731 /*
 732  * Manage a cell record, initialising and destroying it, maintaining its DNS
 733  * records.
 734  */
 735 static void afs_manage_cell(struct afs_cell *cell)
 736 {
 737         struct afs_net *net = cell->net;
 738         int ret, active;
 739
 740         _enter("%s", cell->name);
 741
 742 again:
 743         _debug("state %u", cell->state);
 744         switch (cell->state) {
 745         case AFS_CELL_INACTIVE:
 746         case AFS_CELL_FAILED:
 747                 down_write(&net->cells_lock);
 748                 active = 1;
 749                 if (atomic_try_cmpxchg_relaxed(&cell->active, &active, 0)) {
 750                         rb_erase(&cell->net_node, &net->cells);
 751                         trace_afs_cell(cell->debug_id, atomic_read(&cell->ref), 0,
 752                                        afs_cell_trace_unuse_delete);
 753                         smp_store_release(&cell->state, AFS_CELL_REMOVED);
 754                 }
 755                 up_write(&net->cells_lock);
 756                 if (cell->state == AFS_CELL_REMOVED) {
 757                         wake_up_var(&cell->state);
 758                         goto final_destruction;
 759                 }
 760                 if (cell->state == AFS_CELL_FAILED)
 761                         goto done;
 762                 smp_store_release(&cell->state, AFS_CELL_UNSET);
 763                 wake_up_var(&cell->state);
 764                 goto again;
 765
 766         case AFS_CELL_UNSET:
 767                 smp_store_release(&cell->state, AFS_CELL_ACTIVATING);
 768                 wake_up_var(&cell->state);
 769                 goto again;
 770
 771         case AFS_CELL_ACTIVATING:
 772                 ret = afs_activate_cell(net, cell);
 773                 if (ret < 0)
 774                         goto activation_failed;
 775
 776                 smp_store_release(&cell->state, AFS_CELL_ACTIVE);
 777                 wake_up_var(&cell->state);
 778                 goto again;
 779
 780         case AFS_CELL_ACTIVE:
 781                 if (atomic_read(&cell->active) > 1) {
 782                         if (test_and_clear_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags)) {
 783                                 ret = afs_update_cell(cell);
 784                                 if (ret < 0)
 785                                         cell->error = ret;
 786                         }
 787                         goto done;
 788                 }
 789                 smp_store_release(&cell->state, AFS_CELL_DEACTIVATING);
 790                 wake_up_var(&cell->state);
 791                 goto again;
 792
 793         case AFS_CELL_DEACTIVATING:
 794                 if (atomic_read(&cell->active) > 1)
 795                         goto reverse_deactivation;
 796                 afs_deactivate_cell(net, cell);
 797                 smp_store_release(&cell->state, AFS_CELL_INACTIVE);
 798                 wake_up_var(&cell->state);
 799                 goto again;
 800
 801         case AFS_CELL_REMOVED:
 802                 goto done;
 803
 804         default:
 805                 break;
 806         }
 807         _debug("bad state %u", cell->state);
 808         BUG(); /* Unhandled state */
 809
 810 activation_failed:
 811         cell->error = ret;
 812         afs_deactivate_cell(net, cell);
 813
 814         smp_store_release(&cell->state, AFS_CELL_FAILED); /* vs error */
 815         wake_up_var(&cell->state);
 816         goto again;
 817
 818 reverse_deactivation:
 819         smp_store_release(&cell->state, AFS_CELL_ACTIVE);
 820         wake_up_var(&cell->state);
 821         _leave(" [deact->act]");
 822         return;
 823
 824 done:
 825         _leave(" [done %u]", cell->state);
 826         return;
 827
 828 final_destruction:
 829         /* The root volume is pinning the cell */
 830         afs_put_volume(cell->net, cell->root_volume, afs_volume_trace_put_cell_root);
 831         cell->root_volume = NULL;
 832         afs_put_cell(cell, afs_cell_trace_put_destroy);
 833 }
 834
 835 static void afs_manage_cell_work(struct work_struct *work)
 836 {
 837         struct afs_cell *cell = container_of(work, struct afs_cell, manager);
 838
 839         afs_manage_cell(cell);
 840         afs_put_cell(cell, afs_cell_trace_put_queue_work);
 841 }
 842
 843 /*
 844  * Manage the records of cells known to a network namespace.  This includes
 845  * updating the DNS records and garbage collecting unused cells that were
 846  * automatically added.
 847  *
 848  * Note that constructed cell records may only be removed from net->cells by
 849  * this work item, so it is safe for this work item to stash a cursor pointing
 850  * into the tree and then return to caller (provided it skips cells that are
 851  * still under construction).
 852  *
 853  * Note also that we were given an increment on net->cells_outstanding by
 854  * whoever queued us that we need to deal with before returning.
 855  */
 856 void afs_manage_cells(struct work_struct *work)
 857 {
 858         struct afs_net *net = container_of(work, struct afs_net, cells_manager);
 859         struct rb_node *cursor;
 860         time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX;
 861         bool purging = !net->live;
 862
 863         _enter("");
 864
 865         /* Trawl the cell database looking for cells that have expired from
 866          * lack of use and cells whose DNS results have expired and dispatch
 867          * their managers.
 868          */
 869         down_read(&net->cells_lock);
 870
 871         for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) {
 872                 struct afs_cell *cell =
 873                         rb_entry(cursor, struct afs_cell, net_node);
 874                 unsigned active;
 875                 bool sched_cell = false;
 876
 877                 active = atomic_read(&cell->active);
 878                 trace_afs_cell(cell->debug_id, atomic_read(&cell->ref),
 879                                active, afs_cell_trace_manage);
 880
 881                 ASSERTCMP(active, >=, 1);
 882
 883                 if (purging) {
 884                         if (test_and_clear_bit(AFS_CELL_FL_NO_GC, &cell->flags)) {
 885                                 active = atomic_dec_return(&cell->active);
 886                                 trace_afs_cell(cell->debug_id, atomic_read(&cell->ref),
 887                                                active, afs_cell_trace_unuse_pin);
 888                         }
 889                 }
 890
 891                 if (active == 1) {
 892                         struct afs_vlserver_list *vllist;
 893                         time64_t expire_at = cell->last_inactive;
 894
 895                         read_lock(&cell->vl_servers_lock);
 896                         vllist = rcu_dereference_protected(
 897                                 cell->vl_servers,
 898                                 lockdep_is_held(&cell->vl_servers_lock));
 899                         if (vllist->nr_servers > 0)
 900                                 expire_at += afs_cell_gc_delay;
 901                         read_unlock(&cell->vl_servers_lock);
 902                         if (purging || expire_at <= now)
 903                                 sched_cell = true;
 904                         else if (expire_at < next_manage)
 905                                 next_manage = expire_at;
 906                 }
 907
 908                 if (!purging) {
 909                         if (test_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags))
 910                                 sched_cell = true;
 911                 }
 912
 913                 if (sched_cell)
 914                         afs_queue_cell(cell, afs_cell_trace_get_queue_manage);
 915         }
 916
 917         up_read(&net->cells_lock);
 918
 919         /* Update the timer on the way out.  We have to pass an increment on
 920          * cells_outstanding in the namespace that we are in to the timer or
 921          * the work scheduler.
 922          */
 923         if (!purging && next_manage < TIME64_MAX) {
 924                 now = ktime_get_real_seconds();
 925
 926                 if (next_manage - now <= 0) {
 927                         if (queue_work(afs_wq, &net->cells_manager))
 928                                 atomic_inc(&net->cells_outstanding);
 929                 } else {
 930                         afs_set_cell_timer(net, next_manage - now);
 931                 }
 932         }
 933
 934         afs_dec_cells_outstanding(net);
 935         _leave(" [%d]", atomic_read(&net->cells_outstanding));
 936 }
 937
 938 /*
 939  * Purge in-memory cell database.
 940  */
 941 void afs_cell_purge(struct afs_net *net)
 942 {
 943         struct afs_cell *ws;
 944
 945         _enter("");
 946
 947         down_write(&net->cells_lock);
 948         ws = net->ws_cell;
 949         net->ws_cell = NULL;
 950         up_write(&net->cells_lock);
 951         afs_unuse_cell(net, ws, afs_cell_trace_unuse_ws);
 952
 953         _debug("del timer");
 954         if (del_timer_sync(&net->cells_timer))
 955                 atomic_dec(&net->cells_outstanding);
 956
 957         _debug("kick mgr");
 958         afs_queue_cell_manager(net);
 959
 960         _debug("wait");
 961         wait_var_event(&net->cells_outstanding,
 962                        !atomic_read(&net->cells_outstanding));
 963         _leave("");
 964 }