[mirror_ubuntu-jammy-kernel.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 "afs_fs.h"
#include "internal.h"

/*
 * Deliver reply data to a VL.GetEntryByNameU call.
 */
static int afs_deliver_vl_get_entry_by_name_u(struct afs_call *call)
{
	struct afs_uvldbentry__xdr *uvldb;
	struct afs_vldb_entry *entry;
	bool new_only = false;
	u32 tmp, nr_servers, vlflags;
	int i, ret;

	_enter("");

	ret = afs_transfer_reply(call);
	if (ret < 0)
		return ret;

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

	nr_servers = ntohl(uvldb->nServers);
	if (nr_servers > AFS_NMAXNSERVERS)
		nr_servers = AFS_NMAXNSERVERS;

	for (i = 0; i < ARRAY_SIZE(uvldb->name) - 1; i++)
		entry->name[i] = (u8)ntohl(uvldb->name[i]);
	entry->name[i] = 0;
	entry->name_len = strlen(entry->name);

	/* If there is a new replication site that we can use, ignore all the
	 * sites that aren't marked as new.
	 */
	for (i = 0; i < nr_servers; i++) {
		tmp = ntohl(uvldb->serverFlags[i]);
		if (!(tmp & AFS_VLSF_DONTUSE) &&
		    (tmp & AFS_VLSF_NEWREPSITE))
			new_only = true;
	}

	vlflags = ntohl(uvldb->flags);
	for (i = 0; i < nr_servers; i++) {
		struct afs_uuid__xdr *xdr;
		struct afs_uuid *uuid;
		int j;

		tmp = ntohl(uvldb->serverFlags[i]);
		if (tmp & AFS_VLSF_DONTUSE ||
		    (new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
			continue;
		if (tmp & AFS_VLSF_RWVOL) {
			entry->fs_mask[i] |= AFS_VOL_VTM_RW;
			if (vlflags & AFS_VLF_BACKEXISTS)
				entry->fs_mask[i] |= AFS_VOL_VTM_BAK;
		}
		if (tmp & AFS_VLSF_ROVOL)
			entry->fs_mask[i] |= AFS_VOL_VTM_RO;
		if (!entry->fs_mask[i])
			continue;

		xdr = &uvldb->serverNumber[i];
		uuid = (struct afs_uuid *)&entry->fs_server[i];
		uuid->time_low			= xdr->time_low;
		uuid->time_mid			= htons(ntohl(xdr->time_mid));
		uuid->time_hi_and_version	= htons(ntohl(xdr->time_hi_and_version));
		uuid->clock_seq_hi_and_reserved	= (u8)ntohl(xdr->clock_seq_hi_and_reserved);
		uuid->clock_seq_low		= (u8)ntohl(xdr->clock_seq_low);
		for (j = 0; j < 6; j++)
			uuid->node[j] = (u8)ntohl(xdr->node[j]);

		entry->nr_servers++;
	}

	for (i = 0; i < AFS_MAXTYPES; i++)
		entry->vid[i] = ntohl(uvldb->volumeId[i]);

	if (vlflags & AFS_VLF_RWEXISTS)
		__set_bit(AFS_VLDB_HAS_RW, &entry->flags);
	if (vlflags & AFS_VLF_ROEXISTS)
		__set_bit(AFS_VLDB_HAS_RO, &entry->flags);
	if (vlflags & AFS_VLF_BACKEXISTS)
		__set_bit(AFS_VLDB_HAS_BAK, &entry->flags);

	if (!(vlflags & (AFS_VLF_RWEXISTS | AFS_VLF_ROEXISTS | AFS_VLF_BACKEXISTS))) {
		entry->error = -ENOMEDIUM;
		__set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
	}

	__set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
	_leave(" = 0 [done]");
	return 0;
}

static void afs_destroy_vl_get_entry_by_name_u(struct afs_call *call)
{
	kfree(call->reply[0]);
	afs_flat_call_destructor(call);
}

/*
 * VL.GetEntryByNameU operation type.
 */
static const struct afs_call_type afs_RXVLGetEntryByNameU = {
	.name		= "VL.GetEntryByNameU",
	.op		= afs_VL_GetEntryByNameU,
	.deliver	= afs_deliver_vl_get_entry_by_name_u,
	.destructor	= afs_destroy_vl_get_entry_by_name_u,
};

/*
 * Dispatch a get volume entry by name or ID operation (uuid variant).  If the
 * volname is a decimal number then it's a volume ID not a volume name.
 */
struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *vc,
						  const char *volname,
						  int volnamesz)
{
	struct afs_vldb_entry *entry;
	struct afs_call *call;
	struct afs_net *net = vc->cell->net;
	size_t reqsz, padsz;
	__be32 *bp;

	_enter("");

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

	entry = kzalloc(sizeof(struct afs_vldb_entry), GFP_KERNEL);
	if (!entry)
		return ERR_PTR(-ENOMEM);

	call = afs_alloc_flat_call(net, &afs_RXVLGetEntryByNameU, reqsz,
				   sizeof(struct afs_uvldbentry__xdr));
	if (!call) {
		kfree(entry);
		return ERR_PTR(-ENOMEM);
	}

	call->key = vc->key;
	call->reply[0] = entry;
	call->ret_reply0 = true;

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

	trace_afs_make_vl_call(call);
	return (struct afs_vldb_entry *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
}

/*
 * Deliver reply data to a VL.GetAddrsU call.
 *
 *	GetAddrsU(IN ListAddrByAttributes *inaddr,
 *		  OUT afsUUID *uuidp1,
 *		  OUT uint32_t *uniquifier,
 *		  OUT uint32_t *nentries,
 *		  OUT bulkaddrs *blkaddrs);
 */
static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
{
	struct afs_addr_list *alist;
	__be32 *bp;
	u32 uniquifier, nentries, count;
	int i, ret;

	_enter("{%u,%zu/%u}",
	       call->unmarshall, iov_iter_count(call->_iter), call->count);

	switch (call->unmarshall) {
	case 0:
		afs_extract_to_buf(call,
				   sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
		call->unmarshall++;

		/* Extract the returned uuid, uniquifier, nentries and blkaddrs size */
	case 1:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		bp = call->buffer + sizeof(struct afs_uuid__xdr);
		uniquifier	= ntohl(*bp++);
		nentries	= ntohl(*bp++);
		count		= ntohl(*bp);

		nentries = min(nentries, count);
		alist = afs_alloc_addrlist(nentries, FS_SERVICE, AFS_FS_PORT);
		if (!alist)
			return -ENOMEM;
		alist->version = uniquifier;
		call->reply[0] = alist;
		call->count = count;
		call->count2 = nentries;
		call->unmarshall++;

	more_entries:
		count = min(call->count, 4U);
		afs_extract_to_buf(call, count * sizeof(__be32));

		/* Extract entries */
	case 2:
		ret = afs_extract_data(call, call->count > 4);
		if (ret < 0)
			return ret;

		alist = call->reply[0];
		bp = call->buffer;
		count = min(call->count, 4U);
		for (i = 0; i < count; i++)
			if (alist->nr_addrs < call->count2)
				afs_merge_fs_addr4(alist, *bp++, AFS_FS_PORT);

		call->count -= count;
		if (call->count > 0)
			goto more_entries;
		call->unmarshall++;
		break;
	}

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

static void afs_vl_get_addrs_u_destructor(struct afs_call *call)
{
	afs_put_server(call->net, (struct afs_server *)call->reply[0]);
	kfree(call->reply[1]);
	return afs_flat_call_destructor(call);
}

/*
 * VL.GetAddrsU operation type.
 */
static const struct afs_call_type afs_RXVLGetAddrsU = {
	.name		= "VL.GetAddrsU",
	.op		= afs_VL_GetAddrsU,
	.deliver	= afs_deliver_vl_get_addrs_u,
	.destructor	= afs_vl_get_addrs_u_destructor,
};

/*
 * Dispatch an operation to get the addresses for a server, where the server is
 * nominated by UUID.
 */
struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *vc,
					 const uuid_t *uuid)
{
	struct afs_ListAddrByAttributes__xdr *r;
	const struct afs_uuid *u = (const struct afs_uuid *)uuid;
	struct afs_call *call;
	struct afs_net *net = vc->cell->net;
	__be32 *bp;
	int i;

	_enter("");

	call = afs_alloc_flat_call(net, &afs_RXVLGetAddrsU,
				   sizeof(__be32) + sizeof(struct afs_ListAddrByAttributes__xdr),
				   sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
	if (!call)
		return ERR_PTR(-ENOMEM);

	call->key = vc->key;
	call->reply[0] = NULL;
	call->ret_reply0 = true;

	/* Marshall the parameters */
	bp = call->request;
	*bp++ = htonl(VLGETADDRSU);
	r = (struct afs_ListAddrByAttributes__xdr *)bp;
	r->Mask		= htonl(AFS_VLADDR_UUID);
	r->ipaddr	= 0;
	r->index	= 0;
	r->spare	= 0;
	r->uuid.time_low			= u->time_low;
	r->uuid.time_mid			= htonl(ntohs(u->time_mid));
	r->uuid.time_hi_and_version		= htonl(ntohs(u->time_hi_and_version));
	r->uuid.clock_seq_hi_and_reserved 	= htonl(u->clock_seq_hi_and_reserved);
	r->uuid.clock_seq_low			= htonl(u->clock_seq_low);
	for (i = 0; i < 6; i++)
		r->uuid.node[i] = htonl(u->node[i]);

	trace_afs_make_vl_call(call);
	return (struct afs_addr_list *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
}

/*
 * Deliver reply data to an VL.GetCapabilities operation.
 */
static int afs_deliver_vl_get_capabilities(struct afs_call *call)
{
	u32 count;
	int ret;

	_enter("{%u,%zu/%u}",
	       call->unmarshall, iov_iter_count(call->_iter), call->count);

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

		/* Extract the capabilities word count */
	case 1:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		count = ntohl(call->tmp);
		call->count = count;
		call->count2 = count;

		call->unmarshall++;
		afs_extract_discard(call, count * sizeof(__be32));

		/* Extract capabilities words */
	case 2:
		ret = afs_extract_data(call, false);
		if (ret < 0)
			return ret;

		/* TODO: Examine capabilities */

		call->unmarshall++;
		break;
	}

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

static void afs_destroy_vl_get_capabilities(struct afs_call *call)
{
	struct afs_vlserver *server = call->reply[0];

	afs_put_vlserver(call->net, server);
	afs_flat_call_destructor(call);
}

/*
 * VL.GetCapabilities operation type
 */
static const struct afs_call_type afs_RXVLGetCapabilities = {
	.name		= "VL.GetCapabilities",
	.op		= afs_VL_GetCapabilities,
	.deliver	= afs_deliver_vl_get_capabilities,
	.done		= afs_vlserver_probe_result,
	.destructor	= afs_destroy_vl_get_capabilities,
};

/*
 * Probe a volume server for the capabilities that it supports.  This can
 * return up to 196 words.
 *
 * We use this to probe for service upgrade to determine what the server at the
 * other end supports.
 */
int afs_vl_get_capabilities(struct afs_net *net,
			    struct afs_addr_cursor *ac,
			    struct key *key,
			    struct afs_vlserver *server,
			    unsigned int server_index,
			    bool async)
{
	struct afs_call *call;
	__be32 *bp;

	_enter("");

	call = afs_alloc_flat_call(net, &afs_RXVLGetCapabilities, 1 * 4, 16 * 4);
	if (!call)
		return -ENOMEM;

	call->key = key;
	call->reply[0] = afs_get_vlserver(server);
	call->reply[1] = (void *)(long)server_index;
	call->upgrade = true;
	call->want_reply_time = true;

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

	/* Can't take a ref on server */
	trace_afs_make_vl_call(call);
	return afs_make_call(ac, call, GFP_KERNEL, async);
}

/*
 * Deliver reply data to a YFSVL.GetEndpoints call.
 *
 *	GetEndpoints(IN yfsServerAttributes *attr,
 *		     OUT opr_uuid *uuid,
 *		     OUT afs_int32 *uniquifier,
 *		     OUT endpoints *fsEndpoints,
 *		     OUT endpoints *volEndpoints)
 */
static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
{
	struct afs_addr_list *alist;
	__be32 *bp;
	u32 uniquifier, size;
	int ret;

	_enter("{%u,%zu,%u}",
	       call->unmarshall, iov_iter_count(call->_iter), call->count2);

	switch (call->unmarshall) {
	case 0:
		afs_extract_to_buf(call, sizeof(uuid_t) + 3 * sizeof(__be32));
		call->unmarshall = 1;

		/* Extract the returned uuid, uniquifier, fsEndpoints count and
		 * either the first fsEndpoint type or the volEndpoints
		 * count if there are no fsEndpoints. */
	case 1:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		bp = call->buffer + sizeof(uuid_t);
		uniquifier	= ntohl(*bp++);
		call->count	= ntohl(*bp++);
		call->count2	= ntohl(*bp); /* Type or next count */

		if (call->count > YFS_MAXENDPOINTS)
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_fsendpt_num);

		alist = afs_alloc_addrlist(call->count, FS_SERVICE, AFS_FS_PORT);
		if (!alist)
			return -ENOMEM;
		alist->version = uniquifier;
		call->reply[0] = alist;

		if (call->count == 0)
			goto extract_volendpoints;

	next_fsendpoint:
		switch (call->count2) {
		case YFS_ENDPOINT_IPV4:
			size = sizeof(__be32) * (1 + 1 + 1);
			break;
		case YFS_ENDPOINT_IPV6:
			size = sizeof(__be32) * (1 + 4 + 1);
			break;
		default:
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_fsendpt_type);
		}

		size += sizeof(__be32);
		afs_extract_to_buf(call, size);
		call->unmarshall = 2;

		/* Extract fsEndpoints[] entries */
	case 2:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		alist = call->reply[0];
		bp = call->buffer;
		switch (call->count2) {
		case YFS_ENDPOINT_IPV4:
			if (ntohl(bp[0]) != sizeof(__be32) * 2)
				return afs_protocol_error(call, -EBADMSG,
							  afs_eproto_yvl_fsendpt4_len);
			afs_merge_fs_addr4(alist, bp[1], ntohl(bp[2]));
			bp += 3;
			break;
		case YFS_ENDPOINT_IPV6:
			if (ntohl(bp[0]) != sizeof(__be32) * 5)
				return afs_protocol_error(call, -EBADMSG,
							  afs_eproto_yvl_fsendpt6_len);
			afs_merge_fs_addr6(alist, bp + 1, ntohl(bp[5]));
			bp += 6;
			break;
		default:
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_fsendpt_type);
		}

		/* Got either the type of the next entry or the count of
		 * volEndpoints if no more fsEndpoints.
		 */
		call->count2 = ntohl(*bp++);

		call->count--;
		if (call->count > 0)
			goto next_fsendpoint;

	extract_volendpoints:
		/* Extract the list of volEndpoints. */
		call->count = call->count2;
		if (!call->count)
			goto end;
		if (call->count > YFS_MAXENDPOINTS)
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_vlendpt_type);

		afs_extract_to_buf(call, 1 * sizeof(__be32));
		call->unmarshall = 3;

		/* Extract the type of volEndpoints[0].  Normally we would
		 * extract the type of the next endpoint when we extract the
		 * data of the current one, but this is the first...
		 */
	case 3:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		bp = call->buffer;

	next_volendpoint:
		call->count2 = ntohl(*bp++);
		switch (call->count2) {
		case YFS_ENDPOINT_IPV4:
			size = sizeof(__be32) * (1 + 1 + 1);
			break;
		case YFS_ENDPOINT_IPV6:
			size = sizeof(__be32) * (1 + 4 + 1);
			break;
		default:
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_vlendpt_type);
		}

		if (call->count > 1)
			size += sizeof(__be32); /* Get next type too */
		afs_extract_to_buf(call, size);
		call->unmarshall = 4;

		/* Extract volEndpoints[] entries */
	case 4:
		ret = afs_extract_data(call, true);
		if (ret < 0)
			return ret;

		bp = call->buffer;
		switch (call->count2) {
		case YFS_ENDPOINT_IPV4:
			if (ntohl(bp[0]) != sizeof(__be32) * 2)
				return afs_protocol_error(call, -EBADMSG,
							  afs_eproto_yvl_vlendpt4_len);
			bp += 3;
			break;
		case YFS_ENDPOINT_IPV6:
			if (ntohl(bp[0]) != sizeof(__be32) * 5)
				return afs_protocol_error(call, -EBADMSG,
							  afs_eproto_yvl_vlendpt6_len);
			bp += 6;
			break;
		default:
			return afs_protocol_error(call, -EBADMSG,
						  afs_eproto_yvl_vlendpt_type);
		}

		/* Got either the type of the next entry or the count of
		 * volEndpoints if no more fsEndpoints.
		 */
		call->count--;
		if (call->count > 0)
			goto next_volendpoint;

	end:
		afs_extract_discard(call, 0);
		call->unmarshall = 5;

		/* Done */
	case 5:
		ret = afs_extract_data(call, false);
		if (ret < 0)
			return ret;
		call->unmarshall = 6;

	case 6:
		break;
	}

	alist = call->reply[0];
	_leave(" = 0 [done]");
	return 0;
}

/*
 * YFSVL.GetEndpoints operation type.
 */
static const struct afs_call_type afs_YFSVLGetEndpoints = {
	.name		= "YFSVL.GetEndpoints",
	.op		= afs_YFSVL_GetEndpoints,
	.deliver	= afs_deliver_yfsvl_get_endpoints,
	.destructor	= afs_vl_get_addrs_u_destructor,
};

/*
 * Dispatch an operation to get the addresses for a server, where the server is
 * nominated by UUID.
 */
struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *vc,
					      const uuid_t *uuid)
{
	struct afs_call *call;
	struct afs_net *net = vc->cell->net;
	__be32 *bp;

	_enter("");

	call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
				   sizeof(__be32) * 2 + sizeof(*uuid),
				   sizeof(struct in6_addr) + sizeof(__be32) * 3);
	if (!call)
		return ERR_PTR(-ENOMEM);

	call->key = vc->key;
	call->reply[0] = NULL;
	call->ret_reply0 = true;

	/* Marshall the parameters */
	bp = call->request;
	*bp++ = htonl(YVLGETENDPOINTS);
	*bp++ = htonl(YFS_SERVER_UUID);
	memcpy(bp, uuid, sizeof(*uuid)); /* Type opr_uuid */

	trace_afs_make_vl_call(call);
	return (struct afs_addr_list *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
}
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>
4d9df986	15	#include "afs_fs.h"
1da177e4 LT	16	#include "internal.h"
1da177e4 LT	17
1da177e4	18	/*
d2ddc776	19	* Deliver reply data to a VL.GetEntryByNameU call.
1da177e4	20	*/
d2ddc776	21	static int afs_deliver_vl_get_entry_by_name_u(struct afs_call *call)
1da177e4	22	{
d2ddc776 DH	23	struct afs_uvldbentry__xdr *uvldb;
	24	struct afs_vldb_entry *entry;
	25	bool new_only = false;
1fba5868	26	u32 tmp, nr_servers, vlflags;
d2ddc776	27	int i, ret;
1da177e4	28
d001648e	29	_enter("");
1da177e4	30
d001648e	31	ret = afs_transfer_reply(call);
372ee163 DH	32	if (ret < 0)
372ee163 DH	33	return ret;
1da177e4	34
08e0e7c8	35	/* unmarshall the reply once we've received all of it */
d2ddc776	36	uvldb = call->buffer;
97e3043a	37	entry = call->reply[0];
d2ddc776	38
45df8462 DH	39	nr_servers = ntohl(uvldb->nServers);
	40	if (nr_servers > AFS_NMAXNSERVERS)
	41	nr_servers = AFS_NMAXNSERVERS;
	42
d2ddc776 DH	43	for (i = 0; i < ARRAY_SIZE(uvldb->name) - 1; i++)
	44	entry->name[i] = (u8)ntohl(uvldb->name[i]);
	45	entry->name[i] = 0;
	46	entry->name_len = strlen(entry->name);
	47
	48	/* If there is a new replication site that we can use, ignore all the
	49	* sites that aren't marked as new.
	50	*/
45df8462	51	for (i = 0; i < nr_servers; i++) {
d2ddc776 DH	52	tmp = ntohl(uvldb->serverFlags[i]);
	53	if (!(tmp & AFS_VLSF_DONTUSE) &&
	54	(tmp & AFS_VLSF_NEWREPSITE))
	55	new_only = true;
4d9df986	56	}
1da177e4	57
1fba5868	58	vlflags = ntohl(uvldb->flags);
45df8462	59	for (i = 0; i < nr_servers; i++) {
d2ddc776 DH	60	struct afs_uuid__xdr *xdr;
	61	struct afs_uuid *uuid;
	62	int j;
1da177e4	63
d2ddc776 DH	64	tmp = ntohl(uvldb->serverFlags[i]);
	65	if (tmp & AFS_VLSF_DONTUSE \|\|
	66	(new_only && !(tmp & AFS_VLSF_NEWREPSITE)))
	67	continue;
1fba5868	68	if (tmp & AFS_VLSF_RWVOL) {
d2ddc776	69	entry->fs_mask[i] \|= AFS_VOL_VTM_RW;
1fba5868 MD	70	if (vlflags & AFS_VLF_BACKEXISTS)
	71	entry->fs_mask[i] \|= AFS_VOL_VTM_BAK;
	72	}
1da177e4	73	if (tmp & AFS_VLSF_ROVOL)
d2ddc776	74	entry->fs_mask[i] \|= AFS_VOL_VTM_RO;
d2ddc776 DH	75	if (!entry->fs_mask[i])
	76	continue;
	77
	78	xdr = &uvldb->serverNumber[i];
	79	uuid = (struct afs_uuid *)&entry->fs_server[i];
	80	uuid->time_low = xdr->time_low;
	81	uuid->time_mid = htons(ntohl(xdr->time_mid));
	82	uuid->time_hi_and_version = htons(ntohl(xdr->time_hi_and_version));
	83	uuid->clock_seq_hi_and_reserved = (u8)ntohl(xdr->clock_seq_hi_and_reserved);
	84	uuid->clock_seq_low = (u8)ntohl(xdr->clock_seq_low);
	85	for (j = 0; j < 6; j++)
	86	uuid->node[j] = (u8)ntohl(xdr->node[j]);
1da177e4	87
d2ddc776 DH	88	entry->nr_servers++;
d2ddc776 DH	89	}
1da177e4	90
d2ddc776 DH	91	for (i = 0; i < AFS_MAXTYPES; i++)
d2ddc776 DH	92	entry->vid[i] = ntohl(uvldb->volumeId[i]);
1da177e4	93
1fba5868	94	if (vlflags & AFS_VLF_RWEXISTS)
d2ddc776	95	__set_bit(AFS_VLDB_HAS_RW, &entry->flags);
1fba5868	96	if (vlflags & AFS_VLF_ROEXISTS)
d2ddc776	97	__set_bit(AFS_VLDB_HAS_RO, &entry->flags);
1fba5868	98	if (vlflags & AFS_VLF_BACKEXISTS)
d2ddc776	99	__set_bit(AFS_VLDB_HAS_BAK, &entry->flags);
08e0e7c8	100
1fba5868	101	if (!(vlflags & (AFS_VLF_RWEXISTS \| AFS_VLF_ROEXISTS \| AFS_VLF_BACKEXISTS))) {
d2ddc776 DH	102	entry->error = -ENOMEDIUM;
	103	__set_bit(AFS_VLDB_QUERY_ERROR, &entry->flags);
	104	}
	105
	106	__set_bit(AFS_VLDB_QUERY_VALID, &entry->flags);
08e0e7c8 DH	107	_leave(" = 0 [done]");
08e0e7c8 DH	108	return 0;
ec26815a	109	}
1da177e4	110
d2ddc776 DH	111	static void afs_destroy_vl_get_entry_by_name_u(struct afs_call *call)
	112	{
	113	kfree(call->reply[0]);
	114	afs_flat_call_destructor(call);
	115	}
