debian/patches/pve/0038-vma-byte-based-write-calls.patch

   1 From 8ff103236a11af9b2fa7f6df67af5383f16eb95b Mon Sep 17 00:00:00 2001
   2 From: Wolfgang Bumiller <w.bumiller@proxmox.com>
   3 Date: Fri, 9 Sep 2016 14:51:28 +0200
   4 Subject: [PATCH 38/47] vma: byte based write calls
   5
   6 ---
   7  vma-reader.c | 42 +++++++++++++++++++++---------------------
   8  vma.c        | 22 ++++++++++------------
   9  vma.h        |  2 +-
  10  3 files changed, 32 insertions(+), 34 deletions(-)
  11
  12 diff --git a/vma-reader.c b/vma-reader.c
  13 index 78f1de9..2000889 100644
  14 --- a/vma-reader.c
  15 +++ b/vma-reader.c
  16 @@ -25,7 +25,7 @@
  17  static unsigned char zero_vma_block[VMA_BLOCK_SIZE];
  18
  19  typedef struct VmaRestoreState {
  20 -    BlockDriverState *bs;
  21 +    BlockBackend *target;
  22      bool write_zeroes;
  23      unsigned long *bitmap;
  24      int bitmap_size;
  25 @@ -423,12 +423,12 @@ VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id)
  26  }
  27
  28  static void allocate_rstate(VmaReader *vmar,  guint8 dev_id,
  29 -                            BlockDriverState *bs, bool write_zeroes)
  30 +                            BlockBackend *target, bool write_zeroes)
  31  {
  32      assert(vmar);
  33      assert(dev_id);
  34
  35 -    vmar->rstate[dev_id].bs = bs;
  36 +    vmar->rstate[dev_id].target = target;
  37      vmar->rstate[dev_id].write_zeroes = write_zeroes;
  38
  39      int64_t size = vmar->devinfo[dev_id].size;
  40 @@ -443,15 +443,15 @@ static void allocate_rstate(VmaReader *vmar,  guint8 dev_id,
  41      vmar->cluster_count += size/VMA_CLUSTER_SIZE;
  42  }
  43
  44 -int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockDriverState *bs,
  45 +int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockBackend *target,
  46                             bool write_zeroes, Error **errp)
  47  {
  48      assert(vmar);
  49 -    assert(bs != NULL);
  50 +    assert(target != NULL);
  51      assert(dev_id);
  52 -    assert(vmar->rstate[dev_id].bs == NULL);
  53 +    assert(vmar->rstate[dev_id].target == NULL);
  54
  55 -    int64_t size = bdrv_getlength(bs);
  56 +    int64_t size = blk_getlength(target);
  57      int64_t size_diff = size - vmar->devinfo[dev_id].size;
  58
  59      /* storage types can have different size restrictions, so it
  60 @@ -465,7 +465,7 @@ int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id, BlockDriverState *bs,
  61          return -1;
  62      }
  63
  64 -    allocate_rstate(vmar, dev_id, bs, write_zeroes);
  65 +    allocate_rstate(vmar, dev_id, target, write_zeroes);
  66
  67      return 0;
  68  }
  69 @@ -507,7 +507,7 @@ static size_t full_write(int fd, void *buf, size_t len)
  70  }
  71
  72  static int restore_write_data(VmaReader *vmar, guint8 dev_id,
  73 -                              BlockDriverState *bs, int vmstate_fd,
  74 +                              BlockBackend *target, int vmstate_fd,
  75                                unsigned char *buf, int64_t sector_num,
  76                                int nb_sectors, Error **errp)
  77  {
  78 @@ -523,10 +523,10 @@ static int restore_write_data(VmaReader *vmar, guint8 dev_id,
  79              }
  80          }
  81      } else {
  82 -        int res = bdrv_write(bs, sector_num, buf, nb_sectors);
  83 +        int res = blk_pwrite(target, sector_num * BDRV_SECTOR_SIZE, buf, nb_sectors * BDRV_SECTOR_SIZE, 0);
  84          if (res < 0) {
  85 -            error_setg(errp, "bdrv_write to %s failed (%d)",
  86 -                       bdrv_get_device_name(bs), res);
  87 +            error_setg(errp, "blk_pwrite to %s failed (%d)",
  88 +                       bdrv_get_device_name(blk_bs(target)), res);
  89              return -1;
  90          }
  91      }
  92 @@ -556,11 +556,11 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
  93          }
  94
  95          VmaRestoreState *rstate = &vmar->rstate[dev_id];
  96 -        BlockDriverState *bs = NULL;
  97 +        BlockBackend *target = NULL;
  98
  99          if (dev_id != vmar->vmstate_stream) {
 100 -            bs = rstate->bs;
 101 -            if (!verify && !bs) {
 102 +            target = rstate->target;
 103 +            if (!verify && !target) {
 104                  error_setg(errp, "got wrong dev id %d", dev_id);
 105                  return -1;
 106              }
 107 @@ -618,7 +618,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
 108
 109              if (!verify) {
 110                  int nb_sectors = end_sector - sector_num;
 111 -                if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
 112 +                if (restore_write_data(vmar, dev_id, target, vmstate_fd,
 113                                         buf + start, sector_num, nb_sectors,
 114                                         errp) < 0) {
 115                      return -1;
 116 @@ -654,7 +654,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
 117
 118                      if (!verify) {
 119                          int nb_sectors = end_sector - sector_num;
 120 -                        if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
 121 +                        if (restore_write_data(vmar, dev_id, target, vmstate_fd,
 122                                                 buf + start, sector_num,
 123                                                 nb_sectors, errp) < 0) {
 124                              return -1;
 125 @@ -678,7 +678,7 @@ static int restore_extent(VmaReader *vmar, unsigned char *buf,
 126                          }
 127
 128                          if (rstate->write_zeroes && !verify) {
 129 -                            if (restore_write_data(vmar, dev_id, bs, vmstate_fd,
 130 +                            if (restore_write_data(vmar, dev_id, target, vmstate_fd,
 131                                                     zero_vma_block, sector_num,
 132                                                     nb_sectors, errp) < 0) {
 133                                  return -1;
 134 @@ -786,12 +786,12 @@ static int vma_reader_restore_full(VmaReader *vmar, int vmstate_fd,
 135      int i;
 136      for (i = 1; i < 256; i++) {
 137          VmaRestoreState *rstate = &vmar->rstate[i];
 138 -        if (!rstate->bs) {
 139 +        if (!rstate->target) {
 140              continue;
 141          }
 142
 143 -        if (bdrv_flush(rstate->bs) < 0) {
 144 -            error_setg(errp, "vma bdrv_flush %s failed",
 145 +        if (blk_flush(rstate->target) < 0) {
 146 +            error_setg(errp, "vma blk_flush %s failed",
 147                         vmar->devinfo[i].devname);
 148              return -1;
 149          }
 150 diff --git a/vma.c b/vma.c
 151 index ad51090..aafdc2d 100644
 152 --- a/vma.c
 153 +++ b/vma.c
 154 @@ -334,9 +334,7 @@ static int extract_content(int argc, char **argv)
 155                          error_get_pretty(errp));
 156              }
 157
 158 -           BlockDriverState *bs = blk_bs(blk);
 159 -
 160 -            if (vma_reader_register_bs(vmar, i, bs, write_zero, &errp) < 0) {
 161 +            if (vma_reader_register_bs(vmar, i, blk, write_zero, &errp) < 0) {
 162                  g_error("%s", error_get_pretty(errp));
 163              }
 164
 165 @@ -428,7 +426,7 @@ static int verify_content(int argc, char **argv)
 166  }
 167
 168  typedef struct BackupJob {
 169 -    BlockDriverState *bs;
 170 +    BlockBackend *target;
 171      int64_t len;
 172      VmaWriter *vmaw;
 173      uint8_t dev_id;
 174 @@ -457,7 +455,7 @@ static void coroutine_fn backup_run(void *opaque)
 175      int64_t start, end;
 176      int ret = 0;
 177
 178 -    unsigned char *buf = qemu_blockalign(job->bs, VMA_CLUSTER_SIZE);
 179 +    unsigned char *buf = blk_blockalign(job->target, VMA_CLUSTER_SIZE);
 180
 181      start = 0;
 182      end = DIV_ROUND_UP(job->len / BDRV_SECTOR_SIZE,
 183 @@ -468,8 +466,8 @@ static void coroutine_fn backup_run(void *opaque)
 184          iov.iov_len = VMA_CLUSTER_SIZE;
 185          qemu_iovec_init_external(&qiov, &iov, 1);
 186
 187 -        ret = bdrv_co_readv(job->bs, start * BACKUP_SECTORS_PER_CLUSTER,
 188 -                            BACKUP_SECTORS_PER_CLUSTER, &qiov);
 189 +        ret = blk_co_preadv(job->target, start * BACKUP_SECTORS_PER_CLUSTER,
 190 +                            BACKUP_SECTORS_PER_CLUSTER, &qiov, 0);
 191          if (ret < 0) {
 192              vma_writer_set_error(job->vmaw, "read error", -1);
 193              goto out;
 194 @@ -564,14 +562,14 @@ static int create_archive(int argc, char **argv)
 195          path = extract_devname(path, &devname, devcount++);
 196
 197          Error *errp = NULL;
 198 -        BlockDriverState *bs;
 199 +        BlockBackend *target;
 200
 201 -        bs = bdrv_open(path, NULL, NULL, 0, &errp);
 202 -        if (!bs) {
 203 +        target = blk_new_open(path, NULL, NULL, 0, &errp);
 204 +        if (!target) {
 205              unlink(archivename);
 206              g_error("bdrv_open '%s' failed - %s", path, error_get_pretty(errp));
 207          }
 208 -        int64_t size = bdrv_getlength(bs);
 209 +        int64_t size = blk_getlength(target);
 210          int dev_id = vma_writer_register_stream(vmaw, devname, size);
 211          if (dev_id <= 0) {
 212              unlink(archivename);
 213 @@ -580,7 +578,7 @@ static int create_archive(int argc, char **argv)
 214
 215          BackupJob *job = g_new0(BackupJob, 1);
 216          job->len = size;
 217 -        job->bs = bs;
 218 +        job->target = target;
 219          job->vmaw = vmaw;
 220          job->dev_id = dev_id;
 221
 222 diff --git a/vma.h b/vma.h
 223 index 365ceb2..fa6f4df 100644
 224 --- a/vma.h
 225 +++ b/vma.h
 226 @@ -140,7 +140,7 @@ VmaHeader *vma_reader_get_header(VmaReader *vmar);
 227  GList *vma_reader_get_config_data(VmaReader *vmar);
 228  VmaDeviceInfo *vma_reader_get_device_info(VmaReader *vmar, guint8 dev_id);
 229  int vma_reader_register_bs(VmaReader *vmar, guint8 dev_id,
 230 -                           BlockDriverState *bs, bool write_zeroes,
 231 +                           BlockBackend *target, bool write_zeroes,
 232                             Error **errp);
 233  int vma_reader_restore(VmaReader *vmar, int vmstate_fd, bool verbose,
 234                         Error **errp);
 235 --
 236 2.1.4
 237