migration/channel-block.c

   1 /*
   2  * QEMU I/O channels block driver
   3  *
   4  * Copyright (c) 2022 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "migration/channel-block.h"
  23 #include "qapi/error.h"
  24 #include "block/block.h"
  25 #include "trace.h"
  26
  27 QIOChannelBlock *
  28 qio_channel_block_new(BlockDriverState *bs)
  29 {
  30     QIOChannelBlock *ioc;
  31
  32     ioc = QIO_CHANNEL_BLOCK(object_new(TYPE_QIO_CHANNEL_BLOCK));
  33
  34     bdrv_ref(bs);
  35     ioc->bs = bs;
  36
  37     return ioc;
  38 }
  39
  40
  41 static void
  42 qio_channel_block_finalize(Object *obj)
  43 {
  44     QIOChannelBlock *ioc = QIO_CHANNEL_BLOCK(obj);
  45
  46     g_clear_pointer(&ioc->bs, bdrv_unref);
  47 }
  48
  49
  50 static ssize_t
  51 qio_channel_block_readv(QIOChannel *ioc,
  52                         const struct iovec *iov,
  53                         size_t niov,
  54                         int **fds,
  55                         size_t *nfds,
  56                         int flags,
  57                         Error **errp)
  58 {
  59     QIOChannelBlock *bioc = QIO_CHANNEL_BLOCK(ioc);
  60     QEMUIOVector qiov;
  61     int ret;
  62
  63     qemu_iovec_init_external(&qiov, (struct iovec *)iov, niov);
  64     ret = bdrv_readv_vmstate(bioc->bs, &qiov, bioc->offset);
  65     if (ret < 0) {
  66         error_setg_errno(errp, -ret, "bdrv_readv_vmstate failed");
  67         return -1;
  68     }
  69
  70     bioc->offset += qiov.size;
  71     return qiov.size;
  72 }
  73
  74
  75 static ssize_t
  76 qio_channel_block_writev(QIOChannel *ioc,
  77                          const struct iovec *iov,
  78                          size_t niov,
  79                          int *fds,
  80                          size_t nfds,
  81                          int flags,
  82                          Error **errp)
  83 {
  84     QIOChannelBlock *bioc = QIO_CHANNEL_BLOCK(ioc);
  85     QEMUIOVector qiov;
  86     int ret;
  87
  88     qemu_iovec_init_external(&qiov, (struct iovec *)iov, niov);
  89     ret = bdrv_writev_vmstate(bioc->bs, &qiov, bioc->offset);
  90     if (ret < 0) {
  91         error_setg_errno(errp, -ret, "bdrv_writev_vmstate failed");
  92         return -1;
  93     }
  94
  95     bioc->offset += qiov.size;
  96     return qiov.size;
  97 }
  98
  99
 100 static int
 101 qio_channel_block_set_blocking(QIOChannel *ioc,
 102                                bool enabled,
 103                                Error **errp)
 104 {
 105     if (!enabled) {
 106         error_setg(errp, "Non-blocking mode not supported for block devices");
 107         return -1;
 108     }
 109     return 0;
 110 }
 111
 112
 113 static off_t
 114 qio_channel_block_seek(QIOChannel *ioc,
 115                        off_t offset,
 116                        int whence,
 117                        Error **errp)
 118 {
 119     QIOChannelBlock *bioc = QIO_CHANNEL_BLOCK(ioc);
 120
 121     switch (whence) {
 122     case SEEK_SET:
 123         bioc->offset = offset;
 124         break;
 125     case SEEK_CUR:
 126         bioc->offset += whence;
 127         break;
 128     case SEEK_END:
 129         error_setg(errp, "Size of VMstate region is unknown");
 130         return (off_t)-1;
 131     default:
 132         g_assert_not_reached();
 133     }
 134
 135     return bioc->offset;
 136 }
 137
 138
 139 static int
 140 qio_channel_block_close(QIOChannel *ioc,
 141                         Error **errp)
 142 {
 143     QIOChannelBlock *bioc = QIO_CHANNEL_BLOCK(ioc);
 144     int rv = bdrv_flush(bioc->bs);
 145
 146     if (rv < 0) {
 147         error_setg_errno(errp, -rv,
 148                          "Unable to flush VMState");
 149         return -1;
 150     }
 151
 152     g_clear_pointer(&bioc->bs, bdrv_unref);
 153     bioc->offset = 0;
 154
 155     return 0;
 156 }
 157
 158
 159 static void
 160 qio_channel_block_set_aio_fd_handler(QIOChannel *ioc,
 161                                      AioContext *ctx,
 162                                      IOHandler *io_read,
 163                                      IOHandler *io_write,
 164                                      void *opaque)
 165 {
 166     /* XXX anything we can do here ? */
 167 }
 168
 169
 170 static void
 171 qio_channel_block_class_init(ObjectClass *klass,
 172                              void *class_data G_GNUC_UNUSED)
 173 {
 174     QIOChannelClass *ioc_klass = QIO_CHANNEL_CLASS(klass);
 175
 176     ioc_klass->io_writev = qio_channel_block_writev;
 177     ioc_klass->io_readv = qio_channel_block_readv;
 178     ioc_klass->io_set_blocking = qio_channel_block_set_blocking;
 179     ioc_klass->io_seek = qio_channel_block_seek;
 180     ioc_klass->io_close = qio_channel_block_close;
 181     ioc_klass->io_set_aio_fd_handler = qio_channel_block_set_aio_fd_handler;
 182 }
 183
 184 static const TypeInfo qio_channel_block_info = {
 185     .parent = TYPE_QIO_CHANNEL,
 186     .name = TYPE_QIO_CHANNEL_BLOCK,
 187     .instance_size = sizeof(QIOChannelBlock),
 188     .instance_finalize = qio_channel_block_finalize,
 189     .class_init = qio_channel_block_class_init,
 190 };
 191
 192 static void
 193 qio_channel_block_register_types(void)
 194 {
 195     type_register_static(&qio_channel_block_info);
 196 }
 197
 198 type_init(qio_channel_block_register_types);