1da177e4	116
08e0e7c8	117	/*
d2ddc776	118	* VL.GetEntryByNameU operation type.
08e0e7c8	119	*/
d2ddc776 DH	120	static const struct afs_call_type afs_RXVLGetEntryByNameU = {
d2ddc776 DH	121	.name = "VL.GetEntryByNameU",
025db80c	122	.op = afs_VL_GetEntryByNameU,
d2ddc776 DH	123	.deliver = afs_deliver_vl_get_entry_by_name_u,
d2ddc776 DH	124	.destructor = afs_destroy_vl_get_entry_by_name_u,
08e0e7c8	125	};
1da177e4	126
1da177e4	127	/*
d2ddc776 DH	128	* Dispatch a get volume entry by name or ID operation (uuid variant). If the
d2ddc776 DH	129	* volname is a decimal number then it's a volume ID not a volume name.
1da177e4	130	*/
0a5143f2	131	struct afs_vldb_entry afs_vl_get_entry_by_name_u(struct afs_vl_cursor vc,
d2ddc776 DH	132	const char *volname,
d2ddc776 DH	133	int volnamesz)
1da177e4	134	{
d2ddc776	135	struct afs_vldb_entry *entry;
08e0e7c8	136	struct afs_call *call;
0a5143f2	137	struct afs_net *net = vc->cell->net;
d2ddc776	138	size_t reqsz, padsz;
08e0e7c8	139	__be32 *bp;
1da177e4	140
08e0e7c8	141	_enter("");
1da177e4	142
08e0e7c8 DH	143	padsz = (4 - (volnamesz & 3)) & 3;
08e0e7c8 DH	144	reqsz = 8 + volnamesz + padsz;
1da177e4	145
d2ddc776 DH	146	entry = kzalloc(sizeof(struct afs_vldb_entry), GFP_KERNEL);
	147	if (!entry)
	148	return ERR_PTR(-ENOMEM);
	149
	150	call = afs_alloc_flat_call(net, &afs_RXVLGetEntryByNameU, reqsz,
	151	sizeof(struct afs_uvldbentry__xdr));
	152	if (!call) {
	153	kfree(entry);
	154	return ERR_PTR(-ENOMEM);
	155	}
1da177e4	156
0a5143f2	157	call->key = vc->key;
97e3043a	158	call->reply[0] = entry;
d2ddc776	159	call->ret_reply0 = true;
1da177e4	160
d2ddc776	161	/* Marshall the parameters */
08e0e7c8	162	bp = call->request;
d2ddc776	163	*bp++ = htonl(VLGETENTRYBYNAMEU);
08e0e7c8 DH	164	*bp++ = htonl(volnamesz);
	165	memcpy(bp, volname, volnamesz);
	166	if (padsz > 0)
d2ddc776	167	memset((void *)bp + volnamesz, 0, padsz);
08e0e7c8	168
025db80c	169	trace_afs_make_vl_call(call);
0a5143f2	170	return (struct afs_vldb_entry *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
ec26815a	171	}
1da177e4	172
1da177e4	173	/*
d2ddc776 DH	174	* Deliver reply data to a VL.GetAddrsU call.
	175	*
	176	* GetAddrsU(IN ListAddrByAttributes *inaddr,
	177	* OUT afsUUID *uuidp1,
	178	* OUT uint32_t *uniquifier,
	179	* OUT uint32_t *nentries,
	180	* OUT bulkaddrs *blkaddrs);
1da177e4	181	*/
d2ddc776	182	static int afs_deliver_vl_get_addrs_u(struct afs_call *call)
1da177e4	183	{
d2ddc776 DH	184	struct afs_addr_list *alist;
	185	__be32 *bp;
	186	u32 uniquifier, nentries, count;
	187	int i, ret;
	188
12bdcf33 DH	189	_enter("{%u,%zu/%u}",
12bdcf33 DH	190	call->unmarshall, iov_iter_count(call->_iter), call->count);
d2ddc776	191
d2ddc776 DH	192	switch (call->unmarshall) {
d2ddc776 DH	193	case 0:
12bdcf33 DH	194	afs_extract_to_buf(call,
12bdcf33 DH	195	sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
d2ddc776 DH	196	call->unmarshall++;
	197
	198	/* Extract the returned uuid, uniquifier, nentries and blkaddrs size */
	199	case 1:
12bdcf33	200	ret = afs_extract_data(call, true);
d2ddc776 DH	201	if (ret < 0)
	202	return ret;
	203
	204	bp = call->buffer + sizeof(struct afs_uuid__xdr);
	205	uniquifier = ntohl(*bp++);
	206	nentries = ntohl(*bp++);
	207	count = ntohl(*bp);
	208
	209	nentries = min(nentries, count);
	210	alist = afs_alloc_addrlist(nentries, FS_SERVICE, AFS_FS_PORT);
	211	if (!alist)
	212	return -ENOMEM;
	213	alist->version = uniquifier;
	214	call->reply[0] = alist;
	215	call->count = count;
	216	call->count2 = nentries;
d2ddc776 DH	217	call->unmarshall++;
d2ddc776 DH	218
12bdcf33 DH	219	more_entries:
	220	count = min(call->count, 4U);
	221	afs_extract_to_buf(call, count * sizeof(__be32));
	222
d2ddc776 DH	223	/* Extract entries */
d2ddc776 DH	224	case 2:
12bdcf33	225	ret = afs_extract_data(call, call->count > 4);
d2ddc776 DH	226	if (ret < 0)
	227	return ret;
	228
	229	alist = call->reply[0];
	230	bp = call->buffer;
12bdcf33	231	count = min(call->count, 4U);
d2ddc776 DH	232	for (i = 0; i < count; i++)
d2ddc776 DH	233	if (alist->nr_addrs < call->count2)
bf99a53c	234	afs_merge_fs_addr4(alist, *bp++, AFS_FS_PORT);
d2ddc776 DH	235
	236	call->count -= count;
	237	if (call->count > 0)
12bdcf33	238	goto more_entries;
d2ddc776 DH	239	call->unmarshall++;
	240	break;
	241	}
	242
	243	_leave(" = 0 [done]");
	244	return 0;
	245	}
	246
	247	static void afs_vl_get_addrs_u_destructor(struct afs_call *call)
	248	{
	249	afs_put_server(call->net, (struct afs_server *)call->reply[0]);
	250	kfree(call->reply[1]);
	251	return afs_flat_call_destructor(call);
	252	}
	253
	254	/*
	255	* VL.GetAddrsU operation type.
	256	*/
	257	static const struct afs_call_type afs_RXVLGetAddrsU = {
	258	.name = "VL.GetAddrsU",
025db80c	259	.op = afs_VL_GetAddrsU,
d2ddc776 DH	260	.deliver = afs_deliver_vl_get_addrs_u,
	261	.destructor = afs_vl_get_addrs_u_destructor,
	262	};
	263
	264	/*
	265	* Dispatch an operation to get the addresses for a server, where the server is
	266	* nominated by UUID.
	267	*/
0a5143f2	268	struct afs_addr_list afs_vl_get_addrs_u(struct afs_vl_cursor vc,
d2ddc776 DH	269	const uuid_t *uuid)
	270	{
	271	struct afs_ListAddrByAttributes__xdr *r;
	272	const struct afs_uuid u = (const struct afs_uuid )uuid;
08e0e7c8	273	struct afs_call *call;
0a5143f2	274	struct afs_net *net = vc->cell->net;
1da177e4	275	__be32 *bp;
d2ddc776	276	int i;
1da177e4	277
08e0e7c8	278	_enter("");
1da177e4	279
d2ddc776 DH	280	call = afs_alloc_flat_call(net, &afs_RXVLGetAddrsU,
	281	sizeof(__be32) + sizeof(struct afs_ListAddrByAttributes__xdr),
	282	sizeof(struct afs_uuid__xdr) + 3 * sizeof(__be32));
08e0e7c8	283	if (!call)
d2ddc776	284	return ERR_PTR(-ENOMEM);
1da177e4	285
0a5143f2	286	call->key = vc->key;
d2ddc776 DH	287	call->reply[0] = NULL;
d2ddc776 DH	288	call->ret_reply0 = true;
1da177e4	289
d2ddc776	290	/* Marshall the parameters */
08e0e7c8	291	bp = call->request;
d2ddc776 DH	292	*bp++ = htonl(VLGETADDRSU);
	293	r = (struct afs_ListAddrByAttributes__xdr *)bp;
	294	r->Mask = htonl(AFS_VLADDR_UUID);
	295	r->ipaddr = 0;
	296	r->index = 0;
	297	r->spare = 0;
	298	r->uuid.time_low = u->time_low;
	299	r->uuid.time_mid = htonl(ntohs(u->time_mid));
	300	r->uuid.time_hi_and_version = htonl(ntohs(u->time_hi_and_version));
	301	r->uuid.clock_seq_hi_and_reserved = htonl(u->clock_seq_hi_and_reserved);
	302	r->uuid.clock_seq_low = htonl(u->clock_seq_low);
	303	for (i = 0; i < 6; i++)
fe342cf7	304	r->uuid.node[i] = htonl(u->node[i]);
1da177e4	305
025db80c	306	trace_afs_make_vl_call(call);
0a5143f2	307	return (struct afs_addr_list *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
ec26815a	308	}
bf99a53c DH	309
	310	/*
	311	* Deliver reply data to an VL.GetCapabilities operation.
	312	*/
	313	static int afs_deliver_vl_get_capabilities(struct afs_call *call)
	314	{
	315	u32 count;
	316	int ret;
	317
12bdcf33 DH	318	_enter("{%u,%zu/%u}",
12bdcf33 DH	319	call->unmarshall, iov_iter_count(call->_iter), call->count);
bf99a53c	320
bf99a53c DH	321	switch (call->unmarshall) {
bf99a53c DH	322	case 0:
12bdcf33	323	afs_extract_to_tmp(call);
bf99a53c DH	324	call->unmarshall++;
	325
	326	/* Extract the capabilities word count */
	327	case 1:
12bdcf33	328	ret = afs_extract_data(call, true);
bf99a53c DH	329	if (ret < 0)
	330	return ret;
	331
	332	count = ntohl(call->tmp);
bf99a53c DH	333	call->count = count;
bf99a53c DH	334	call->count2 = count;
12bdcf33	335
bf99a53c	336	call->unmarshall++;
12bdcf33	337	afs_extract_discard(call, count * sizeof(__be32));
bf99a53c DH	338
	339	/* Extract capabilities words */
	340	case 2:
12bdcf33	341	ret = afs_extract_data(call, false);
bf99a53c DH	342	if (ret < 0)
	343	return ret;
	344
	345	/* TODO: Examine capabilities */
	346
bf99a53c DH	347	call->unmarshall++;
	348	break;
	349	}
	350
bf99a53c DH	351	_leave(" = 0 [done]");
	352	return 0;
	353	}
	354
3bf0fb6f DH	355	static void afs_destroy_vl_get_capabilities(struct afs_call *call)
	356	{
	357	struct afs_vlserver *server = call->reply[0];
	358
	359	afs_put_vlserver(call->net, server);
	360	afs_flat_call_destructor(call);
	361	}
	362
bf99a53c DH	363	/*
	364	* VL.GetCapabilities operation type
	365	*/
	366	static const struct afs_call_type afs_RXVLGetCapabilities = {
	367	.name = "VL.GetCapabilities",
025db80c	368	.op = afs_VL_GetCapabilities,
bf99a53c	369	.deliver = afs_deliver_vl_get_capabilities,
3bf0fb6f DH	370	.done = afs_vlserver_probe_result,
3bf0fb6f DH	371	.destructor = afs_destroy_vl_get_capabilities,
bf99a53c DH	372	};
	373
	374	/*
0a5143f2	375	* Probe a volume server for the capabilities that it supports. This can
bf99a53c DH	376	* return up to 196 words.
	377	*
	378	* We use this to probe for service upgrade to determine what the server at the
	379	* other end supports.
	380	*/
3bf0fb6f DH	381	int afs_vl_get_capabilities(struct afs_net *net,
	382	struct afs_addr_cursor *ac,
	383	struct key *key,
	384	struct afs_vlserver *server,
	385	unsigned int server_index,
	386	bool async)
bf99a53c DH	387	{
	388	struct afs_call *call;
	389	__be32 *bp;
	390
	391	_enter("");
	392
	393	call = afs_alloc_flat_call(net, &afs_RXVLGetCapabilities, 1 * 4, 16 * 4);
	394	if (!call)
	395	return -ENOMEM;
	396
	397	call->key = key;
3bf0fb6f DH	398	call->reply[0] = afs_get_vlserver(server);
	399	call->reply[1] = (void *)(long)server_index;
	400	call->upgrade = true;
	401	call->want_reply_time = true;
bf99a53c DH	402
	403	/* marshall the parameters */
	404	bp = call->request;
	405	*bp++ = htonl(VLGETCAPABILITIES);
	406
	407	/* Can't take a ref on server */
025db80c	408	trace_afs_make_vl_call(call);
3bf0fb6f	409	return afs_make_call(ac, call, GFP_KERNEL, async);
bf99a53c DH	410	}
	411
	412	/*
	413	* Deliver reply data to a YFSVL.GetEndpoints call.
	414	*
	415	* GetEndpoints(IN yfsServerAttributes *attr,
	416	* OUT opr_uuid *uuid,
	417	* OUT afs_int32 *uniquifier,
	418	* OUT endpoints *fsEndpoints,
	419	* OUT endpoints *volEndpoints)
	420	*/
	421	static int afs_deliver_yfsvl_get_endpoints(struct afs_call *call)
	422	{
	423	struct afs_addr_list *alist;
	424	__be32 *bp;
	425	u32 uniquifier, size;
	426	int ret;
	427
12bdcf33 DH	428	_enter("{%u,%zu,%u}",
12bdcf33 DH	429	call->unmarshall, iov_iter_count(call->_iter), call->count2);
bf99a53c	430
bf99a53c DH	431	switch (call->unmarshall) {
bf99a53c DH	432	case 0:
12bdcf33	433	afs_extract_to_buf(call, sizeof(uuid_t) + 3 * sizeof(__be32));
bf99a53c DH	434	call->unmarshall = 1;
	435
	436	/* Extract the returned uuid, uniquifier, fsEndpoints count and
	437	* either the first fsEndpoint type or the volEndpoints
	438	* count if there are no fsEndpoints. */
	439	case 1:
12bdcf33	440	ret = afs_extract_data(call, true);
bf99a53c DH	441	if (ret < 0)
	442	return ret;
	443
	444	bp = call->buffer + sizeof(uuid_t);
	445	uniquifier = ntohl(*bp++);
	446	call->count = ntohl(*bp++);
	447	call->count2 = ntohl(bp); / Type or next count */
	448
	449	if (call->count > YFS_MAXENDPOINTS)
160cb957 DH	450	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	451	afs_eproto_yvl_fsendpt_num);
bf99a53c DH	452
	453	alist = afs_alloc_addrlist(call->count, FS_SERVICE, AFS_FS_PORT);
	454	if (!alist)
	455	return -ENOMEM;
	456	alist->version = uniquifier;
	457	call->reply[0] = alist;
bf99a53c DH	458
	459	if (call->count == 0)
	460	goto extract_volendpoints;
	461
12bdcf33	462	next_fsendpoint:
bf99a53c DH	463	switch (call->count2) {
	464	case YFS_ENDPOINT_IPV4:
	465	size = sizeof(__be32) * (1 + 1 + 1);
	466	break;
	467	case YFS_ENDPOINT_IPV6:
	468	size = sizeof(__be32) * (1 + 4 + 1);
	469	break;
	470	default:
160cb957 DH	471	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	472	afs_eproto_yvl_fsendpt_type);
bf99a53c DH	473	}
	474
	475	size += sizeof(__be32);
12bdcf33 DH	476	afs_extract_to_buf(call, size);
	477	call->unmarshall = 2;
	478
	479	/* Extract fsEndpoints[] entries */
	480	case 2:
	481	ret = afs_extract_data(call, true);
bf99a53c DH	482	if (ret < 0)
	483	return ret;
	484
	485	alist = call->reply[0];
	486	bp = call->buffer;
	487	switch (call->count2) {
	488	case YFS_ENDPOINT_IPV4:
	489	if (ntohl(bp[0]) != sizeof(__be32) * 2)
160cb957 DH	490	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	491	afs_eproto_yvl_fsendpt4_len);
bf99a53c DH	492	afs_merge_fs_addr4(alist, bp[1], ntohl(bp[2]));
	493	bp += 3;
	494	break;
	495	case YFS_ENDPOINT_IPV6:
	496	if (ntohl(bp[0]) != sizeof(__be32) * 5)
160cb957 DH	497	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	498	afs_eproto_yvl_fsendpt6_len);
bf99a53c DH	499	afs_merge_fs_addr6(alist, bp + 1, ntohl(bp[5]));
	500	bp += 6;
	501	break;
	502	default:
160cb957 DH	503	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	504	afs_eproto_yvl_fsendpt_type);
bf99a53c DH	505	}
	506
	507	/* Got either the type of the next entry or the count of
	508	* volEndpoints if no more fsEndpoints.
	509	*/
