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