1 /* AFS cell and server record management
3 * Copyright (C) 2002, 2017 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/slab.h>
13 #include <linux/key.h>
14 #include <linux/ctype.h>
15 #include <linux/dns_resolver.h>
16 #include <linux/sched.h>
17 #include <linux/inet.h>
18 #include <keys/rxrpc-type.h>
21 unsigned __read_mostly afs_cell_gc_delay = 10;
23 static void afs_manage_cell(struct work_struct *);
25 static void afs_dec_cells_outstanding(struct afs_net *net)
27 if (atomic_dec_and_test(&net->cells_outstanding))
28 wake_up_var(&net->cells_outstanding);
32 * Set the cell timer to fire after a given delay, assuming it's not already
33 * set for an earlier time.
35 static void afs_set_cell_timer(struct afs_net *net, time64_t delay)
38 atomic_inc(&net->cells_outstanding);
39 if (timer_reduce(&net->cells_timer, jiffies + delay * HZ))
40 afs_dec_cells_outstanding(net);
45 * Look up and get an activation reference on a cell record under RCU
46 * conditions. The caller must hold the RCU read lock.
48 struct afs_cell *afs_lookup_cell_rcu(struct afs_net *net,
49 const char *name, unsigned int namesz)
51 struct afs_cell *cell = NULL;
53 int n, seq = 0, ret = 0;
55 _enter("%*.*s", namesz, namesz, name);
57 if (name && namesz == 0)
58 return ERR_PTR(-EINVAL);
59 if (namesz > AFS_MAXCELLNAME)
60 return ERR_PTR(-ENAMETOOLONG);
63 /* Unfortunately, rbtree walking doesn't give reliable results
64 * under just the RCU read lock, so we have to check for
68 afs_put_cell(net, cell);
72 read_seqbegin_or_lock(&net->cells_lock, &seq);
75 cell = rcu_dereference_raw(net->ws_cell);
84 p = rcu_dereference_raw(net->cells.rb_node);
86 cell = rb_entry(p, struct afs_cell, net_node);
88 n = strncasecmp(cell->name, name,
89 min_t(size_t, cell->name_len, namesz));
91 n = cell->name_len - namesz;
93 p = rcu_dereference_raw(p->rb_left);
95 p = rcu_dereference_raw(p->rb_right);
97 if (atomic_inc_not_zero(&cell->usage)) {
101 /* We want to repeat the search, this time with
102 * the lock properly locked.
108 } while (need_seqretry(&net->cells_lock, seq));
110 done_seqretry(&net->cells_lock, seq);
112 return ret == 0 ? cell : ERR_PTR(ret);
116 * Set up a cell record and fill in its name, VL server address list and
117 * allocate an anonymous key
119 static struct afs_cell *afs_alloc_cell(struct afs_net *net,
120 const char *name, unsigned int namelen,
123 struct afs_cell *cell;
128 return ERR_PTR(-EINVAL);
129 if (namelen > AFS_MAXCELLNAME) {
130 _leave(" = -ENAMETOOLONG");
131 return ERR_PTR(-ENAMETOOLONG);
134 _enter("%*.*s,%s", namelen, namelen, name, vllist);
136 cell = kzalloc(sizeof(struct afs_cell), GFP_KERNEL);
138 _leave(" = -ENOMEM");
139 return ERR_PTR(-ENOMEM);
143 cell->name_len = namelen;
144 for (i = 0; i < namelen; i++)
145 cell->name[i] = tolower(name[i]);
147 atomic_set(&cell->usage, 2);
148 INIT_WORK(&cell->manager, afs_manage_cell);
149 cell->flags = ((1 << AFS_CELL_FL_NOT_READY) |
150 (1 << AFS_CELL_FL_NO_LOOKUP_YET));
151 INIT_LIST_HEAD(&cell->proc_volumes);
152 rwlock_init(&cell->proc_lock);
153 rwlock_init(&cell->vl_addrs_lock);
155 /* Fill in the VL server list if we were given a list of addresses to
159 struct afs_addr_list *alist;
161 alist = afs_parse_text_addrs(vllist, strlen(vllist), ':',
162 VL_SERVICE, AFS_VL_PORT);
164 ret = PTR_ERR(alist);
168 rcu_assign_pointer(cell->vl_addrs, alist);
169 cell->dns_expiry = TIME64_MAX;
172 _leave(" = %p", cell);
177 printk(KERN_ERR "kAFS: bad VL server IP address\n");
179 _leave(" = %d", ret);
184 * afs_lookup_cell - Look up or create a cell record.
185 * @net: The network namespace
186 * @name: The name of the cell.
187 * @namesz: The strlen of the cell name.
188 * @vllist: A colon/comma separated list of numeric IP addresses or NULL.
189 * @excl: T if an error should be given if the cell name already exists.
191 * Look up a cell record by name and query the DNS for VL server addresses if
192 * needed. Note that that actual DNS query is punted off to the manager thread
193 * so that this function can return immediately if interrupted whilst allowing
194 * cell records to be shared even if not yet fully constructed.
196 struct afs_cell *afs_lookup_cell(struct afs_net *net,
197 const char *name, unsigned int namesz,
198 const char *vllist, bool excl)
200 struct afs_cell *cell, *candidate, *cursor;
201 struct rb_node *parent, **pp;
204 _enter("%s,%s", name, vllist);
208 cell = afs_lookup_cell_rcu(net, name, namesz);
214 /* Assume we're probably going to create a cell and preallocate and
215 * mostly set up a candidate record. We can then use this to stash the
216 * name, the net namespace and VL server addresses.
218 * We also want to do this before we hold any locks as it may involve
219 * upcalling to userspace to make DNS queries.
221 candidate = afs_alloc_cell(net, name, namesz, vllist);
222 if (IS_ERR(candidate)) {
223 _leave(" = %ld", PTR_ERR(candidate));
227 /* Find the insertion point and check to see if someone else added a
228 * cell whilst we were allocating.
230 write_seqlock(&net->cells_lock);
232 pp = &net->cells.rb_node;
236 cursor = rb_entry(parent, struct afs_cell, net_node);
238 n = strncasecmp(cursor->name, name,
239 min_t(size_t, cursor->name_len, namesz));
241 n = cursor->name_len - namesz;
243 pp = &(*pp)->rb_left;
245 pp = &(*pp)->rb_right;
247 goto cell_already_exists;
252 rb_link_node_rcu(&cell->net_node, parent, pp);
253 rb_insert_color(&cell->net_node, &net->cells);
254 atomic_inc(&net->cells_outstanding);
255 write_sequnlock(&net->cells_lock);
257 queue_work(afs_wq, &cell->manager);
260 _debug("wait_for_cell");
261 ret = wait_on_bit(&cell->flags, AFS_CELL_FL_NOT_READY, TASK_INTERRUPTIBLE);
264 switch (READ_ONCE(cell->state)) {
265 case AFS_CELL_FAILED:
269 _debug("weird %u %d", cell->state, cell->error);
271 case AFS_CELL_ACTIVE:
275 _leave(" = %p [cell]", cell);
279 _debug("cell exists");
284 afs_get_cell(cursor);
287 write_sequnlock(&net->cells_lock);
293 afs_put_cell(net, cell);
295 _leave(" = %d [error]", ret);
300 * set the root cell information
301 * - can be called with a module parameter string
302 * - can be called from a write to /proc/fs/afs/rootcell
304 int afs_cell_init(struct afs_net *net, const char *rootcell)
306 struct afs_cell *old_root, *new_root;
307 const char *cp, *vllist;
313 /* module is loaded with no parameters, or built statically.
314 * - in the future we might initialize cell DB here.
316 _leave(" = 0 [no root]");
320 cp = strchr(rootcell, ':');
322 _debug("kAFS: no VL server IP addresses specified");
324 len = strlen(rootcell);
330 /* allocate a cell record for the root cell */
331 new_root = afs_lookup_cell(net, rootcell, len, vllist, false);
332 if (IS_ERR(new_root)) {
333 _leave(" = %ld", PTR_ERR(new_root));
334 return PTR_ERR(new_root);
337 set_bit(AFS_CELL_FL_NO_GC, &new_root->flags);
338 afs_get_cell(new_root);
340 /* install the new cell */
341 write_seqlock(&net->cells_lock);
342 old_root = net->ws_cell;
343 net->ws_cell = new_root;
344 write_sequnlock(&net->cells_lock);
346 afs_put_cell(net, old_root);
352 * Update a cell's VL server address list from the DNS.
354 static void afs_update_cell(struct afs_cell *cell)
356 struct afs_addr_list *alist, *old;
357 time64_t now, expiry;
359 _enter("%s", cell->name);
361 alist = afs_dns_query(cell, &expiry);
363 switch (PTR_ERR(alist)) {
365 /* The DNS said that the cell does not exist */
366 set_bit(AFS_CELL_FL_NOT_FOUND, &cell->flags);
367 clear_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags);
368 cell->dns_expiry = ktime_get_real_seconds() + 61;
374 set_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags);
375 cell->dns_expiry = ktime_get_real_seconds() + 10;
379 cell->error = -EDESTADDRREQ;
381 clear_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags);
382 clear_bit(AFS_CELL_FL_NOT_FOUND, &cell->flags);
384 /* Exclusion on changing vl_addrs is achieved by a
385 * non-reentrant work item.
387 old = rcu_dereference_protected(cell->vl_addrs, true);
388 rcu_assign_pointer(cell->vl_addrs, alist);
389 cell->dns_expiry = expiry;
392 afs_put_addrlist(old);
395 if (test_and_clear_bit(AFS_CELL_FL_NO_LOOKUP_YET, &cell->flags))
396 wake_up_bit(&cell->flags, AFS_CELL_FL_NO_LOOKUP_YET);
398 now = ktime_get_real_seconds();
399 afs_set_cell_timer(cell->net, cell->dns_expiry - now);
404 * Destroy a cell record
406 static void afs_cell_destroy(struct rcu_head *rcu)
408 struct afs_cell *cell = container_of(rcu, struct afs_cell, rcu);
410 _enter("%p{%s}", cell, cell->name);
412 ASSERTCMP(atomic_read(&cell->usage), ==, 0);
414 afs_put_addrlist(cell->vl_addrs);
415 key_put(cell->anonymous_key);
418 _leave(" [destroyed]");
422 * Queue the cell manager.
424 static void afs_queue_cell_manager(struct afs_net *net)
426 int outstanding = atomic_inc_return(&net->cells_outstanding);
428 _enter("%d", outstanding);
430 if (!queue_work(afs_wq, &net->cells_manager))
431 afs_dec_cells_outstanding(net);
435 * Cell management timer. We have an increment on cells_outstanding that we
436 * need to pass along to the work item.
438 void afs_cells_timer(struct timer_list *timer)
440 struct afs_net *net = container_of(timer, struct afs_net, cells_timer);
443 if (!queue_work(afs_wq, &net->cells_manager))
444 afs_dec_cells_outstanding(net);
448 * Get a reference on a cell record.
450 struct afs_cell *afs_get_cell(struct afs_cell *cell)
452 atomic_inc(&cell->usage);
457 * Drop a reference on a cell record.
459 void afs_put_cell(struct afs_net *net, struct afs_cell *cell)
461 time64_t now, expire_delay;
466 _enter("%s", cell->name);
468 now = ktime_get_real_seconds();
469 cell->last_inactive = now;
471 if (!test_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags) &&
472 !test_bit(AFS_CELL_FL_NOT_FOUND, &cell->flags))
473 expire_delay = afs_cell_gc_delay;
475 if (atomic_dec_return(&cell->usage) > 1)
478 /* 'cell' may now be garbage collected. */
479 afs_set_cell_timer(net, expire_delay);
483 * Allocate a key to use as a placeholder for anonymous user security.
485 static int afs_alloc_anon_key(struct afs_cell *cell)
488 char keyname[4 + AFS_MAXCELLNAME + 1], *cp, *dp;
490 /* Create a key to represent an anonymous user. */
491 memcpy(keyname, "afs@", 4);
495 *dp++ = tolower(*cp);
498 key = rxrpc_get_null_key(keyname);
502 cell->anonymous_key = key;
504 _debug("anon key %p{%x}",
505 cell->anonymous_key, key_serial(cell->anonymous_key));
512 static int afs_activate_cell(struct afs_net *net, struct afs_cell *cell)
516 if (!cell->anonymous_key) {
517 ret = afs_alloc_anon_key(cell);
522 #ifdef CONFIG_AFS_FSCACHE
523 cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,
524 &afs_cell_cache_index_def,
527 ret = afs_proc_cell_setup(net, cell);
530 spin_lock(&net->proc_cells_lock);
531 list_add_tail(&cell->proc_link, &net->proc_cells);
532 spin_unlock(&net->proc_cells_lock);
539 static void afs_deactivate_cell(struct afs_net *net, struct afs_cell *cell)
541 _enter("%s", cell->name);
543 afs_proc_cell_remove(net, cell);
545 spin_lock(&net->proc_cells_lock);
546 list_del_init(&cell->proc_link);
547 spin_unlock(&net->proc_cells_lock);
549 #ifdef CONFIG_AFS_FSCACHE
550 fscache_relinquish_cookie(cell->cache, 0);
558 * Manage a cell record, initialising and destroying it, maintaining its DNS
561 static void afs_manage_cell(struct work_struct *work)
563 struct afs_cell *cell = container_of(work, struct afs_cell, manager);
564 struct afs_net *net = cell->net;
568 _enter("%s", cell->name);
571 _debug("state %u", cell->state);
572 switch (cell->state) {
573 case AFS_CELL_INACTIVE:
574 case AFS_CELL_FAILED:
575 write_seqlock(&net->cells_lock);
577 deleted = atomic_try_cmpxchg_relaxed(&cell->usage, &usage, 0);
579 rb_erase(&cell->net_node, &net->cells);
580 write_sequnlock(&net->cells_lock);
582 goto final_destruction;
583 if (cell->state == AFS_CELL_FAILED)
585 cell->state = AFS_CELL_UNSET;
589 cell->state = AFS_CELL_ACTIVATING;
592 case AFS_CELL_ACTIVATING:
593 ret = afs_activate_cell(net, cell);
595 goto activation_failed;
597 cell->state = AFS_CELL_ACTIVE;
599 clear_bit(AFS_CELL_FL_NOT_READY, &cell->flags);
600 wake_up_bit(&cell->flags, AFS_CELL_FL_NOT_READY);
603 case AFS_CELL_ACTIVE:
604 if (atomic_read(&cell->usage) > 1) {
605 time64_t now = ktime_get_real_seconds();
606 if (cell->dns_expiry <= now && net->live)
607 afs_update_cell(cell);
610 cell->state = AFS_CELL_DEACTIVATING;
613 case AFS_CELL_DEACTIVATING:
614 set_bit(AFS_CELL_FL_NOT_READY, &cell->flags);
615 if (atomic_read(&cell->usage) > 1)
616 goto reverse_deactivation;
617 afs_deactivate_cell(net, cell);
618 cell->state = AFS_CELL_INACTIVE;
624 _debug("bad state %u", cell->state);
625 BUG(); /* Unhandled state */
629 afs_deactivate_cell(net, cell);
631 cell->state = AFS_CELL_FAILED;
633 if (test_and_clear_bit(AFS_CELL_FL_NOT_READY, &cell->flags))
634 wake_up_bit(&cell->flags, AFS_CELL_FL_NOT_READY);
637 reverse_deactivation:
638 cell->state = AFS_CELL_ACTIVE;
640 clear_bit(AFS_CELL_FL_NOT_READY, &cell->flags);
641 wake_up_bit(&cell->flags, AFS_CELL_FL_NOT_READY);
642 _leave(" [deact->act]");
646 _leave(" [done %u]", cell->state);
650 call_rcu(&cell->rcu, afs_cell_destroy);
651 afs_dec_cells_outstanding(net);
652 _leave(" [destruct %d]", atomic_read(&net->cells_outstanding));
656 * Manage the records of cells known to a network namespace. This includes
657 * updating the DNS records and garbage collecting unused cells that were
658 * automatically added.
660 * Note that constructed cell records may only be removed from net->cells by
661 * this work item, so it is safe for this work item to stash a cursor pointing
662 * into the tree and then return to caller (provided it skips cells that are
663 * still under construction).
665 * Note also that we were given an increment on net->cells_outstanding by
666 * whoever queued us that we need to deal with before returning.
668 void afs_manage_cells(struct work_struct *work)
670 struct afs_net *net = container_of(work, struct afs_net, cells_manager);
671 struct rb_node *cursor;
672 time64_t now = ktime_get_real_seconds(), next_manage = TIME64_MAX;
673 bool purging = !net->live;
677 /* Trawl the cell database looking for cells that have expired from
678 * lack of use and cells whose DNS results have expired and dispatch
681 read_seqlock_excl(&net->cells_lock);
683 for (cursor = rb_first(&net->cells); cursor; cursor = rb_next(cursor)) {
684 struct afs_cell *cell =
685 rb_entry(cursor, struct afs_cell, net_node);
687 bool sched_cell = false;
689 usage = atomic_read(&cell->usage);
690 _debug("manage %s %u", cell->name, usage);
692 ASSERTCMP(usage, >=, 1);
695 if (test_and_clear_bit(AFS_CELL_FL_NO_GC, &cell->flags))
696 usage = atomic_dec_return(&cell->usage);
697 ASSERTCMP(usage, ==, 1);
701 time64_t expire_at = cell->last_inactive;
703 if (!test_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags) &&
704 !test_bit(AFS_CELL_FL_NOT_FOUND, &cell->flags))
705 expire_at += afs_cell_gc_delay;
706 if (purging || expire_at <= now)
708 else if (expire_at < next_manage)
709 next_manage = expire_at;
713 if (cell->dns_expiry <= now)
715 else if (cell->dns_expiry <= next_manage)
716 next_manage = cell->dns_expiry;
720 queue_work(afs_wq, &cell->manager);
723 read_sequnlock_excl(&net->cells_lock);
725 /* Update the timer on the way out. We have to pass an increment on
726 * cells_outstanding in the namespace that we are in to the timer or
727 * the work scheduler.
729 if (!purging && next_manage < TIME64_MAX) {
730 now = ktime_get_real_seconds();
732 if (next_manage - now <= 0) {
733 if (queue_work(afs_wq, &net->cells_manager))
734 atomic_inc(&net->cells_outstanding);
736 afs_set_cell_timer(net, next_manage - now);
740 afs_dec_cells_outstanding(net);
741 _leave(" [%d]", atomic_read(&net->cells_outstanding));
745 * Purge in-memory cell database.
747 void afs_cell_purge(struct afs_net *net)
753 write_seqlock(&net->cells_lock);
756 write_sequnlock(&net->cells_lock);
757 afs_put_cell(net, ws);
760 if (del_timer_sync(&net->cells_timer))
761 atomic_dec(&net->cells_outstanding);
764 afs_queue_cell_manager(net);
767 wait_var_event(&net->cells_outstanding,
768 !atomic_read(&net->cells_outstanding));