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