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