fe342cf7	510	call->count2 = ntohl(*bp++);
bf99a53c	511
bf99a53c DH	512	call->count--;
bf99a53c DH	513	if (call->count > 0)
12bdcf33	514	goto next_fsendpoint;
bf99a53c DH	515
	516	extract_volendpoints:
	517	/* Extract the list of volEndpoints. */
	518	call->count = call->count2;
	519	if (!call->count)
	520	goto end;
	521	if (call->count > YFS_MAXENDPOINTS)
160cb957 DH	522	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	523	afs_eproto_yvl_vlendpt_type);
bf99a53c	524
12bdcf33	525	afs_extract_to_buf(call, 1 * sizeof(__be32));
bf99a53c DH	526	call->unmarshall = 3;
	527
	528	/* Extract the type of volEndpoints[0]. Normally we would
	529	* extract the type of the next endpoint when we extract the
	530	* data of the current one, but this is the first...
	531	*/
	532	case 3:
12bdcf33	533	ret = afs_extract_data(call, true);
bf99a53c DH	534	if (ret < 0)
	535	return ret;
	536
	537	bp = call->buffer;
bf99a53c	538
12bdcf33 DH	539	next_volendpoint:
12bdcf33 DH	540	call->count2 = ntohl(*bp++);
bf99a53c DH	541	switch (call->count2) {
	542	case YFS_ENDPOINT_IPV4:
	543	size = sizeof(__be32) * (1 + 1 + 1);
	544	break;
	545	case YFS_ENDPOINT_IPV6:
	546	size = sizeof(__be32) * (1 + 4 + 1);
	547	break;
	548	default:
160cb957 DH	549	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	550	afs_eproto_yvl_vlendpt_type);
bf99a53c DH	551	}
	552
	553	if (call->count > 1)
