blob: 8bab0e3437f9384507721cb68e93245c4c154ff6 [file] [log] [blame]
David Howellsec268152007-04-26 15:49:28 -07001/* AFS volume management
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 *
David Howells08e0e7c2007-04-26 15:55:03 -07003 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040018#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "internal.h"
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021static const char *afs_voltypes[] = { "R/W", "R/O", "BAK" };
Linus Torvalds1da177e2005-04-16 15:20:36 -070022
Linus Torvalds1da177e2005-04-16 15:20:36 -070023/*
24 * lookup a volume by name
25 * - this can be one of the following:
26 * "%[cell:]volume[.]" R/W volume
27 * "#[cell:]volume[.]" R/O or R/W volume (rwparent=0),
28 * or R/W (rwparent=1) volume
29 * "%[cell:]volume.readonly" R/O volume
30 * "#[cell:]volume.readonly" R/O volume
31 * "%[cell:]volume.backup" Backup volume
32 * "#[cell:]volume.backup" Backup volume
33 *
34 * The cell name is optional, and defaults to the current cell.
35 *
36 * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
37 * Guide
38 * - Rule 1: Explicit type suffix forces access of that type or nothing
39 * (no suffix, then use Rule 2 & 3)
40 * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
41 * if not available
42 * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
43 * explicitly told otherwise
44 */
David Howells00d3b7a2007-04-26 15:57:07 -070045struct afs_volume *afs_volume_lookup(struct afs_mount_params *params)
Linus Torvalds1da177e2005-04-16 15:20:36 -070046{
47 struct afs_vlocation *vlocation = NULL;
48 struct afs_volume *volume = NULL;
David Howells08e0e7c2007-04-26 15:55:03 -070049 struct afs_server *server = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 char srvtmask;
David Howells00d3b7a2007-04-26 15:57:07 -070051 int ret, loop;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
David Howells00d3b7a2007-04-26 15:57:07 -070053 _enter("{%*.*s,%d}",
54 params->volnamesz, params->volnamesz, params->volname, params->rwpath);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56 /* lookup the volume location record */
David Howells00d3b7a2007-04-26 15:57:07 -070057 vlocation = afs_vlocation_lookup(params->cell, params->key,
58 params->volname, params->volnamesz);
David Howells08e0e7c2007-04-26 15:55:03 -070059 if (IS_ERR(vlocation)) {
60 ret = PTR_ERR(vlocation);
61 vlocation = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 goto error;
David Howells08e0e7c2007-04-26 15:55:03 -070063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
65 /* make the final decision on the type we want */
66 ret = -ENOMEDIUM;
David Howells00d3b7a2007-04-26 15:57:07 -070067 if (params->force && !(vlocation->vldb.vidmask & (1 << params->type)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 goto error;
69
70 srvtmask = 0;
71 for (loop = 0; loop < vlocation->vldb.nservers; loop++)
72 srvtmask |= vlocation->vldb.srvtmask[loop];
73
David Howells00d3b7a2007-04-26 15:57:07 -070074 if (params->force) {
75 if (!(srvtmask & (1 << params->type)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 goto error;
David Howellsec268152007-04-26 15:49:28 -070077 } else if (srvtmask & AFS_VOL_VTM_RO) {
David Howells00d3b7a2007-04-26 15:57:07 -070078 params->type = AFSVL_ROVOL;
David Howellsec268152007-04-26 15:49:28 -070079 } else if (srvtmask & AFS_VOL_VTM_RW) {
David Howells00d3b7a2007-04-26 15:57:07 -070080 params->type = AFSVL_RWVOL;
David Howellsec268152007-04-26 15:49:28 -070081 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 goto error;
83 }
84
David Howells00d3b7a2007-04-26 15:57:07 -070085 down_write(&params->cell->vl_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086
87 /* is the volume already active? */
David Howells00d3b7a2007-04-26 15:57:07 -070088 if (vlocation->vols[params->type]) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 /* yes - re-use it */
David Howells00d3b7a2007-04-26 15:57:07 -070090 volume = vlocation->vols[params->type];
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 afs_get_volume(volume);
92 goto success;
93 }
94
95 /* create a new volume record */
96 _debug("creating new volume record");
97
98 ret = -ENOMEM;
Panagiotis Issarisf8314dc2006-09-27 01:49:37 -070099 volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 if (!volume)
101 goto error_up;
102
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 atomic_set(&volume->usage, 1);
David Howells00d3b7a2007-04-26 15:57:07 -0700104 volume->type = params->type;
105 volume->type_force = params->force;
106 volume->cell = params->cell;
107 volume->vid = vlocation->vldb.vid[params->type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109 init_rwsem(&volume->server_sem);
110
111 /* look up all the applicable server records */
112 for (loop = 0; loop < 8; loop++) {
113 if (vlocation->vldb.srvtmask[loop] & (1 << volume->type)) {
David Howells08e0e7c2007-04-26 15:55:03 -0700114 server = afs_lookup_server(
115 volume->cell, &vlocation->vldb.servers[loop]);
116 if (IS_ERR(server)) {
117 ret = PTR_ERR(server);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 goto error_discard;
David Howells08e0e7c2007-04-26 15:55:03 -0700119 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120
David Howells08e0e7c2007-04-26 15:55:03 -0700121 volume->servers[volume->nservers] = server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 volume->nservers++;
123 }
124 }
125
126 /* attach the cache and volume location */
127#ifdef AFS_CACHING_SUPPORT
128 cachefs_acquire_cookie(vlocation->cache,
129 &afs_vnode_cache_index_def,
130 volume,
131 &volume->cache);
132#endif
133
134 afs_get_vlocation(vlocation);
135 volume->vlocation = vlocation;
136
David Howells00d3b7a2007-04-26 15:57:07 -0700137 vlocation->vols[volume->type] = volume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
David Howellsec268152007-04-26 15:49:28 -0700139success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 _debug("kAFS selected %s volume %08x",
141 afs_voltypes[volume->type], volume->vid);
David Howells00d3b7a2007-04-26 15:57:07 -0700142 up_write(&params->cell->vl_sem);
David Howells08e0e7c2007-04-26 15:55:03 -0700143 afs_put_vlocation(vlocation);
David Howells08e0e7c2007-04-26 15:55:03 -0700144 _leave(" = %p", volume);
145 return volume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146
147 /* clean up */
David Howellsec268152007-04-26 15:49:28 -0700148error_up:
David Howells00d3b7a2007-04-26 15:57:07 -0700149 up_write(&params->cell->vl_sem);
David Howellsec268152007-04-26 15:49:28 -0700150error:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 afs_put_vlocation(vlocation);
David Howells08e0e7c2007-04-26 15:55:03 -0700152 _leave(" = %d", ret);
153 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
David Howellsec268152007-04-26 15:49:28 -0700155error_discard:
David Howells00d3b7a2007-04-26 15:57:07 -0700156 up_write(&params->cell->vl_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
158 for (loop = volume->nservers - 1; loop >= 0; loop--)
159 afs_put_server(volume->servers[loop]);
160
161 kfree(volume);
162 goto error;
David Howellsec268152007-04-26 15:49:28 -0700163}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165/*
166 * destroy a volume record
167 */
168void afs_put_volume(struct afs_volume *volume)
169{
170 struct afs_vlocation *vlocation;
171 int loop;
172
173 if (!volume)
174 return;
175
176 _enter("%p", volume);
177
David Howells08e0e7c2007-04-26 15:55:03 -0700178 ASSERTCMP(atomic_read(&volume->usage), >, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179
David Howells08e0e7c2007-04-26 15:55:03 -0700180 vlocation = volume->vlocation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 /* to prevent a race, the decrement and the dequeue must be effectively
183 * atomic */
184 down_write(&vlocation->cell->vl_sem);
185
186 if (likely(!atomic_dec_and_test(&volume->usage))) {
187 up_write(&vlocation->cell->vl_sem);
188 _leave("");
189 return;
190 }
191
192 vlocation->vols[volume->type] = NULL;
193
194 up_write(&vlocation->cell->vl_sem);
195
196 /* finish cleaning up the volume */
197#ifdef AFS_CACHING_SUPPORT
198 cachefs_relinquish_cookie(volume->cache, 0);
199#endif
200 afs_put_vlocation(vlocation);
201
202 for (loop = volume->nservers - 1; loop >= 0; loop--)
203 afs_put_server(volume->servers[loop]);
204
205 kfree(volume);
206
207 _leave(" [destroyed]");
David Howellsec268152007-04-26 15:49:28 -0700208}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210/*
211 * pick a server to use to try accessing this volume
212 * - returns with an elevated usage count on the server chosen
213 */
David Howells08e0e7c2007-04-26 15:55:03 -0700214struct afs_server *afs_volume_pick_fileserver(struct afs_vnode *vnode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
David Howells08e0e7c2007-04-26 15:55:03 -0700216 struct afs_volume *volume = vnode->volume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 struct afs_server *server;
218 int ret, state, loop;
219
220 _enter("%s", volume->vlocation->vldb.name);
221
David Howells08e0e7c2007-04-26 15:55:03 -0700222 /* stick with the server we're already using if we can */
223 if (vnode->server && vnode->server->fs_state == 0) {
224 afs_get_server(vnode->server);
225 _leave(" = %p [current]", vnode->server);
226 return vnode->server;
227 }
228
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 down_read(&volume->server_sem);
230
231 /* handle the no-server case */
232 if (volume->nservers == 0) {
233 ret = volume->rjservers ? -ENOMEDIUM : -ESTALE;
234 up_read(&volume->server_sem);
235 _leave(" = %d [no servers]", ret);
David Howells08e0e7c2007-04-26 15:55:03 -0700236 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
238
239 /* basically, just search the list for the first live server and use
240 * that */
241 ret = 0;
242 for (loop = 0; loop < volume->nservers; loop++) {
243 server = volume->servers[loop];
244 state = server->fs_state;
245
David Howells08e0e7c2007-04-26 15:55:03 -0700246 _debug("consider %d [%d]", loop, state);
247
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 switch (state) {
249 /* found an apparently healthy server */
250 case 0:
251 afs_get_server(server);
252 up_read(&volume->server_sem);
David Howells08e0e7c2007-04-26 15:55:03 -0700253 _leave(" = %p (picked %08x)",
254 server, ntohl(server->addr.s_addr));
255 return server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 case -ENETUNREACH:
258 if (ret == 0)
259 ret = state;
260 break;
261
262 case -EHOSTUNREACH:
263 if (ret == 0 ||
264 ret == -ENETUNREACH)
265 ret = state;
266 break;
267
268 case -ECONNREFUSED:
269 if (ret == 0 ||
270 ret == -ENETUNREACH ||
271 ret == -EHOSTUNREACH)
272 ret = state;
273 break;
274
275 default:
276 case -EREMOTEIO:
277 if (ret == 0 ||
278 ret == -ENETUNREACH ||
279 ret == -EHOSTUNREACH ||
280 ret == -ECONNREFUSED)
281 ret = state;
282 break;
283 }
284 }
285
286 /* no available servers
287 * - TODO: handle the no active servers case better
288 */
289 up_read(&volume->server_sem);
290 _leave(" = %d", ret);
David Howells08e0e7c2007-04-26 15:55:03 -0700291 return ERR_PTR(ret);
David Howellsec268152007-04-26 15:49:28 -0700292}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294/*
295 * release a server after use
296 * - releases the ref on the server struct that was acquired by picking
297 * - records result of using a particular server to access a volume
298 * - return 0 to try again, 1 if okay or to issue error
David Howells260a9802007-04-26 15:59:35 -0700299 * - the caller must release the server struct if result was 0
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 */
David Howells08e0e7c2007-04-26 15:55:03 -0700301int afs_volume_release_fileserver(struct afs_vnode *vnode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 struct afs_server *server,
303 int result)
304{
David Howells08e0e7c2007-04-26 15:55:03 -0700305 struct afs_volume *volume = vnode->volume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 unsigned loop;
307
308 _enter("%s,%08x,%d",
309 volume->vlocation->vldb.name, ntohl(server->addr.s_addr),
310 result);
311
312 switch (result) {
313 /* success */
314 case 0:
315 server->fs_act_jif = jiffies;
David Howells08e0e7c2007-04-26 15:55:03 -0700316 server->fs_state = 0;
David Howells260a9802007-04-26 15:59:35 -0700317 _leave("");
318 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
320 /* the fileserver denied all knowledge of the volume */
321 case -ENOMEDIUM:
322 server->fs_act_jif = jiffies;
323 down_write(&volume->server_sem);
324
David Howells08e0e7c2007-04-26 15:55:03 -0700325 /* firstly, find where the server is in the active list (if it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 * is) */
327 for (loop = 0; loop < volume->nservers; loop++)
328 if (volume->servers[loop] == server)
329 goto present;
330
331 /* no longer there - may have been discarded by another op */
332 goto try_next_server_upw;
333
334 present:
335 volume->nservers--;
336 memmove(&volume->servers[loop],
337 &volume->servers[loop + 1],
338 sizeof(volume->servers[loop]) *
339 (volume->nservers - loop));
340 volume->servers[volume->nservers] = NULL;
341 afs_put_server(server);
342 volume->rjservers++;
343
344 if (volume->nservers > 0)
345 /* another server might acknowledge its existence */
346 goto try_next_server_upw;
347
348 /* handle the case where all the fileservers have rejected the
349 * volume
350 * - TODO: try asking the fileservers for volume information
351 * - TODO: contact the VL server again to see if the volume is
352 * no longer registered
353 */
354 up_write(&volume->server_sem);
355 afs_put_server(server);
356 _leave(" [completely rejected]");
357 return 1;
358
359 /* problem reaching the server */
360 case -ENETUNREACH:
361 case -EHOSTUNREACH:
362 case -ECONNREFUSED:
David Howells08e0e7c2007-04-26 15:55:03 -0700363 case -ETIME:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 case -ETIMEDOUT:
365 case -EREMOTEIO:
366 /* mark the server as dead
367 * TODO: vary dead timeout depending on error
368 */
369 spin_lock(&server->fs_lock);
370 if (!server->fs_state) {
371 server->fs_dead_jif = jiffies + HZ * 10;
372 server->fs_state = result;
373 printk("kAFS: SERVER DEAD state=%d\n", result);
374 }
375 spin_unlock(&server->fs_lock);
376 goto try_next_server;
377
378 /* miscellaneous error */
379 default:
380 server->fs_act_jif = jiffies;
381 case -ENOMEM:
382 case -ENONET:
David Howells260a9802007-04-26 15:59:35 -0700383 /* tell the caller to accept the result */
384 afs_put_server(server);
385 _leave(" [local failure]");
386 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 }
388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 /* tell the caller to loop around and try the next server */
David Howellsec268152007-04-26 15:49:28 -0700390try_next_server_upw:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 up_write(&volume->server_sem);
David Howellsec268152007-04-26 15:49:28 -0700392try_next_server:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 afs_put_server(server);
394 _leave(" [try next server]");
395 return 0;
David Howellsec268152007-04-26 15:49:28 -0700396}