qemu/fsdev/virtio-9p-marshal.c

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