[PATCH] core-dumping unreadable binaries via PT_INTERP
[linux-2.6/verdex.git] / fs / afs / vlocation.c
blob782ee7c600caf0ec80c43f9c91407d1d93d6d506
1 /* vlocation.c: volume location management
3 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
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.
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)
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);
45 static const struct afs_timer_ops afs_vlocation_timer_ops = {
46 .timed_out = __afs_vlocation_timeout,
49 static const struct afs_timer_ops afs_vlocation_update_timer_ops = {
50 .timed_out = afs_vlocation_update_timer,
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,
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,
74 #endif
76 /*****************************************************************************/
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
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)
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;
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;
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;
143 /* rotate the server records upon lookup failure */
144 rotate:
145 cell->vl_curr_svix++;
146 cell->vl_curr_svix %= cell->vl_naddrs;
149 out:
150 _leave(" = %d", ret);
151 return ret;
153 } /* end afs_vlocation_access_vl_by_name() */
155 /*****************************************************************************/
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
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)
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;
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;
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;
222 /* rotate the server records upon lookup failure */
223 rotate:
224 cell->vl_curr_svix++;
225 cell->vl_curr_svix %= cell->vl_naddrs;
228 out:
229 _leave(" = %d", ret);
230 return ret;
232 } /* end afs_vlocation_access_vl_by_id() */
234 /*****************************************************************************/
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
243 int afs_vlocation_lookup(struct afs_cell *cell,
244 const char *name,
245 unsigned namesz,
246 struct afs_vlocation **_vlocation)
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;
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;
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;
281 spin_unlock(&cell->vl_gylock);
283 /* not in the cell's in-memory lists - create a new record */
284 vlocation = kzalloc(sizeof(struct afs_vlocation), GFP_KERNEL);
285 if (!vlocation)
286 return -ENOMEM;
288 atomic_set(&vlocation->usage, 1);
289 INIT_LIST_HEAD(&vlocation->link);
290 rwlock_init(&vlocation->lock);
291 memcpy(vlocation->vldb.name, name, namesz);
293 afs_timer_init(&vlocation->timeout, &afs_vlocation_timer_ops);
294 afs_timer_init(&vlocation->upd_timer, &afs_vlocation_update_timer_ops);
295 afs_async_op_init(&vlocation->upd_op, &afs_vlocation_update_op_ops);
297 afs_get_cell(cell);
298 vlocation->cell = cell;
300 list_add_tail(&vlocation->link, &cell->vl_list);
302 #ifdef AFS_CACHING_SUPPORT
303 /* we want to store it in the cache, plus it might already be
304 * encached */
305 cachefs_acquire_cookie(cell->cache,
306 &afs_volume_cache_index_def,
307 vlocation,
308 &vlocation->cache);
310 if (vlocation->valid)
311 goto found_in_cache;
312 #endif
314 /* try to look up an unknown volume in the cell VL databases by name */
315 ret = afs_vlocation_access_vl_by_name(vlocation, name, namesz, &vldb);
316 if (ret < 0) {
317 printk("kAFS: failed to locate '%*.*s' in cell '%s'\n",
318 namesz, namesz, name, cell->name);
319 goto error;
322 goto found_on_vlserver;
324 found_in_graveyard:
325 /* found in the graveyard - resurrect */
326 _debug("found in graveyard");
327 atomic_inc(&vlocation->usage);
328 list_move_tail(&vlocation->link, &cell->vl_list);
329 spin_unlock(&cell->vl_gylock);
331 afs_kafstimod_del_timer(&vlocation->timeout);
332 goto active;
334 found_in_memory:
335 /* found in memory - check to see if it's active */
336 _debug("found in memory");
337 atomic_inc(&vlocation->usage);
339 active:
340 active = 1;
342 #ifdef AFS_CACHING_SUPPORT
343 found_in_cache:
344 #endif
345 /* try to look up a cached volume in the cell VL databases by ID */
346 _debug("found in cache");
348 _debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }",
349 vlocation->vldb.name,
350 vlocation->vldb.vidmask,
351 ntohl(vlocation->vldb.servers[0].s_addr),
352 vlocation->vldb.srvtmask[0],
353 ntohl(vlocation->vldb.servers[1].s_addr),
354 vlocation->vldb.srvtmask[1],
355 ntohl(vlocation->vldb.servers[2].s_addr),
356 vlocation->vldb.srvtmask[2]
359 _debug("Vids: %08x %08x %08x",
360 vlocation->vldb.vid[0],
361 vlocation->vldb.vid[1],
362 vlocation->vldb.vid[2]);
364 if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
365 vid = vlocation->vldb.vid[0];
366 voltype = AFSVL_RWVOL;
368 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) {
369 vid = vlocation->vldb.vid[1];
370 voltype = AFSVL_ROVOL;
372 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) {
373 vid = vlocation->vldb.vid[2];
374 voltype = AFSVL_BACKVOL;
376 else {
377 BUG();
378 vid = 0;
379 voltype = 0;
382 ret = afs_vlocation_access_vl_by_id(vlocation, vid, voltype, &vldb);
383 switch (ret) {
384 /* net error */
385 default:
386 printk("kAFS: failed to volume '%*.*s' (%x) up in '%s': %d\n",
387 namesz, namesz, name, vid, cell->name, ret);
388 goto error;
390 /* pulled from local cache into memory */
391 case 0:
392 goto found_on_vlserver;
394 /* uh oh... looks like the volume got deleted */
395 case -ENOMEDIUM:
396 printk("kAFS: volume '%*.*s' (%x) does not exist '%s'\n",
397 namesz, namesz, name, vid, cell->name);
399 /* TODO: make existing record unavailable */
400 goto error;
403 found_on_vlserver:
404 _debug("Done VL Lookup: %*.*s %02x { %08x(%x) %08x(%x) %08x(%x) }",
405 namesz, namesz, name,
406 vldb.vidmask,
407 ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0],
408 ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1],
409 ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2]
412 _debug("Vids: %08x %08x %08x", vldb.vid[0], vldb.vid[1], vldb.vid[2]);
414 if ((namesz < sizeof(vlocation->vldb.name) &&
415 vlocation->vldb.name[namesz] != '\0') ||
416 memcmp(vldb.name, name, namesz) != 0)
417 printk("kAFS: name of volume '%*.*s' changed to '%s' on server\n",
418 namesz, namesz, name, vldb.name);
420 memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
422 afs_kafstimod_add_timer(&vlocation->upd_timer, 10 * HZ);
424 #ifdef AFS_CACHING_SUPPORT
425 /* update volume entry in local cache */
426 cachefs_update_cookie(vlocation->cache);
427 #endif
429 *_vlocation = vlocation;
430 _leave(" = 0 (%p)",vlocation);
431 return 0;
433 error:
434 if (vlocation) {
435 if (active) {
436 __afs_put_vlocation(vlocation);
438 else {
439 list_del(&vlocation->link);
440 #ifdef AFS_CACHING_SUPPORT
441 cachefs_relinquish_cookie(vlocation->cache, 0);
442 #endif
443 afs_put_cell(vlocation->cell);
444 kfree(vlocation);
448 _leave(" = %d", ret);
449 return ret;
450 } /* end afs_vlocation_lookup() */
452 /*****************************************************************************/
454 * finish using a volume location record
455 * - caller must have cell->vol_sem write-locked
457 static void __afs_put_vlocation(struct afs_vlocation *vlocation)
459 struct afs_cell *cell;
461 if (!vlocation)
462 return;
464 _enter("%s", vlocation->vldb.name);
466 cell = vlocation->cell;
468 /* sanity check */
469 BUG_ON(atomic_read(&vlocation->usage) <= 0);
471 spin_lock(&cell->vl_gylock);
472 if (likely(!atomic_dec_and_test(&vlocation->usage))) {
473 spin_unlock(&cell->vl_gylock);
474 _leave("");
475 return;
478 /* move to graveyard queue */
479 list_move_tail(&vlocation->link,&cell->vl_graveyard);
481 /* remove from pending timeout queue (refcounted if actually being
482 * updated) */
483 list_del_init(&vlocation->upd_op.link);
485 /* time out in 10 secs */
486 afs_kafstimod_del_timer(&vlocation->upd_timer);
487 afs_kafstimod_add_timer(&vlocation->timeout, 10 * HZ);
489 spin_unlock(&cell->vl_gylock);
491 _leave(" [killed]");
492 } /* end __afs_put_vlocation() */
494 /*****************************************************************************/
496 * finish using a volume location record
498 void afs_put_vlocation(struct afs_vlocation *vlocation)
500 if (vlocation) {
501 struct afs_cell *cell = vlocation->cell;
503 down_write(&cell->vl_sem);
504 __afs_put_vlocation(vlocation);
505 up_write(&cell->vl_sem);
507 } /* end afs_put_vlocation() */
509 /*****************************************************************************/
511 * timeout vlocation record
512 * - removes from the cell's graveyard if the usage count is zero
514 void afs_vlocation_do_timeout(struct afs_vlocation *vlocation)
516 struct afs_cell *cell;
518 _enter("%s", vlocation->vldb.name);
520 cell = vlocation->cell;
522 BUG_ON(atomic_read(&vlocation->usage) < 0);
524 /* remove from graveyard if still dead */
525 spin_lock(&cell->vl_gylock);
526 if (atomic_read(&vlocation->usage) == 0)
527 list_del_init(&vlocation->link);
528 else
529 vlocation = NULL;
530 spin_unlock(&cell->vl_gylock);
532 if (!vlocation) {
533 _leave("");
534 return; /* resurrected */
537 /* we can now destroy it properly */
538 #ifdef AFS_CACHING_SUPPORT
539 cachefs_relinquish_cookie(vlocation->cache, 0);
540 #endif
541 afs_put_cell(cell);
543 kfree(vlocation);
545 _leave(" [destroyed]");
546 } /* end afs_vlocation_do_timeout() */
548 /*****************************************************************************/
550 * send an update operation to the currently selected server
552 static int afs_vlocation_update_begin(struct afs_vlocation *vlocation)
554 afs_voltype_t voltype;
555 afs_volid_t vid;
556 int ret;
558 _enter("%s{ufs=%u ucs=%u}",
559 vlocation->vldb.name,
560 vlocation->upd_first_svix,
561 vlocation->upd_curr_svix);
563 /* try to look up a cached volume in the cell VL databases by ID */
564 if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) {
565 vid = vlocation->vldb.vid[0];
566 voltype = AFSVL_RWVOL;
568 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) {
569 vid = vlocation->vldb.vid[1];
570 voltype = AFSVL_ROVOL;
572 else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) {
573 vid = vlocation->vldb.vid[2];
574 voltype = AFSVL_BACKVOL;
576 else {
577 BUG();
578 vid = 0;
579 voltype = 0;
582 /* contact the chosen server */
583 ret = afs_server_lookup(
584 vlocation->cell,
585 &vlocation->cell->vl_addrs[vlocation->upd_curr_svix],
586 &vlocation->upd_op.server);
588 switch (ret) {
589 case 0:
590 break;
591 case -ENOMEM:
592 case -ENONET:
593 default:
594 _leave(" = %d", ret);
595 return ret;
598 /* initiate the update operation */
599 ret = afs_rxvl_get_entry_by_id_async(&vlocation->upd_op, vid, voltype);
600 if (ret < 0) {
601 _leave(" = %d", ret);
602 return ret;
605 _leave(" = %d", ret);
606 return ret;
607 } /* end afs_vlocation_update_begin() */
609 /*****************************************************************************/
611 * abandon updating a VL record
612 * - does not restart the update timer
614 static void afs_vlocation_update_abandon(struct afs_vlocation *vlocation,
615 afs_vlocation_upd_t state,
616 int ret)
618 _enter("%s,%u", vlocation->vldb.name, state);
620 if (ret < 0)
621 printk("kAFS: Abandoning VL update '%s': %d\n",
622 vlocation->vldb.name, ret);
624 /* discard the server record */
625 afs_put_server(vlocation->upd_op.server);
626 vlocation->upd_op.server = NULL;
628 spin_lock(&afs_vlocation_update_lock);
629 afs_vlocation_update = NULL;
630 vlocation->upd_state = state;
632 /* TODO: start updating next VL record on pending list */
634 spin_unlock(&afs_vlocation_update_lock);
636 _leave("");
637 } /* end afs_vlocation_update_abandon() */
639 /*****************************************************************************/
641 * handle periodic update timeouts and busy retry timeouts
642 * - called from kafstimod
644 static void afs_vlocation_update_timer(struct afs_timer *timer)
646 struct afs_vlocation *vlocation =
647 list_entry(timer, struct afs_vlocation, upd_timer);
648 int ret;
650 _enter("%s", vlocation->vldb.name);
652 /* only update if not in the graveyard (defend against putting too) */
653 spin_lock(&vlocation->cell->vl_gylock);
655 if (!atomic_read(&vlocation->usage))
656 goto out_unlock1;
658 spin_lock(&afs_vlocation_update_lock);
660 /* if we were woken up due to EBUSY sleep then restart immediately if
661 * possible or else jump to front of pending queue */
662 if (vlocation->upd_state == AFS_VLUPD_BUSYSLEEP) {
663 if (afs_vlocation_update) {
664 list_add(&vlocation->upd_op.link,
665 &afs_vlocation_update_pendq);
667 else {
668 afs_get_vlocation(vlocation);
669 afs_vlocation_update = vlocation;
670 vlocation->upd_state = AFS_VLUPD_INPROGRESS;
672 goto out_unlock2;
675 /* put on pending queue if there's already another update in progress */
676 if (afs_vlocation_update) {
677 vlocation->upd_state = AFS_VLUPD_PENDING;
678 list_add_tail(&vlocation->upd_op.link,
679 &afs_vlocation_update_pendq);
680 goto out_unlock2;
683 /* hold a ref on it while actually updating */
684 afs_get_vlocation(vlocation);
685 afs_vlocation_update = vlocation;
686 vlocation->upd_state = AFS_VLUPD_INPROGRESS;
688 spin_unlock(&afs_vlocation_update_lock);
689 spin_unlock(&vlocation->cell->vl_gylock);
691 /* okay... we can start the update */
692 _debug("BEGIN VL UPDATE [%s]", vlocation->vldb.name);
693 vlocation->upd_first_svix = vlocation->cell->vl_curr_svix;
694 vlocation->upd_curr_svix = vlocation->upd_first_svix;
695 vlocation->upd_rej_cnt = 0;
696 vlocation->upd_busy_cnt = 0;
698 ret = afs_vlocation_update_begin(vlocation);
699 if (ret < 0) {
700 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
701 afs_kafstimod_add_timer(&vlocation->upd_timer,
702 AFS_VLDB_TIMEOUT);
703 afs_put_vlocation(vlocation);
706 _leave("");
707 return;
709 out_unlock2:
710 spin_unlock(&afs_vlocation_update_lock);
711 out_unlock1:
712 spin_unlock(&vlocation->cell->vl_gylock);
713 _leave("");
714 return;
716 } /* end afs_vlocation_update_timer() */
718 /*****************************************************************************/
720 * attend to an update operation upon which an event happened
721 * - called in kafsasyncd context
723 static void afs_vlocation_update_attend(struct afs_async_op *op)
725 struct afs_cache_vlocation vldb;
726 struct afs_vlocation *vlocation =
727 list_entry(op, struct afs_vlocation, upd_op);
728 unsigned tmp;
729 int ret;
731 _enter("%s", vlocation->vldb.name);
733 ret = afs_rxvl_get_entry_by_id_async2(op, &vldb);
734 switch (ret) {
735 case -EAGAIN:
736 _leave(" [unfinished]");
737 return;
739 case 0:
740 _debug("END VL UPDATE: %d\n", ret);
741 vlocation->valid = 1;
743 _debug("Done VL Lookup: %02x { %08x(%x) %08x(%x) %08x(%x) }",
744 vldb.vidmask,
745 ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0],
746 ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1],
747 ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2]
750 _debug("Vids: %08x %08x %08x",
751 vldb.vid[0], vldb.vid[1], vldb.vid[2]);
753 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
755 down_write(&vlocation->cell->vl_sem);
757 /* actually update the cache */
758 if (strncmp(vldb.name, vlocation->vldb.name,
759 sizeof(vlocation->vldb.name)) != 0)
760 printk("kAFS: name of volume '%s'"
761 " changed to '%s' on server\n",
762 vlocation->vldb.name, vldb.name);
764 memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb));
766 #if 0
767 /* TODO update volume entry in local cache */
768 #endif
770 up_write(&vlocation->cell->vl_sem);
772 if (ret < 0)
773 printk("kAFS: failed to update local cache: %d\n", ret);
775 afs_kafstimod_add_timer(&vlocation->upd_timer,
776 AFS_VLDB_TIMEOUT);
777 afs_put_vlocation(vlocation);
778 _leave(" [found]");
779 return;
781 case -ENOMEDIUM:
782 vlocation->upd_rej_cnt++;
783 goto try_next;
785 /* the server is locked - retry in a very short while */
786 case -EBUSY:
787 vlocation->upd_busy_cnt++;
788 if (vlocation->upd_busy_cnt > 3)
789 goto try_next; /* too many retries */
791 afs_vlocation_update_abandon(vlocation,
792 AFS_VLUPD_BUSYSLEEP, 0);
793 afs_kafstimod_add_timer(&vlocation->upd_timer, HZ / 2);
794 afs_put_vlocation(vlocation);
795 _leave(" [busy]");
796 return;
798 case -ENETUNREACH:
799 case -EHOSTUNREACH:
800 case -ECONNREFUSED:
801 case -EREMOTEIO:
802 /* record bad vlserver info in the cell too
803 * - TODO: use down_write_trylock() if available
805 if (vlocation->upd_curr_svix == vlocation->cell->vl_curr_svix)
806 vlocation->cell->vl_curr_svix =
807 vlocation->cell->vl_curr_svix %
808 vlocation->cell->vl_naddrs;
810 case -EBADRQC:
811 case -EINVAL:
812 case -EACCES:
813 case -EBADMSG:
814 goto try_next;
816 default:
817 goto abandon;
820 /* try contacting the next server */
821 try_next:
822 vlocation->upd_busy_cnt = 0;
824 /* discard the server record */
825 afs_put_server(vlocation->upd_op.server);
826 vlocation->upd_op.server = NULL;
828 tmp = vlocation->cell->vl_naddrs;
829 if (tmp == 0)
830 goto abandon;
832 vlocation->upd_curr_svix++;
833 if (vlocation->upd_curr_svix >= tmp)
834 vlocation->upd_curr_svix = 0;
835 if (vlocation->upd_first_svix >= tmp)
836 vlocation->upd_first_svix = tmp - 1;
838 /* move to the next server */
839 if (vlocation->upd_curr_svix != vlocation->upd_first_svix) {
840 afs_vlocation_update_begin(vlocation);
841 _leave(" [next]");
842 return;
845 /* run out of servers to try - was the volume rejected? */
846 if (vlocation->upd_rej_cnt > 0) {
847 printk("kAFS: Active volume no longer valid '%s'\n",
848 vlocation->vldb.name);
849 vlocation->valid = 0;
850 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0);
851 afs_kafstimod_add_timer(&vlocation->upd_timer,
852 AFS_VLDB_TIMEOUT);
853 afs_put_vlocation(vlocation);
854 _leave(" [invalidated]");
855 return;
858 /* abandon the update */
859 abandon:
860 afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret);
861 afs_kafstimod_add_timer(&vlocation->upd_timer, HZ * 10);
862 afs_put_vlocation(vlocation);
863 _leave(" [abandoned]");
865 } /* end afs_vlocation_update_attend() */
867 /*****************************************************************************/
869 * deal with an update operation being discarded
870 * - called in kafsasyncd context when it's dying due to rmmod
871 * - the call has already been aborted and put()'d
873 static void afs_vlocation_update_discard(struct afs_async_op *op)
875 struct afs_vlocation *vlocation =
876 list_entry(op, struct afs_vlocation, upd_op);
878 _enter("%s", vlocation->vldb.name);
880 afs_put_server(op->server);
881 op->server = NULL;
883 afs_put_vlocation(vlocation);
885 _leave("");
886 } /* end afs_vlocation_update_discard() */
888 /*****************************************************************************/
890 * match a VLDB record stored in the cache
891 * - may also load target from entry
893 #ifdef AFS_CACHING_SUPPORT
894 static cachefs_match_val_t afs_vlocation_cache_match(void *target,
895 const void *entry)
897 const struct afs_cache_vlocation *vldb = entry;
898 struct afs_vlocation *vlocation = target;
900 _enter("{%s},{%s}", vlocation->vldb.name, vldb->name);
902 if (strncmp(vlocation->vldb.name, vldb->name, sizeof(vldb->name)) == 0
904 if (!vlocation->valid ||
905 vlocation->vldb.rtime == vldb->rtime
907 vlocation->vldb = *vldb;
908 vlocation->valid = 1;
909 _leave(" = SUCCESS [c->m]");
910 return CACHEFS_MATCH_SUCCESS;
912 /* need to update cache if cached info differs */
913 else if (memcmp(&vlocation->vldb, vldb, sizeof(*vldb)) != 0) {
914 /* delete if VIDs for this name differ */
915 if (memcmp(&vlocation->vldb.vid,
916 &vldb->vid,
917 sizeof(vldb->vid)) != 0) {
918 _leave(" = DELETE");
919 return CACHEFS_MATCH_SUCCESS_DELETE;
922 _leave(" = UPDATE");
923 return CACHEFS_MATCH_SUCCESS_UPDATE;
925 else {
926 _leave(" = SUCCESS");
927 return CACHEFS_MATCH_SUCCESS;
931 _leave(" = FAILED");
932 return CACHEFS_MATCH_FAILED;
933 } /* end afs_vlocation_cache_match() */
934 #endif
936 /*****************************************************************************/
938 * update a VLDB record stored in the cache
940 #ifdef AFS_CACHING_SUPPORT
941 static void afs_vlocation_cache_update(void *source, void *entry)
943 struct afs_cache_vlocation *vldb = entry;
944 struct afs_vlocation *vlocation = source;
946 _enter("");
948 *vldb = vlocation->vldb;
950 } /* end afs_vlocation_cache_update() */
951 #endif