fsdev/9p-iov-marshal.c

   1 /*
   2  * 9p backend
   3  *
   4  * Copyright IBM, Corp. 2010
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/osdep.h"
  15 #include <glib.h>
  16 #include <glib/gprintf.h>
  17 #include <utime.h>
  18 #include <sys/uio.h>
  19
  20 #include "9p-iov-marshal.h"
  21 #include "qemu/bswap.h"
  22
  23 static ssize_t v9fs_packunpack(void *addr, struct iovec *sg, int sg_count,
  24                                size_t offset, size_t size, int pack)
  25 {
  26     int i = 0;
  27     size_t copied = 0;
  28     size_t req_size = size;
  29
  30
  31     for (i = 0; size && i < sg_count; i++) {
  32         size_t len;
  33         if (offset >= sg[i].iov_len) {
  34             /* skip this sg */
  35             offset -= sg[i].iov_len;
  36             continue;
  37         } else {
  38             len = MIN(sg[i].iov_len - offset, size);
  39             if (pack) {
  40                 memcpy(sg[i].iov_base + offset, addr, len);
  41             } else {
  42                 memcpy(addr, sg[i].iov_base + offset, len);
  43             }
  44             size -= len;
  45             copied += len;
  46             addr += len;
  47             if (size) {
  48                 offset = 0;
  49                 continue;
  50             }
  51         }
  52     }
  53     if (copied < req_size) {
  54         /*
  55          * We copied less that requested size. error out
  56          */
  57         return -ENOBUFS;
  58     }
  59     return copied;
  60 }
  61
  62 static ssize_t v9fs_unpack(void *dst, struct iovec *out_sg, int out_num,
  63                            size_t offset, size_t size)
  64 {
  65     return v9fs_packunpack(dst, out_sg, out_num, offset, size, 0);
  66 }
  67
  68 ssize_t v9fs_pack(struct iovec *in_sg, int in_num, size_t offset,
  69                   const void *src, size_t size)
  70 {
  71     return v9fs_packunpack((void *)src, in_sg, in_num, offset, size, 1);
  72 }
  73
  74 ssize_t v9fs_iov_vunmarshal(struct iovec *out_sg, int out_num, size_t offset,
  75                             int bswap, const char *fmt, va_list ap)
  76 {
  77     int i;
  78     ssize_t copied = 0;
  79     size_t old_offset = offset;
  80
  81     for (i = 0; fmt[i]; i++) {
  82         switch (fmt[i]) {
  83         case 'b': {
  84             uint8_t *valp = va_arg(ap, uint8_t *);
  85             copied = v9fs_unpack(valp, out_sg, out_num, offset, sizeof(*valp));
  86             break;
  87         }
  88         case 'w': {
  89             uint16_t val, *valp;
  90             valp = va_arg(ap, uint16_t *);
  91             copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
  92             if (bswap) {
  93                 *valp = le16_to_cpu(val);
  94             } else {
  95                 *valp = val;
  96             }
  97             break;
  98         }
  99         case 'd': {
 100             uint32_t val, *valp;
 101             valp = va_arg(ap, uint32_t *);
 102             copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
 103             if (bswap) {
 104                 *valp = le32_to_cpu(val);
 105             } else {
 106                 *valp = val;
 107             }
 108             break;
 109         }
 110         case 'q': {
 111             uint64_t val, *valp;
 112             valp = va_arg(ap, uint64_t *);
 113             copied = v9fs_unpack(&val, out_sg, out_num, offset, sizeof(val));
 114             if (bswap) {
 115                 *valp = le64_to_cpu(val);
 116             } else {
 117                 *valp = val;
 118             }
 119             break;
 120         }
 121         case 's': {
 122             V9fsString *str = va_arg(ap, V9fsString *);
 123             copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
 124                                         "w", &str->size);
 125             if (copied > 0) {
 126                 offset += copied;
 127                 str->data = g_malloc(str->size + 1);
 128                 copied = v9fs_unpack(str->data, out_sg, out_num, offset,
 129                                      str->size);
 130                 if (copied > 0) {
 131                     str->data[str->size] = 0;
 132                 } else {
 133                     v9fs_string_free(str);
 134                 }
 135             }
 136             break;
 137         }
 138         case 'Q': {
 139             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 140             copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
 141                                         "bdq", &qidp->type, &qidp->version,
 142                                         &qidp->path);
 143             break;
 144         }
 145         case 'S': {
 146             V9fsStat *statp = va_arg(ap, V9fsStat *);
 147             copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
 148                                         "wwdQdddqsssssddd",
 149                                         &statp->size, &statp->type,
 150                                         &statp->dev, &statp->qid,
 151                                         &statp->mode, &statp->atime,
 152                                         &statp->mtime, &statp->length,
 153                                         &statp->name, &statp->uid,
 154                                         &statp->gid, &statp->muid,
 155                                         &statp->extension,
 156                                         &statp->n_uid, &statp->n_gid,
 157                                         &statp->n_muid);
 158             break;
 159         }
 160         case 'I': {
 161             V9fsIattr *iattr = va_arg(ap, V9fsIattr *);
 162             copied = v9fs_iov_unmarshal(out_sg, out_num, offset, bswap,
 163                                         "ddddqqqqq",
 164                                         &iattr->valid, &iattr->mode,
 165                                         &iattr->uid, &iattr->gid,
 166                                         &iattr->size, &iattr->atime_sec,
 167                                         &iattr->atime_nsec,
 168                                         &iattr->mtime_sec,
 169                                         &iattr->mtime_nsec);
 170             break;
 171         }
 172         default:
 173             break;
 174         }
 175         if (copied < 0) {
 176             return copied;
 177         }
 178         offset += copied;
 179     }
 180
 181     return offset - old_offset;
 182 }
 183
 184 ssize_t v9fs_iov_unmarshal(struct iovec *out_sg, int out_num, size_t offset,
 185                            int bswap, const char *fmt, ...)
 186 {
 187     ssize_t ret;
 188     va_list ap;
 189
 190     va_start(ap, fmt);
 191     ret = v9fs_iov_vunmarshal(out_sg, out_num, offset, bswap, fmt, ap);
 192     va_end(ap);
 193
 194     return ret;
 195 }
 196
 197 ssize_t v9fs_iov_vmarshal(struct iovec *in_sg, int in_num, size_t offset,
 198                           int bswap, const char *fmt, va_list ap)
 199 {
 200     int i;
 201     ssize_t copied = 0;
 202     size_t old_offset = offset;
 203
 204     for (i = 0; fmt[i]; i++) {
 205         switch (fmt[i]) {
 206         case 'b': {
 207             uint8_t val = va_arg(ap, int);
 208             copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
 209             break;
 210         }
 211         case 'w': {
 212             uint16_t val;
 213             if (bswap) {
 214                 cpu_to_le16w(&val, va_arg(ap, int));
 215             } else {
 216                 val =  va_arg(ap, int);
 217             }
 218             copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
 219             break;
 220         }
 221         case 'd': {
 222             uint32_t val;
 223             if (bswap) {
 224                 cpu_to_le32w(&val, va_arg(ap, uint32_t));
 225             } else {
 226                 val =  va_arg(ap, uint32_t);
 227             }
 228             copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
 229             break;
 230         }
 231         case 'q': {
 232             uint64_t val;
 233             if (bswap) {
 234                 cpu_to_le64w(&val, va_arg(ap, uint64_t));
 235             } else {
 236                 val =  va_arg(ap, uint64_t);
 237             }
 238             copied = v9fs_pack(in_sg, in_num, offset, &val, sizeof(val));
 239             break;
 240         }
 241         case 's': {
 242             V9fsString *str = va_arg(ap, V9fsString *);
 243             copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
 244                                       "w", str->size);
 245             if (copied > 0) {
 246                 offset += copied;
 247                 copied = v9fs_pack(in_sg, in_num, offset, str->data, str->size);
 248             }
 249             break;
 250         }
 251         case 'Q': {
 252             V9fsQID *qidp = va_arg(ap, V9fsQID *);
 253             copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap, "bdq",
 254                                       qidp->type, qidp->version,
 255                                       qidp->path);
 256             break;
 257         }
 258         case 'S': {
 259             V9fsStat *statp = va_arg(ap, V9fsStat *);
 260             copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
 261                                       "wwdQdddqsssssddd",
 262                                       statp->size, statp->type, statp->dev,
 263                                       &statp->qid, statp->mode, statp->atime,
 264                                       statp->mtime, statp->length,
 265                                       &statp->name,
 266                                       &statp->uid, &statp->gid, &statp->muid,
 267                                       &statp->extension, statp->n_uid,
 268                                       statp->n_gid, statp->n_muid);
 269             break;
 270         }
 271         case 'A': {
 272             V9fsStatDotl *statp = va_arg(ap, V9fsStatDotl *);
 273             copied = v9fs_iov_marshal(in_sg, in_num, offset, bswap,
 274                                       "qQdddqqqqqqqqqqqqqqq",
 275                                       statp->st_result_mask,
 276                                       &statp->qid, statp->st_mode,
 277                                       statp->st_uid, statp->st_gid,
 278                                       statp->st_nlink, statp->st_rdev,
 279                                       statp->st_size, statp->st_blksize,
 280                                       statp->st_blocks, statp->st_atime_sec,
 281                                       statp->st_atime_nsec,
 282                                       statp->st_mtime_sec,
 283                                       statp->st_mtime_nsec,
 284                                       statp->st_ctime_sec,
 285                                       statp->st_ctime_nsec,
 286                                       statp->st_btime_sec,
 287                                       statp->st_btime_nsec, statp->st_gen,
 288                                       statp->st_data_version);
 289             break;
 290         }
 291         default:
 292             break;
 293         }
 294         if (copied < 0) {
 295             return copied;
 296         }
 297         offset += copied;
 298     }
 299
 300     return offset - old_offset;
 301 }
 302
 303 ssize_t v9fs_iov_marshal(struct iovec *in_sg, int in_num, size_t offset,
 304                          int bswap, const char *fmt, ...)
 305 {
 306     ssize_t ret;
 307     va_list ap;
 308
 309     va_start(ap, fmt);
 310     ret = v9fs_iov_vmarshal(in_sg, in_num, offset, bswap, fmt, ap);
 311     va_end(ap);
 312
 313     return ret;
 314 }