[linux.git] / fs / afs / cmservice.c

/* AFS Cache Manager Service
 *
 * Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells ([email protected])
 *
 * 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/module.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/ip.h>
#include "internal.h"
#include "afs_cm.h"

#if 0
struct workqueue_struct *afs_cm_workqueue;
#endif  /*  0  */

static int afs_deliver_cb_init_call_back_state(struct afs_call *,
					       struct sk_buff *, bool);
static int afs_deliver_cb_init_call_back_state3(struct afs_call *,
						struct sk_buff *, bool);
static int afs_deliver_cb_probe(struct afs_call *, struct sk_buff *, bool);
static int afs_deliver_cb_callback(struct afs_call *, struct sk_buff *, bool);
static int afs_deliver_cb_probe_uuid(struct afs_call *, struct sk_buff *, bool);
static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *,
						 struct sk_buff *, bool);
static void afs_cm_destructor(struct afs_call *);

/*
 * CB.CallBack operation type
 */
static const struct afs_call_type afs_SRXCBCallBack = {
	.name		= "CB.CallBack",
	.deliver	= afs_deliver_cb_callback,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * CB.InitCallBackState operation type
 */
static const struct afs_call_type afs_SRXCBInitCallBackState = {
	.name		= "CB.InitCallBackState",
	.deliver	= afs_deliver_cb_init_call_back_state,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * CB.InitCallBackState3 operation type
 */
static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
	.name		= "CB.InitCallBackState3",
	.deliver	= afs_deliver_cb_init_call_back_state3,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * CB.Probe operation type
 */
static const struct afs_call_type afs_SRXCBProbe = {
	.name		= "CB.Probe",
	.deliver	= afs_deliver_cb_probe,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * CB.ProbeUuid operation type
 */
static const struct afs_call_type afs_SRXCBProbeUuid = {
	.name		= "CB.ProbeUuid",
	.deliver	= afs_deliver_cb_probe_uuid,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * CB.TellMeAboutYourself operation type
 */
static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
	.name		= "CB.TellMeAboutYourself",
	.deliver	= afs_deliver_cb_tell_me_about_yourself,
	.abort_to_error	= afs_abort_to_error,
	.destructor	= afs_cm_destructor,
};

/*
 * route an incoming cache manager call
 * - return T if supported, F if not
 */
bool afs_cm_incoming_call(struct afs_call *call)
{
	u32 operation_id = ntohl(call->operation_ID);

	_enter("{CB.OP %u}", operation_id);

	switch (operation_id) {
	case CBCallBack:
		call->type = &afs_SRXCBCallBack;
		return true;
	case CBInitCallBackState:
		call->type = &afs_SRXCBInitCallBackState;
		return true;
	case CBInitCallBackState3:
		call->type = &afs_SRXCBInitCallBackState3;
		return true;
	case CBProbe:
		call->type = &afs_SRXCBProbe;
		return true;
	case CBTellMeAboutYourself:
		call->type = &afs_SRXCBTellMeAboutYourself;
		return true;
	default:
		return false;
	}
}

/*
 * clean up a cache manager call
 */
static void afs_cm_destructor(struct afs_call *call)
{
	_enter("");

	afs_put_server(call->server);
	call->server = NULL;
	kfree(call->buffer);
	call->buffer = NULL;
}

/*
 * allow the fileserver to see if the cache manager is still alive
 */
static void SRXAFSCB_CallBack(struct work_struct *work)
{
	struct afs_call *call = container_of(work, struct afs_call, work);

	_enter("");

	/* be sure to send the reply *before* attempting to spam the AFS server
	 * with FSFetchStatus requests on the vnodes with broken callbacks lest
	 * the AFS server get into a vicious cycle of trying to break further
	 * callbacks because it hadn't received completion of the CBCallBack op
	 * yet */
	afs_send_empty_reply(call);

	afs_break_callbacks(call->server, call->count, call->request);
	_leave("");
}

/*
 * deliver request data to a CB.CallBack call
 */
static int afs_deliver_cb_callback(struct afs_call *call, struct sk_buff *skb,
				   bool last)
{
	struct afs_callback *cb;
	struct afs_server *server;
	struct in_addr addr;
	__be32 *bp;
	u32 tmp;
	int ret, loop;

	_enter("{%u},{%u},%d", call->unmarshall, skb->len, last);

	switch (call->unmarshall) {
	case 0:
		call->offset = 0;
		call->unmarshall++;

		/* extract the FID array and its count in two steps */
	case 1:
		_debug("extract FID count");
		ret = afs_extract_data(call, skb, last, &call->tmp, 4);
		switch (ret) {
		case 0:		break;
		case -EAGAIN:	return 0;
		default:	return ret;
		}

		call->count = ntohl(call->tmp);
		_debug("FID count: %u", call->count);
		if (call->count > AFSCBMAX)
			return -EBADMSG;

		call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
		if (!call->buffer)
			return -ENOMEM;
		call->offset = 0;
		call->unmarshall++;

	case 2:
		_debug("extract FID array");
		ret = afs_extract_data(call, skb, last, call->buffer,
				       call->count * 3 * 4);
		switch (ret) {
		case 0:		break;
		case -EAGAIN:	return 0;
		default:	return ret;
		}

		_debug("unmarshall FID array");
		call->request = kcalloc(call->count,
					sizeof(struct afs_callback),
					GFP_KERNEL);
		if (!call->request)
			return -ENOMEM;

		cb = call->request;
		bp = call->buffer;
		for (loop = call->count; loop > 0; loop--, cb++) {
			cb->fid.vid	= ntohl(*bp++);
			cb->fid.vnode	= ntohl(*bp++);
			cb->fid.unique	= ntohl(*bp++);
			cb->type	= AFSCM_CB_UNTYPED;
		}

		call->offset = 0;
		call->unmarshall++;

		/* extract the callback array and its count in two steps */
	case 3:
		_debug("extract CB count");
		ret = afs_extract_data(call, skb, last, &call->tmp, 4);
		switch (ret) {
		case 0:		break;
		case -EAGAIN:	return 0;
		default:	return ret;
		}

		tmp = ntohl(call->tmp);
		_debug("CB count: %u", tmp);
		if (tmp != call->count && tmp != 0)
			return -EBADMSG;
		call->offset = 0;
		call->unmarshall++;
		if (tmp == 0)
			goto empty_cb_array;

	case 4:
		_debug("extract CB array");
		ret = afs_extract_data(call, skb, last, call->request,
				       call->count * 3 * 4);
		switch (ret) {
		case 0:		break;
		case -EAGAIN:	return 0;
		default:	return ret;
		}

		_debug("unmarshall CB array");
		cb = call->request;
		bp = call->buffer;
		for (loop = call->count; loop > 0; loop--, cb++) {
			cb->version	= ntohl(*bp++);
			cb->expiry	= ntohl(*bp++);
			cb->type	= ntohl(*bp++);
		}

	empty_cb_array:
		call->offset = 0;
		call->unmarshall++;

	case 5:
		_debug("trailer");
		if (skb->len != 0)
			return -EBADMSG;
		break;
	}

	if (!last)
		return 0;

	call->state = AFS_CALL_REPLYING;

	/* we'll need the file server record as that tells us which set of
	 * vnodes to operate upon */
	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	server = afs_find_server(&addr);
	if (!server)
		return -ENOTCONN;
	call->server = server;

	INIT_WORK(&call->work, SRXAFSCB_CallBack);
	schedule_work(&call->work);
	return 0;
}

/*
 * allow the fileserver to request callback state (re-)initialisation
 */
static void SRXAFSCB_InitCallBackState(struct work_struct *work)
{
	struct afs_call *call = container_of(work, struct afs_call, work);

	_enter("{%p}", call->server);

	afs_init_callback_state(call->server);
	afs_send_empty_reply(call);
	_leave("");
}

/*
 * deliver request data to a CB.InitCallBackState call
 */
static int afs_deliver_cb_init_call_back_state(struct afs_call *call,
					       struct sk_buff *skb,
					       bool last)
{
	struct afs_server *server;
	struct in_addr addr;

	_enter(",{%u},%d", skb->len, last);

	if (skb->len > 0)
		return -EBADMSG;
	if (!last)
		return 0;

	/* no unmarshalling required */
	call->state = AFS_CALL_REPLYING;

	/* we'll need the file server record as that tells us which set of
	 * vnodes to operate upon */
	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	server = afs_find_server(&addr);
	if (!server)
		return -ENOTCONN;
	call->server = server;

	INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
	schedule_work(&call->work);
	return 0;
}

/*
 * deliver request data to a CB.InitCallBackState3 call
 */
static int afs_deliver_cb_init_call_back_state3(struct afs_call *call,
						struct sk_buff *skb,
						bool last)
{
	struct afs_server *server;
	struct in_addr addr;

	_enter(",{%u},%d", skb->len, last);

	if (!last)
		return 0;

	/* no unmarshalling required */
	call->state = AFS_CALL_REPLYING;

	/* we'll need the file server record as that tells us which set of
	 * vnodes to operate upon */
	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	server = afs_find_server(&addr);
	if (!server)
		return -ENOTCONN;
	call->server = server;

	INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
	schedule_work(&call->work);
	return 0;
}

/*
 * allow the fileserver to see if the cache manager is still alive
 */
static void SRXAFSCB_Probe(struct work_struct *work)
{
	struct afs_call *call = container_of(work, struct afs_call, work);

	_enter("");
	afs_send_empty_reply(call);
	_leave("");
}

/*
 * deliver request data to a CB.Probe call
 */
static int afs_deliver_cb_probe(struct afs_call *call, struct sk_buff *skb,
				bool last)
{
	_enter(",{%u},%d", skb->len, last);

	if (skb->len > 0)
		return -EBADMSG;
	if (!last)
		return 0;

	/* no unmarshalling required */
	call->state = AFS_CALL_REPLYING;

	INIT_WORK(&call->work, SRXAFSCB_Probe);
	schedule_work(&call->work);
	return 0;
}

/*
 * allow the fileserver to quickly find out if the fileserver has been rebooted
 */
static void SRXAFSCB_ProbeUuid(struct work_struct *work)
{
	struct afs_call *call = container_of(work, struct afs_call, work);
	struct afs_uuid *r = call->request;

	struct {
		__be32	match;
	} reply;

	_enter("");


	if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
		reply.match = htonl(0);
	else
		reply.match = htonl(1);

	afs_send_simple_reply(call, &reply, sizeof(reply));
	_leave("");
}

/*
 * deliver request data to a CB.ProbeUuid call
 */
static int afs_deliver_cb_probe_uuid(struct afs_call *call, struct sk_buff *skb,
				     bool last)
{
	struct afs_uuid *r;
	unsigned loop;
	__be32 *b;
	int ret;

	_enter("{%u},{%u},%d", call->unmarshall, skb->len, last);

	if (skb->len > 0)
		return -EBADMSG;
	if (!last)
		return 0;

	switch (call->unmarshall) {
	case 0:
		call->offset = 0;
		call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
		if (!call->buffer)
			return -ENOMEM;
		call->unmarshall++;

	case 1:
		_debug("extract UUID");
		ret = afs_extract_data(call, skb, last, call->buffer,
				       11 * sizeof(__be32));
		switch (ret) {
		case 0:		break;
		case -EAGAIN:	return 0;
		default:	return ret;
		}

		_debug("unmarshall UUID");
		call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
		if (!call->request)
			return -ENOMEM;

		b = call->buffer;
		r = call->request;
		r->time_low			= ntohl(b[0]);
		r->time_mid			= ntohl(b[1]);
		r->time_hi_and_version		= ntohl(b[2]);
		r->clock_seq_hi_and_reserved 	= ntohl(b[3]);
		r->clock_seq_low		= ntohl(b[4]);

		for (loop = 0; loop < 6; loop++)
			r->node[loop] = ntohl(b[loop + 5]);

		call->offset = 0;
		call->unmarshall++;

	case 2:
		_debug("trailer");
		if (skb->len != 0)
			return -EBADMSG;
		break;
	}

	if (!last)
		return 0;

	call->state = AFS_CALL_REPLYING;

	INIT_WORK(&call->work, SRXAFSCB_ProbeUuid);
	schedule_work(&call->work);
	return 0;
}

/*
 * allow the fileserver to ask about the cache manager's capabilities
 */
static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
{
	struct afs_interface *ifs;
	struct afs_call *call = container_of(work, struct afs_call, work);
	int loop, nifs;

	struct {
		struct /* InterfaceAddr */ {
			__be32 nifs;
			__be32 uuid[11];
			__be32 ifaddr[32];
			__be32 netmask[32];
			__be32 mtu[32];
		} ia;
		struct /* Capabilities */ {
			__be32 capcount;
			__be32 caps[1];
		} cap;
	} reply;

	_enter("");

	nifs = 0;
	ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
	if (ifs) {
		nifs = afs_get_ipv4_interfaces(ifs, 32, false);
		if (nifs < 0) {
			kfree(ifs);
			ifs = NULL;
			nifs = 0;
		}
	}

	memset(&reply, 0, sizeof(reply));
	reply.ia.nifs = htonl(nifs);

	reply.ia.uuid[0] = htonl(afs_uuid.time_low);
	reply.ia.uuid[1] = htonl(afs_uuid.time_mid);
	reply.ia.uuid[2] = htonl(afs_uuid.time_hi_and_version);
	reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved);
	reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low);
	for (loop = 0; loop < 6; loop++)
		reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]);

	if (ifs) {
		for (loop = 0; loop < nifs; loop++) {
			reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
			reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
			reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
		}
		kfree(ifs);
	}

	reply.cap.capcount = htonl(1);
	reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
	afs_send_simple_reply(call, &reply, sizeof(reply));

	_leave("");
}

