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/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 {
  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  */
 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                              bool async)
 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, async);
 181 }
 182
 183 /*
 184  * dispatch a get volume entry by ID operation
 185  */
 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                            bool async)
 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, async);
 215 }