AFS: Guard afs_file_readpage_read_complete() definition with CONFIG_AFS_FSCACHE
[linux-2.6.git] / fs / afs / vlclient.c
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 }