/*
 * deliver request data to a CB.TellMeAboutYourself call
 */
static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call,
						 struct sk_buff *skb, bool last)
{
	_enter(",{%u},%d", skb->len, last);

	if (skb->len > 0)
		return -EBADMSG;
	if (!last)
		return 0;

	/* no unmarshalling required */
	call->state = AFS_CALL_REPLYING;

	INIT_WORK(&call->work, SRXAFSCB_TellMeAboutYourself);
	schedule_work(&call->work);
	return 0;
}
Commit	Line	Data
ec26815a	1	/* AFS Cache Manager Service
1da177e4 LT	2	*
	3	* Copyright (C) 2002 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells ([email protected])
	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/module.h>
	13	#include <linux/init.h>
	14	#include <linux/sched.h>
08e0e7c8	15	#include <linux/ip.h>
1da177e4	16	#include "internal.h"
08e0e7c8	17	#include "afs_cm.h"
1da177e4	18
c1206a2c	19	#if 0
08e0e7c8	20	struct workqueue_struct *afs_cm_workqueue;
c1206a2c	21	#endif /* 0 */
1da177e4	22
08e0e7c8 DH	23	static int afs_deliver_cb_init_call_back_state(struct afs_call *,
08e0e7c8 DH	24	struct sk_buff *, bool);
c35eccb1 DH	25	static int afs_deliver_cb_init_call_back_state3(struct afs_call *,
c35eccb1 DH	26	struct sk_buff *, bool);
08e0e7c8 DH	27	static int afs_deliver_cb_probe(struct afs_call , struct sk_buff , bool);
08e0e7c8 DH	28	static int afs_deliver_cb_callback(struct afs_call , struct sk_buff , bool);
9396d496	29	static int afs_deliver_cb_probe_uuid(struct afs_call , struct sk_buff , bool);
7c80bcce DH	30	static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *,
7c80bcce DH	31	struct sk_buff *, bool);
08e0e7c8	32	static void afs_cm_destructor(struct afs_call *);
1da177e4	33
1da177e4	34	/*
08e0e7c8	35	* CB.CallBack operation type
1da177e4	36	*/
08e0e7c8	37	static const struct afs_call_type afs_SRXCBCallBack = {
00d3b7a4	38	.name = "CB.CallBack",
08e0e7c8 DH	39	.deliver = afs_deliver_cb_callback,
	40	.abort_to_error = afs_abort_to_error,
	41	.destructor = afs_cm_destructor,
	42	};
