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