768c6dbd323ac625277d478086a98f4585a6ae88
[linux-2.6.git] / fs / afs / volume.c
1 /* volume.c: AFS volume 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 "vnode.h"
20 #include "cell.h"
21 #include "cache.h"
22 #include "cmservice.h"
23 #include "fsclient.h"
24 #include "vlclient.h"
25 #include "internal.h"
26
27 #ifdef __KDEBUG
28 static const char *afs_voltypes[] = { "R/W", "R/O", "BAK" };
29 #endif
30
31 #ifdef AFS_CACHING_SUPPORT
32 static cachefs_match_val_t afs_volume_cache_match(void *target,
33                                                   const void *entry);
34 static void afs_volume_cache_update(void *source, void *entry);
35
36 struct cachefs_index_def afs_volume_cache_index_def = {
37         .name           = "volume",
38         .data_size      = sizeof(struct afs_cache_vhash),
39         .keys[0]        = { CACHEFS_INDEX_KEYS_BIN, 1 },
40         .keys[1]        = { CACHEFS_INDEX_KEYS_BIN, 1 },
41         .match          = afs_volume_cache_match,
42         .update         = afs_volume_cache_update,
43 };
44 #endif
45
46 /*****************************************************************************/
47 /*
48  * lookup a volume by name
49  * - this can be one of the following:
50  *      "%[cell:]volume[.]"             R/W volume
51  *      "#[cell:]volume[.]"             R/O or R/W volume (rwparent=0),
52  *                                       or R/W (rwparent=1) volume
53  *      "%[cell:]volume.readonly"       R/O volume
54  *      "#[cell:]volume.readonly"       R/O volume
55  *      "%[cell:]volume.backup"         Backup volume
56  *      "#[cell:]volume.backup"         Backup volume
57  *
58  * The cell name is optional, and defaults to the current cell.
59  *
60  * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
61  * Guide
62  * - Rule 1: Explicit type suffix forces access of that type or nothing
63  *           (no suffix, then use Rule 2 & 3)
64  * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
65  *           if not available
66  * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
67  *           explicitly told otherwise
68  */
69 int afs_volume_lookup(const char *name, struct afs_cell *cell, int rwpath,
70                       struct afs_volume **_volume)
71 {
72         struct afs_vlocation *vlocation = NULL;
73         struct afs_volume *volume = NULL;
74         afs_voltype_t type;
75         const char *cellname, *volname, *suffix;
76         char srvtmask;
77         int force, ret, loop, cellnamesz, volnamesz;
78
79         _enter("%s,,%d,", name, rwpath);
80
81         if (!name || (name[0] != '%' && name[0] != '#') || !name[1]) {
82                 printk("kAFS: unparsable volume name\n");
83                 return -EINVAL;
84         }
85
86         /* determine the type of volume we're looking for */
87         force = 0;
88         type = AFSVL_ROVOL;
89
90         if (rwpath || name[0] == '%') {
91                 type = AFSVL_RWVOL;
92                 force = 1;
93         }
94
95         suffix = strrchr(name, '.');
96         if (suffix) {
97                 if (strcmp(suffix, ".readonly") == 0) {
98                         type = AFSVL_ROVOL;
99                         force = 1;
100                 }
101                 else if (strcmp(suffix, ".backup") == 0) {
102                         type = AFSVL_BACKVOL;
103                         force = 1;
104                 }
105                 else if (suffix[1] == 0) {
106                 }
107                 else {
108                         suffix = NULL;
109                 }
110         }
111
112         /* split the cell and volume names */
113         name++;
114         volname = strchr(name, ':');
115         if (volname) {
116                 cellname = name;
117                 cellnamesz = volname - name;
118                 volname++;
119         }
120         else {
121                 volname = name;
122                 cellname = NULL;
123                 cellnamesz = 0;
124         }
125
126         volnamesz = suffix ? suffix - volname : strlen(volname);
127
128         _debug("CELL:%*.*s [%p] VOLUME:%*.*s SUFFIX:%s TYPE:%d%s",
129                cellnamesz, cellnamesz, cellname ?: "", cell,
130                volnamesz, volnamesz, volname, suffix ?: "-",
131                type,
132                force ? " FORCE" : "");
133
134         /* lookup the cell record */
135         if (cellname || !cell) {
136                 ret = afs_cell_lookup(cellname, cellnamesz, &cell);
137                 if (ret<0) {
138                         printk("kAFS: unable to lookup cell '%s'\n",
139                                cellname ?: "");
140                         goto error;
141                 }
142         }
143         else {
144                 afs_get_cell(cell);
145         }
146
147         /* lookup the volume location record */
148         ret = afs_vlocation_lookup(cell, volname, volnamesz, &vlocation);
149         if (ret < 0)
150                 goto error;
151
152         /* make the final decision on the type we want */
153         ret = -ENOMEDIUM;
154         if (force && !(vlocation->vldb.vidmask & (1 << type)))
155                 goto error;
156
157         srvtmask = 0;
158         for (loop = 0; loop < vlocation->vldb.nservers; loop++)
159                 srvtmask |= vlocation->vldb.srvtmask[loop];
160
161         if (force) {
162                 if (!(srvtmask & (1 << type)))
163                         goto error;
164         }
165         else if (srvtmask & AFS_VOL_VTM_RO) {
166                 type = AFSVL_ROVOL;
167         }
168         else if (srvtmask & AFS_VOL_VTM_RW) {
169                 type = AFSVL_RWVOL;
170         }
171         else {
172                 goto error;
173         }
174
175         down_write(&cell->vl_sem);
176
177         /* is the volume already active? */
178         if (vlocation->vols[type]) {
179                 /* yes - re-use it */
180                 volume = vlocation->vols[type];
181                 afs_get_volume(volume);
182                 goto success;
183         }
184
185         /* create a new volume record */
186         _debug("creating new volume record");
187
188         ret = -ENOMEM;
189         volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
190         if (!volume)
191                 goto error_up;
192
193         atomic_set(&volume->usage, 1);
194         volume->type            = type;
195         volume->type_force      = force;
196         volume->cell            = cell;
197         volume->vid             = vlocation->vldb.vid[type];
198
199         init_rwsem(&volume->server_sem);
200
201         /* look up all the applicable server records */
202         for (loop = 0; loop < 8; loop++) {
203                 if (vlocation->vldb.srvtmask[loop] & (1 << volume->type)) {
204                         ret = afs_server_lookup(
205                                 volume->cell,
206                                 &vlocation->vldb.servers[loop],
207                                 &volume->servers[volume->nservers]);
208                         if (ret < 0)
209                                 goto error_discard;
210
211                         volume->nservers++;
212                 }
213         }
214
215         /* attach the cache and volume location */
216 #ifdef AFS_CACHING_SUPPORT
217         cachefs_acquire_cookie(vlocation->cache,
218                                &afs_vnode_cache_index_def,
219                                volume,
220                                &volume->cache);
221 #endif
222
223         afs_get_vlocation(vlocation);
224         volume->vlocation = vlocation;
225
226         vlocation->vols[type] = volume;
227
228  success:
229         _debug("kAFS selected %s volume %08x",
230                afs_voltypes[volume->type], volume->vid);
231         *_volume = volume;
232         ret = 0;
233
234         /* clean up */
235  error_up:
236         up_write(&cell->vl_sem);
237  error:
238         afs_put_vlocation(vlocation);
239         afs_put_cell(cell);
240
241         _leave(" = %d (%p)", ret, volume);
242         return ret;
243
244  error_discard:
245         up_write(&cell->vl_sem);
246
247         for (loop = volume->nservers - 1; loop >= 0; loop--)
248                 afs_put_server(volume->servers[loop]);
249
250         kfree(volume);
251         goto error;
252 } /* end afs_volume_lookup() */
253
254 /*****************************************************************************/
255 /*
256  * destroy a volume record
257  */
258 void afs_put_volume(struct afs_volume *volume)
259 {
260         struct afs_vlocation *vlocation;
261         int loop;
262
263         if (!volume)
264                 return;
265
266         _enter("%p", volume);
267
268         vlocation = volume->vlocation;
269
270         /* sanity check */
271         BUG_ON(atomic_read(&volume->usage) <= 0);
272
273         /* to prevent a race, the decrement and the dequeue must be effectively
274          * atomic */
275         down_write(&vlocation->cell->vl_sem);
276
277         if (likely(!atomic_dec_and_test(&volume->usage))) {
278                 up_write(&vlocation->cell->vl_sem);
279                 _leave("");
280                 return;
281         }
282
283         vlocation->vols[volume->type] = NULL;
284
285         up_write(&vlocation->cell->vl_sem);
286
287         /* finish cleaning up the volume */
288 #ifdef AFS_CACHING_SUPPORT
289         cachefs_relinquish_cookie(volume->cache, 0);
290 #endif
291         afs_put_vlocation(vlocation);
292
293         for (loop = volume->nservers - 1; loop >= 0; loop--)
294                 afs_put_server(volume->servers[loop]);
295
296         kfree(volume);
297
298         _leave(" [destroyed]");
299 } /* end afs_put_volume() */
300
301 /*****************************************************************************/
302 /*
303  * pick a server to use to try accessing this volume
304  * - returns with an elevated usage count on the server chosen
305  */
306 int afs_volume_pick_fileserver(struct afs_volume *volume,
307                                struct afs_server **_server)
308 {
309         struct afs_server *server;
310         int ret, state, loop;
311
312         _enter("%s", volume->vlocation->vldb.name);
313
314         down_read(&volume->server_sem);
315
316         /* handle the no-server case */
317         if (volume->nservers == 0) {
318                 ret = volume->rjservers ? -ENOMEDIUM : -ESTALE;
319                 up_read(&volume->server_sem);
320                 _leave(" = %d [no servers]", ret);
321                 return ret;
322         }
323
324         /* basically, just search the list for the first live server and use
325          * that */
326         ret = 0;
327         for (loop = 0; loop < volume->nservers; loop++) {
328                 server = volume->servers[loop];
329                 state = server->fs_state;
330
331                 switch (state) {
332                         /* found an apparently healthy server */
333                 case 0:
334                         afs_get_server(server);
335                         up_read(&volume->server_sem);
336                         *_server = server;
337                         _leave(" = 0 (picked %08x)",
338                                ntohl(server->addr.s_addr));
339                         return 0;
340
341                 case -ENETUNREACH:
342                         if (ret == 0)
343                                 ret = state;
344                         break;
345
346                 case -EHOSTUNREACH:
347                         if (ret == 0 ||
348                             ret == -ENETUNREACH)
349                                 ret = state;
350                         break;
351
352                 case -ECONNREFUSED:
353                         if (ret == 0 ||
354                             ret == -ENETUNREACH ||
355                             ret == -EHOSTUNREACH)
356                                 ret = state;
357                         break;
358
359                 default:
360                 case -EREMOTEIO:
361                         if (ret == 0 ||
362                             ret == -ENETUNREACH ||
363                             ret == -EHOSTUNREACH ||
364                             ret == -ECONNREFUSED)
365                                 ret = state;
366                         break;
367                 }
368         }
369
370         /* no available servers
371          * - TODO: handle the no active servers case better
372          */
373         up_read(&volume->server_sem);
374         _leave(" = %d", ret);
375         return ret;
376 } /* end afs_volume_pick_fileserver() */
377
378 /*****************************************************************************/
379 /*
380  * release a server after use
381  * - releases the ref on the server struct that was acquired by picking
382  * - records result of using a particular server to access a volume
383  * - return 0 to try again, 1 if okay or to issue error
384  */
385 int afs_volume_release_fileserver(struct afs_volume *volume,
386                                   struct afs_server *server,
387                                   int result)
388 {
389         unsigned loop;
390
391         _enter("%s,%08x,%d",
392                volume->vlocation->vldb.name, ntohl(server->addr.s_addr),
393                result);
394
395         switch (result) {
396                 /* success */
397         case 0:
398                 server->fs_act_jif = jiffies;
399                 break;
400
401                 /* the fileserver denied all knowledge of the volume */
402         case -ENOMEDIUM:
403                 server->fs_act_jif = jiffies;
404                 down_write(&volume->server_sem);
405
406                 /* first, find where the server is in the active list (if it
407                  * is) */
408                 for (loop = 0; loop < volume->nservers; loop++)
409                         if (volume->servers[loop] == server)
410                                 goto present;
411
412                 /* no longer there - may have been discarded by another op */
413                 goto try_next_server_upw;
414
415         present:
416                 volume->nservers--;
417                 memmove(&volume->servers[loop],
418                         &volume->servers[loop + 1],
419                         sizeof(volume->servers[loop]) *
420                         (volume->nservers - loop));
421                 volume->servers[volume->nservers] = NULL;
422                 afs_put_server(server);
423                 volume->rjservers++;
424
425                 if (volume->nservers > 0)
426                         /* another server might acknowledge its existence */
427                         goto try_next_server_upw;
428
429                 /* handle the case where all the fileservers have rejected the
430                  * volume
431                  * - TODO: try asking the fileservers for volume information
432                  * - TODO: contact the VL server again to see if the volume is
433                  *         no longer registered
434                  */
435                 up_write(&volume->server_sem);
436                 afs_put_server(server);
437                 _leave(" [completely rejected]");
438                 return 1;
439
440                 /* problem reaching the server */
441         case -ENETUNREACH:
442         case -EHOSTUNREACH:
443         case -ECONNREFUSED:
444         case -ETIMEDOUT:
445         case -EREMOTEIO:
446                 /* mark the server as dead
447                  * TODO: vary dead timeout depending on error
448                  */
449                 spin_lock(&server->fs_lock);
450                 if (!server->fs_state) {
451                         server->fs_dead_jif = jiffies + HZ * 10;
452                         server->fs_state = result;
453                         printk("kAFS: SERVER DEAD state=%d\n", result);
454                 }
455                 spin_unlock(&server->fs_lock);
456                 goto try_next_server;
457
458                 /* miscellaneous error */
459         default:
460                 server->fs_act_jif = jiffies;
461         case -ENOMEM:
462         case -ENONET:
463                 break;
464         }
465
466         /* tell the caller to accept the result */
467         afs_put_server(server);
468         _leave("");
469         return 1;
470
471         /* tell the caller to loop around and try the next server */
472  try_next_server_upw:
473         up_write(&volume->server_sem);
474  try_next_server:
475         afs_put_server(server);
476         _leave(" [try next server]");
477         return 0;
478
479 } /* end afs_volume_release_fileserver() */
480
481 /*****************************************************************************/
482 /*
483  * match a volume hash record stored in the cache
484  */
485 #ifdef AFS_CACHING_SUPPORT
486 static cachefs_match_val_t afs_volume_cache_match(void *target,
487                                                   const void *entry)
488 {
489         const struct afs_cache_vhash *vhash = entry;
490         struct afs_volume *volume = target;
491
492         _enter("{%u},{%u}", volume->type, vhash->vtype);
493
494         if (volume->type == vhash->vtype) {
495                 _leave(" = SUCCESS");
496                 return CACHEFS_MATCH_SUCCESS;
497         }
498
499         _leave(" = FAILED");
500         return CACHEFS_MATCH_FAILED;
501 } /* end afs_volume_cache_match() */
502 #endif
503
504 /*****************************************************************************/
505 /*
506  * update a volume hash record stored in the cache
507  */
508 #ifdef AFS_CACHING_SUPPORT
509 static void afs_volume_cache_update(void *source, void *entry)
510 {
511         struct afs_cache_vhash *vhash = entry;
512         struct afs_volume *volume = source;
513
514         _enter("");
515
516         vhash->vtype = volume->type;
517
518 } /* end afs_volume_cache_update() */
519 #endif