1da177e4	43
1da177e4	44	/*
08e0e7c8	45	* CB.InitCallBackState operation type
1da177e4	46	*/
08e0e7c8	47	static const struct afs_call_type afs_SRXCBInitCallBackState = {
00d3b7a4	48	.name = "CB.InitCallBackState",
08e0e7c8 DH	49	.deliver = afs_deliver_cb_init_call_back_state,
	50	.abort_to_error = afs_abort_to_error,
	51	.destructor = afs_cm_destructor,
	52	};
1da177e4	53
c35eccb1 DH	54	/*
	55	* CB.InitCallBackState3 operation type
	56	*/
	57	static const struct afs_call_type afs_SRXCBInitCallBackState3 = {
	58	.name = "CB.InitCallBackState3",
	59	.deliver = afs_deliver_cb_init_call_back_state3,
	60	.abort_to_error = afs_abort_to_error,
	61	.destructor = afs_cm_destructor,
	62	};
	63
1da177e4	64	/*
08e0e7c8	65	* CB.Probe operation type
1da177e4	66	*/
08e0e7c8	67	static const struct afs_call_type afs_SRXCBProbe = {
00d3b7a4	68	.name = "CB.Probe",
08e0e7c8 DH	69	.deliver = afs_deliver_cb_probe,
	70	.abort_to_error = afs_abort_to_error,
	71	.destructor = afs_cm_destructor,
	72	};