12bdcf33 DH	554	size += sizeof(__be32); /* Get next type too */
	555	afs_extract_to_buf(call, size);
	556	call->unmarshall = 4;
	557
	558	/* Extract volEndpoints[] entries */
	559	case 4:
	560	ret = afs_extract_data(call, true);
bf99a53c DH	561	if (ret < 0)
	562	return ret;
	563
	564	bp = call->buffer;
	565	switch (call->count2) {
	566	case YFS_ENDPOINT_IPV4:
	567	if (ntohl(bp[0]) != sizeof(__be32) * 2)
160cb957 DH	568	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	569	afs_eproto_yvl_vlendpt4_len);
bf99a53c DH	570	bp += 3;
	571	break;
	572	case YFS_ENDPOINT_IPV6:
	573	if (ntohl(bp[0]) != sizeof(__be32) * 5)
160cb957 DH	574	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	575	afs_eproto_yvl_vlendpt6_len);
bf99a53c DH	576	bp += 6;
	577	break;
	578	default:
160cb957 DH	579	return afs_protocol_error(call, -EBADMSG,
160cb957 DH	580	afs_eproto_yvl_vlendpt_type);
bf99a53c DH	581	}
	582
	583	/* Got either the type of the next entry or the count of
	584	* volEndpoints if no more fsEndpoints.
	585	*/
