ia64/linux-2.6.18-xen.hg

view fs/afs/vlocation.c @ 524:7f8b544237bf

netfront: Allow netfront in domain 0.

This is useful if your physical network device is in a utility domain.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Apr 15 15:18:58 2008 +0100 (2008-04-15)
parents 831230e53067
children
line source
1 /* vlocation.c: volume location management
2 *
3 * Copyright (C) 2002 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 */
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/slab.h>
16 #include <linux/fs.h>
17 #include <linux/pagemap.h>
18 #include "volume.h"
19 #include "cell.h"
20 #include "cmservice.h"
21 #include "fsclient.h"
22 #include "vlclient.h"
23 #include "kafstimod.h"
24 #include <rxrpc/connection.h>
25 #include "internal.h"
27 #define AFS_VLDB_TIMEOUT HZ*1000
29 static void afs_vlocation_update_timer(struct afs_timer *timer);
30 static void afs_vlocation_update_attend(struct afs_async_op *op);
31 static void afs_vlocation_update_discard(struct afs_async_op *op);
32 static void __afs_put_vlocation(struct afs_vlocation *vlocation);
34 static void __afs_vlocation_timeout(struct afs_timer *timer)
35 {
36 struct afs_vlocation *vlocation =
37 list_entry(timer, struct afs_vlocation, timeout);
39 _debug("VL TIMEOUT [%s{u=%d}]",
40 vlocation->vldb.name, atomic_read(&vlocation->usage));
42 afs_vlocation_do_timeout(vlocation);
43 }
45 static const struct afs_timer_ops afs_vlocation_timer_ops = {
46 .timed_out = __afs_vlocation_timeout,
47 };
49 static const struct afs_timer_ops afs_vlocation_update_timer_ops = {
50 .timed_out = afs_vlocation_update_timer,
51 };
53 static const struct afs_async_op_ops afs_vlocation_update_op_ops = {
54 .attend = afs_vlocation_update_attend,
55 .discard = afs_vlocation_update_discard,
56 };
58 static LIST_HEAD(afs_vlocation_update_pendq); /* queue of VLs awaiting update */
59 static struct afs_vlocation *afs_vlocation_update; /* VL currently being updated */
60 static DEFINE_SPINLOCK(afs_vlocation_update_lock); /* lock guarding update queue */
62 #ifdef AFS_CACHING_SUPPORT
63 static cachefs_match_val_t afs_vlocation_cache_match(void *target,
64 const void *entry);
65 static void afs_vlocation_cache_update(void *source, void *entry);
67 struct cachefs_index_def afs_vlocation_cache_index_def = {
68 .name = "vldb",
69 .data_size = sizeof(struct afs_cache_vlocation),
70 .keys[0] = { CACHEFS_INDEX_KEYS_ASCIIZ, 64 },
71 .match = afs_vlocation_cache_match,
72 .update = afs_vlocation_cache_update,
73 };
74 #endif
76 /*****************************************************************************/
77 /*
78 * iterate through the VL servers in a cell until one of them admits knowing
79 * about the volume in question
80 * - caller must have cell->vl_sem write-locked
81 */
82 static int afs_vlocation_access_vl_by_name(struct afs_vlocation *vlocation,
83 const char *name,
84 unsigned namesz,
85 struct afs_cache_vlocation *vldb)
86 {
87 struct afs_server *server = NULL;
88 struct afs_cell *cell = vlocation->cell;
89 int count, ret;
91 _enter("%s,%*.*s,%u", cell->name, namesz, namesz, name, namesz);
93 ret = -ENOMEDIUM;
94 for (count = cell->vl_naddrs; count > 0; count--) {
95 _debug("CellServ[%hu]: %08x",
96 cell->vl_curr_svix,
97 cell->vl_addrs[cell->vl_curr_svix].s_addr);
99 /* try and create a server */
100 ret = afs_server_lookup(cell,
101 &cell->vl_addrs[cell->vl_curr_svix],
102 &server);
103 switch (ret) {
104 case 0:
105 break;
106 case -ENOMEM:
107 case -ENONET:
108 goto out;
109 default:
110 goto rotate;
111 }
113 /* attempt to access the VL server */
114 ret = afs_rxvl_get_entry_by_name(server, name, namesz, vldb);
115 switch (ret) {
116 case 0:
117 afs_put_server(server);
118 goto out;
119 case -ENOMEM:
120 case -ENONET:
121 case -ENETUNREACH:
122 case -EHOSTUNREACH:
123 case -ECONNREFUSED:
124 down_write(&server->sem);
125 if (server->vlserver) {
126 rxrpc_put_connection(server->vlserver);
127 server->vlserver = NULL;
128 }
129 up_write(&server->sem);
130 afs_put_server(server);
131 if (ret == -ENOMEM || ret == -ENONET)
132 goto out;
133 goto rotate;
134 case -ENOMEDIUM:
135 afs_put_server(server);
136 goto out;
137 default:
138 afs_put_server(server);
139 ret = -ENOMEDIUM;
140 goto rotate;
141 }
143 /* rotate the server records upon lookup failure */
144 rotate:
145 cell->vl_curr_svix++;
146 cell->vl_curr_svix %= cell->vl_naddrs;
147 }
149 out:
150 _leave(" = %d", ret);
151 return ret;
153 } /* end afs_vlocation_access_vl_by_name() */
155 /*****************************************************************************/
156 /*
157 * iterate through the VL servers in a cell until one of them admits knowing
158 * about the volume in question
159 * - caller must have cell->vl_sem write-locked
160 */
161 static int afs_vlocation_access_vl_by_id(struct afs_vlocation *vlocation,
162 afs_volid_t volid,
163 afs_voltype_t voltype,
164 struct afs_cache_vlocation *vldb)
165 {
166 struct afs_server *server = NULL;
167 struct afs_cell *cell = vlocation->cell;
168 int count, ret;
170 _enter("%s,%x,%d,", cell->name, volid, voltype);
172 ret = -ENOMEDIUM;
173 for (count = cell->vl_naddrs; count > 0; count--) {
174 _debug("CellServ[%hu]: %08x",
175 cell->vl_curr_svix,
176 cell->vl_addrs[cell->vl_curr_svix].s_addr);
178 /* try and create a server */
179 ret = afs_server_lookup(cell,
180 &cell->vl_addrs[cell->vl_curr_svix],
181 &server);
182 switch (ret) {
183 case 0:
184 break;
185 case -ENOMEM:
186 case -ENONET:
187 goto out;
188 default:
189 goto rotate;
190 }
192 /* attempt to access the VL server */
193 ret = afs_rxvl_get_entry_by_id(server, volid, voltype, vldb);
194 switch (ret) {
195 case 0:
196 afs_put_server(server);
197 goto out;
198 case -ENOMEM:
199 case -ENONET:
200 case -ENETUNREACH:
201 case -EHOSTUNREACH:
202 case -ECONNREFUSED:
203 down_write(&server->sem);
204 if (server->vlserver) {
205 rxrpc_put_connection(server->vlserver);
206 server->vlserver = NULL;
207 }
208 up_write(&server->sem);
209 afs_put_server(server);
210 if (ret == -ENOMEM || ret == -ENONET)
211 goto out;
212 goto rotate;
213 case -ENOMEDIUM:
214 afs_put_server(server);
215 goto out;
216 default:
217 afs_put_server(server);
218 ret = -ENOMEDIUM;
219 goto rotate;
220 }
222 /* rotate the server records upon lookup failure */
223 rotate:
224 cell->vl_curr_svix++;
225 cell->vl_curr_svix %= cell->vl_naddrs;
226 }
228 out:
229 _leave(" = %d", ret);
230 return ret;
232 } /* end afs_vlocation_access_vl_by_id() */
234 /*****************************************************************************/
235 /*
236 * lookup volume location
237 * - caller must have cell->vol_sem write-locked
238 * - iterate through the VL servers in a cell until one of them admits knowing
239 * about the volume in question
240 * - lookup in the local cache if not able to find on the VL server
241 * - insert/update in the local cache if did get a VL response
242 */
243 int afs_vlocation_lookup(struct afs_cell *cell,
244 const char *name,
245 unsigned namesz,
246 struct afs_vlocation **_vlocation)
247 {
248 struct afs_cache_vlocation vldb;
249 struct afs_vlocation *vlocation;
250 afs_voltype_t voltype;
251 afs_volid_t vid;
252 int active = 0, ret;
254 _enter("{%s},%*.*s,%u,", cell->name, namesz, namesz, name, namesz);
256 if (namesz > sizeof(vlocation->vldb.name)) {
257 _leave(" = -ENAMETOOLONG");
258 return -ENAMETOOLONG;
259 }
261 /* search the cell's active list first */
262 list_for_each_entry(vlocation, &cell->vl_list, link) {
263 if (namesz < sizeof(vlocation->vldb.name) &&
264 vlocation->vldb.name[namesz] != '\0')
265 continue;
267 if (memcmp(vlocation->vldb.name, name, namesz) == 0)
268 goto found_in_memory;
269 }
271 /* search the cell's graveyard list second */
272 spin_lock(&cell->vl_gylock);
273 list_for_each_entry(vlocation, &cell->vl_graveyard, link) {
274 if (namesz < sizeof(vlocation->vldb.name) &&
275 vlocation->vldb.name[namesz] != '\0')
276 continue;
278 if (memcmp(vlocation->vldb.name, name, namesz) == 0)
279 goto found_in_graveyard;
280 }
281 spin_unlock(&cell->vl_gylock);
283 /* not in the cell's in-memory lists - create a new record */
284 vlocation = kmalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
285 if (!vlocation)
286 return -ENOMEM;
288 memset(vlocation, 0, sizeof(struct afs_vlocation));
289 atomic_set(&vlocation->usage, 1);
290 INIT_LIST_HEAD(&vlocation->link);
291 rwlock_init(&vlocation->lock);
292 memcpy(vlocation->vldb.name, name, namesz);
294 afs_timer_init(&vlocation->timeout, &afs_vlocation_timer_ops);
295 afs_timer_init(&vlocation->upd_timer, &afs_vlocation_update_timer_ops);
296 afs_async_op_init(&vlocation->upd_op, &afs_vlocation_update_op_ops);
298 afs_get_cell(cell);
299 vlocation->cell = cell;
301 list_add_tail(&vlocation->link, &cell->vl_list);
303 #ifdef AFS_CACHING_SUPPORT
304 /* we want to store it in the cache, plus it might already be
305 * encached */
306 cachefs_acquire_cookie(cell->cache,
307 &afs_volume_cache_index_def,
308 vlocation,
309 &vlocation->cache);
311 if (vlocation->valid)
312 goto found_in_cache;
313 #endif
315 /* try to look up an unknown volume in the cell VL databases by name */
316 ret = afs_vlocation_access_vl_by_name(vlocation, name, namesz, &vldb);
317 if (ret < 0) {
318 printk("kAFS: failed to locate '%*.*s' in cell '%s'\n",
319 namesz, namesz, name, cell->name);
320 goto error;
321 }
323 goto found_on_vlserver;
325 found_in_graveyard:
326 /* found in the graveyard - resurrect */
327 _debug("found in graveyard");
328 atomic_inc(&vlocation->usage);
329 list_move_tail(&vlocation->link, &cell->vl_list);
330 spin_unlock(&cell->vl_gylock);
332 afs_kafstimod_del_timer(&vlocation->timeout);
333 goto active;
335 found_in_memory:
336 /* found in memory - check to see if it's active */
337 _debug("found in memory");
338 atomic_inc(&vlocation->usage);
340 active:
341 active = 1;
343 #ifdef AFS_CACHING_SUPPORT
344 found_in_cache:
345 #endif
346 /* try to look up a cached volume in the cell VL databases by ID */
347 _debug("found in cache");
349 _debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
350 vlocation->vldb.name,
351 vlocation->vldb.vidmask,
352 ntohl(vlocation->vldb.servers[0].s_addr),
353 vlocation->vldb.srvtmask[0],
354 ntohl(vlocation->vldb.servers[1].s_addr),
355 vlocation->vldb.srvtmask[1],
356 ntohl(vlocation->vldb.servers[2].s_addr),
357 vlocation->vldb.srvtmask[2]
358 );
360 _debug("Vids: %08x %08x %08x",
361 vlocation->vldb.vid[0],
362 vlocation->vldb.vid[1],
363 vlocation->vldb.vid[2]);
365 if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
366 vid = vlocation->vldb.vid[0];
367 voltype = AFSVL_RWVOL;
368 }
369 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) {
370 vid = vlocation->vldb.vid[1];
371 voltype = AFSVL_ROVOL;
372 }
373 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) {
374 vid = vlocation->vldb.vid[2];
375 voltype = AFSVL_BACKVOL;
376 }
377 else {
378 BUG();
379 vid = 0;
380 voltype = 0;
381 }
383 ret = afs_vlocation_access_vl_by_id(vlocation, vid, voltype, &vldb);
384 switch (ret) {
385 /* net error */
386 default:
387 printk("kAFS: failed to volume '%*.*s' (%x) up in '%s': %d\n",
388 namesz, namesz, name, vid, cell->name, ret);
389 goto error;
391 /* pulled from local cache into memory */
392 case 0:
393 goto found_on_vlserver;
395 /* uh oh... looks like the volume got deleted */
396 case -ENOMEDIUM:
397 printk("kAFS: volume '%*.*s' (%x) does not exist '%s'\n",
398 namesz, namesz, name, vid, cell->name);
400 /* TODO: make existing record unavailable */
401 goto error;
402 }
404 found_on_vlserver:
405 _debug("Done VL Lookup: %*.*s %02x { %08x(%x) %08x(%x) %08x(%x) }",
406 namesz, namesz, name,
407 vldb.vidmask,
408 ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0],
409 ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1],
410 ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2]
411 );
413 _debug("Vids: %08x %08x %08x", vldb.vid[0], vldb.vid[1], vldb.vid[2]);
415 if ((namesz < sizeof(vlocation->vldb.name) &&
416 vlocation->vldb.name[namesz] != '\0') ||
417 memcmp(vldb.name, name, namesz) != 0)
418 printk("kAFS: name of volume '%*.*s' changed to '%s' on server\n",
419 namesz, namesz, name, vldb.name);
421 memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
423 afs_kafstimod_add_timer(&vlocation->upd_timer, 10 * HZ);
425 #ifdef AFS_CACHING_SUPPORT
426 /* update volume entry in local cache */
427 cachefs_update_cookie(vlocation->cache);
428 #endif
430 *_vlocation = vlocation;
431 _leave(" = 0 (%p)",vlocation);
432 return 0;
434 error:
435 if (vlocation) {
436 if (active) {
437 __afs_put_vlocation(vlocation);
438 }
439 else {
440 list_del(&vlocation->link);
441 #ifdef AFS_CACHING_SUPPORT
442 cachefs_relinquish_cookie(vlocation->cache, 0);
443 #endif
444 afs_put_cell(vlocation->cell);
445 kfree(vlocation);
446 }
447 }
449 _leave(" = %d", ret);
450 return ret;
451 } /* end afs_vlocation_lookup() */
453 /*****************************************************************************/
454 /*
455 * finish using a volume location record
456 * - caller must have cell->vol_sem write-locked
457 */
458 static void __afs_put_vlocation(struct afs_vlocation *vlocation)
459 {
460 struct afs_cell *cell;
462 if (!vlocation)
463 return;
465 _enter("%s", vlocation->vldb.name);
467 cell = vlocation->cell;
469 /* sanity check */
470 BUG_ON(atomic_read(&vlocation->usage) <= 0);
472 spin_lock(&cell->vl_gylock);
473 if (likely(!atomic_dec_and_test(&vlocation->usage))) {
474 spin_unlock(&cell->vl_gylock);
475 _leave("");
476 return;
477 }
479 /* move to graveyard queue */
480 list_move_tail(&vlocation->link,&cell->vl_graveyard);
482 /* remove from pending timeout queue (refcounted if actually being
483 * updated) */
484 list_del_init(&vlocation->upd_op.link);
486 /* time out in 10 secs */
487 afs_kafstimod_del_timer(&vlocation->upd_timer);
488 afs_kafstimod_add_timer(&vlocation->timeout, 10 * HZ);
490 spin_unlock(&cell->vl_gylock);
492 _leave(" [killed]");
493 } /* end __afs_put_vlocation() */
495 /*****************************************************************************/
496 /*
497 * finish using a volume location record
498 */
499 void afs_put_vlocation(struct afs_vlocation *vlocation)
500 {
501 if (vlocation) {
502 struct afs_cell *cell = vlocation->cell;
504 down_write(&cell->vl_sem);
505 __afs_put_vlocation(vlocation);
506 up_write(&cell->vl_sem);
507 }
508 } /* end afs_put_vlocation() */
510 /*****************************************************************************/
511 /*
512 * timeout vlocation record
513 * - removes from the cell's graveyard if the usage count is zero
514 */
515 void afs_vlocation_do_timeout(struct afs_vlocation *vlocation)
516 {
517 struct afs_cell *cell;
519 _enter("%s", vlocation->vldb.name);
521 cell = vlocation->cell;
523 BUG_ON(atomic_read(&vlocation->usage) < 0);
525 /* remove from graveyard if still dead */
526 spin_lock(&cell->vl_gylock);
527 if (atomic_read(&vlocation->usage) == 0)
528 list_del_init(&vlocation->link);
529 else
530 vlocation = NULL;
531 spin_unlock(&cell->vl_gylock);
533 if (!vlocation) {
534 _leave("");
535 return; /* resurrected */
536 }
538 /* we can now destroy it properly */
539 #ifdef AFS_CACHING_SUPPORT
540 cachefs_relinquish_cookie(vlocation->cache, 0);
541 #endif
542 afs_put_cell(cell);
544 kfree(vlocation);
546 _leave(" [destroyed]");
547 } /* end afs_vlocation_do_timeout() */
549 /*****************************************************************************/
550 /*
551 * send an update operation to the currently selected server
552 */
553 static int afs_vlocation_update_begin(struct afs_vlocation *vlocation)
554 {
555 afs_voltype_t voltype;
556 afs_volid_t vid;
557 int ret;
559 _enter("%s{ufs=%u ucs=%u}",
560 vlocation->vldb.name,
561 vlocation->upd_first_svix,
562 vlocation->upd_curr_svix);
564 /* try to look up a cached volume in the cell VL databases by ID */
565 if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
566 vid = vlocation->vldb.vid[0];
567 voltype = AFSVL_RWVOL;
568 }
569 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) {
570 vid = vlocation->vldb.vid[1];
571 voltype = AFSVL_ROVOL;
572 }
573 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) {
574 vid = vlocation->vldb.vid[2];
575 voltype = AFSVL_BACKVOL;
576 }
577 else {
578 BUG();
579 vid = 0;
580 voltype = 0;
581 }
583 /* contact the chosen server */
584 ret = afs_server_lookup(
585 vlocation->cell,
586 &vlocation->cell->vl_addrs[vlocation->upd_curr_svix],
587 &vlocation->upd_op.server);
589 switch (ret) {
590 case 0:
591 break;
592 case -ENOMEM:
593 case -ENONET:
594 default:
595 _leave(" = %d", ret);
596 return ret;
597 }
599 /* initiate the update operation */
600 ret = afs_rxvl_get_entry_by_id_async(&vlocation->upd_op, vid, voltype);
601 if (ret < 0) {
602 _leave(" = %d", ret);
603 return ret;
604 }
606 _leave(" = %d", ret);
607 return ret;
608 } /* end afs_vlocation_update_begin() */
610 /*****************************************************************************/
611 /*
612 * abandon updating a VL record
613 * - does not restart the update timer
614 */
615 static void afs_vlocation_update_abandon(struct afs_vlocation *vlocation,
616 afs_vlocation_upd_t state,
617 int ret)
618 {
619 _enter("%s,%u", vlocation->vldb.name, state);
621 if (ret < 0)
622 printk("kAFS: Abandoning VL update '%s': %d\n",
623 vlocation->vldb.name, ret);
625 /* discard the server record */
626 afs_put_server(vlocation->upd_op.server);
627 vlocation->upd_op.server = NULL;
629 spin_lock(&afs_vlocation_update_lock);
630 afs_vlocation_update = NULL;
631 vlocation->upd_state = state;
633 /* TODO: start updating next VL record on pending list */
635 spin_unlock(&afs_vlocation_update_lock);
637 _leave("");
638 } /* end afs_vlocation_update_abandon() */
640 /*****************************************************************************/
641 /*
642 * handle periodic update timeouts and busy retry timeouts
643 * - called from kafstimod
644 */
645 static void afs_vlocation_update_timer(struct afs_timer *timer)
646 {
647 struct afs_vlocation *vlocation =
648 list_entry(timer, struct afs_vlocation, upd_timer);
649 int ret;
651 _enter("%s", vlocation->vldb.name);
653 /* only update if not in the graveyard (defend against putting too) */
654 spin_lock(&vlocation->cell->vl_gylock);
656 if (!atomic_read(&vlocation->usage))
657 goto out_unlock1;
659 spin_lock(&afs_vlocation_update_lock);
661 /* if we were woken up due to EBUSY sleep then restart immediately if
662 * possible or else jump to front of pending queue */
663 if (vlocation->upd_state == AFS_VLUPD_BUSYSLEEP) {
664 if (afs_vlocation_update) {
665 list_add(&vlocation->upd_op.link,
666 &afs_vlocation_update_pendq);
667 }
668 else {
669 afs_get_vlocation(vlocation);
670 afs_vlocation_update = vlocation;
671 vlocation->upd_state = AFS_VLUPD_INPROGRESS;
672 }
673 goto out_unlock2;
674 }
676 /* put on pending queue if there's already another update in progress */
677 if (afs_vlocation_update) {
678 vlocation->upd_state = AFS_VLUPD_PENDING;
679 list_add_tail(&vlocation->upd_op.link,
680 &afs_vlocation_update_pendq);
681 goto out_unlock2;
682 }
684 /* hold a ref on it while actually updating */
685 afs_get_vlocation(vlocation);
686 afs_vlocation_update = vlocation;
687 vlocation->upd_state = AFS_VLUPD_INPROGRESS;
689 spin_unlock(&afs_vlocation_update_lock);
690 spin_unlock(&vlocation->cell->vl_gylock);
692 /* okay... we can start the update */
693 _debug("BEGIN VL UPDATE [%s]", vlocation->vldb.name);
694 vlocation->upd_first_svix = vlocation->cell->vl_curr_svix;
695 vlocation->upd_curr_svix = vlocation->upd_first_svix;
696 vlocation->upd_rej_cnt = 0;
697 vlocation->upd_busy_cnt = 0;
699 ret = afs_vlocation_update_begin(vlocation);
700 if (ret < 0) {
701 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
702 afs_kafstimod_add_timer(&vlocation->upd_timer,
703 AFS_VLDB_TIMEOUT);
704 afs_put_vlocation(vlocation);
705 }
707 _leave("");
708 return;
710 out_unlock2:
711 spin_unlock(&afs_vlocation_update_lock);
712 out_unlock1:
713 spin_unlock(&vlocation->cell->vl_gylock);
714 _leave("");
715 return;
717 } /* end afs_vlocation_update_timer() */
719 /*****************************************************************************/
720 /*
721 * attend to an update operation upon which an event happened
722 * - called in kafsasyncd context
723 */
724 static void afs_vlocation_update_attend(struct afs_async_op *op)
725 {
726 struct afs_cache_vlocation vldb;
727 struct afs_vlocation *vlocation =
728 list_entry(op, struct afs_vlocation, upd_op);
729 unsigned tmp;
730 int ret;
732 _enter("%s", vlocation->vldb.name);
734 ret = afs_rxvl_get_entry_by_id_async2(op, &vldb);
735 switch (ret) {
736 case -EAGAIN:
737 _leave(" [unfinished]");
738 return;
740 case 0:
741 _debug("END VL UPDATE: %d\n", ret);
742 vlocation->valid = 1;
744 _debug("Done VL Lookup: %02x { %08x(%x) %08x(%x) %08x(%x) }",
745 vldb.vidmask,
746 ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0],
747 ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1],
748 ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2]
749 );
751 _debug("Vids: %08x %08x %08x",
752 vldb.vid[0], vldb.vid[1], vldb.vid[2]);
754 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
756 down_write(&vlocation->cell->vl_sem);
758 /* actually update the cache */
759 if (strncmp(vldb.name, vlocation->vldb.name,
760 sizeof(vlocation->vldb.name)) != 0)
761 printk("kAFS: name of volume '%s'"
762 " changed to '%s' on server\n",
763 vlocation->vldb.name, vldb.name);
765 memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
767 #if 0
768 /* TODO update volume entry in local cache */
769 #endif
771 up_write(&vlocation->cell->vl_sem);
773 if (ret < 0)
774 printk("kAFS: failed to update local cache: %d\n", ret);
776 afs_kafstimod_add_timer(&vlocation->upd_timer,
777 AFS_VLDB_TIMEOUT);
778 afs_put_vlocation(vlocation);
779 _leave(" [found]");
780 return;
782 case -ENOMEDIUM:
783 vlocation->upd_rej_cnt++;
784 goto try_next;
786 /* the server is locked - retry in a very short while */
787 case -EBUSY:
788 vlocation->upd_busy_cnt++;
789 if (vlocation->upd_busy_cnt > 3)
790 goto try_next; /* too many retries */
792 afs_vlocation_update_abandon(vlocation,
793 AFS_VLUPD_BUSYSLEEP, 0);
794 afs_kafstimod_add_timer(&vlocation->upd_timer, HZ / 2);
795 afs_put_vlocation(vlocation);
796 _leave(" [busy]");
797 return;
799 case -ENETUNREACH:
800 case -EHOSTUNREACH:
801 case -ECONNREFUSED:
802 case -EREMOTEIO:
803 /* record bad vlserver info in the cell too
804 * - TODO: use down_write_trylock() if available
805 */
806 if (vlocation->upd_curr_svix == vlocation->cell->vl_curr_svix)
807 vlocation->cell->vl_curr_svix =
808 vlocation->cell->vl_curr_svix %
809 vlocation->cell->vl_naddrs;
811 case -EBADRQC:
812 case -EINVAL:
813 case -EACCES:
814 case -EBADMSG:
815 goto try_next;
817 default:
818 goto abandon;
819 }
821 /* try contacting the next server */
822 try_next:
823 vlocation->upd_busy_cnt = 0;
825 /* discard the server record */
826 afs_put_server(vlocation->upd_op.server);
827 vlocation->upd_op.server = NULL;
829 tmp = vlocation->cell->vl_naddrs;
830 if (tmp == 0)
831 goto abandon;
833 vlocation->upd_curr_svix++;
834 if (vlocation->upd_curr_svix >= tmp)
835 vlocation->upd_curr_svix = 0;
836 if (vlocation->upd_first_svix >= tmp)
837 vlocation->upd_first_svix = tmp - 1;
839 /* move to the next server */
840 if (vlocation->upd_curr_svix != vlocation->upd_first_svix) {
841 afs_vlocation_update_begin(vlocation);
842 _leave(" [next]");
843 return;
844 }
846 /* run out of servers to try - was the volume rejected? */
847 if (vlocation->upd_rej_cnt > 0) {
848 printk("kAFS: Active volume no longer valid '%s'\n",
849 vlocation->vldb.name);
850 vlocation->valid = 0;
851 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
852 afs_kafstimod_add_timer(&vlocation->upd_timer,
853 AFS_VLDB_TIMEOUT);
854 afs_put_vlocation(vlocation);
855 _leave(" [invalidated]");
856 return;
857 }
859 /* abandon the update */
860 abandon:
861 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
862 afs_kafstimod_add_timer(&vlocation->upd_timer, HZ * 10);
863 afs_put_vlocation(vlocation);
864 _leave(" [abandoned]");
866 } /* end afs_vlocation_update_attend() */
868 /*****************************************************************************/
869 /*
870 * deal with an update operation being discarded
871 * - called in kafsasyncd context when it's dying due to rmmod
872 * - the call has already been aborted and put()'d
873 */
874 static void afs_vlocation_update_discard(struct afs_async_op *op)
875 {
876 struct afs_vlocation *vlocation =
877 list_entry(op, struct afs_vlocation, upd_op);
879 _enter("%s", vlocation->vldb.name);
881 afs_put_server(op->server);
882 op->server = NULL;
884 afs_put_vlocation(vlocation);
886 _leave("");
887 } /* end afs_vlocation_update_discard() */
889 /*****************************************************************************/
890 /*
891 * match a VLDB record stored in the cache
892 * - may also load target from entry
893 */
894 #ifdef AFS_CACHING_SUPPORT
895 static cachefs_match_val_t afs_vlocation_cache_match(void *target,
896 const void *entry)
897 {
898 const struct afs_cache_vlocation *vldb = entry;
899 struct afs_vlocation *vlocation = target;
901 _enter("{%s},{%s}", vlocation->vldb.name, vldb->name);
903 if (strncmp(vlocation->vldb.name, vldb->name, sizeof(vldb->name)) == 0
904 ) {
905 if (!vlocation->valid ||
906 vlocation->vldb.rtime == vldb->rtime
907 ) {
908 vlocation->vldb = *vldb;
909 vlocation->valid = 1;
910 _leave(" = SUCCESS [c->m]");
911 return CACHEFS_MATCH_SUCCESS;
912 }
913 /* need to update cache if cached info differs */
914 else if (memcmp(&vlocation->vldb, vldb, sizeof(*vldb)) != 0) {
915 /* delete if VIDs for this name differ */
916 if (memcmp(&vlocation->vldb.vid,
917 &vldb->vid,
918 sizeof(vldb->vid)) != 0) {
919 _leave(" = DELETE");
920 return CACHEFS_MATCH_SUCCESS_DELETE;
921 }
923 _leave(" = UPDATE");
924 return CACHEFS_MATCH_SUCCESS_UPDATE;
925 }
926 else {
927 _leave(" = SUCCESS");
928 return CACHEFS_MATCH_SUCCESS;
929 }
930 }
932 _leave(" = FAILED");
933 return CACHEFS_MATCH_FAILED;
934 } /* end afs_vlocation_cache_match() */
935 #endif
937 /*****************************************************************************/
938 /*
939 * update a VLDB record stored in the cache
940 */
941 #ifdef AFS_CACHING_SUPPORT
942 static void afs_vlocation_cache_update(void *source, void *entry)
943 {
944 struct afs_cache_vlocation *vldb = entry;
945 struct afs_vlocation *vlocation = source;
947 _enter("");
949 *vldb = vlocation->vldb;
951 } /* end afs_vlocation_cache_update() */
952 #endif