1da177e4	73
9396d496 DH	74	/*
	75	* CB.ProbeUuid operation type
	76	*/
	77	static const struct afs_call_type afs_SRXCBProbeUuid = {
	78	.name = "CB.ProbeUuid",
	79	.deliver = afs_deliver_cb_probe_uuid,
	80	.abort_to_error = afs_abort_to_error,
	81	.destructor = afs_cm_destructor,
	82	};
	83
b908fe6b	84	/*
7c80bcce	85	* CB.TellMeAboutYourself operation type
b908fe6b	86	*/
7c80bcce DH	87	static const struct afs_call_type afs_SRXCBTellMeAboutYourself = {
	88	.name = "CB.TellMeAboutYourself",
	89	.deliver = afs_deliver_cb_tell_me_about_yourself,
b908fe6b DH	90	.abort_to_error = afs_abort_to_error,
	91	.destructor = afs_cm_destructor,
	92	};
	93
1da177e4	94	/*
08e0e7c8 DH	95	* route an incoming cache manager call
08e0e7c8 DH	96	* - return T if supported, F if not
1da177e4	97	*/
08e0e7c8	98	bool afs_cm_incoming_call(struct afs_call *call)
1da177e4	99	{
08e0e7c8 DH	100	u32 operation_id = ntohl(call->operation_ID);
	101
	102	_enter("{CB.OP %u}", operation_id);
	103
	104	switch (operation_id) {
	105	case CBCallBack:
	106	call->type = &afs_SRXCBCallBack;
	107	return true;
	108	case CBInitCallBackState:
	109	call->type = &afs_SRXCBInitCallBackState;
	110	return true;
c35eccb1 DH	111	case CBInitCallBackState3:
	112	call->type = &afs_SRXCBInitCallBackState3;
	113	return true;
08e0e7c8 DH	114	case CBProbe:
	115	call->type = &afs_SRXCBProbe;
	116	return true;
7c80bcce DH	117	case CBTellMeAboutYourself:
7c80bcce DH	118	call->type = &afs_SRXCBTellMeAboutYourself;
b908fe6b	119	return true;
08e0e7c8 DH	120	default:
08e0e7c8 DH	121	return false;
1da177e4	122	}
ec26815a	123	}
1da177e4	124
1da177e4	125	/*
08e0e7c8	126	* clean up a cache manager call
1da177e4	127	*/
08e0e7c8	128	static void afs_cm_destructor(struct afs_call *call)
1da177e4	129	{
08e0e7c8 DH	130	_enter("");
	131
	132	afs_put_server(call->server);
	133	call->server = NULL;
	134	kfree(call->buffer);
	135	call->buffer = NULL;
ec26815a	136	}
1da177e4	137
1da177e4	138	/*
08e0e7c8	139	* allow the fileserver to see if the cache manager is still alive
1da177e4	140	*/
08e0e7c8	141	static void SRXAFSCB_CallBack(struct work_struct *work)
1da177e4	142	{
08e0e7c8	143	struct afs_call *call = container_of(work, struct afs_call, work);
1da177e4	144
08e0e7c8	145	_enter("");
1da177e4	146
08e0e7c8 DH	147	/* be sure to send the reply before attempting to spam the AFS server
	148	* with FSFetchStatus requests on the vnodes with broken callbacks lest
	149	* the AFS server get into a vicious cycle of trying to break further
	150	* callbacks because it hadn't received completion of the CBCallBack op
	151	* yet */
	152	afs_send_empty_reply(call);
1da177e4	153
08e0e7c8 DH	154	afs_break_callbacks(call->server, call->count, call->request);
08e0e7c8 DH	155	_leave("");
ec26815a	156	}
1da177e4	157
1da177e4	158	/*
08e0e7c8	159	* deliver request data to a CB.CallBack call
1da177e4	160	*/
08e0e7c8 DH	161	static int afs_deliver_cb_callback(struct afs_call call, struct sk_buff skb,
08e0e7c8 DH	162	bool last)
1da177e4	163	{
08e0e7c8 DH	164	struct afs_callback *cb;
	165	struct afs_server *server;
	166	struct in_addr addr;
	167	__be32 *bp;
	168	u32 tmp;
	169	int ret, loop;
	170
	171	_enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
	172
	173	switch (call->unmarshall) {
	174	case 0:
	175	call->offset = 0;
	176	call->unmarshall++;
	177
	178	/* extract the FID array and its count in two steps */
	179	case 1:
	180	_debug("extract FID count");
	181	ret = afs_extract_data(call, skb, last, &call->tmp, 4);
	182	switch (ret) {
	183	case 0: break;
	184	case -EAGAIN: return 0;
	185	default: return ret;
1da177e4	186	}
1da177e4	187
08e0e7c8 DH	188	call->count = ntohl(call->tmp);
	189	_debug("FID count: %u", call->count);
	190	if (call->count > AFSCBMAX)
	191	return -EBADMSG;
	192
	193	call->buffer = kmalloc(call->count * 3 * 4, GFP_KERNEL);
	194	if (!call->buffer)
	195	return -ENOMEM;
	196	call->offset = 0;
	197	call->unmarshall++;
	198
	199	case 2:
	200	_debug("extract FID array");
	201	ret = afs_extract_data(call, skb, last, call->buffer,
	202	call->count * 3 * 4);
	203	switch (ret) {
	204	case 0: break;
	205	case -EAGAIN: return 0;
	206	default: return ret;
1da177e4	207	}
1da177e4	208
08e0e7c8 DH	209	_debug("unmarshall FID array");
	210	call->request = kcalloc(call->count,
	211	sizeof(struct afs_callback),
	212	GFP_KERNEL);
	213	if (!call->request)
	214	return -ENOMEM;
	215
	216	cb = call->request;
	217	bp = call->buffer;
	218	for (loop = call->count; loop > 0; loop--, cb++) {
	219	cb->fid.vid = ntohl(*bp++);
	220	cb->fid.vnode = ntohl(*bp++);
	221	cb->fid.unique = ntohl(*bp++);
	222	cb->type = AFSCM_CB_UNTYPED;
1da177e4 LT	223	}
1da177e4 LT	224
08e0e7c8 DH	225	call->offset = 0;
	226	call->unmarshall++;
	227
	228	/* extract the callback array and its count in two steps */
	229	case 3:
	230	_debug("extract CB count");
	231	ret = afs_extract_data(call, skb, last, &call->tmp, 4);
	232	switch (ret) {
	233	case 0: break;
	234	case -EAGAIN: return 0;
	235	default: return ret;
	236	}
1da177e4	237
08e0e7c8 DH	238	tmp = ntohl(call->tmp);
	239	_debug("CB count: %u", tmp);
	240	if (tmp != call->count && tmp != 0)
	241	return -EBADMSG;
	242	call->offset = 0;
	243	call->unmarshall++;
	244	if (tmp == 0)
	245	goto empty_cb_array;
	246
	247	case 4:
	248	_debug("extract CB array");
	249	ret = afs_extract_data(call, skb, last, call->request,
	250	call->count * 3 * 4);
	251	switch (ret) {
	252	case 0: break;
	253	case -EAGAIN: return 0;
	254	default: return ret;
1da177e4	255	}
1da177e4	256
08e0e7c8 DH	257	_debug("unmarshall CB array");
	258	cb = call->request;
	259	bp = call->buffer;
	260	for (loop = call->count; loop > 0; loop--, cb++) {
	261	cb->version = ntohl(*bp++);
	262	cb->expiry = ntohl(*bp++);
	263	cb->type = ntohl(*bp++);
	264	}
1da177e4	265
08e0e7c8 DH	266	empty_cb_array:
	267	call->offset = 0;
	268	call->unmarshall++;
1da177e4	269
08e0e7c8 DH	270	case 5:
	271	_debug("trailer");
	272	if (skb->len != 0)
	273	return -EBADMSG;
1da177e4 LT	274	break;
	275	}
	276
08e0e7c8 DH	277	if (!last)
08e0e7c8 DH	278	return 0;
1da177e4	279
08e0e7c8	280	call->state = AFS_CALL_REPLYING;
1da177e4	281
08e0e7c8 DH	282	/* we'll need the file server record as that tells us which set of
	283	* vnodes to operate upon */
	284	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	285	server = afs_find_server(&addr);
	286	if (!server)
	287	return -ENOTCONN;
	288	call->server = server;
	289
	290	INIT_WORK(&call->work, SRXAFSCB_CallBack);
	291	schedule_work(&call->work);
	292	return 0;
ec26815a	293	}
1da177e4	294
1da177e4	295	/*
08e0e7c8	296	* allow the fileserver to request callback state (re-)initialisation
1da177e4	297	*/
08e0e7c8	298	static void SRXAFSCB_InitCallBackState(struct work_struct *work)
1da177e4	299	{
08e0e7c8	300	struct afs_call *call = container_of(work, struct afs_call, work);
1da177e4	301
08e0e7c8	302	_enter("{%p}", call->server);
1da177e4	303
08e0e7c8 DH	304	afs_init_callback_state(call->server);
	305	afs_send_empty_reply(call);
	306	_leave("");
ec26815a	307	}
1da177e4	308
1da177e4	309	/*
08e0e7c8	310	* deliver request data to a CB.InitCallBackState call
1da177e4	311	*/
08e0e7c8 DH	312	static int afs_deliver_cb_init_call_back_state(struct afs_call *call,
	313	struct sk_buff *skb,
	314	bool last)
