git.oblomov.eu Git - linux-2.6/blob - 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 }