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 <linux/namei.h>
19 #include <keys/rxrpc-type.h>
22 static unsigned __read_mostly afs_cell_gc_delay
= 10;
23 static unsigned __read_mostly afs_cell_min_ttl
= 10 * 60;
24 static unsigned __read_mostly afs_cell_max_ttl
= 24 * 60 * 60;
26 static void afs_manage_cell(struct work_struct
*);
28 static void afs_dec_cells_outstanding(struct afs_net
*net
)
30 if (atomic_dec_and_test(&net
->cells_outstanding
))
31 wake_up_var(&net
->cells_outstanding
);
35 * Set the cell timer to fire after a given delay, assuming it's not already
36 * set for an earlier time.
38 static void afs_set_cell_timer(struct afs_net
*net
, time64_t delay
)
41 atomic_inc(&net
->cells_outstanding
);
42 if (timer_reduce(&net
->cells_timer
, jiffies
+ delay
* HZ
))
43 afs_dec_cells_outstanding(net
);
48 * Look up and get an activation reference on a cell record under RCU
49 * conditions. The caller must hold the RCU read lock.
51 struct afs_cell
*afs_lookup_cell_rcu(struct afs_net
*net
,
52 const char *name
, unsigned int namesz
)
54 struct afs_cell
*cell
= NULL
;
56 int n
, seq
= 0, ret
= 0;
58 _enter("%*.*s", namesz
, namesz
, name
);
60 if (name
&& namesz
== 0)
61 return ERR_PTR(-EINVAL
);
62 if (namesz
> AFS_MAXCELLNAME
)
63 return ERR_PTR(-ENAMETOOLONG
);
66 /* Unfortunately, rbtree walking doesn't give reliable results
67 * under just the RCU read lock, so we have to check for
71 afs_put_cell(net
, cell
);
75 read_seqbegin_or_lock(&net
->cells_lock
, &seq
);
78 cell
= rcu_dereference_raw(net
->ws_cell
);
87 p
= rcu_dereference_raw(net
->cells
.rb_node
);
89 cell
= rb_entry(p
, struct afs_cell
, net_node
);
91 n
= strncasecmp(cell
->name
, name
,
92 min_t(size_t, cell
->name_len
, namesz
));
94 n
= cell
->name_len
- namesz
;
96 p
= rcu_dereference_raw(p
->rb_left
);
98 p
= rcu_dereference_raw(p
->rb_right
);
100 if (atomic_inc_not_zero(&cell
->usage
)) {
104 /* We want to repeat the search, this time with
105 * the lock properly locked.
111 } while (need_seqretry(&net
->cells_lock
, seq
));
113 done_seqretry(&net
->cells_lock
, seq
);
115 return ret
== 0 ? cell
: ERR_PTR(ret
);
119 * Set up a cell record and fill in its name, VL server address list and
120 * allocate an anonymous key
122 static struct afs_cell
*afs_alloc_cell(struct afs_net
*net
,
123 const char *name
, unsigned int namelen
,
124 const char *addresses
)
126 struct afs_cell
*cell
;
131 return ERR_PTR(-EINVAL
);
132 if (namelen
> AFS_MAXCELLNAME
) {
133 _leave(" = -ENAMETOOLONG");
134 return ERR_PTR(-ENAMETOOLONG
);
136 if (namelen
== 5 && memcmp(name
, "@cell", 5) == 0)
137 return ERR_PTR(-EINVAL
);
139 _enter("%*.*s,%s", namelen
, namelen
, name
, addresses
);
141 cell
= kzalloc(sizeof(struct afs_cell
), GFP_KERNEL
);
143 _leave(" = -ENOMEM");
144 return ERR_PTR(-ENOMEM
);
148 cell
->name_len
= namelen
;
149 for (i
= 0; i
< namelen
; i
++)
150 cell
->name
[i
] = tolower(name
[i
]);
152 atomic_set(&cell
->usage
, 2);
153 INIT_WORK(&cell
->manager
, afs_manage_cell
);
154 cell
->flags
= ((1 << AFS_CELL_FL_NOT_READY
) |
155 (1 << AFS_CELL_FL_NO_LOOKUP_YET
));
156 INIT_LIST_HEAD(&cell
->proc_volumes
);
157 rwlock_init(&cell
->proc_lock
);
158 rwlock_init(&cell
->vl_servers_lock
);
160 /* Fill in the VL server list if we were given a list of addresses to
164 struct afs_vlserver_list
*vllist
;
166 vllist
= afs_parse_text_addrs(net
,
167 addresses
, strlen(addresses
), ':',
168 VL_SERVICE
, AFS_VL_PORT
);
169 if (IS_ERR(vllist
)) {
170 ret
= PTR_ERR(vllist
);
174 rcu_assign_pointer(cell
->vl_servers
, vllist
);
175 cell
->dns_expiry
= TIME64_MAX
;
176 __clear_bit(AFS_CELL_FL_NO_LOOKUP_YET
, &cell
->flags
);
178 cell
->dns_expiry
= ktime_get_real_seconds();
181 _leave(" = %p", cell
);
186 printk(KERN_ERR
"kAFS: bad VL server IP address\n");
188 _leave(" = %d", ret
);
193 * afs_lookup_cell - Look up or create a cell record.
194 * @net: The network namespace
195 * @name: The name of the cell.
196 * @namesz: The strlen of the cell name.
197 * @vllist: A colon/comma separated list of numeric IP addresses or NULL.
198 * @excl: T if an error should be given if the cell name already exists.
200 * Look up a cell record by name and query the DNS for VL server addresses if
201 * needed. Note that that actual DNS query is punted off to the manager thread
202 * so that this function can return immediately if interrupted whilst allowing
203 * cell records to be shared even if not yet fully constructed.
205 struct afs_cell
*afs_lookup_cell(struct afs_net
*net
,
206 const char *name
, unsigned int namesz
,
207 const char *vllist
, bool excl
)
209 struct afs_cell
*cell
, *candidate
, *cursor
;
210 struct rb_node
*parent
, **pp
;
213 _enter("%s,%s", name
, vllist
);
217 cell
= afs_lookup_cell_rcu(net
, name
, namesz
);
223 /* Assume we're probably going to create a cell and preallocate and
224 * mostly set up a candidate record. We can then use this to stash the
225 * name, the net namespace and VL server addresses.
227 * We also want to do this before we hold any locks as it may involve
228 * upcalling to userspace to make DNS queries.
230 candidate
= afs_alloc_cell(net
, name
, namesz
, vllist
);
231 if (IS_ERR(candidate
)) {
232 _leave(" = %ld", PTR_ERR(candidate
));
236 /* Find the insertion point and check to see if someone else added a
237 * cell whilst we were allocating.
239 write_seqlock(&net
->cells_lock
);
241 pp
= &net
->cells
.rb_node
;
245 cursor
= rb_entry(parent
, struct afs_cell
, net_node
);
247 n
= strncasecmp(cursor
->name
, name
,
248 min_t(size_t, cursor
->name_len
, namesz
));
250 n
= cursor
->name_len
- namesz
;
252 pp
= &(*pp
)->rb_left
;
254 pp
= &(*pp
)->rb_right
;
256 goto cell_already_exists
;
261 rb_link_node_rcu(&cell
->net_node
, parent
, pp
);
262 rb_insert_color(&cell
->net_node
, &net
->cells
);
263 atomic_inc(&net
->cells_outstanding
);
264 write_sequnlock(&net
->cells_lock
);
266 queue_work(afs_wq
, &cell
->manager
);
269 _debug("wait_for_cell");
270 ret
= wait_on_bit(&cell
->flags
, AFS_CELL_FL_NOT_READY
, TASK_INTERRUPTIBLE
);
273 switch (READ_ONCE(cell
->state
)) {
274 case AFS_CELL_FAILED
:
278 _debug("weird %u %d", cell
->state
, cell
->error
);
280 case AFS_CELL_ACTIVE
:
284 _leave(" = %p [cell]", cell
);
288 _debug("cell exists");
293 afs_get_cell(cursor
);
296 write_sequnlock(&net
->cells_lock
);
302 afs_put_cell(net
, cell
);
304 _leave(" = %d [error]", ret
);
309 * set the root cell information
310 * - can be called with a module parameter string
311 * - can be called from a write to /proc/fs/afs/rootcell
313 int afs_cell_init(struct afs_net
*net
, const char *rootcell
)
315 struct afs_cell
*old_root
, *new_root
;
316 const char *cp
, *vllist
;
322 /* module is loaded with no parameters, or built statically.
323 * - in the future we might initialize cell DB here.
325 _leave(" = 0 [no root]");
329 cp
= strchr(rootcell
, ':');
331 _debug("kAFS: no VL server IP addresses specified");
333 len
= strlen(rootcell
);
339 /* allocate a cell record for the root cell */
340 new_root
= afs_lookup_cell(net
, rootcell
, len
, vllist
, false);
341 if (IS_ERR(new_root
)) {
342 _leave(" = %ld", PTR_ERR(new_root
));
343 return PTR_ERR(new_root
);
346 if (!test_and_set_bit(AFS_CELL_FL_NO_GC
, &new_root
->flags
))
347 afs_get_cell(new_root
);
349 /* install the new cell */
350 write_seqlock(&net
->cells_lock
);
351 old_root
= rcu_access_pointer(net
->ws_cell
);
352 rcu_assign_pointer(net
->ws_cell
, new_root
);
353 write_sequnlock(&net
->cells_lock
);
355 afs_put_cell(net
, old_root
);
361 * Update a cell's VL server address list from the DNS.
363 static void afs_update_cell(struct afs_cell
*cell
)
365 struct afs_vlserver_list
*vllist
, *old
;
366 unsigned int min_ttl
= READ_ONCE(afs_cell_min_ttl
);
367 unsigned int max_ttl
= READ_ONCE(afs_cell_max_ttl
);
368 time64_t now
, expiry
= 0;
370 _enter("%s", cell
->name
);
372 vllist
= afs_dns_query(cell
, &expiry
);
374 now
= ktime_get_real_seconds();
375 if (min_ttl
> max_ttl
)
377 if (expiry
< now
+ min_ttl
)
378 expiry
= now
+ min_ttl
;
379 else if (expiry
> now
+ max_ttl
)
380 expiry
= now
+ max_ttl
;
382 if (IS_ERR(vllist
)) {
383 switch (PTR_ERR(vllist
)) {
386 /* The DNS said that the cell does not exist or there
387 * weren't any addresses to be had.
389 set_bit(AFS_CELL_FL_NOT_FOUND
, &cell
->flags
);
390 clear_bit(AFS_CELL_FL_DNS_FAIL
, &cell
->flags
);
391 cell
->dns_expiry
= expiry
;
397 set_bit(AFS_CELL_FL_DNS_FAIL
, &cell
->flags
);
398 cell
->dns_expiry
= now
+ 10;
402 cell
->error
= -EDESTADDRREQ
;
404 clear_bit(AFS_CELL_FL_DNS_FAIL
, &cell
->flags
);
405 clear_bit(AFS_CELL_FL_NOT_FOUND
, &cell
->flags
);
407 /* Exclusion on changing vl_addrs is achieved by a
408 * non-reentrant work item.
410 old
= rcu_dereference_protected(cell
->vl_servers
, true);
411 rcu_assign_pointer(cell
->vl_servers
, vllist
);
412 cell
->dns_expiry
= expiry
;
415 afs_put_vlserverlist(cell
->net
, old
);
418 if (test_and_clear_bit(AFS_CELL_FL_NO_LOOKUP_YET
, &cell
->flags
))
419 wake_up_bit(&cell
->flags
, AFS_CELL_FL_NO_LOOKUP_YET
);
421 now
= ktime_get_real_seconds();
422 afs_set_cell_timer(cell
->net
, cell
->dns_expiry
- now
);
427 * Destroy a cell record
429 static void afs_cell_destroy(struct rcu_head
*rcu
)
431 struct afs_cell
*cell
= container_of(rcu
, struct afs_cell
, rcu
);
433 _enter("%p{%s}", cell
, cell
->name
);
435 ASSERTCMP(atomic_read(&cell
->usage
), ==, 0);
437 afs_put_vlserverlist(cell
->net
, rcu_access_pointer(cell
->vl_servers
));
438 key_put(cell
->anonymous_key
);
441 _leave(" [destroyed]");
445 * Queue the cell manager.
447 static void afs_queue_cell_manager(struct afs_net
*net
)
449 int outstanding
= atomic_inc_return(&net
->cells_outstanding
);
451 _enter("%d", outstanding
);
453 if (!queue_work(afs_wq
, &net
->cells_manager
))
454 afs_dec_cells_outstanding(net
);
458 * Cell management timer. We have an increment on cells_outstanding that we
459 * need to pass along to the work item.
461 void afs_cells_timer(struct timer_list
*timer
)
463 struct afs_net
*net
= container_of(timer
, struct afs_net
, cells_timer
);
466 if (!queue_work(afs_wq
, &net
->cells_manager
))
467 afs_dec_cells_outstanding(net
);
471 * Get a reference on a cell record.
473 struct afs_cell
*afs_get_cell(struct afs_cell
*cell
)
475 atomic_inc(&cell
->usage
);
480 * Drop a reference on a cell record.
482 void afs_put_cell(struct afs_net
*net
, struct afs_cell
*cell
)
484 time64_t now
, expire_delay
;
489 _enter("%s", cell
->name
);
491 now
= ktime_get_real_seconds();
492 cell
->last_inactive
= now
;
494 if (!test_bit(AFS_CELL_FL_DNS_FAIL
, &cell
->flags
) &&
495 !test_bit(AFS_CELL_FL_NOT_FOUND
, &cell
->flags
))
496 expire_delay
= afs_cell_gc_delay
;
498 if (atomic_dec_return(&cell
->usage
) > 1)
501 /* 'cell' may now be garbage collected. */
502 afs_set_cell_timer(net
, expire_delay
);
506 * Allocate a key to use as a placeholder for anonymous user security.
508 static int afs_alloc_anon_key(struct afs_cell
*cell
)
511 char keyname
[4 + AFS_MAXCELLNAME
+ 1], *cp
, *dp
;
513 /* Create a key to represent an anonymous user. */
514 memcpy(keyname
, "afs@", 4);
518 *dp
++ = tolower(*cp
);
521 key
= rxrpc_get_null_key(keyname
);
525 cell
->anonymous_key
= key
;
527 _debug("anon key %p{%x}",
528 cell
->anonymous_key
, key_serial(cell
->anonymous_key
));
535 static int afs_activate_cell(struct afs_net
*net
, struct afs_cell
*cell
)
537 struct hlist_node
**p
;
538 struct afs_cell
*pcell
;
541 if (!cell
->anonymous_key
) {
542 ret
= afs_alloc_anon_key(cell
);
547 #ifdef CONFIG_AFS_FSCACHE
548 cell
->cache
= fscache_acquire_cookie(afs_cache_netfs
.primary_index
,
549 &afs_cell_cache_index_def
,
550 cell
->name
, strlen(cell
->name
),
554 ret
= afs_proc_cell_setup(cell
);
558 mutex_lock(&net
->proc_cells_lock
);
559 for (p
= &net
->proc_cells
.first
; *p
; p
= &(*p
)->next
) {
560 pcell
= hlist_entry(*p
, struct afs_cell
, proc_link
);
561 if (strcmp(cell
->name
, pcell
->name
) < 0)
565 cell
->proc_link
.pprev
= p
;
566 cell
->proc_link
.next
= *p
;
567 rcu_assign_pointer(*p
, &cell
->proc_link
.next
);
568 if (cell
->proc_link
.next
)
569 cell
->proc_link
.next
->pprev
= &cell
->proc_link
.next
;
571 afs_dynroot_mkdir(net
, cell
);
572 mutex_unlock(&net
->proc_cells_lock
);
579 static void afs_deactivate_cell(struct afs_net
*net
, struct afs_cell
*cell
)
581 _enter("%s", cell
->name
);
583 afs_proc_cell_remove(cell
);
585 mutex_lock(&net
->proc_cells_lock
);
586 hlist_del_rcu(&cell
->proc_link
);
587 afs_dynroot_rmdir(net
, cell
);
588 mutex_unlock(&net
->proc_cells_lock
);
590 #ifdef CONFIG_AFS_FSCACHE
591 fscache_relinquish_cookie(cell
->cache
, NULL
, false);
599 * Manage a cell record, initialising and destroying it, maintaining its DNS
602 static void afs_manage_cell(struct work_struct
*work
)
604 struct afs_cell
*cell
= container_of(work
, struct afs_cell
, manager
);
605 struct afs_net
*net
= cell
->net
;
609 _enter("%s", cell
->name
);
612 _debug("state %u", cell
->state
);
613 switch (cell
->state
) {
614 case AFS_CELL_INACTIVE
:
615 case AFS_CELL_FAILED
:
616 write_seqlock(&net
->cells_lock
);
618 deleted
= atomic_try_cmpxchg_relaxed(&cell
->usage
, &usage
, 0);
620 rb_erase(&cell
->net_node
, &net
->cells
);
621 write_sequnlock(&net
->cells_lock
);
623 goto final_destruction
;
624 if (cell
->state
== AFS_CELL_FAILED
)
626 cell
->state
= AFS_CELL_UNSET
;
630 cell
->state
= AFS_CELL_ACTIVATING
;
633 case AFS_CELL_ACTIVATING
:
634 ret
= afs_activate_cell(net
, cell
);
636 goto activation_failed
;
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
);
644 case AFS_CELL_ACTIVE
:
645 if (atomic_read(&cell
->usage
) > 1) {
646 time64_t now
= ktime_get_real_seconds();
647 if (cell
->dns_expiry
<= now
&& net
->live
)
648 afs_update_cell(cell
);
651 cell
->state
= AFS_CELL_DEACTIVATING
;
654 case AFS_CELL_DEACTIVATING
:
655 set_bit(AFS_CELL_FL_NOT_READY
, &cell
->flags
);
656 if (atomic_read(&cell
->usage
) > 1)
657 goto reverse_deactivation
;
658 afs_deactivate_cell(net
, cell
);
659 cell
->state
= AFS_CELL_INACTIVE
;
665 _debug("bad state %u", cell
->state
);
666 BUG(); /* Unhandled state */
670 afs_deactivate_cell(net
, cell
);
672 cell
->state
= AFS_CELL_FAILED
;
674 if (test_and_clear_bit(AFS_CELL_FL_NOT_READY
, &cell
->flags
))
675 wake_up_bit(&cell
->flags
, AFS_CELL_FL_NOT_READY
);
678 reverse_deactivation
:
679 cell
->state
= AFS_CELL_ACTIVE
;
681 clear_bit(AFS_CELL_FL_NOT_READY
, &cell
->flags
);
682 wake_up_bit(&cell
->flags
, AFS_CELL_FL_NOT_READY
);
683 _leave(" [deact->act]");
687 _leave(" [done %u]", cell
->state
);
691 call_rcu(&cell
->rcu
, afs_cell_destroy
);
692 afs_dec_cells_outstanding(net
);
693 _leave(" [destruct %d]", atomic_read(&net
->cells_outstanding
));
697 * Manage the records of cells known to a network namespace. This includes
698 * updating the DNS records and garbage collecting unused cells that were
699 * automatically added.
701 * Note that constructed cell records may only be removed from net->cells by
702 * this work item, so it is safe for this work item to stash a cursor pointing
703 * into the tree and then return to caller (provided it skips cells that are
704 * still under construction).
706 * Note also that we were given an increment on net->cells_outstanding by
707 * whoever queued us that we need to deal with before returning.
709 void afs_manage_cells(struct work_struct
*work
)
711 struct afs_net
*net
= container_of(work
, struct afs_net
, cells_manager
);
712 struct rb_node
*cursor
;
713 time64_t now
= ktime_get_real_seconds(), next_manage
= TIME64_MAX
;
714 bool purging
= !net
->live
;
718 /* Trawl the cell database looking for cells that have expired from
719 * lack of use and cells whose DNS results have expired and dispatch
722 read_seqlock_excl(&net
->cells_lock
);
724 for (cursor
= rb_first(&net
->cells
); cursor
; cursor
= rb_next(cursor
)) {
725 struct afs_cell
*cell
=
726 rb_entry(cursor
, struct afs_cell
, net_node
);
728 bool sched_cell
= false;
730 usage
= atomic_read(&cell
->usage
);
731 _debug("manage %s %u", cell
->name
, usage
);
733 ASSERTCMP(usage
, >=, 1);
736 if (test_and_clear_bit(AFS_CELL_FL_NO_GC
, &cell
->flags
))
737 usage
= atomic_dec_return(&cell
->usage
);
738 ASSERTCMP(usage
, ==, 1);
742 time64_t expire_at
= cell
->last_inactive
;
744 if (!test_bit(AFS_CELL_FL_DNS_FAIL
, &cell
->flags
) &&
745 !test_bit(AFS_CELL_FL_NOT_FOUND
, &cell
->flags
))
746 expire_at
+= afs_cell_gc_delay
;
747 if (purging
|| expire_at
<= now
)
749 else if (expire_at
< next_manage
)
750 next_manage
= expire_at
;
754 if (cell
->dns_expiry
<= now
)
756 else if (cell
->dns_expiry
<= next_manage
)
757 next_manage
= cell
->dns_expiry
;
761 queue_work(afs_wq
, &cell
->manager
);
764 read_sequnlock_excl(&net
->cells_lock
);
766 /* Update the timer on the way out. We have to pass an increment on
767 * cells_outstanding in the namespace that we are in to the timer or
768 * the work scheduler.
770 if (!purging
&& next_manage
< TIME64_MAX
) {
771 now
= ktime_get_real_seconds();
773 if (next_manage
- now
<= 0) {
774 if (queue_work(afs_wq
, &net
->cells_manager
))
775 atomic_inc(&net
->cells_outstanding
);
777 afs_set_cell_timer(net
, next_manage
- now
);
781 afs_dec_cells_outstanding(net
);
782 _leave(" [%d]", atomic_read(&net
->cells_outstanding
));
786 * Purge in-memory cell database.
788 void afs_cell_purge(struct afs_net
*net
)
794 write_seqlock(&net
->cells_lock
);
795 ws
= rcu_access_pointer(net
->ws_cell
);
796 RCU_INIT_POINTER(net
->ws_cell
, NULL
);
797 write_sequnlock(&net
->cells_lock
);
798 afs_put_cell(net
, ws
);
801 if (del_timer_sync(&net
->cells_timer
))
802 atomic_dec(&net
->cells_outstanding
);
805 afs_queue_cell_manager(net
);
808 wait_var_event(&net
->cells_outstanding
,
809 !atomic_read(&net
->cells_outstanding
));