1da177e4 LT	315	{
1da177e4 LT	316	struct afs_server *server;
08e0e7c8	317	struct in_addr addr;
1da177e4	318
08e0e7c8	319	_enter(",{%u},%d", skb->len, last);
1da177e4	320
08e0e7c8 DH	321	if (skb->len > 0)
	322	return -EBADMSG;
	323	if (!last)
	324	return 0;
1da177e4	325
08e0e7c8 DH	326	/* no unmarshalling required */
08e0e7c8 DH	327	call->state = AFS_CALL_REPLYING;
1da177e4	328
08e0e7c8 DH	329	/* we'll need the file server record as that tells us which set of
	330	* vnodes to operate upon */
	331	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	332	server = afs_find_server(&addr);
	333	if (!server)
	334	return -ENOTCONN;
	335	call->server = server;
1da177e4	336
08e0e7c8 DH	337	INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
	338	schedule_work(&call->work);
	339	return 0;
	340	}
1da177e4	341
c35eccb1 DH	342	/*
	343	* deliver request data to a CB.InitCallBackState3 call
	344	*/
	345	static int afs_deliver_cb_init_call_back_state3(struct afs_call *call,
	346	struct sk_buff *skb,
	347	bool last)
	348	{
	349	struct afs_server *server;
	350	struct in_addr addr;
	351
	352	_enter(",{%u},%d", skb->len, last);
	353
	354	if (!last)
	355	return 0;
	356
	357	/* no unmarshalling required */
	358	call->state = AFS_CALL_REPLYING;
	359
	360	/* we'll need the file server record as that tells us which set of
	361	* vnodes to operate upon */
	362	memcpy(&addr, &ip_hdr(skb)->saddr, 4);
	363	server = afs_find_server(&addr);
	364	if (!server)
	365	return -ENOTCONN;
	366	call->server = server;
	367
	368	INIT_WORK(&call->work, SRXAFSCB_InitCallBackState);
	369	schedule_work(&call->work);
	370	return 0;
	371	}
	372
