]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | */ | |
11 | ||
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" | |
26 | ||
27 | #define AFS_VLDB_TIMEOUT HZ*1000 | |
28 | ||
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); | |
33 | ||
34 | static void __afs_vlocation_timeout(struct afs_timer *timer) | |
35 | { | |
36 | struct afs_vlocation *vlocation = | |
37 | list_entry(timer, struct afs_vlocation, timeout); | |
38 | ||
39 | _debug("VL TIMEOUT [%s{u=%d}]", | |
40 | vlocation->vldb.name, atomic_read(&vlocation->usage)); | |
41 | ||
42 | afs_vlocation_do_timeout(vlocation); | |
43 | } | |
44 | ||
45 | static const struct afs_timer_ops afs_vlocation_timer_ops = { | |
46 | .timed_out = __afs_vlocation_timeout, | |
47 | }; | |
48 | ||
49 | static const struct afs_timer_ops afs_vlocation_update_timer_ops = { | |
50 | .timed_out = afs_vlocation_update_timer, | |
51 | }; | |
52 | ||
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 | }; | |
57 | ||
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 */ | |
61 | ||
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); | |
66 | ||
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 | |
75 | ||
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; | |
90 | ||
91 | _enter("%s,%*.*s,%u", cell->name, namesz, namesz, name, namesz); | |
92 | ||
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); | |
98 | ||
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 | } | |
112 | ||
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 | } | |
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 | } | |
148 | ||
149 | out: | |
150 | _leave(" = %d", ret); | |
151 | return ret; | |
152 | ||
153 | } /* end afs_vlocation_access_vl_by_name() */ | |
154 | ||
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; | |
169 | ||
170 | _enter("%s,%x,%d,", cell->name, volid, voltype); | |
171 | ||
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); | |
177 | ||
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 | } | |
191 | ||
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 | } | |
221 | ||
222 | /* rotate the server records upon lookup failure */ | |
223 | rotate: | |
224 | cell->vl_curr_svix++; | |
225 | cell->vl_curr_svix %= cell->vl_naddrs; | |
226 | } | |
227 | ||
228 | out: | |
229 | _leave(" = %d", ret); | |
230 | return ret; | |
231 | ||
232 | } /* end afs_vlocation_access_vl_by_id() */ | |
233 | ||
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; | |
253 | ||
254 | _enter("{%s},%*.*s,%u,", cell->name, namesz, namesz, name, namesz); | |
255 | ||
256 | if (namesz > sizeof(vlocation->vldb.name)) { | |
257 | _leave(" = -ENAMETOOLONG"); | |
258 | return -ENAMETOOLONG; | |
259 | } | |
260 | ||
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; | |
266 | ||
267 | if (memcmp(vlocation->vldb.name, name, namesz) == 0) | |
268 | goto found_in_memory; | |
269 | } | |
270 | ||
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; | |
277 | ||
278 | if (memcmp(vlocation->vldb.name, name, namesz) == 0) | |
279 | goto found_in_graveyard; | |
280 | } | |
281 | spin_unlock(&cell->vl_gylock); | |
282 | ||
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; | |
287 | ||
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); | |
293 | ||
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); | |
297 | ||
298 | afs_get_cell(cell); | |
299 | vlocation->cell = cell; | |
300 | ||
301 | list_add_tail(&vlocation->link, &cell->vl_list); | |
302 | ||
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); | |
310 | ||
311 | if (vlocation->valid) | |
312 | goto found_in_cache; | |
313 | #endif | |
314 | ||
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 | } | |
322 | ||
323 | goto found_on_vlserver; | |
324 | ||
325 | found_in_graveyard: | |
326 | /* found in the graveyard - resurrect */ | |
327 | _debug("found in graveyard"); | |
328 | atomic_inc(&vlocation->usage); | |
329 | list_del(&vlocation->link); | |
330 | list_add_tail(&vlocation->link, &cell->vl_list); | |
331 | spin_unlock(&cell->vl_gylock); | |
332 | ||
333 | afs_kafstimod_del_timer(&vlocation->timeout); | |
334 | goto active; | |
335 | ||
336 | found_in_memory: | |
337 | /* found in memory - check to see if it's active */ | |
338 | _debug("found in memory"); | |
339 | atomic_inc(&vlocation->usage); | |
340 | ||
341 | active: | |
342 | active = 1; | |
343 | ||
344 | #ifdef AFS_CACHING_SUPPORT | |
345 | found_in_cache: | |
346 | #endif | |
347 | /* try to look up a cached volume in the cell VL databases by ID */ | |
348 | _debug("found in cache"); | |
349 | ||
350 | _debug("Locally Cached: %s %02x { %08x(%x) %08x(%x) %08x(%x) }", | |
351 | vlocation->vldb.name, | |
352 | vlocation->vldb.vidmask, | |
353 | ntohl(vlocation->vldb.servers[0].s_addr), | |
354 | vlocation->vldb.srvtmask[0], | |
355 | ntohl(vlocation->vldb.servers[1].s_addr), | |
356 | vlocation->vldb.srvtmask[1], | |
357 | ntohl(vlocation->vldb.servers[2].s_addr), | |
358 | vlocation->vldb.srvtmask[2] | |
359 | ); | |
360 | ||
361 | _debug("Vids: %08x %08x %08x", | |
362 | vlocation->vldb.vid[0], | |
363 | vlocation->vldb.vid[1], | |
364 | vlocation->vldb.vid[2]); | |
365 | ||
366 | if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) { | |
367 | vid = vlocation->vldb.vid[0]; | |
368 | voltype = AFSVL_RWVOL; | |
369 | } | |
370 | else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) { | |
371 | vid = vlocation->vldb.vid[1]; | |
372 | voltype = AFSVL_ROVOL; | |
373 | } | |
374 | else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) { | |
375 | vid = vlocation->vldb.vid[2]; | |
376 | voltype = AFSVL_BACKVOL; | |
377 | } | |
378 | else { | |
379 | BUG(); | |
380 | vid = 0; | |
381 | voltype = 0; | |
382 | } | |
383 | ||
384 | ret = afs_vlocation_access_vl_by_id(vlocation, vid, voltype, &vldb); | |
385 | switch (ret) { | |
386 | /* net error */ | |
387 | default: | |
388 | printk("kAFS: failed to volume '%*.*s' (%x) up in '%s': %d\n", | |
389 | namesz, namesz, name, vid, cell->name, ret); | |
390 | goto error; | |
391 | ||
392 | /* pulled from local cache into memory */ | |
393 | case 0: | |
394 | goto found_on_vlserver; | |
395 | ||
396 | /* uh oh... looks like the volume got deleted */ | |
397 | case -ENOMEDIUM: | |
398 | printk("kAFS: volume '%*.*s' (%x) does not exist '%s'\n", | |
399 | namesz, namesz, name, vid, cell->name); | |
400 | ||
401 | /* TODO: make existing record unavailable */ | |
402 | goto error; | |
403 | } | |
404 | ||
405 | found_on_vlserver: | |
406 | _debug("Done VL Lookup: %*.*s %02x { %08x(%x) %08x(%x) %08x(%x) }", | |
407 | namesz, namesz, name, | |
408 | vldb.vidmask, | |
409 | ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0], | |
410 | ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1], | |
411 | ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2] | |
412 | ); | |
413 | ||
414 | _debug("Vids: %08x %08x %08x", vldb.vid[0], vldb.vid[1], vldb.vid[2]); | |
415 | ||
416 | if ((namesz < sizeof(vlocation->vldb.name) && | |
417 | vlocation->vldb.name[namesz] != '\0') || | |
418 | memcmp(vldb.name, name, namesz) != 0) | |
419 | printk("kAFS: name of volume '%*.*s' changed to '%s' on server\n", | |
420 | namesz, namesz, name, vldb.name); | |
421 | ||
422 | memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb)); | |
423 | ||
424 | afs_kafstimod_add_timer(&vlocation->upd_timer, 10 * HZ); | |
425 | ||
426 | #ifdef AFS_CACHING_SUPPORT | |
427 | /* update volume entry in local cache */ | |
428 | cachefs_update_cookie(vlocation->cache); | |
429 | #endif | |
430 | ||
431 | *_vlocation = vlocation; | |
432 | _leave(" = 0 (%p)",vlocation); | |
433 | return 0; | |
434 | ||
435 | error: | |
436 | if (vlocation) { | |
437 | if (active) { | |
438 | __afs_put_vlocation(vlocation); | |
439 | } | |
440 | else { | |
441 | list_del(&vlocation->link); | |
442 | #ifdef AFS_CACHING_SUPPORT | |
443 | cachefs_relinquish_cookie(vlocation->cache, 0); | |
444 | #endif | |
445 | afs_put_cell(vlocation->cell); | |
446 | kfree(vlocation); | |
447 | } | |
448 | } | |
449 | ||
450 | _leave(" = %d", ret); | |
451 | return ret; | |
452 | } /* end afs_vlocation_lookup() */ | |
453 | ||
454 | /*****************************************************************************/ | |
455 | /* | |
456 | * finish using a volume location record | |
457 | * - caller must have cell->vol_sem write-locked | |
458 | */ | |
459 | static void __afs_put_vlocation(struct afs_vlocation *vlocation) | |
460 | { | |
461 | struct afs_cell *cell; | |
462 | ||
463 | if (!vlocation) | |
464 | return; | |
465 | ||
466 | _enter("%s", vlocation->vldb.name); | |
467 | ||
468 | cell = vlocation->cell; | |
469 | ||
470 | /* sanity check */ | |
471 | BUG_ON(atomic_read(&vlocation->usage) <= 0); | |
472 | ||
473 | spin_lock(&cell->vl_gylock); | |
474 | if (likely(!atomic_dec_and_test(&vlocation->usage))) { | |
475 | spin_unlock(&cell->vl_gylock); | |
476 | _leave(""); | |
477 | return; | |
478 | } | |
479 | ||
480 | /* move to graveyard queue */ | |
481 | list_del(&vlocation->link); | |
482 | list_add_tail(&vlocation->link,&cell->vl_graveyard); | |
483 | ||
484 | /* remove from pending timeout queue (refcounted if actually being | |
485 | * updated) */ | |
486 | list_del_init(&vlocation->upd_op.link); | |
487 | ||
488 | /* time out in 10 secs */ | |
489 | afs_kafstimod_del_timer(&vlocation->upd_timer); | |
490 | afs_kafstimod_add_timer(&vlocation->timeout, 10 * HZ); | |
491 | ||
492 | spin_unlock(&cell->vl_gylock); | |
493 | ||
494 | _leave(" [killed]"); | |
495 | } /* end __afs_put_vlocation() */ | |
496 | ||
497 | /*****************************************************************************/ | |
498 | /* | |
499 | * finish using a volume location record | |
500 | */ | |
501 | void afs_put_vlocation(struct afs_vlocation *vlocation) | |
502 | { | |
503 | if (vlocation) { | |
504 | struct afs_cell *cell = vlocation->cell; | |
505 | ||
506 | down_write(&cell->vl_sem); | |
507 | __afs_put_vlocation(vlocation); | |
508 | up_write(&cell->vl_sem); | |
509 | } | |
510 | } /* end afs_put_vlocation() */ | |
511 | ||
512 | /*****************************************************************************/ | |
513 | /* | |
514 | * timeout vlocation record | |
515 | * - removes from the cell's graveyard if the usage count is zero | |
516 | */ | |
517 | void afs_vlocation_do_timeout(struct afs_vlocation *vlocation) | |
518 | { | |
519 | struct afs_cell *cell; | |
520 | ||
521 | _enter("%s", vlocation->vldb.name); | |
522 | ||
523 | cell = vlocation->cell; | |
524 | ||
525 | BUG_ON(atomic_read(&vlocation->usage) < 0); | |
526 | ||
527 | /* remove from graveyard if still dead */ | |
528 | spin_lock(&cell->vl_gylock); | |
529 | if (atomic_read(&vlocation->usage) == 0) | |
530 | list_del_init(&vlocation->link); | |
531 | else | |
532 | vlocation = NULL; | |
533 | spin_unlock(&cell->vl_gylock); | |
534 | ||
535 | if (!vlocation) { | |
536 | _leave(""); | |
537 | return; /* resurrected */ | |
538 | } | |
539 | ||
540 | /* we can now destroy it properly */ | |
541 | #ifdef AFS_CACHING_SUPPORT | |
542 | cachefs_relinquish_cookie(vlocation->cache, 0); | |
543 | #endif | |
544 | afs_put_cell(cell); | |
545 | ||
546 | kfree(vlocation); | |
547 | ||
548 | _leave(" [destroyed]"); | |
549 | } /* end afs_vlocation_do_timeout() */ | |
550 | ||
551 | /*****************************************************************************/ | |
552 | /* | |
553 | * send an update operation to the currently selected server | |
554 | */ | |
555 | static int afs_vlocation_update_begin(struct afs_vlocation *vlocation) | |
556 | { | |
557 | afs_voltype_t voltype; | |
558 | afs_volid_t vid; | |
559 | int ret; | |
560 | ||
561 | _enter("%s{ufs=%u ucs=%u}", | |
562 | vlocation->vldb.name, | |
563 | vlocation->upd_first_svix, | |
564 | vlocation->upd_curr_svix); | |
565 | ||
566 | /* try to look up a cached volume in the cell VL databases by ID */ | |
567 | if (vlocation->vldb.vidmask & AFS_VOL_VTM_RW) { | |
568 | vid = vlocation->vldb.vid[0]; | |
569 | voltype = AFSVL_RWVOL; | |
570 | } | |
571 | else if (vlocation->vldb.vidmask & AFS_VOL_VTM_RO) { | |
572 | vid = vlocation->vldb.vid[1]; | |
573 | voltype = AFSVL_ROVOL; | |
574 | } | |
575 | else if (vlocation->vldb.vidmask & AFS_VOL_VTM_BAK) { | |
576 | vid = vlocation->vldb.vid[2]; | |
577 | voltype = AFSVL_BACKVOL; | |
578 | } | |
579 | else { | |
580 | BUG(); | |
581 | vid = 0; | |
582 | voltype = 0; | |
583 | } | |
584 | ||
585 | /* contact the chosen server */ | |
586 | ret = afs_server_lookup( | |
587 | vlocation->cell, | |
588 | &vlocation->cell->vl_addrs[vlocation->upd_curr_svix], | |
589 | &vlocation->upd_op.server); | |
590 | ||
591 | switch (ret) { | |
592 | case 0: | |
593 | break; | |
594 | case -ENOMEM: | |
595 | case -ENONET: | |
596 | default: | |
597 | _leave(" = %d", ret); | |
598 | return ret; | |
599 | } | |
600 | ||
601 | /* initiate the update operation */ | |
602 | ret = afs_rxvl_get_entry_by_id_async(&vlocation->upd_op, vid, voltype); | |
603 | if (ret < 0) { | |
604 | _leave(" = %d", ret); | |
605 | return ret; | |
606 | } | |
607 | ||
608 | _leave(" = %d", ret); | |
609 | return ret; | |
610 | } /* end afs_vlocation_update_begin() */ | |
611 | ||
612 | /*****************************************************************************/ | |
613 | /* | |
614 | * abandon updating a VL record | |
615 | * - does not restart the update timer | |
616 | */ | |
617 | static void afs_vlocation_update_abandon(struct afs_vlocation *vlocation, | |
618 | afs_vlocation_upd_t state, | |
619 | int ret) | |
620 | { | |
621 | _enter("%s,%u", vlocation->vldb.name, state); | |
622 | ||
623 | if (ret < 0) | |
624 | printk("kAFS: Abandoning VL update '%s': %d\n", | |
625 | vlocation->vldb.name, ret); | |
626 | ||
627 | /* discard the server record */ | |
628 | afs_put_server(vlocation->upd_op.server); | |
629 | vlocation->upd_op.server = NULL; | |
630 | ||
631 | spin_lock(&afs_vlocation_update_lock); | |
632 | afs_vlocation_update = NULL; | |
633 | vlocation->upd_state = state; | |
634 | ||
635 | /* TODO: start updating next VL record on pending list */ | |
636 | ||
637 | spin_unlock(&afs_vlocation_update_lock); | |
638 | ||
639 | _leave(""); | |
640 | } /* end afs_vlocation_update_abandon() */ | |
641 | ||
642 | /*****************************************************************************/ | |
643 | /* | |
644 | * handle periodic update timeouts and busy retry timeouts | |
645 | * - called from kafstimod | |
646 | */ | |
647 | static void afs_vlocation_update_timer(struct afs_timer *timer) | |
648 | { | |
649 | struct afs_vlocation *vlocation = | |
650 | list_entry(timer, struct afs_vlocation, upd_timer); | |
651 | int ret; | |
652 | ||
653 | _enter("%s", vlocation->vldb.name); | |
654 | ||
655 | /* only update if not in the graveyard (defend against putting too) */ | |
656 | spin_lock(&vlocation->cell->vl_gylock); | |
657 | ||
658 | if (!atomic_read(&vlocation->usage)) | |
659 | goto out_unlock1; | |
660 | ||
661 | spin_lock(&afs_vlocation_update_lock); | |
662 | ||
663 | /* if we were woken up due to EBUSY sleep then restart immediately if | |
664 | * possible or else jump to front of pending queue */ | |
665 | if (vlocation->upd_state == AFS_VLUPD_BUSYSLEEP) { | |
666 | if (afs_vlocation_update) { | |
667 | list_add(&vlocation->upd_op.link, | |
668 | &afs_vlocation_update_pendq); | |
669 | } | |
670 | else { | |
671 | afs_get_vlocation(vlocation); | |
672 | afs_vlocation_update = vlocation; | |
673 | vlocation->upd_state = AFS_VLUPD_INPROGRESS; | |
674 | } | |
675 | goto out_unlock2; | |
676 | } | |
677 | ||
678 | /* put on pending queue if there's already another update in progress */ | |
679 | if (afs_vlocation_update) { | |
680 | vlocation->upd_state = AFS_VLUPD_PENDING; | |
681 | list_add_tail(&vlocation->upd_op.link, | |
682 | &afs_vlocation_update_pendq); | |
683 | goto out_unlock2; | |
684 | } | |
685 | ||
686 | /* hold a ref on it while actually updating */ | |
687 | afs_get_vlocation(vlocation); | |
688 | afs_vlocation_update = vlocation; | |
689 | vlocation->upd_state = AFS_VLUPD_INPROGRESS; | |
690 | ||
691 | spin_unlock(&afs_vlocation_update_lock); | |
692 | spin_unlock(&vlocation->cell->vl_gylock); | |
693 | ||
694 | /* okay... we can start the update */ | |
695 | _debug("BEGIN VL UPDATE [%s]", vlocation->vldb.name); | |
696 | vlocation->upd_first_svix = vlocation->cell->vl_curr_svix; | |
697 | vlocation->upd_curr_svix = vlocation->upd_first_svix; | |
698 | vlocation->upd_rej_cnt = 0; | |
699 | vlocation->upd_busy_cnt = 0; | |
700 | ||
701 | ret = afs_vlocation_update_begin(vlocation); | |
702 | if (ret < 0) { | |
703 | afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret); | |
704 | afs_kafstimod_add_timer(&vlocation->upd_timer, | |
705 | AFS_VLDB_TIMEOUT); | |
706 | afs_put_vlocation(vlocation); | |
707 | } | |
708 | ||
709 | _leave(""); | |
710 | return; | |
711 | ||
712 | out_unlock2: | |
713 | spin_unlock(&afs_vlocation_update_lock); | |
714 | out_unlock1: | |
715 | spin_unlock(&vlocation->cell->vl_gylock); | |
716 | _leave(""); | |
717 | return; | |
718 | ||
719 | } /* end afs_vlocation_update_timer() */ | |
720 | ||
721 | /*****************************************************************************/ | |
722 | /* | |
723 | * attend to an update operation upon which an event happened | |
724 | * - called in kafsasyncd context | |
725 | */ | |
726 | static void afs_vlocation_update_attend(struct afs_async_op *op) | |
727 | { | |
728 | struct afs_cache_vlocation vldb; | |
729 | struct afs_vlocation *vlocation = | |
730 | list_entry(op, struct afs_vlocation, upd_op); | |
731 | unsigned tmp; | |
732 | int ret; | |
733 | ||
734 | _enter("%s", vlocation->vldb.name); | |
735 | ||
736 | ret = afs_rxvl_get_entry_by_id_async2(op, &vldb); | |
737 | switch (ret) { | |
738 | case -EAGAIN: | |
739 | _leave(" [unfinished]"); | |
740 | return; | |
741 | ||
742 | case 0: | |
743 | _debug("END VL UPDATE: %d\n", ret); | |
744 | vlocation->valid = 1; | |
745 | ||
746 | _debug("Done VL Lookup: %02x { %08x(%x) %08x(%x) %08x(%x) }", | |
747 | vldb.vidmask, | |
748 | ntohl(vldb.servers[0].s_addr), vldb.srvtmask[0], | |
749 | ntohl(vldb.servers[1].s_addr), vldb.srvtmask[1], | |
750 | ntohl(vldb.servers[2].s_addr), vldb.srvtmask[2] | |
751 | ); | |
752 | ||
753 | _debug("Vids: %08x %08x %08x", | |
754 | vldb.vid[0], vldb.vid[1], vldb.vid[2]); | |
755 | ||
756 | afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0); | |
757 | ||
758 | down_write(&vlocation->cell->vl_sem); | |
759 | ||
760 | /* actually update the cache */ | |
761 | if (strncmp(vldb.name, vlocation->vldb.name, | |
762 | sizeof(vlocation->vldb.name)) != 0) | |
763 | printk("kAFS: name of volume '%s'" | |
764 | " changed to '%s' on server\n", | |
765 | vlocation->vldb.name, vldb.name); | |
766 | ||
767 | memcpy(&vlocation->vldb, &vldb, sizeof(vlocation->vldb)); | |
768 | ||
769 | #if 0 | |
770 | /* TODO update volume entry in local cache */ | |
771 | #endif | |
772 | ||
773 | up_write(&vlocation->cell->vl_sem); | |
774 | ||
775 | if (ret < 0) | |
776 | printk("kAFS: failed to update local cache: %d\n", ret); | |
777 | ||
778 | afs_kafstimod_add_timer(&vlocation->upd_timer, | |
779 | AFS_VLDB_TIMEOUT); | |
780 | afs_put_vlocation(vlocation); | |
781 | _leave(" [found]"); | |
782 | return; | |
783 | ||
784 | case -ENOMEDIUM: | |
785 | vlocation->upd_rej_cnt++; | |
786 | goto try_next; | |
787 | ||
788 | /* the server is locked - retry in a very short while */ | |
789 | case -EBUSY: | |
790 | vlocation->upd_busy_cnt++; | |
791 | if (vlocation->upd_busy_cnt > 3) | |
792 | goto try_next; /* too many retries */ | |
793 | ||
794 | afs_vlocation_update_abandon(vlocation, | |
795 | AFS_VLUPD_BUSYSLEEP, 0); | |
796 | afs_kafstimod_add_timer(&vlocation->upd_timer, HZ / 2); | |
797 | afs_put_vlocation(vlocation); | |
798 | _leave(" [busy]"); | |
799 | return; | |
800 | ||
801 | case -ENETUNREACH: | |
802 | case -EHOSTUNREACH: | |
803 | case -ECONNREFUSED: | |
804 | case -EREMOTEIO: | |
805 | /* record bad vlserver info in the cell too | |
806 | * - TODO: use down_write_trylock() if available | |
807 | */ | |
808 | if (vlocation->upd_curr_svix == vlocation->cell->vl_curr_svix) | |
809 | vlocation->cell->vl_curr_svix = | |
810 | vlocation->cell->vl_curr_svix % | |
811 | vlocation->cell->vl_naddrs; | |
812 | ||
813 | case -EBADRQC: | |
814 | case -EINVAL: | |
815 | case -EACCES: | |
816 | case -EBADMSG: | |
817 | goto try_next; | |
818 | ||
819 | default: | |
820 | goto abandon; | |
821 | } | |
822 | ||
823 | /* try contacting the next server */ | |
824 | try_next: | |
825 | vlocation->upd_busy_cnt = 0; | |
826 | ||
827 | /* discard the server record */ | |
828 | afs_put_server(vlocation->upd_op.server); | |
829 | vlocation->upd_op.server = NULL; | |
830 | ||
831 | tmp = vlocation->cell->vl_naddrs; | |
832 | if (tmp == 0) | |
833 | goto abandon; | |
834 | ||
835 | vlocation->upd_curr_svix++; | |
836 | if (vlocation->upd_curr_svix >= tmp) | |
837 | vlocation->upd_curr_svix = 0; | |
838 | if (vlocation->upd_first_svix >= tmp) | |
839 | vlocation->upd_first_svix = tmp - 1; | |
840 | ||
841 | /* move to the next server */ | |
842 | if (vlocation->upd_curr_svix != vlocation->upd_first_svix) { | |
843 | afs_vlocation_update_begin(vlocation); | |
844 | _leave(" [next]"); | |
845 | return; | |
846 | } | |
847 | ||
848 | /* run out of servers to try - was the volume rejected? */ | |
849 | if (vlocation->upd_rej_cnt > 0) { | |
850 | printk("kAFS: Active volume no longer valid '%s'\n", | |
851 | vlocation->vldb.name); | |
852 | vlocation->valid = 0; | |
853 | afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, 0); | |
854 | afs_kafstimod_add_timer(&vlocation->upd_timer, | |
855 | AFS_VLDB_TIMEOUT); | |
856 | afs_put_vlocation(vlocation); | |
857 | _leave(" [invalidated]"); | |
858 | return; | |
859 | } | |
860 | ||
861 | /* abandon the update */ | |
862 | abandon: | |
863 | afs_vlocation_update_abandon(vlocation, AFS_VLUPD_SLEEP, ret); | |
864 | afs_kafstimod_add_timer(&vlocation->upd_timer, HZ * 10); | |
865 | afs_put_vlocation(vlocation); | |
866 | _leave(" [abandoned]"); | |
867 | ||
868 | } /* end afs_vlocation_update_attend() */ | |
869 | ||
870 | /*****************************************************************************/ | |
871 | /* | |
872 | * deal with an update operation being discarded | |
873 | * - called in kafsasyncd context when it's dying due to rmmod | |
874 | * - the call has already been aborted and put()'d | |
875 | */ | |
876 | static void afs_vlocation_update_discard(struct afs_async_op *op) | |
877 | { | |
878 | struct afs_vlocation *vlocation = | |
879 | list_entry(op, struct afs_vlocation, upd_op); | |
880 | ||
881 | _enter("%s", vlocation->vldb.name); | |
882 | ||
883 | afs_put_server(op->server); | |
884 | op->server = NULL; | |
885 | ||
886 | afs_put_vlocation(vlocation); | |
887 | ||
888 | _leave(""); | |
889 | } /* end afs_vlocation_update_discard() */ | |
890 | ||
891 | /*****************************************************************************/ | |
892 | /* | |
893 | * match a VLDB record stored in the cache | |
894 | * - may also load target from entry | |
895 | */ | |
896 | #ifdef AFS_CACHING_SUPPORT | |
897 | static cachefs_match_val_t afs_vlocation_cache_match(void *target, | |
898 | const void *entry) | |
899 | { | |
900 | const struct afs_cache_vlocation *vldb = entry; | |
901 | struct afs_vlocation *vlocation = target; | |
902 | ||
903 | _enter("{%s},{%s}", vlocation->vldb.name, vldb->name); | |
904 | ||
905 | if (strncmp(vlocation->vldb.name, vldb->name, sizeof(vldb->name)) == 0 | |
906 | ) { | |
907 | if (!vlocation->valid || | |
908 | vlocation->vldb.rtime == vldb->rtime | |
909 | ) { | |
910 | vlocation->vldb = *vldb; | |
911 | vlocation->valid = 1; | |
912 | _leave(" = SUCCESS [c->m]"); | |
913 | return CACHEFS_MATCH_SUCCESS; | |
914 | } | |
915 | /* need to update cache if cached info differs */ | |
916 | else if (memcmp(&vlocation->vldb, vldb, sizeof(*vldb)) != 0) { | |
917 | /* delete if VIDs for this name differ */ | |
918 | if (memcmp(&vlocation->vldb.vid, | |
919 | &vldb->vid, | |
920 | sizeof(vldb->vid)) != 0) { | |
921 | _leave(" = DELETE"); | |
922 | return CACHEFS_MATCH_SUCCESS_DELETE; | |
923 | } | |
924 | ||
925 | _leave(" = UPDATE"); | |
926 | return CACHEFS_MATCH_SUCCESS_UPDATE; | |
927 | } | |
928 | else { | |
929 | _leave(" = SUCCESS"); | |
930 | return CACHEFS_MATCH_SUCCESS; | |
931 | } | |
932 | } | |
933 | ||
934 | _leave(" = FAILED"); | |
935 | return CACHEFS_MATCH_FAILED; | |
936 | } /* end afs_vlocation_cache_match() */ | |
937 | #endif | |
938 | ||
939 | /*****************************************************************************/ | |
940 | /* | |
941 | * update a VLDB record stored in the cache | |
942 | */ | |
943 | #ifdef AFS_CACHING_SUPPORT | |
944 | static void afs_vlocation_cache_update(void *source, void *entry) | |
945 | { | |
946 | struct afs_cache_vlocation *vldb = entry; | |
947 | struct afs_vlocation *vlocation = source; | |
948 | ||
949 | _enter(""); | |
950 | ||
951 | *vldb = vlocation->vldb; | |
952 | ||
953 | } /* end afs_vlocation_cache_update() */ | |
954 | #endif |