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