08e0e7c8 DH	373	/*
	374	* allow the fileserver to see if the cache manager is still alive
	375	*/
	376	static void SRXAFSCB_Probe(struct work_struct *work)
	377	{
	378	struct afs_call *call = container_of(work, struct afs_call, work);
1da177e4	379
08e0e7c8 DH	380	_enter("");
	381	afs_send_empty_reply(call);
	382	_leave("");
	383	}
1da177e4	384
08e0e7c8 DH	385	/*
	386	* deliver request data to a CB.Probe call
	387	*/
	388	static int afs_deliver_cb_probe(struct afs_call call, struct sk_buff skb,
	389	bool last)
	390	{
	391	_enter(",{%u},%d", skb->len, last);
1da177e4	392
08e0e7c8 DH	393	if (skb->len > 0)
	394	return -EBADMSG;
	395	if (!last)
	396	return 0;
1da177e4	397
08e0e7c8 DH	398	/* no unmarshalling required */
08e0e7c8 DH	399	call->state = AFS_CALL_REPLYING;
1da177e4	400
08e0e7c8 DH	401	INIT_WORK(&call->work, SRXAFSCB_Probe);
	402	schedule_work(&call->work);
	403	return 0;
ec26815a	404	}
b908fe6b	405
9396d496 DH	406	/*
	407	* allow the fileserver to quickly find out if the fileserver has been rebooted
	408	*/
	409	static void SRXAFSCB_ProbeUuid(struct work_struct *work)
	410	{
	411	struct afs_call *call = container_of(work, struct afs_call, work);
	412	struct afs_uuid *r = call->request;
	413
	414	struct {
	415	__be32 match;
	416	} reply;
	417
	418	_enter("");
	419
	420
	421	if (memcmp(r, &afs_uuid, sizeof(afs_uuid)) == 0)
	422	reply.match = htonl(0);
	423	else
	424	reply.match = htonl(1);
	425
	426	afs_send_simple_reply(call, &reply, sizeof(reply));
	427	_leave("");
	428	}
	429
	430	/*
	431	* deliver request data to a CB.ProbeUuid call
	432	*/
	433	static int afs_deliver_cb_probe_uuid(struct afs_call call, struct sk_buff skb,
	434	bool last)
	435	{
	436	struct afs_uuid *r;
	437	unsigned loop;
	438	__be32 *b;
	439	int ret;
	440
	441	_enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
	442
	443	if (skb->len > 0)
	444	return -EBADMSG;
	445	if (!last)
	446	return 0;
	447
	448	switch (call->unmarshall) {
	449	case 0:
	450	call->offset = 0;
	451	call->buffer = kmalloc(11 * sizeof(__be32), GFP_KERNEL);
	452	if (!call->buffer)
	453	return -ENOMEM;
	454	call->unmarshall++;
	455
	456	case 1:
	457	_debug("extract UUID");
	458	ret = afs_extract_data(call, skb, last, call->buffer,
	459	11 * sizeof(__be32));
	460	switch (ret) {
	461	case 0: break;
	462	case -EAGAIN: return 0;
	463	default: return ret;
	464	}
	465
	466	_debug("unmarshall UUID");
	467	call->request = kmalloc(sizeof(struct afs_uuid), GFP_KERNEL);
	468	if (!call->request)
	469	return -ENOMEM;
470
471	b = call->buffer;
472	r = call->request;
473	r->time_low = ntohl(b[0]);
474	r->time_mid = ntohl(b[1]);
475	r->time_hi_and_version = ntohl(b[2]);
476	r->clock_seq_hi_and_reserved = ntohl(b[3]);
477	r->clock_seq_low = ntohl(b[4]);
478
479	for (loop = 0; loop < 6; loop++)
480	r->node[loop] = ntohl(b[loop + 5]);
481
482	call->offset = 0;
483	call->unmarshall++;
484
485	case 2:
486	_debug("trailer");
487	if (skb->len != 0)
488	return -EBADMSG;
489	break;
490	}
491
492	if (!last)
493	return 0;
494
495	call->state = AFS_CALL_REPLYING;
496
497	INIT_WORK(&call->work, SRXAFSCB_ProbeUuid);
498	schedule_work(&call->work);
499	return 0;
500	}
501
b908fe6b DH	502	/*
	503	* allow the fileserver to ask about the cache manager's capabilities
	504	*/
