tools/virtiofsd/buffer.c

   1 /*
   2  * FUSE: Filesystem in Userspace
   3  * Copyright (C) 2010  Miklos Szeredi <miklos@szeredi.hu>
   4  *
   5  * Functions for dealing with `struct fuse_buf` and `struct
   6  * fuse_bufvec`.
   7  *
   8  * This program can be distributed under the terms of the GNU LGPLv2.
   9  * See the file COPYING.LIB
  10  */
  11
  12 #include "qemu/osdep.h"
  13 #include "fuse_i.h"
  14 #include "fuse_lowlevel.h"
  15
  16 size_t fuse_buf_size(const struct fuse_bufvec *bufv)
  17 {
  18     size_t i;
  19     size_t size = 0;
  20
  21     for (i = 0; i < bufv->count; i++) {
  22         if (bufv->buf[i].size == SIZE_MAX) {
  23             size = SIZE_MAX;
  24         } else {
  25             size += bufv->buf[i].size;
  26         }
  27     }
  28
  29     return size;
  30 }
  31
  32 static ssize_t fuse_buf_writev(struct fuse_buf *out_buf,
  33                                struct fuse_bufvec *in_buf)
  34 {
  35     ssize_t res, i, j;
  36     size_t iovcnt = in_buf->count;
  37     struct iovec *iov;
  38     int fd = out_buf->fd;
  39
  40     iov = calloc(iovcnt, sizeof(struct iovec));
  41     if (!iov) {
  42         return -ENOMEM;
  43     }
  44
  45     for (i = 0, j = 0; i < iovcnt; i++) {
  46         /* Skip the buf with 0 size */
  47         if (in_buf->buf[i].size) {
  48             iov[j].iov_base = in_buf->buf[i].mem;
  49             iov[j].iov_len = in_buf->buf[i].size;
  50             j++;
  51         }
  52     }
  53
  54     if (out_buf->flags & FUSE_BUF_FD_SEEK) {
  55         res = pwritev(fd, iov, iovcnt, out_buf->pos);
  56     } else {
  57         res = writev(fd, iov, iovcnt);
  58     }
  59
  60     if (res == -1) {
  61         res = -errno;
  62     }
  63
  64     free(iov);
  65     return res;
  66 }
  67
  68 static size_t min_size(size_t s1, size_t s2)
  69 {
  70     return s1 < s2 ? s1 : s2;
  71 }
  72
  73 static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
  74                               const struct fuse_buf *src, size_t src_off,
  75                               size_t len)
  76 {
  77     ssize_t res = 0;
  78     size_t copied = 0;
  79
  80     while (len) {
  81         if (dst->flags & FUSE_BUF_FD_SEEK) {
  82             res = pwrite(dst->fd, (char *)src->mem + src_off, len,
  83                          dst->pos + dst_off);
  84         } else {
  85             res = write(dst->fd, (char *)src->mem + src_off, len);
  86         }
  87         if (res == -1) {
  88             if (!copied) {
  89                 return -errno;
  90             }
  91             break;
  92         }
  93         if (res == 0) {
  94             break;
  95         }
  96
  97         copied += res;
  98         if (!(dst->flags & FUSE_BUF_FD_RETRY)) {
  99             break;
 100         }
 101
 102         src_off += res;
 103         dst_off += res;
 104         len -= res;
 105     }
 106
 107     return copied;
 108 }
 109
 110 static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
 111                              const struct fuse_buf *src, size_t src_off,
 112                              size_t len)
 113 {
 114     ssize_t res = 0;
 115     size_t copied = 0;
 116
 117     while (len) {
 118         if (src->flags & FUSE_BUF_FD_SEEK) {
 119             res = pread(src->fd, (char *)dst->mem + dst_off, len,
 120                         src->pos + src_off);
 121         } else {
 122             res = read(src->fd, (char *)dst->mem + dst_off, len);
 123         }
 124         if (res == -1) {
 125             if (!copied) {
 126                 return -errno;
 127             }
 128             break;
 129         }
 130         if (res == 0) {
 131             break;
 132         }
 133
 134         copied += res;
 135         if (!(src->flags & FUSE_BUF_FD_RETRY)) {
 136             break;
 137         }
 138
 139         dst_off += res;
 140         src_off += res;
 141         len -= res;
 142     }
 143
 144     return copied;
 145 }
 146
 147 static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
 148                                  const struct fuse_buf *src, size_t src_off,
 149                                  size_t len)
 150 {
 151     char buf[4096];
 152     struct fuse_buf tmp = {
 153         .size = sizeof(buf),
 154         .flags = 0,
 155     };
 156     ssize_t res;
 157     size_t copied = 0;
 158
 159     tmp.mem = buf;
 160
 161     while (len) {
 162         size_t this_len = min_size(tmp.size, len);
 163         size_t read_len;
 164
 165         res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
 166         if (res < 0) {
 167             if (!copied) {
 168                 return res;
 169             }
 170             break;
 171         }
 172         if (res == 0) {
 173             break;
 174         }
 175
 176         read_len = res;
 177         res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
 178         if (res < 0) {
 179             if (!copied) {
 180                 return res;
 181             }
 182             break;
 183         }
 184         if (res == 0) {
 185             break;
 186         }
 187
 188         copied += res;
 189
 190         if (res < this_len) {
 191             break;
 192         }
 193
 194         dst_off += res;
 195         src_off += res;
 196         len -= res;
 197     }
 198
 199     return copied;
 200 }
 201
 202 static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
 203                                  const struct fuse_buf *src, size_t src_off,
 204                                  size_t len)
 205 {
 206     int src_is_fd = src->flags & FUSE_BUF_IS_FD;
 207     int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
 208
 209     if (!src_is_fd && !dst_is_fd) {
 210         char *dstmem = (char *)dst->mem + dst_off;
 211         char *srcmem = (char *)src->mem + src_off;
 212
 213         if (dstmem != srcmem) {
 214             if (dstmem + len <= srcmem || srcmem + len <= dstmem) {
 215                 memcpy(dstmem, srcmem, len);
 216             } else {
 217                 memmove(dstmem, srcmem, len);
 218             }
 219         }
 220
 221         return len;
 222     } else if (!src_is_fd) {
 223         return fuse_buf_write(dst, dst_off, src, src_off, len);
 224     } else if (!dst_is_fd) {
 225         return fuse_buf_read(dst, dst_off, src, src_off, len);
 226     } else {
 227         return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
 228     }
 229 }
 230
 231 static const struct fuse_buf *fuse_bufvec_current(struct fuse_bufvec *bufv)
 232 {
 233     if (bufv->idx < bufv->count) {
 234         return &bufv->buf[bufv->idx];
 235     } else {
 236         return NULL;
 237     }
 238 }
 239
 240 static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
 241 {
 242     const struct fuse_buf *buf = fuse_bufvec_current(bufv);
 243
 244     if (!buf) {
 245         return 0;
 246     }
 247
 248     bufv->off += len;
 249     assert(bufv->off <= buf->size);
 250     if (bufv->off == buf->size) {
 251         assert(bufv->idx < bufv->count);
 252         bufv->idx++;
 253         if (bufv->idx == bufv->count) {
 254             return 0;
 255         }
 256         bufv->off = 0;
 257     }
 258     return 1;
 259 }
 260
 261 ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv)
 262 {
 263     size_t copied = 0, i;
 264
 265     if (dstv == srcv) {
 266         return fuse_buf_size(dstv);
 267     }
 268
 269     /*
 270      * use writev to improve bandwidth when all the
 271      * src buffers already mapped by the daemon
 272      * process
 273      */
 274     for (i = 0; i < srcv->count; i++) {
 275         if (srcv->buf[i].flags & FUSE_BUF_IS_FD) {
 276             break;
 277         }
 278     }
 279     if ((i == srcv->count) && (dstv->count == 1) &&
 280         (dstv->idx == 0) &&
 281         (dstv->buf[0].flags & FUSE_BUF_IS_FD)) {
 282         dstv->buf[0].pos += dstv->off;
 283         return fuse_buf_writev(&dstv->buf[0], srcv);
 284     }
 285
 286     for (;;) {
 287         const struct fuse_buf *src = fuse_bufvec_current(srcv);
 288         const struct fuse_buf *dst = fuse_bufvec_current(dstv);
 289         size_t src_len;
 290         size_t dst_len;
 291         size_t len;
 292         ssize_t res;
 293
 294         if (src == NULL || dst == NULL) {
 295             break;
 296         }
 297
 298         src_len = src->size - srcv->off;
 299         dst_len = dst->size - dstv->off;
 300         len = min_size(src_len, dst_len);
 301
 302         res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len);
 303         if (res < 0) {
 304             if (!copied) {
 305                 return res;
 306             }
 307             break;
 308         }
 309         copied += res;
 310
 311         if (!fuse_bufvec_advance(srcv, res) ||
 312             !fuse_bufvec_advance(dstv, res)) {
 313             break;
 314         }
 315
 316         if (res < len) {
 317             break;
 318         }
 319     }
 320
 321     return copied;
 322 }
 323
 324 void *fuse_mbuf_iter_advance(struct fuse_mbuf_iter *iter, size_t len)
 325 {
 326     void *ptr;
 327
 328     if (len > iter->size - iter->pos) {
 329         return NULL;
 330     }
 331
 332     ptr = iter->mem + iter->pos;
 333     iter->pos += len;
 334     return ptr;
 335 }
 336
 337 const char *fuse_mbuf_iter_advance_str(struct fuse_mbuf_iter *iter)
 338 {
 339     const char *str = iter->mem + iter->pos;
 340     size_t remaining = iter->size - iter->pos;
 341     size_t i;
 342
 343     for (i = 0; i < remaining; i++) {
 344         if (str[i] == '\0') {
 345             iter->pos += i + 1;
 346             return str;
 347         }
 348     }
 349     return NULL;
 350 }