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