volume.c 9.74 KB
Newer Older
1
/* AFS volume management
Linus Torvalds's avatar
Linus Torvalds committed
2
 *
3
 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
18
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
#include "internal.h"

static const char *afs_voltypes[] = { "R/W", "R/O", "BAK" };

/*
 * lookup a volume by name
 * - this can be one of the following:
 *	"%[cell:]volume[.]"		R/W volume
 *	"#[cell:]volume[.]"		R/O or R/W volume (rwparent=0),
 *					 or R/W (rwparent=1) volume
 *	"%[cell:]volume.readonly"	R/O volume
 *	"#[cell:]volume.readonly"	R/O volume
 *	"%[cell:]volume.backup"		Backup volume
 *	"#[cell:]volume.backup"		Backup volume
 *
 * The cell name is optional, and defaults to the current cell.
 *
 * See "The Rules of Mount Point Traversal" in Chapter 5 of the AFS SysAdmin
 * Guide
 * - Rule 1: Explicit type suffix forces access of that type or nothing
 *           (no suffix, then use Rule 2 & 3)
 * - Rule 2: If parent volume is R/O, then mount R/O volume by preference, R/W
 *           if not available
 * - Rule 3: If parent volume is R/W, then only mount R/W volume unless
 *           explicitly told otherwise
 */