7c80bcce	505	static void SRXAFSCB_TellMeAboutYourself(struct work_struct *work)
b908fe6b DH	506	{
	507	struct afs_interface *ifs;
	508	struct afs_call *call = container_of(work, struct afs_call, work);
	509	int loop, nifs;
	510
	511	struct {
	512	struct /* InterfaceAddr */ {
	513	__be32 nifs;
	514	__be32 uuid[11];
	515	__be32 ifaddr[32];
	516	__be32 netmask[32];
	517	__be32 mtu[32];
	518	} ia;
	519	struct /* Capabilities */ {
	520	__be32 capcount;
	521	__be32 caps[1];
	522	} cap;
	523	} reply;
	524
	525	_enter("");
	526
	527	nifs = 0;
	528	ifs = kcalloc(32, sizeof(*ifs), GFP_KERNEL);
	529	if (ifs) {
	530	nifs = afs_get_ipv4_interfaces(ifs, 32, false);
	531	if (nifs < 0) {
	532	kfree(ifs);
	533	ifs = NULL;
	534	nifs = 0;
	535	}
	536	}
	537
	538	memset(&reply, 0, sizeof(reply));
	539	reply.ia.nifs = htonl(nifs);
	540
	541	reply.ia.uuid[0] = htonl(afs_uuid.time_low);
	542	reply.ia.uuid[1] = htonl(afs_uuid.time_mid);
	543	reply.ia.uuid[2] = htonl(afs_uuid.time_hi_and_version);
	544	reply.ia.uuid[3] = htonl((s8) afs_uuid.clock_seq_hi_and_reserved);
	545	reply.ia.uuid[4] = htonl((s8) afs_uuid.clock_seq_low);
	546	for (loop = 0; loop < 6; loop++)
	547	reply.ia.uuid[loop + 5] = htonl((s8) afs_uuid.node[loop]);
	548
	549	if (ifs) {
	550	for (loop = 0; loop < nifs; loop++) {
	551	reply.ia.ifaddr[loop] = ifs[loop].address.s_addr;
	552	reply.ia.netmask[loop] = ifs[loop].netmask.s_addr;
	553	reply.ia.mtu[loop] = htonl(ifs[loop].mtu);
	554	}
5b35fad9	555	kfree(ifs);
b908fe6b DH	556	}
	557
	558	reply.cap.capcount = htonl(1);
	559	reply.cap.caps[0] = htonl(AFS_CAP_ERROR_TRANSLATION);
	560	afs_send_simple_reply(call, &reply, sizeof(reply));
	561
	562	_leave("");
	563	}
	564
	565	/*
7c80bcce	566	* deliver request data to a CB.TellMeAboutYourself call
b908fe6b	567	*/
7c80bcce DH	568	static int afs_deliver_cb_tell_me_about_yourself(struct afs_call *call,
7c80bcce DH	569	struct sk_buff *skb, bool last)
b908fe6b DH	570	{
	571	_enter(",{%u},%d", skb->len, last);
	572
	573	if (skb->len > 0)
	574	return -EBADMSG;
	575	if (!last)
	576	return 0;
	577
	578	/* no unmarshalling required */
	579	call->state = AFS_CALL_REPLYING;
	580
7c80bcce	581	INIT_WORK(&call->work, SRXAFSCB_TellMeAboutYourself);
b908fe6b DH	582	schedule_work(&call->work);
	583	return 0;
	584	}