[net-next-2.6.git] / fs / afs / vlclient.c

/* AFS Volume Location Service client
 *
 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
 * 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/gfp.h>
#include <linux/init.h>
#include <linux/sched.h>
#include "internal.h"

/*
 * map volume locator abort codes to error codes
 */
static int afs_vl_abort_to_error(u32 abort_code)
{
	_enter("%u", abort_code);

	switch (abort_code) {
	case AFSVL_IDEXIST:		return -EEXIST;
	case AFSVL_IO:			return -EREMOTEIO;
	case AFSVL_NAMEEXIST:		return -EEXIST;
	case AFSVL_CREATEFAIL:		return -EREMOTEIO;
	case AFSVL_NOENT:		return -ENOMEDIUM;
	case AFSVL_EMPTY:		return -ENOMEDIUM;
	case AFSVL_ENTDELETED:		return -ENOMEDIUM;
	case AFSVL_BADNAME:		return -EINVAL;
	case AFSVL_BADINDEX:		return -EINVAL;
	case AFSVL_BADVOLTYPE:		return -EINVAL;
	case AFSVL_BADSERVER:		return -EINVAL;
	case AFSVL_BADPARTITION:	return -EINVAL;
	case AFSVL_REPSFULL:		return -EFBIG;
	case AFSVL_NOREPSERVER:		return -ENOENT;
	case AFSVL_DUPREPSERVER:	return -EEXIST;
	case AFSVL_RWNOTFOUND:		return -ENOENT;
	case AFSVL_BADREFCOUNT:		return -EINVAL;
	case AFSVL_SIZEEXCEEDED:	return -EINVAL;
	case AFSVL_BADENTRY:		return -EINVAL;
	case AFSVL_BADVOLIDBUMP:	return -EINVAL;
	case AFSVL_IDALREADYHASHED:	return -EINVAL;
	case AFSVL_ENTRYLOCKED:		return -EBUSY;
	case AFSVL_BADVOLOPER:		return -EBADRQC;
	case AFSVL_BADRELLOCKTYPE:	return -EINVAL;
	case AFSVL_RERELEASE:		return -EREMOTEIO;
	case AFSVL_BADSERVERFLAG:	return -EINVAL;
	case AFSVL_PERM:		return -EACCES;
	case AFSVL_NOMEM:		return -EREMOTEIO;
	default:
		return afs_abort_to_error(abort_code);
	}
}

/*
 * deliver reply data to a VL.GetEntryByXXX call
 */
static int afs_deliver_vl_get_entry_by_xxx(struct afs_call *call,
					   struct sk_buff *skb, bool last)
{
	struct afs_cache_vlocation *entry;
	__be32 *bp;
	u32 tmp;
	int loop;

	_enter(",,%u", last);

	afs_transfer_reply(call, skb);
	if (!last)
		return 0;

	if (call->reply_size != call->reply_max)
		return -EBADMSG;

	/* unmarshall the reply once we've received all of it */
	entry = call->reply;
	bp = call->buffer;

	for (loop = 0; loop < 64; loop++)
		entry->name[loop] = ntohl(*bp++);
	entry->name[loop] = 0;
	bp++; /* final NUL */

	bp++; /* type */
	entry->nservers = ntohl(*bp++);

	for (loop = 0; loop < 8; loop++)
		entry->servers[loop].s_addr = *bp++;

	bp += 8; /* partition IDs */

	for (loop = 0; loop < 8; loop++) {
		tmp = ntohl(*bp++);
		entry->srvtmask[loop] = 0;
		if (tmp & AFS_VLSF_RWVOL)
			entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
		if (tmp & AFS_VLSF_ROVOL)
			entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
		if (tmp & AFS_VLSF_BACKVOL)
			entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
	}

	entry->vid[0] = ntohl(*bp++);
	entry->vid[1] = ntohl(*bp++);
	entry->vid[2] = ntohl(*bp++);

	bp++; /* clone ID */

	tmp = ntohl(*bp++); /* flags */
	entry->vidmask = 0;
	if (tmp & AFS_VLF_RWEXISTS)
		entry->vidmask |= AFS_VOL_VTM_RW;
	if (tmp & AFS_VLF_ROEXISTS)
		entry->vidmask |= AFS_VOL_VTM_RO;
	if (tmp & AFS_VLF_BACKEXISTS)
		entry->vidmask |= AFS_VOL_VTM_BAK;
	if (!entry->vidmask)
		return -EBADMSG;

