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