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

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

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 volume location management
  2  *
  3  * Copyright (C) 2002, 2007 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/kernel.h>
 13 #include <linux/module.h>
 14 #include <linux/slab.h>
 15 #include <linux/init.h>
 16 #include <linux/sched.h>
 17 #include "internal.h"
 18 
 19 static unsigned afs_vlocation_timeout = 10;     /* volume location timeout in seconds */
 20 static unsigned afs_vlocation_update_timeout = 10 * 60;
 21 
 22 static void afs_vlocation_reaper(struct work_struct *);
 23 static void afs_vlocation_updater(struct work_struct *);
 24 
 25 static LIST_HEAD(afs_vlocation_updates);
 26 static LIST_HEAD(afs_vlocation_graveyard);
 27 static DEFINE_SPINLOCK(afs_vlocation_updates_lock);
 28 static DEFINE_SPINLOCK(afs_vlocation_graveyard_lock);
 29 static DECLARE_DELAYED_WORK(afs_vlocation_reap, afs_vlocation_reaper);
 30 static DECLARE_DELAYED_WORK(afs_vlocation_update, afs_vlocation_updater);
 31 static struct workqueue_struct *afs_vlocation_update_worker;
 32 
 33 /*
 34  * iterate through the VL servers in a cell until one of them admits knowing
 35  * about the volume in question
 36  */
 37 static int afs_vlocation_access_vl_by_name(struct afs_vlocation *vl,
 38                                            struct key *key,
 39                                            struct afs_cache_vlocation *vldb)
 40 {
 41         struct afs_cell *cell = vl->cell;
 42         struct in_addr addr;
 43         int count, ret;
 44 
 45         _enter("%s,%s", cell->name, vl->vldb.name);
 46 
 47         down_write(&vl->cell->vl_sem);
 48         ret = -ENOMEDIUM;
 49         for (count = cell->vl_naddrs; count > 0; count--) {
 50                 addr = cell->vl_addrs[cell->vl_curr_svix];
 51 
 52                 _debug("CellServ[%hu]: %08x", cell->vl_curr_svix, addr.s_addr);
 53 
 54                 /* attempt to access the VL server */
 55                 ret = afs_vl_get_entry_by_name(&addr, key, vl->vldb.name, vldb,
 56                                                &afs_sync_call);
 57                 switch (ret) {
 58                 case 0:
 59                         goto out;
 60                 case -ENOMEM:
 61                 case -ENONET:
 62                 case -ENETUNREACH:
 63                 case -EHOSTUNREACH:
 64                 case -ECONNREFUSED:
 65                         if (ret == -ENOMEM || ret == -ENONET)
 66                                 goto out;
 67                         goto rotate;
 68                 case -ENOMEDIUM:
 69                 case -EKEYREJECTED:
 70                 case -EKEYEXPIRED:
 71                         goto out;
 72                 default:
 73                         ret = -EIO;
 74                         goto rotate;
 75                 }
 76 
 77                 /* rotate the server records upon lookup failure */
 78         rotate:
 79                 cell->vl_curr_svix++;
 80                 cell->vl_curr_svix %= cell->vl_naddrs;
 81         }
 82 
 83 out:
 84         up_write(&vl->cell->vl_sem);
 85         _leave(" = %d", ret);
 86         return ret;
 87 }
 88 
 89 /*
 90  * iterate through the VL servers in a cell until one of them admits knowing
 91  * about the volume in question
 92  */
 93 static int afs_vlocation_access_vl_by_id(struct afs_vlocation *vl,
 94                                          struct key *key,
 95                                          afs_volid_t volid,
 96                                          afs_voltype_t voltype,
 97                                          struct afs_cache_vlocation *vldb)
 98 {
 99         struct afs_cell *cell = vl->cell;
100         struct in_addr addr;
101         int count, ret;
102 
103         _enter("%s,%x,%d,", cell->name, volid, voltype);
104 
105         down_write(&vl->cell->vl_sem);
106         ret = -ENOMEDIUM;
107         for (count = cell->vl_naddrs; count > 0; count--) {
108                 addr = cell->vl_addrs[cell->vl_curr_svix];
109 
110                 _debug("CellServ[%hu]: %08x", cell->vl_curr_svix, addr.s_addr);
111 
112                 /* attempt to access the VL server */
113                 ret = afs_vl_get_entry_by_id(&addr, key, volid, voltype, vldb,
114                                              &afs_sync_call);
115                 switch (ret) {
116                 case 0:
117                         goto out;
118                 case -ENOMEM:
119                 case -ENONET:
120                 case -ENETUNREACH:
121                 case -EHOSTUNREACH:
122                 case -ECONNREFUSED:
123                         if (ret == -ENOMEM || ret == -ENONET)
124                                 goto out;
125                         goto rotate;
126                 case -EBUSY:
127                         vl->upd_busy_cnt++;
128                         if (vl->upd_busy_cnt <= 3) {
129                                 if (vl->upd_busy_cnt > 1) {
130                                         /* second+ BUSY - sleep a little bit */
131                                         set_current_state(TASK_UNINTERRUPTIBLE);
132                                         schedule_timeout(1);
133                                 }
134                                 continue;
135                         }
136                         break;
137                 case -ENOMEDIUM:
138                         vl->upd_rej_cnt++;
139                         goto rotate;
140                 default:
141                         ret = -EIO;
142                         goto rotate;
143                 }
144 
145                 /* rotate the server records upon lookup failure */
146         rotate:
147                 cell->vl_curr_svix++;
148                 cell->vl_curr_svix %= cell->vl_naddrs;
149                 vl->upd_busy_cnt = 0;
150         }
151 
152 out:
153         if (ret < 0 && vl->upd_rej_cnt > 0) {
154                 printk(KERN_NOTICE "kAFS:"
155                        " Active volume no longer valid '%s'\n",
156                        vl->vldb.name);
157                 vl->valid = 0;
158                 ret = -ENOMEDIUM;
159         }
160 
161         up_write(&vl->cell->vl_sem);
162         _leave(" = %d", ret);
163         return ret;
164 }
165 
166 /*
167  * allocate a volume location record
168  */
169 static struct afs_vlocation *afs_vlocation_alloc(struct afs_cell *cell,
170                                                  const char *name,
171                                                  size_t namesz)
172 {
173         struct afs_vlocation *vl;
174 
175         vl = kzalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
176         if (vl) {
177                 vl->cell = cell;
178                 vl->state = AFS_VL_NEW;
179                 atomic_set(&vl->usage, 1);
180                 INIT_LIST_HEAD(&vl->link);
181                 INIT_LIST_HEAD(&vl->grave);
182                 INIT_LIST_HEAD(&vl->update);
183                 init_waitqueue_head(&vl->waitq);
184                 spin_lock_init(&vl->lock);
185                 memcpy(vl->vldb.name, name, namesz);
186         }
187 
188         _leave(" = %p", vl);
189         return vl;
190 }
191 
192 /*
193  * update record if we found it in the cache
194  */
195 static int afs_vlocation_update_record(struct afs_vlocation *vl,
196                                        struct key *key,
197                                        struct afs_cache_vlocation *vldb)
198 {
199         afs_voltype_t voltype;
200         afs_volid_t vid;
201         int ret;
202 
203         /* try to look up a cached volume in the cell VL databases by ID */
204         _debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
205                vl->vldb.name,
206                vl->vldb.vidmask,
207                ntohl(vl->vldb.servers[0].s_addr),
208                vl->vldb.srvtmask[0],
209                ntohl(vl->vldb.servers[1].s_addr),
210                vl->vldb.srvtmask[1],
211                ntohl(vl->vldb.servers[2].s_addr),
212                vl->vldb.srvtmask[2]);
213 
214         _debug("Vids: %08x %08x %08x",
215                vl->vldb.vid[0],
216                vl->vldb.vid[1],
217                vl->vldb.vid[2]);
218 
219         if (vl->vldb.vidmask & AFS_VOL_VTM_RW) {
220                 vid = vl->vldb.vid[0];
221                 voltype = AFSVL_RWVOL;
222         } else if (vl->vldb.vidmask & AFS_VOL_VTM_RO) {
223                 vid = vl->vldb.vid[1];
224                 voltype = AFSVL_ROVOL;
225         } else if (vl->vldb.vidmask & AFS_VOL_VTM_BAK) {
226                 vid = vl->vldb.vid[2];
227                 voltype = AFSVL_BACKVOL;
228         } else {
229                 BUG();
230                 vid = 0;
231                 voltype = 0;
232         }
233 
234         /* contact the server to make sure the volume is still available
235          * - TODO: need to handle disconnected operation here
236          */
237         ret = afs_vlocation_access_vl_by_id(vl, key, vid, voltype, vldb);
238         switch (ret) {
239                 /* net error */
240         default:
241                 printk(KERN_WARNING "kAFS:"
242                        " failed to update volume '%s' (%x) up in '%s': %d\n",
243                        vl->vldb.name, vid, vl->cell->name, ret);
244                 _leave(" = %d", ret);
245                 return ret;
246 
247                 /* pulled from local cache into memory */
248         case 0:
249                 _leave(" = 0");
250                 return 0;
251 
252                 /* uh oh... looks like the volume got deleted */
253         case -ENOMEDIUM:
254                 printk(KERN_ERR "kAFS:"
255                        " volume '%s' (%x) does not exist '%s'\n",
256                        vl->vldb.name, vid, vl->cell->name);
257 
258                 /* TODO: make existing record unavailable */
259                 _leave(" = %d", ret);
260                 return ret;
261         }
262 }
263 
264 /*
265  * apply the update to a VL record
266  */
267 static void afs_vlocation_apply_update(struct afs_vlocation *vl,
268                                        struct afs_cache_vlocation *vldb)
269 {
270         _debug("Done VL Lookup: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
271                vldb->name, vldb->vidmask,
272                ntohl(vldb->servers[0].s_addr), vldb->srvtmask[0],
273                ntohl(vldb->servers[1].s_addr), vldb->srvtmask[1],
274                ntohl(vldb->servers[2].s_addr), vldb->srvtmask[2]);
275 
276         _debug("Vids: %08x %08x %08x",
277                vldb->vid[0], vldb->vid[1], vldb->vid[2]);
278 
279         if (strcmp(vldb->name, vl->vldb.name) != 0)
280                 printk(KERN_NOTICE "kAFS:"
281                        " name of volume '%s' changed to '%s' on server\n",
282                        vl->vldb.name, vldb->name);
283 
284         vl->vldb = *vldb;
285 
286 #ifdef CONFIG_AFS_FSCACHE
287         fscache_update_cookie(vl->cache);
288 #endif
289 }
290 
291 /*
292  * fill in a volume location record, consulting the cache and the VL server
293  * both
294  */
295 static int afs_vlocation_fill_in_record(struct afs_vlocation *vl,
296                                         struct key *key)
297 {
298         struct afs_cache_vlocation vldb;
299         int ret;
300 
301         _enter("");
302 
303         ASSERTCMP(vl->valid, ==, 0);
304 
305         memset(&vldb, 0, sizeof(vldb));
306 
307         /* see if we have an in-cache copy (will set vl->valid if there is) */
308 #ifdef CONFIG_AFS_FSCACHE
309         vl->cache = fscache_acquire_cookie(vl->cell->cache,
310                                            &afs_vlocation_cache_index_def, vl,
311                                            true);
312 #endif
313 
314         if (vl->valid) {
315                 /* try to update a known volume in the cell VL databases by
316                  * ID as the name may have changed */
317                 _debug("found in cache");
318                 ret = afs_vlocation_update_record(vl, key, &vldb);
319         } else {
320                 /* try to look up an unknown volume in the cell VL databases by
321                  * name */
322                 ret = afs_vlocation_access_vl_by_name(vl, key, &vldb);
323                 if (ret < 0) {
324                         printk("kAFS: failed to locate '%s' in cell '%s'\n",
325                                vl->vldb.name, vl->cell->name);
326                         return ret;
327                 }
328         }
329 
330         afs_vlocation_apply_update(vl, &vldb);
331         _leave(" = 0");
332         return 0;
333 }
334 
335 /*
336  * queue a vlocation record for updates
337  */
338 static void afs_vlocation_queue_for_updates(struct afs_vlocation *vl)
339 {
340         struct afs_vlocation *xvl;
341 
342         /* wait at least 10 minutes before updating... */
343         vl->update_at = ktime_get_real_seconds() +
344                         afs_vlocation_update_timeout;
345 
346         spin_lock(&afs_vlocation_updates_lock);
347 
348         if (!list_empty(&afs_vlocation_updates)) {
349                 /* ... but wait at least 1 second more than the newest record
350                  * already queued so that we don't spam the VL server suddenly
351                  * with lots of requests
352                  */
353                 xvl = list_entry(afs_vlocation_updates.prev,
354                                  struct afs_vlocation, update);
355                 if (vl->update_at <= xvl->update_at)
356                         vl->update_at = xvl->update_at + 1;
357         } else {
358                 queue_delayed_work(afs_vlocation_update_worker,
359                                    &afs_vlocation_update,
360                                    afs_vlocation_update_timeout * HZ);
361         }
362 
363         list_add_tail(&vl->update, &afs_vlocation_updates);
364         spin_unlock(&afs_vlocation_updates_lock);
365 }
366 
367 /*
368  * lookup volume location
369  * - iterate through the VL servers in a cell until one of them admits knowing
370  *   about the volume in question
371  * - lookup in the local cache if not able to find on the VL server
372  * - insert/update in the local cache if did get a VL response
373  */
374 struct afs_vlocation *afs_vlocation_lookup(struct afs_cell *cell,
375                                            struct key *key,
376                                            const char *name,
377                                            size_t namesz)
378 {
379         struct afs_vlocation *vl;
380         int ret;
381 
382         _enter("{%s},{%x},%*.*s,%zu",
383                cell->name, key_serial(key),
384                (int) namesz, (int) namesz, name, namesz);
385 
386         if (namesz >= sizeof(vl->vldb.name)) {
387                 _leave(" = -ENAMETOOLONG");
388                 return ERR_PTR(-ENAMETOOLONG);
389         }
390 
391         /* see if we have an in-memory copy first */
392         down_write(&cell->vl_sem);
393         spin_lock(&cell->vl_lock);
394         list_for_each_entry(vl, &cell->vl_list, link) {
395                 if (vl->vldb.name[namesz] != '\0')
396                         continue;
397                 if (memcmp(vl->vldb.name, name, namesz) == 0)
398                         goto found_in_memory;
399         }
400         spin_unlock(&cell->vl_lock);
401 
402         /* not in the cell's in-memory lists - create a new record */
403         vl = afs_vlocation_alloc(cell, name, namesz);
404         if (!vl) {
405                 up_write(&cell->vl_sem);
406                 return ERR_PTR(-ENOMEM);
407         }
408 
409         afs_get_cell(cell);
410 
411         list_add_tail(&vl->link, &cell->vl_list);
412         vl->state = AFS_VL_CREATING;
413         up_write(&cell->vl_sem);
414 
415 fill_in_record:
416         ret = afs_vlocation_fill_in_record(vl, key);
417         if (ret < 0)
418                 goto error_abandon;
419         spin_lock(&vl->lock);
420         vl->state = AFS_VL_VALID;
421         spin_unlock(&vl->lock);
422         wake_up(&vl->waitq);
423 
424         /* update volume entry in local cache */
425 #ifdef CONFIG_AFS_FSCACHE
426         fscache_update_cookie(vl->cache);
427 #endif
428 
429         /* schedule for regular updates */
430         afs_vlocation_queue_for_updates(vl);
431         goto success;
432 
433 found_in_memory:
434         /* found in memory */
435         _debug("found in memory");
436         atomic_inc(&vl->usage);
437         spin_unlock(&cell->vl_lock);
438         if (!list_empty(&vl->grave)) {
439                 spin_lock(&afs_vlocation_graveyard_lock);
440                 list_del_init(&vl->grave);
441                 spin_unlock(&afs_vlocation_graveyard_lock);
442         }
443         up_write(&cell->vl_sem);
444 
445         /* see if it was an abandoned record that we might try filling in */
446         spin_lock(&vl->lock);
447         while (vl->state != AFS_VL_VALID) {
448                 afs_vlocation_state_t state = vl->state;
449 
450                 _debug("invalid [state %d]", state);
451 
452                 if (state == AFS_VL_NEW || state == AFS_VL_NO_VOLUME) {
453                         vl->state = AFS_VL_CREATING;
454                         spin_unlock(&vl->lock);
455                         goto fill_in_record;
456                 }
457 
458                 /* must now wait for creation or update by someone else to
459                  * complete */
460                 _debug("wait");
461 
462                 spin_unlock(&vl->lock);
463                 ret = wait_event_interruptible(vl->waitq,
464                                                vl->state == AFS_VL_NEW ||
465                                                vl->state == AFS_VL_VALID ||
466                                                vl->state == AFS_VL_NO_VOLUME);
467                 if (ret < 0)
468                         goto error;
469                 spin_lock(&vl->lock);
470         }
471         spin_unlock(&vl->lock);
472 
473 success:
474         _leave(" = %p", vl);
475         return vl;
476 
477 error_abandon:
478         spin_lock(&vl->lock);
479         vl->state = AFS_VL_NEW;
480         spin_unlock(&vl->lock);
481         wake_up(&vl->waitq);
482 error:
483         ASSERT(vl != NULL);
484         afs_put_vlocation(vl);
485         _leave(" = %d", ret);
486         return ERR_PTR(ret);
487 }
488 
489 /*
490  * finish using a volume location record
491  */
492 void afs_put_vlocation(struct afs_vlocation *vl)
493 {
494         if (!vl)
495                 return;
496 
497         _enter("%s", vl->vldb.name);
498 
499         ASSERTCMP(atomic_read(&vl->usage), >, 0);
500 
501         if (likely(!atomic_dec_and_test(&vl->usage))) {
502                 _leave("");
503                 return;
504         }
505 
506         spin_lock(&afs_vlocation_graveyard_lock);
507         if (atomic_read(&vl->usage) == 0) {
508                 _debug("buried");
509                 list_move_tail(&vl->grave, &afs_vlocation_graveyard);
510                 vl->time_of_death = ktime_get_real_seconds();
511                 queue_delayed_work(afs_wq, &afs_vlocation_reap,
512                                    afs_vlocation_timeout * HZ);
513 
514                 /* suspend updates on this record */
515                 if (!list_empty(&vl->update)) {
516                         spin_lock(&afs_vlocation_updates_lock);
517                         list_del_init(&vl->update);
518                         spin_unlock(&afs_vlocation_updates_lock);
519                 }
520         }
521         spin_unlock(&afs_vlocation_graveyard_lock);
522         _leave(" [killed?]");
523 }
524 
525 /*
526  * destroy a dead volume location record
527  */
528 static void afs_vlocation_destroy(struct afs_vlocation *vl)
529 {
530         _enter("%p", vl);
531 
532 #ifdef CONFIG_AFS_FSCACHE
533         fscache_relinquish_cookie(vl->cache, 0);
534 #endif
535         afs_put_cell(vl->cell);
536         kfree(vl);
537 }
538 
539 /*
540  * reap dead volume location records
541  */
542 static void afs_vlocation_reaper(struct work_struct *work)
543 {
544         LIST_HEAD(corpses);
545         struct afs_vlocation *vl;
546         unsigned long delay, expiry;
547         time64_t now;
548 
549         _enter("");
550 
551         now = ktime_get_real_seconds();
552         spin_lock(&afs_vlocation_graveyard_lock);
553 
554         while (!list_empty(&afs_vlocation_graveyard)) {
555                 vl = list_entry(afs_vlocation_graveyard.next,
556                                 struct afs_vlocation, grave);
557 
558                 _debug("check %p", vl);
559 
560                 /* the queue is ordered most dead first */
561                 expiry = vl->time_of_death + afs_vlocation_timeout;
562                 if (expiry > now) {
563                         delay = (expiry - now) * HZ;
564                         _debug("delay %lu", delay);
565                         mod_delayed_work(afs_wq, &afs_vlocation_reap, delay);
566                         break;
567                 }
568 
569                 spin_lock(&vl->cell->vl_lock);
570                 if (atomic_read(&vl->usage) > 0) {
571                         _debug("no reap");
572                         list_del_init(&vl->grave);
573                 } else {
574                         _debug("reap");
575                         list_move_tail(&vl->grave, &corpses);
576                         list_del_init(&vl->link);
577                 }
578                 spin_unlock(&vl->cell->vl_lock);
579         }
580 
581         spin_unlock(&afs_vlocation_graveyard_lock);
582 
583         /* now reap the corpses we've extracted */
584         while (!list_empty(&corpses)) {
585                 vl = list_entry(corpses.next, struct afs_vlocation, grave);
586                 list_del(&vl->grave);
587                 afs_vlocation_destroy(vl);
588         }
589 
590         _leave("");
591 }
592 
593 /*
594  * initialise the VL update process
595  */
596 int __init afs_vlocation_update_init(void)
597 {
598         afs_vlocation_update_worker =
599                 create_singlethread_workqueue("kafs_vlupdated");
600         return afs_vlocation_update_worker ? 0 : -ENOMEM;
601 }
602 
603 /*
604  * discard all the volume location records for rmmod
605  */
606 void afs_vlocation_purge(void)
607 {
608         afs_vlocation_timeout = 0;
609 
610         spin_lock(&afs_vlocation_updates_lock);
611         list_del_init(&afs_vlocation_updates);
612         spin_unlock(&afs_vlocation_updates_lock);
613         mod_delayed_work(afs_vlocation_update_worker, &afs_vlocation_update, 0);
614         destroy_workqueue(afs_vlocation_update_worker);
615 
616         mod_delayed_work(afs_wq, &afs_vlocation_reap, 0);
617 }
618 
619 /*
620  * update a volume location
621  */
622 static void afs_vlocation_updater(struct work_struct *work)
623 {
624         struct afs_cache_vlocation vldb;
625         struct afs_vlocation *vl, *xvl;
626         time64_t now;
627         long timeout;
628         int ret;
629 
630         _enter("");
631 
632         now = ktime_get_real_seconds();
633 
634         /* find a record to update */
635         spin_lock(&afs_vlocation_updates_lock);
636         for (;;) {
637                 if (list_empty(&afs_vlocation_updates)) {
638                         spin_unlock(&afs_vlocation_updates_lock);
639                         _leave(" [nothing]");
640                         return;
641                 }
642 
643                 vl = list_entry(afs_vlocation_updates.next,
644                                 struct afs_vlocation, update);
645                 if (atomic_read(&vl->usage) > 0)
646                         break;
647                 list_del_init(&vl->update);
648         }
649 
650         timeout = vl->update_at - now;
651         if (timeout > 0) {
652                 queue_delayed_work(afs_vlocation_update_worker,
653                                    &afs_vlocation_update, timeout * HZ);
654                 spin_unlock(&afs_vlocation_updates_lock);
655                 _leave(" [nothing]");
656                 return;
657         }
658 
659         list_del_init(&vl->update);
660         atomic_inc(&vl->usage);
661         spin_unlock(&afs_vlocation_updates_lock);
662 
663         /* we can now perform the update */
664         _debug("update %s", vl->vldb.name);
665         vl->state = AFS_VL_UPDATING;
666         vl->upd_rej_cnt = 0;
667         vl->upd_busy_cnt = 0;
668 
669         ret = afs_vlocation_update_record(vl, NULL, &vldb);
670         spin_lock(&vl->lock);
671         switch (ret) {
672         case 0:
673                 afs_vlocation_apply_update(vl, &vldb);
674                 vl->state = AFS_VL_VALID;
675                 break;
676         case -ENOMEDIUM:
677                 vl->state = AFS_VL_VOLUME_DELETED;
678                 break;
679         default:
680                 vl->state = AFS_VL_UNCERTAIN;
681                 break;
682         }
683         spin_unlock(&vl->lock);
684         wake_up(&vl->waitq);
685 
686         /* and then reschedule */
687         _debug("reschedule");
688         vl->update_at = ktime_get_real_seconds() +
689                         afs_vlocation_update_timeout;
690 
691         spin_lock(&afs_vlocation_updates_lock);
692 
693         if (!list_empty(&afs_vlocation_updates)) {
694                 /* next update in 10 minutes, but wait at least 1 second more
695                  * than the newest record already queued so that we don't spam
696                  * the VL server suddenly with lots of requests
697                  */
698                 xvl = list_entry(afs_vlocation_updates.prev,
699                                  struct afs_vlocation, update);
700                 if (vl->update_at <= xvl->update_at)
701                         vl->update_at = xvl->update_at + 1;
702                 xvl = list_entry(afs_vlocation_updates.next,
703                                  struct afs_vlocation, update);
704                 timeout = xvl->update_at - now;
705                 if (timeout < 0)
706                         timeout = 0;
707         } else {
708                 timeout = afs_vlocation_update_timeout;
709         }
710 
711         ASSERT(list_empty(&vl->update));
712 
713         list_add_tail(&vl->update, &afs_vlocation_updates);
714 
715         _debug("timeout %ld", timeout);
716         queue_delayed_work(afs_vlocation_update_worker,
717                            &afs_vlocation_update, timeout * HZ);
718         spin_unlock(&afs_vlocation_updates_lock);
719         afs_put_vlocation(vl);
720 }
721 

~ [ 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