	_leave(" = 0 [done]");
	return 0;
}

/*
 * VL.GetEntryByName operation type
 */
static const struct afs_call_type afs_RXVLGetEntryByName = {
	.name		= "VL.GetEntryByName",
	.deliver	= afs_deliver_vl_get_entry_by_xxx,
	.abort_to_error	= afs_vl_abort_to_error,
	.destructor	= afs_flat_call_destructor,
};

/*
 * VL.GetEntryById operation type
 */
static const struct afs_call_type afs_RXVLGetEntryById = {
	.name		= "VL.GetEntryById",
	.deliver	= afs_deliver_vl_get_entry_by_xxx,
	.abort_to_error	= afs_vl_abort_to_error,
	.destructor	= afs_flat_call_destructor,
};

/*
 * dispatch a get volume entry by name operation
 */
int afs_vl_get_entry_by_name(struct in_addr *addr,
			     struct key *key,
			     const char *volname,
			     struct afs_cache_vlocation *entry,
			     const struct afs_wait_mode *wait_mode)
{
	struct afs_call *call;
	size_t volnamesz, reqsz, padsz;
	__be32 *bp;

	_enter("");

	volnamesz = strlen(volname);
	padsz = (4 - (volnamesz & 3)) & 3;
	reqsz = 8 + volnamesz + padsz;

	call = afs_alloc_flat_call(&afs_RXVLGetEntryByName, reqsz, 384);
	if (!call)
		return -ENOMEM;

	call->key = key;
	call->reply = entry;
	call->service_id = VL_SERVICE;
	call->port = htons(AFS_VL_PORT);

	/* marshall the parameters */
	bp = call->request;
	*bp++ = htonl(VLGETENTRYBYNAME);
	*bp++ = htonl(volnamesz);
	memcpy(bp, volname, volnamesz);
	if (padsz > 0)
		memset((void *) bp + volnamesz, 0, padsz);

	/* initiate the call */
	return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
}

/*
 * dispatch a get volume entry by ID operation
 */