bf99a53c	586	call->count--;
12bdcf33 DH	587	if (call->count > 0)
12bdcf33 DH	588	goto next_volendpoint;
bf99a53c DH	589
bf99a53c DH	590	end:
12bdcf33	591	afs_extract_discard(call, 0);
bf99a53c DH	592	call->unmarshall = 5;
	593
	594	/* Done */
	595	case 5:
12bdcf33	596	ret = afs_extract_data(call, false);
bf99a53c DH	597	if (ret < 0)
	598	return ret;
	599	call->unmarshall = 6;
	600
	601	case 6:
	602	break;
	603	}
	604
	605	alist = call->reply[0];
bf99a53c DH	606	_leave(" = 0 [done]");
	607	return 0;
	608	}
	609
	610	/*
	611	* YFSVL.GetEndpoints operation type.
	612	*/
	613	static const struct afs_call_type afs_YFSVLGetEndpoints = {
025db80c DH	614	.name = "YFSVL.GetEndpoints",
025db80c DH	615	.op = afs_YFSVL_GetEndpoints,
bf99a53c DH	616	.deliver = afs_deliver_yfsvl_get_endpoints,
	617	.destructor = afs_vl_get_addrs_u_destructor,
	618	};
	619
	620	/*
	621	* Dispatch an operation to get the addresses for a server, where the server is
	622	* nominated by UUID.
	623	*/
