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