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 */ 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 */ 61 static int afs_deliver_vl_get_entry_by_xxx(struct afs_call *call, 62 struct sk_buff *skb, bool last) 63 { 64 struct afs_cache_vlocation *entry; 65 __be32 *bp; 66 u32 tmp; 67 int loop, ret; 68 69 _enter(",,%u", last); 70 71 ret = afs_transfer_reply(call, skb, last); 72 if (ret < 0) 73 return ret; 74 75 /* unmarshall the reply once we've received all of it */ 76 entry = call->reply; 77 bp = call->buffer; 78 79 for (loop = 0; loop < 64; loop++) 80 entry->name[loop] = ntohl(*bp++); 81 entry->name[loop] = 0; 82 bp++; /* final NUL */ 83 84 bp++; /* type */ 85 entry->nservers = ntohl(*bp++); 86 87 for (loop = 0; loop < 8; loop++) 88 entry->servers[loop].s_addr = *bp++; 89 90 bp += 8; /* partition IDs */ 91 92 for (loop = 0; loop < 8; loop++) { 93 tmp = ntohl(*bp++); 94 entry->srvtmask[loop] = 0; 95 if (tmp & AFS_VLSF_RWVOL) 96 entry->srvtmask[loop] |= AFS_VOL_VTM_RW; 97 if (tmp & AFS_VLSF_ROVOL) 98 entry->srvtmask[loop] |= AFS_VOL_VTM_RO; 99 if (tmp & AFS_VLSF_BACKVOL) 100 entry->srvtmask[loop] |= AFS_VOL_VTM_BAK; 101 } 102 103 entry->vid[0] = ntohl(*bp++); 104 entry->vid[1] = ntohl(*bp++); 105 entry->vid[2] = ntohl(*bp++); 106 107 bp++; /* clone ID */ 108 109 tmp = ntohl(*bp++); /* flags */ 110 entry->vidmask = 0; 111 if (tmp & AFS_VLF_RWEXISTS) 112 entry->vidmask |= AFS_VOL_VTM_RW; 113 if (tmp & AFS_VLF_ROEXISTS) 114 entry->vidmask |= AFS_VOL_VTM_RO; 115 if (tmp & AFS_VLF_BACKEXISTS) 116 entry->vidmask |= AFS_VOL_VTM_BAK; 117 if (!entry->vidmask) 118 return -EBADMSG; 119 120 _leave(" = 0 [done]"); 121 return 0; 122 } 123 124 /* 125 * VL.GetEntryByName operation type 126 */ 127 static const struct afs_call_type afs_RXVLGetEntryByName = { 128 .name = "VL.GetEntryByName", 129 .deliver = afs_deliver_vl_get_entry_by_xxx, 130 .abort_to_error = afs_vl_abort_to_error, 131 .destructor = afs_flat_call_destructor, 132 }; 133 134 /* 135 * VL.GetEntryById operation type 136 */ 137 static const struct afs_call_type afs_RXVLGetEntryById = { 138 .name = "VL.GetEntryById", 139 .deliver = afs_deliver_vl_get_entry_by_xxx, 140 .abort_to_error = afs_vl_abort_to_error, 141 .destructor = afs_flat_call_destructor, 142 }; 143 144 /* 145 * dispatch a get volume entry by name operation 146 */ 147 int afs_vl_get_entry_by_name(struct in_addr *addr, 148 struct key *key, 149 const char *volname, 150 struct afs_cache_vlocation *entry, 151 const struct afs_wait_mode *wait_mode) 152 { 153 struct afs_call *call; 154 size_t volnamesz, reqsz, padsz; 155 __be32 *bp; 156 157 _enter(""); 158 159 volnamesz = strlen(volname); 160 padsz = (4 - (volnamesz & 3)) & 3; 161 reqsz = 8 + volnamesz + padsz; 162 163 call = afs_alloc_flat_call(&afs_RXVLGetEntryByName, reqsz, 384); 164 if (!call) 165 return -ENOMEM; 166 167 call->key = key; 168 call->reply = entry; 169 call->service_id = VL_SERVICE; 170 call->port = htons(AFS_VL_PORT); 171 172 /* marshall the parameters */ 173 bp = call->request; 174 *bp++ = htonl(VLGETENTRYBYNAME); 175 *bp++ = htonl(volnamesz); 176 memcpy(bp, volname, volnamesz); 177 if (padsz > 0) 178 memset((void *) bp + volnamesz, 0, padsz); 179 180 /* initiate the call */ 181 return afs_make_call(addr, call, GFP_KERNEL, wait_mode); 182 } 183 184 /* 185 * dispatch a get volume entry by ID operation 186 */ 187 int afs_vl_get_entry_by_id(struct in_addr *addr, 188 struct key *key, 189 afs_volid_t volid, 190 afs_voltype_t voltype, 191 struct afs_cache_vlocation *entry, 192 const struct afs_wait_mode *wait_mode) 193 { 194 struct afs_call *call; 195 __be32 *bp; 196 197 _enter(""); 198 199 call = afs_alloc_flat_call(&afs_RXVLGetEntryById, 12, 384); 200 if (!call) 201 return -ENOMEM; 202 203 call->key = key; 204 call->reply = entry; 205 call->service_id = VL_SERVICE; 206 call->port = htons(AFS_VL_PORT); 207 208 /* marshall the parameters */ 209 bp = call->request; 210 *bp++ = htonl(VLGETENTRYBYID); 211 *bp++ = htonl(volid); 212 *bp = htonl(voltype); 213 214 /* initiate the call */ 215 return afs_make_call(addr, call, GFP_KERNEL, wait_mode); 216 } 217