0a5143f2	624	struct afs_addr_list afs_yfsvl_get_endpoints(struct afs_vl_cursor vc,
bf99a53c DH	625	const uuid_t *uuid)
	626	{
	627	struct afs_call *call;
0a5143f2	628	struct afs_net *net = vc->cell->net;
bf99a53c DH	629	__be32 *bp;
	630
	631	_enter("");
	632
	633	call = afs_alloc_flat_call(net, &afs_YFSVLGetEndpoints,
	634	sizeof(__be32) * 2 + sizeof(*uuid),
	635	sizeof(struct in6_addr) + sizeof(__be32) * 3);
	636	if (!call)
	637	return ERR_PTR(-ENOMEM);
	638
0a5143f2	639	call->key = vc->key;
bf99a53c DH	640	call->reply[0] = NULL;
	641	call->ret_reply0 = true;
	642
	643	/* Marshall the parameters */
	644	bp = call->request;
	645	*bp++ = htonl(YVLGETENDPOINTS);
	646	*bp++ = htonl(YFS_SERVER_UUID);
	647	memcpy(bp, uuid, sizeof(uuid)); / Type opr_uuid */
	648
025db80c	649	trace_afs_make_vl_call(call);
0a5143f2	650	return (struct afs_addr_list *)afs_make_call(&vc->ac, call, GFP_KERNEL, false);
bf99a53c	651	}