~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/afs/cell.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* AFS cell and server record management
  2  *
  3  * Copyright (C) 2002, 2017 Red Hat, Inc. All Rights Reserved.
  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 
 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>
 19 #include "internal.h"
 20 
 21 static unsigned __read_mostly afs_cell_gc_delay = 10;
 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))
 28                 wake_up_var(&net->cells_outstanding);
 29 }
 30 
 31 /*
 32  * Set the cell timer to fire after a given delay, assuming it's not already
 33  * set for an earlier time.
 34  */
 35 static void afs_set_cell_timer(struct afs_net *net, time64_t delay)
 36 {
 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);
 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         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);
129         if (namelen > AFS_MAXCELLNAME) {
130                 _leave(" = -ENAMETOOLONG");
131                 return ERR_PTR(-ENAMETOOLONG);
132         }
133         if (namelen == 5 && memcmp(name, "@cell", 5) == 0)
134                 return ERR_PTR(-EINVAL);
135 
136         _enter("%*.*s,%s", namelen, namelen, name, vllist);
137 
138         cell = kzalloc(sizeof(struct afs_cell), GFP_KERNEL);
139         if (!cell) {
140                 _leave(" = -ENOMEM");
141                 return ERR_PTR(-ENOMEM);
142         }
143 
144         cell->net = net;
145         cell->name_len = namelen;
146         for (i = 0; i < namelen; i++)
147                 cell->name[i] = tolower(name[i]);
148 
149         atomic_set(&cell->usage, 2);
150         INIT_WORK(&cell->manager, afs_manage_cell);
151         cell->flags = ((1 << AFS_CELL_FL_NOT_READY) |
152                        (1 << AFS_CELL_FL_NO_LOOKUP_YET));
153         INIT_LIST_HEAD(&cell->proc_volumes);
154         rwlock_init(&cell->proc_lock);
155         rwlock_init(&cell->vl_addrs_lock);
156 
157         /* Fill in the VL server list if we were given a list of addresses to
158          * use.
159          */
160         if (vllist) {
161                 struct afs_addr_list *alist;
162 
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                 }
169 
170                 rcu_assign_pointer(cell->vl_addrs, alist);
171                 cell->dns_expiry = TIME64_MAX;
172         }
173 
174         _leave(" = %p", cell);
175         return cell;
176 
177 parse_failed:
178         if (ret == -EINVAL)
179                 printk(KERN_ERR "kAFS: bad VL server IP address\n");
180         kfree(cell);
181         _leave(" = %d", ret);
182         return ERR_PTR(ret);
183 }
184 
185 /*
186  * afs_lookup_cell - Look up or create a cell record.
187  * @net:        The network namespace
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.
197  */
198 struct afs_cell *afs_lookup_cell(struct afs_net *net,
199                                  const char *name, unsigned int namesz,
200                                  const char *vllist, bool excl)
201 {
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();
212                 if (!IS_ERR(cell))
213                         goto wait_for_cell;
214         }
215 
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;
227         }
228 
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;
250         }
251 
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);
258 
259         queue_work(afs_wq, &cell->manager);
260 
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();
265 
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         }
276 
277         _leave(" = %p [cell]", cell);
278         return cell;
279 
280 cell_already_exists:
281         _debug("cell exists");
282         cell = cursor;
283         if (excl) {
284                 ret = -EEXIST;
285         } else {
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;
293         goto error_noput;
294 error:
295         afs_put_cell(net, cell);
296 error_noput:
297         _leave(" = %d [error]", ret);
298         return ERR_PTR(ret);
299 }
300 
301 /*
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
305  */
306 int afs_cell_init(struct afs_net *net, const char *rootcell)
307 {
308         struct afs_cell *old_root, *new_root;
309         const char *cp, *vllist;
310         size_t len;
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                  */
318                 _leave(" = 0 [no root]");
319                 return 0;
320         }
321 
322         cp = strchr(rootcell, ':');
323         if (!cp) {
324                 _debug("kAFS: no VL server IP addresses specified");
325                 vllist = NULL;
326                 len = strlen(rootcell);
327         } else {
328                 vllist = cp + 1;
329                 len = cp - rootcell;
330         }
331 
332         /* allocate a cell record for the root cell */
333         new_root = afs_lookup_cell(net, rootcell, len, vllist, false);
334         if (IS_ERR(new_root)) {
335                 _leave(" = %ld", PTR_ERR(new_root));
336                 return PTR_ERR(new_root);
337         }
338 
339         if (!test_and_set_bit(AFS_CELL_FL_NO_GC, &new_root->flags))
340                 afs_get_cell(new_root);
341 
342         /* install the new cell */
343         write_seqlock(&net->cells_lock);
344         old_root = net->ws_cell;
345         net->ws_cell = new_root;
346         write_sequnlock(&net->cells_lock);
347 
348         afs_put_cell(net, old_root);
349         _leave(" = 0");
350         return 0;
351 }
352 
353 /*
354  * Update a cell's VL server address list from the DNS.
355  */
356 static void afs_update_cell(struct afs_cell *cell)
357 {
358         struct afs_addr_list *alist, *old;
359         time64_t now, expiry;
360 
361         _enter("%s", cell->name);
362 
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;
372 
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                 }
380 
381                 cell->error = -EDESTADDRREQ;
382         } else {
383                 clear_bit(AFS_CELL_FL_DNS_FAIL, &cell->flags);
384                 clear_bit(AFS_CELL_FL_NOT_FOUND, &cell->flags);
385 
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;
392 
393                 if (old)
394                         afs_put_addrlist(old);
395         }
396 
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);
399 
400         now = ktime_get_real_seconds();
401         afs_set_cell_timer(cell->net, cell->dns_expiry - now);
402         _leave("");
403 }
404 
405 /*
406  * Destroy a cell record
407  */
408 static void afs_cell_destroy(struct rcu_head *rcu)
409 {
410         struct afs_cell *cell = container_of(rcu, struct afs_cell, rcu);
411 
412         _enter("%p{%s}", cell, cell->name);
413 
414         ASSERTCMP(atomic_read(&cell->usage), ==, 0);
415 
416         afs_put_addrlist(rcu_access_pointer(cell->vl_addrs));
417         key_put(cell->anonymous_key);
418         kfree(cell);
419 
420         _leave(" [destroyed]");
421 }
422 
423 /*
424  * Queue the cell manager.
425  */
426 static void afs_queue_cell_manager(struct afs_net *net)
427 {
428         int outstanding = atomic_inc_return(&net->cells_outstanding);
429 
430         _enter("%d", outstanding);
431 
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 }
448 
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 
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;
464 
465         if (!cell)
466                 return;
467 
468         _enter("%s", cell->name);
469 
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;
476 
477         if (atomic_dec_return(&cell->usage) > 1)
478                 return;
479 
480         /* 'cell' may now be garbage collected. */
481         afs_set_cell_timer(net, expire_delay);
482 }
483 
484 /*
485  * Allocate a key to use as a placeholder for anonymous user security.
486  */
487 static int afs_alloc_anon_key(struct afs_cell *cell)
488 {
489         struct key *key;
490         char keyname[4 + AFS_MAXCELLNAME + 1], *cp, *dp;
491 
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++);
499 
500         key = rxrpc_get_null_key(keyname);
501         if (IS_ERR(key))
502                 return PTR_ERR(key);
503 
504         cell->anonymous_key = key;
505 
506         _debug("anon key %p{%x}",
507                cell->anonymous_key, key_serial(cell->anonymous_key));
508         return 0;
509 }
510 
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;
522         }
523 
524 #ifdef CONFIG_AFS_FSCACHE
525         cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,
526                                              &afs_cell_cache_index_def,
527                                              cell->name, strlen(cell->name),
528                                              NULL, 0,
529                                              cell, 0, true);
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);
546 
547         afs_proc_cell_remove(net, cell);
548 
549         spin_lock(&net->proc_cells_lock);
550         list_del_init(&cell->proc_link);
551         spin_unlock(&net->proc_cells_lock);
552 
553 #ifdef CONFIG_AFS_FSCACHE
554         fscache_relinquish_cookie(cell->cache, NULL, false);
555         cell->cache = NULL;
556 #endif
557 
558         _leave("");
559 }
560 
561 /*
562  * Manage a cell record, initialising and destroying it, maintaining its DNS
563  * records.
564  */
565 static void afs_manage_cell(struct work_struct *work)
566 {
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;
678 
679         _enter("");
680 
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);
686 
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;
692 
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                 }
703 
704                 if (usage == 1) {
705                         time64_t expire_at = cell->last_inactive;
706 
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;
714                 }
715 
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);
728 
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();
735 
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);
741                 }
742         }
743 
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);
758         ws = net->ws_cell;
759         net->ws_cell = NULL;
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");
771         wait_var_event(&net->cells_outstanding,
772                        !atomic_read(&net->cells_outstanding));
773         _leave("");
774 }
775 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp