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