45
struct afs_volume *afs_volume_lookup(struct afs_mount_params *params)
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48
{
	struct afs_vlocation *vlocation = NULL;
	struct afs_volume *volume = NULL;
49
	struct afs_server *server = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
50
	char srvtmask;
51
	int ret, loop;
Linus Torvalds's avatar
Linus Torvalds committed
52

53 54
	_enter("{%*.*s,%d}",
	       params->volnamesz, params->volnamesz, params->volname, params->rwpath);
Linus Torvalds's avatar
Linus Torvalds committed
55 56

	/* lookup the volume location record */
57 58
	vlocation = afs_vlocation_lookup(params->cell, params->key,
					 params->volname, params->volnamesz);
59 60 61
	if (IS_ERR(vlocation)) {
		ret = PTR_ERR(vlocation);
		vlocation = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
62
		goto error;
63
	}
Linus Torvalds's avatar
Linus Torvalds committed
64 65 66

	/* make the final decision on the type we want */
	ret = -ENOMEDIUM;
67
	if (params->force && !(vlocation->vldb.vidmask & (1 << params->type)))
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70 71 72 73
		goto error;

	srvtmask = 0;
	for (loop = 0; loop < vlocation->vldb.nservers; loop++)
		srvtmask |= vlocation->vldb.srvtmask[loop];

74 75
	if (params->force) {
		if (!(srvtmask & (1 << params->type)))
Linus Torvalds's avatar
Linus Torvalds committed
76
			goto error;
77
	} else if (srvtmask & AFS_VOL_VTM_RO) {
78
		params->type = AFSVL_ROVOL;
79
	} else if (srvtmask & AFS_VOL_VTM_RW) {
80
		params->type = AFSVL_RWVOL;
81
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
82 83 84
		goto error;
	}

85
	down_write(&params->cell->vl_sem);
Linus Torvalds's avatar
Linus Torvalds committed
86 87

	/* is the volume already active? */
88
	if (vlocation->vols[params->type]) {
Linus Torvalds's avatar
Linus Torvalds committed
89
		/* yes - re-use it */
90
		volume = vlocation->vols[params->type];
Linus Torvalds's avatar
Linus Torvalds committed
91 92 93 94 95 96 97 98
		afs_get_volume(volume);
		goto success;
	}

	/* create a new volume record */
	_debug("creating new volume record");

	ret = -ENOMEM;
99
	volume = kzalloc(sizeof(struct afs_volume), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102 103
	if (!volume)
		goto error_up;

	atomic_set(&volume->usage, 1);
104 105 106 107
	volume->type		= params->type;
	volume->type_force	= params->force;
	volume->cell		= params->cell;
	volume->vid		= vlocation->vldb.vid[params->type];
Linus Torvalds's avatar
Linus Torvalds committed
108 109 110 111 112 113

	init_rwsem(&volume->server_sem);

	/* look up all the applicable server records */
	for (loop = 0; loop < 8; loop++) {
		if (vlocation->vldb.srvtmask[loop] & (1 << volume->type)) {
114 115 116 117
			server = afs_lookup_server(
			       volume->cell, &vlocation->vldb.servers[loop]);
			if (IS_ERR(server)) {
				ret = PTR_ERR(server);
Linus Torvalds's avatar
Linus Torvalds committed
118
				goto error_discard;
119
			}
Linus Torvalds's avatar
Linus Torvalds committed
120

121
			volume->servers[volume->nservers] = server;
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124 125 126
			volume->nservers++;
		}
	}

	/* attach the cache and volume location */
127 128 129
#ifdef CONFIG_AFS_FSCACHE
	volume->cache = fscache_acquire_cookie(vlocation->cache,
					       &afs_volume_cache_index_def,
130
					       volume, true);
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133 134
#endif
	afs_get_vlocation(vlocation);
	volume->vlocation = vlocation;

135
	vlocation->vols[volume->type] = volume;
Linus Torvalds's avatar
Linus Torvalds committed
136

137
success:
Linus Torvalds's avatar
Linus Torvalds committed
138 139
	_debug("kAFS selected %s volume %08x",
	       afs_voltypes[volume->type], volume->vid);
140
	up_write(&params->cell->vl_sem);
141 142 143
	afs_put_vlocation(vlocation);
	_leave(" = %p", volume);
	return volume;
Linus Torvalds's avatar
Linus Torvalds committed
144 145

	/* clean up */
146
error_up:
147
	up_write(&params->cell->vl_sem);
148
error:
Linus Torvalds's avatar
Linus Torvalds committed
149
	afs_put_vlocation(vlocation);
150 151
	_leave(" = %d", ret);
	return ERR_PTR(ret);
Linus Torvalds's avatar
Linus Torvalds committed
152

153
error_discard:
154
	up_write(&params->cell->vl_sem);
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157 158 159 160

	for (loop = volume->nservers - 1; loop >= 0; loop--)
		afs_put_server(volume->servers[loop]);

	kfree(volume);
	goto error;
161
}
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164 165 166 167 168 169 170 171 172 173 174 175

/*
 * destroy a volume record
 */
void afs_put_volume(struct afs_volume *volume)
{
	struct afs_vlocation *vlocation;
	int loop;

	if (!volume)
		return;

	_enter("%p", volume);

176
	ASSERTCMP(atomic_read(&volume->usage), >, 0);
Linus Torvalds's avatar
Linus Torvalds committed
177

178
	vlocation = volume->vlocation;
Linus Torvalds's avatar
Linus Torvalds committed
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194

	/* to prevent a race, the decrement and the dequeue must be effectively
	 * atomic */
	down_write(&vlocation->cell->vl_sem);

	if (likely(!atomic_dec_and_test(&volume->usage))) {
		up_write(&vlocation->cell->vl_sem);
		_leave("");
		return;
	}

	vlocation->vols[volume->type] = NULL;

	up_write(&vlocation->cell->vl_sem);

	/* finish cleaning up the volume */
195 196
#ifdef CONFIG_AFS_FSCACHE
	fscache_relinquish_cookie(volume->cache, 0);
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205
#endif
	afs_put_vlocation(vlocation);

	for (loop = volume->nservers - 1; loop >= 0; loop--)
		afs_put_server(volume->servers[loop]);

	kfree(volume);

	_leave(" [destroyed]");
206
}
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209 210 211

/*
 * pick a server to use to try accessing this volume
 * - returns with an elevated usage count on the server chosen
 */
212
struct afs_server *afs_volume_pick_fileserver(struct afs_vnode *vnode)
Linus Torvalds's avatar
Linus Torvalds committed
213
{
214
	struct afs_volume *volume = vnode->volume;
Linus Torvalds's avatar
Linus Torvalds committed
215 216 217 218 219
	struct afs_server *server;
	int ret, state, loop;

	_enter("%s", volume->vlocation->vldb.name);

220 221 222 223 224 225 226
	/* stick with the server we're already using if we can */
	if (vnode->server && vnode->server->fs_state == 0) {
		afs_get_server(vnode->server);
		_leave(" = %p [current]", vnode->server);
		return vnode->server;
	}

Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230 231 232 233
	down_read(&volume->server_sem);

	/* handle the no-server case */
	if (volume->nservers == 0) {
		ret = volume->rjservers ? -ENOMEDIUM : -ESTALE;
		up_read(&volume->server_sem);
		_leave(" = %d [no servers]", ret);
234
		return ERR_PTR(ret);
Linus Torvalds's avatar
Linus Torvalds committed
235 236 237 238 239 240 241 242 243
	}

	/* basically, just search the list for the first live server and use
	 * that */
	ret = 0;
	for (loop = 0; loop < volume->nservers; loop++) {
		server = volume->servers[loop];
		state = server->fs_state;

244 245
		_debug("consider %d [%d]", loop, state);

Linus Torvalds's avatar
Linus Torvalds committed
246 247 248 249 250
		switch (state) {
			/* found an apparently healthy server */
		case 0:
			afs_get_server(server);
			up_read(&volume->server_sem);
251 252 253
			_leave(" = %p (picked %08x)",
			       server, ntohl(server->addr.s_addr));
			return server;
Linus Torvalds's avatar
Linus Torvalds committed
254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288

		case -ENETUNREACH:
			if (ret == 0)
				ret = state;
			break;

		case -EHOSTUNREACH:
			if (ret == 0 ||
			    ret == -ENETUNREACH)
				ret = state;
			break;

		case -ECONNREFUSED:
			if (ret == 0 ||
			    ret == -ENETUNREACH ||
			    ret == -EHOSTUNREACH)
				ret = state;
			break;

		default:
		case -EREMOTEIO:
			if (ret == 0 ||
			    ret == -ENETUNREACH ||
			    ret == -EHOSTUNREACH ||
			    ret == -ECONNREFUSED)
				ret = state;
			break;
		}
	}

	/* no available servers
	 * - TODO: handle the no active servers case better
	 */
	up_read(&volume->server_sem);
	_leave(" = %d", ret);
289
	return ERR_PTR(ret);
290
}
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293 294 295 296

/*
 * release a server after use
 * - releases the ref on the server struct that was acquired by picking
 * - records result of using a particular server to access a volume
 * - return 0 to try again, 1 if okay or to issue error
297
 * - the caller must release the server struct if result was 0
Linus Torvalds's avatar
Linus Torvalds committed
298
 */
299
int afs_volume_release_fileserver(struct afs_vnode *vnode,
Linus Torvalds's avatar
Linus Torvalds committed
300 301 302
				  struct afs_server *server,
				  int result)
{
303
	struct afs_volume *volume = vnode->volume;
Linus Torvalds's avatar
Linus Torvalds committed
304 305 306 307 308 309 310 311 312 313
	unsigned loop;

	_enter("%s,%08x,%d",
	       volume->vlocation->vldb.name, ntohl(server->addr.s_addr),
	       result);

	switch (result) {
		/* success */
	case 0:
		server->fs_act_jif = jiffies;
314
		server->fs_state = 0;
315 316
		_leave("");
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319 320 321 322

		/* the fileserver denied all knowledge of the volume */
	case -ENOMEDIUM:
		server->fs_act_jif = jiffies;
		down_write(&volume->server_sem);

323
		/* firstly, find where the server is in the active list (if it
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
		 * is) */
		for (loop = 0; loop < volume->nservers; loop++)
			if (volume->servers[loop] == server)
				goto present;

		/* no longer there - may have been discarded by another op */
		goto try_next_server_upw;

	present:
		volume->nservers--;
		memmove(&volume->servers[loop],
			&volume->servers[loop + 1],
			sizeof(volume->servers[loop]) *
			(volume->nservers - loop));
		volume->servers[volume->nservers] = NULL;
		afs_put_server(server);
		volume->rjservers++;

		if (volume->nservers > 0)
			/* another server might acknowledge its existence */
			goto try_next_server_upw;

		/* handle the case where all the fileservers have rejected the
		 * volume
		 * - TODO: try asking the fileservers for volume information
		 * - TODO: contact the VL server again to see if the volume is
		 *         no longer registered
		 */
		up_write(&volume->server_sem);
		afs_put_server(server);
		_leave(" [completely rejected]");
		return 1;

		/* problem reaching the server */
	case -ENETUNREACH:
	case -EHOSTUNREACH:
	case -ECONNREFUSED:
361
	case -ETIME:
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380
	case -ETIMEDOUT:
	case -EREMOTEIO:
		/* mark the server as dead
		 * TODO: vary dead timeout depending on error
		 */
		spin_lock(&server->fs_lock);
		if (!server->fs_state) {
			server->fs_dead_jif = jiffies + HZ * 10;
			server->fs_state = result;
			printk("kAFS: SERVER DEAD state=%d\n", result);
		}
		spin_unlock(&server->fs_lock);
		goto try_next_server;

		/* miscellaneous error */
	default:
		server->fs_act_jif = jiffies;
	case -ENOMEM:
	case -ENONET:
381 382 383 384
		/* tell the caller to accept the result */
		afs_put_server(server);
		_leave(" [local failure]");
		return 1;
Linus Torvalds's avatar
Linus Torvalds committed
385 386 387
	}

	/* tell the caller to loop around and try the next server */
388
try_next_server_upw:
Linus Torvalds's avatar
Linus Torvalds committed
389
	up_write(&volume->server_sem);
390
try_next_server:
Linus Torvalds's avatar
Linus Torvalds committed
391 392 393
	afs_put_server(server);
	_leave(" [try next server]");
	return 0;
394
}