int afs_vl_get_entry_by_id(struct in_addr *addr,
			   struct key *key,
			   afs_volid_t volid,
			   afs_voltype_t voltype,
			   struct afs_cache_vlocation *entry,
			   const struct afs_wait_mode *wait_mode)
{
	struct afs_call *call;
	__be32 *bp;

	_enter("");

	call = afs_alloc_flat_call(&afs_RXVLGetEntryById, 12, 384);
	if (!call)
		return -ENOMEM;

	call->key = key;
	call->reply = entry;
	call->service_id = VL_SERVICE;
	call->port = htons(AFS_VL_PORT);

	/* marshall the parameters */
	bp = call->request;
	*bp++ = htonl(VLGETENTRYBYID);
	*bp++ = htonl(volid);
	*bp   = htonl(voltype);

	/* initiate the call */
	return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
}
Commit	Line	Data
ec26815a	1	/* AFS Volume Location Service client
1da177e4 LT	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
5a0e3ad6	12	#include <linux/gfp.h>
1da177e4 LT	13	#include <linux/init.h>
1da177e4 LT	14	#include <linux/sched.h>
1da177e4 LT	15	#include "internal.h"
1da177e4 LT	16
1da177e4	17	/*
08e0e7c8	18	* map volume locator abort codes to error codes
1da177e4	19	*/
08e0e7c8	20	static int afs_vl_abort_to_error(u32 abort_code)
1da177e4	21	{
08e0e7c8 DH	22	_enter("%u", abort_code);
	23
	24	switch (abort_code) {
	25	case AFSVL_IDEXIST: return -EEXIST;
	26	case AFSVL_IO: return -EREMOTEIO;
	27	case AFSVL_NAMEEXIST: return -EEXIST;
	28	case AFSVL_CREATEFAIL: return -EREMOTEIO;
	29	case AFSVL_NOENT: return -ENOMEDIUM;
	30	case AFSVL_EMPTY: return -ENOMEDIUM;
	31	case AFSVL_ENTDELETED: return -ENOMEDIUM;
	32	case AFSVL_BADNAME: return -EINVAL;
	33	case AFSVL_BADINDEX: return -EINVAL;
	34	case AFSVL_BADVOLTYPE: return -EINVAL;
	35	case AFSVL_BADSERVER: return -EINVAL;
	36	case AFSVL_BADPARTITION: return -EINVAL;
	37	case AFSVL_REPSFULL: return -EFBIG;
	38	case AFSVL_NOREPSERVER: return -ENOENT;
	39	case AFSVL_DUPREPSERVER: return -EEXIST;
	40	case AFSVL_RWNOTFOUND: return -ENOENT;
	41	case AFSVL_BADREFCOUNT: return -EINVAL;
	42	case AFSVL_SIZEEXCEEDED: return -EINVAL;
	43	case AFSVL_BADENTRY: return -EINVAL;
	44	case AFSVL_BADVOLIDBUMP: return -EINVAL;
	45	case AFSVL_IDALREADYHASHED: return -EINVAL;
	46	case AFSVL_ENTRYLOCKED: return -EBUSY;
	47	case AFSVL_BADVOLOPER: return -EBADRQC;
	48	case AFSVL_BADRELLOCKTYPE: return -EINVAL;
	49	case AFSVL_RERELEASE: return -EREMOTEIO;
	50	case AFSVL_BADSERVERFLAG: return -EINVAL;
	51	case AFSVL_PERM: return -EACCES;
	52	case AFSVL_NOMEM: return -EREMOTEIO;
1da177e4	53	default:
08e0e7c8	54	return afs_abort_to_error(abort_code);
1da177e4	55	}
ec26815a	56	}
1da177e4	57
1da177e4	58	/*
08e0e7c8	59	* deliver reply data to a VL.GetEntryByXXX call
1da177e4	60	*/
08e0e7c8 DH	61	static int afs_deliver_vl_get_entry_by_xxx(struct afs_call *call,
08e0e7c8 DH	62	struct sk_buff *skb, bool last)
1da177e4	63	{
08e0e7c8 DH	64	struct afs_cache_vlocation *entry;
	65	__be32 *bp;
	66	u32 tmp;
	67	int loop;
1da177e4	68
08e0e7c8	69	_enter(",,%u", last);
1da177e4	70
08e0e7c8 DH	71	afs_transfer_reply(call, skb);
	72	if (!last)
	73	return 0;
1da177e4	74
08e0e7c8 DH	75	if (call->reply_size != call->reply_max)
08e0e7c8 DH	76	return -EBADMSG;
1da177e4	77
08e0e7c8 DH	78	/* unmarshall the reply once we've received all of it */
	79	entry = call->reply;
	80	bp = call->buffer;
1da177e4	81
1da177e4 LT	82	for (loop = 0; loop < 64; loop++)
1da177e4 LT	83	entry->name[loop] = ntohl(*bp++);
08e0e7c8	84	entry->name[loop] = 0;
1da177e4 LT	85	bp++; /* final NUL */
	86
	87	bp++; /* type */
	88	entry->nservers = ntohl(*bp++);
	89
	90	for (loop = 0; loop < 8; loop++)
	91	entry->servers[loop].s_addr = *bp++;
	92
	93	bp += 8; /* partition IDs */
	94
	95	for (loop = 0; loop < 8; loop++) {
	96	tmp = ntohl(*bp++);
08e0e7c8	97	entry->srvtmask[loop] = 0;
1da177e4 LT	98	if (tmp & AFS_VLSF_RWVOL)
	99	entry->srvtmask[loop] \|= AFS_VOL_VTM_RW;
	100	if (tmp & AFS_VLSF_ROVOL)
	101	entry->srvtmask[loop] \|= AFS_VOL_VTM_RO;
	102	if (tmp & AFS_VLSF_BACKVOL)
	103	entry->srvtmask[loop] \|= AFS_VOL_VTM_BAK;
	104	}
	105
	106	entry->vid[0] = ntohl(*bp++);
	107	entry->vid[1] = ntohl(*bp++);
	108	entry->vid[2] = ntohl(*bp++);
	109
	110	bp++; /* clone ID */
	111
	112	tmp = ntohl(bp++); / flags */
08e0e7c8	113	entry->vidmask = 0;
1da177e4 LT	114	if (tmp & AFS_VLF_RWEXISTS)
	115	entry->vidmask \|= AFS_VOL_VTM_RW;
	116	if (tmp & AFS_VLF_ROEXISTS)
	117	entry->vidmask \|= AFS_VOL_VTM_RO;
	118	if (tmp & AFS_VLF_BACKEXISTS)
	119	entry->vidmask \|= AFS_VOL_VTM_BAK;
1da177e4	120	if (!entry->vidmask)
08e0e7c8 DH	121	return -EBADMSG;
	122
	123	_leave(" = 0 [done]");
	124	return 0;
ec26815a	125	}
1da177e4	126
1da177e4	127	/*
08e0e7c8	128	* VL.GetEntryByName operation type
1da177e4	129	*/
08e0e7c8	130	static const struct afs_call_type afs_RXVLGetEntryByName = {
00d3b7a4	131	.name = "VL.GetEntryByName",
08e0e7c8 DH	132	.deliver = afs_deliver_vl_get_entry_by_xxx,
	133	.abort_to_error = afs_vl_abort_to_error,
	134	.destructor = afs_flat_call_destructor,
	135	};
1da177e4	136
08e0e7c8 DH	137	/*
	138	* VL.GetEntryById operation type
	139	*/
	140	static const struct afs_call_type afs_RXVLGetEntryById = {
00d3b7a4	141	.name = "VL.GetEntryById",
08e0e7c8 DH	142	.deliver = afs_deliver_vl_get_entry_by_xxx,
	143	.abort_to_error = afs_vl_abort_to_error,
	144	.destructor = afs_flat_call_destructor,
	145	};
1da177e4	146
1da177e4	147	/*
08e0e7c8	148	* dispatch a get volume entry by name operation
1da177e4	149	*/
08e0e7c8	150	int afs_vl_get_entry_by_name(struct in_addr *addr,
00d3b7a4	151	struct key *key,
08e0e7c8 DH	152	const char *volname,
	153	struct afs_cache_vlocation *entry,
	154	const struct afs_wait_mode *wait_mode)
1da177e4	155	{
08e0e7c8 DH	156	struct afs_call *call;
	157	size_t volnamesz, reqsz, padsz;
	158	__be32 *bp;
1da177e4	159
08e0e7c8	160	_enter("");
1da177e4	161
08e0e7c8 DH	162	volnamesz = strlen(volname);
	163	padsz = (4 - (volnamesz & 3)) & 3;
	164	reqsz = 8 + volnamesz + padsz;
1da177e4	165
08e0e7c8 DH	166	call = afs_alloc_flat_call(&afs_RXVLGetEntryByName, reqsz, 384);
	167	if (!call)
	168	return -ENOMEM;
1da177e4	169
00d3b7a4	170	call->key = key;
08e0e7c8 DH	171	call->reply = entry;
	172	call->service_id = VL_SERVICE;
	173	call->port = htons(AFS_VL_PORT);
1da177e4 LT	174
1da177e4 LT	175	/* marshall the parameters */
08e0e7c8 DH	176	bp = call->request;
	177	*bp++ = htonl(VLGETENTRYBYNAME);
	178	*bp++ = htonl(volnamesz);
	179	memcpy(bp, volname, volnamesz);
	180	if (padsz > 0)
	181	memset((void *) bp + volnamesz, 0, padsz);
	182
	183	/* initiate the call */
	184	return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
ec26815a	185	}
1da177e4	186
1da177e4	187	/*
08e0e7c8	188	* dispatch a get volume entry by ID operation
1da177e4	189	*/
08e0e7c8	190	int afs_vl_get_entry_by_id(struct in_addr *addr,
00d3b7a4	191	struct key *key,
08e0e7c8 DH	192	afs_volid_t volid,
	193	afs_voltype_t voltype,
	194	struct afs_cache_vlocation *entry,
	195	const struct afs_wait_mode *wait_mode)
1da177e4	196	{
08e0e7c8	197	struct afs_call *call;
1da177e4	198	__be32 *bp;
1da177e4	199
08e0e7c8	200	_enter("");
1da177e4	201
08e0e7c8 DH	202	call = afs_alloc_flat_call(&afs_RXVLGetEntryById, 12, 384);
	203	if (!call)
	204	return -ENOMEM;
1da177e4	205
00d3b7a4	206	call->key = key;
08e0e7c8 DH	207	call->reply = entry;
	208	call->service_id = VL_SERVICE;
	209	call->port = htons(AFS_VL_PORT);
1da177e4	210
08e0e7c8 DH	211	/* marshall the parameters */
	212	bp = call->request;
	213	*bp++ = htonl(VLGETENTRYBYID);
	214	*bp++ = htonl(volid);
	215	*bp = htonl(voltype);
1da177e4	216
08e0e7c8 DH	217	/* initiate the call */
08e0e7c8 DH	218	return afs_make_call(addr, call, GFP_KERNEL, wait_mode);
ec26815a	219	}