/ - Diff - qemu - Greek Research and Technology Network's projects

Revision 8d3b1a2d

+    }
     /*
      * Process a synchronous request using coroutines
      * Process a vectored synchronous request using coroutines
      */
     static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
                           int nb_sectors, bool is_write)
     static int bdrv_rwv_co(BlockDriverState *bs, int64_t sector_num,
                            QEMUIOVector *qiov, bool is_write)
+    {
         QEMUIOVector qiov;
         struct iovec iov = {
             .iov_base = (void *)buf,
             .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
         };
         Coroutine *co;
         RwCo rwco = {
             .bs = bs,
             .sector_num = sector_num,
             .nb_sectors = nb_sectors,
             .qiov = &qiov,
             .nb_sectors = qiov->size >> BDRV_SECTOR_BITS,
             .qiov = qiov,
             .is_write = is_write,
             .ret = NOT_DONE,
         };
         qemu_iovec_init_external(&qiov, &iov, 1);
         assert((qiov->size & (BDRV_SECTOR_SIZE - 1)) == 0);
         /**
          * In sync call context, when the vcpu is blocked, this throttling timer
-...
         return rwco.ret;
+    }
     /*
      * Process a synchronous request using coroutines
      */
     static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
                           int nb_sectors, bool is_write)
+    {
         QEMUIOVector qiov;
         struct iovec iov = {
             .iov_base = (void *)buf,
             .iov_len = nb_sectors * BDRV_SECTOR_SIZE,
         };
         qemu_iovec_init_external(&qiov, &iov, 1);
         return bdrv_rwv_co(bs, sector_num, &qiov, is_write);
+    }
     /* return < 0 if error. See bdrv_write() for the return codes */
     int bdrv_read(BlockDriverState *bs, int64_t sector_num,
                   uint8_t *buf, int nb_sectors)
-...
         return bdrv_rw_co(bs, sector_num, (uint8_t *)buf, nb_sectors, true);
+    }
     int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov)
+    {
         return bdrv_rwv_co(bs, sector_num, qiov, true);
+    }
     int bdrv_pread(BlockDriverState *bs, int64_t offset,
                    void *buf, int count1)
+    {
-...
         return count1;
+    }
     int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                     const void *buf, int count1)
     int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov)
+    {
         uint8_t tmp_buf[BDRV_SECTOR_SIZE];
         int len, nb_sectors, count;
         int64_t sector_num;
         int ret;
         count = count1;
         count = qiov->size;
         /* first write to align to sector start */
         len = (BDRV_SECTOR_SIZE - offset) & (BDRV_SECTOR_SIZE - 1);
         if (len > count)
-...
         if (len > 0) {
             if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                 return ret;
             memcpy(tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)), buf, len);
             qemu_iovec_to_buf(qiov, 0, tmp_buf + (offset & (BDRV_SECTOR_SIZE - 1)),
                               len);
             if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
                 return ret;
             count -= len;
             if (count == 0)
                 return count1;
                 return qiov->size;
             sector_num++;
             buf += len;
+        }
         /* write the sectors "in place" */
         nb_sectors = count >> BDRV_SECTOR_BITS;
         if (nb_sectors > 0) {
             if ((ret = bdrv_write(bs, sector_num, buf, nb_sectors)) < 0)
             QEMUIOVector qiov_inplace;
             qemu_iovec_init(&qiov_inplace, qiov->niov);
             qemu_iovec_concat(&qiov_inplace, qiov, len,
                               nb_sectors << BDRV_SECTOR_BITS);
             ret = bdrv_writev(bs, sector_num, &qiov_inplace);
             qemu_iovec_destroy(&qiov_inplace);
             if (ret < 0) {
                 return ret;
+            }
             sector_num += nb_sectors;
             len = nb_sectors << BDRV_SECTOR_BITS;
             buf += len;
             count -= len;
+        }
-...
         if (count > 0) {
             if ((ret = bdrv_read(bs, sector_num, tmp_buf, 1)) < 0)
                 return ret;
             memcpy(tmp_buf, buf, count);
             qemu_iovec_to_buf(qiov, qiov->size - count, tmp_buf, count);
             if ((ret = bdrv_write(bs, sector_num, tmp_buf, 1)) < 0)
                 return ret;
+        }
         return count1;
         return qiov->size;
+    }
     int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                     const void *buf, int count1)
+    {
         QEMUIOVector qiov;
         struct iovec iov = {
             .iov_base   = (void *) buf,
             .iov_len    = count1,
         };
         qemu_iovec_init_external(&qiov, &iov, 1);
         return bdrv_pwritev(bs, offset, &qiov);
+    }
     /*

         BDRVQcowState *s = bs->opaque;
         int growable = bs->growable;
         int ret;
         void *buf;
         buf = qemu_blockalign(bs, qiov->size);
         qemu_iovec_to_buf(qiov, 0, buf, qiov->size);
         BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
         bs->growable = 1;
         ret = bdrv_pwrite(bs, qcow2_vm_state_offset(s) + pos, buf, qiov->size);
         ret = bdrv_pwritev(bs, qcow2_vm_state_offset(s) + pos, qiov);
         bs->growable = growable;
         qemu_vfree(buf);
         return ret;
+    }

                               uint8_t *buf, int nb_sectors);
     int bdrv_write(BlockDriverState *bs, int64_t sector_num,
                    const uint8_t *buf, int nb_sectors);
     int bdrv_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov);
     int bdrv_pread(BlockDriverState *bs, int64_t offset,
                    void *buf, int count);
     int bdrv_pwrite(BlockDriverState *bs, int64_t offset,
                     const void *buf, int count);
     int bdrv_pwritev(BlockDriverState *bs, int64_t offset, QEMUIOVector *qiov);
     int bdrv_pwrite_sync(BlockDriverState *bs, int64_t offset,
         const void *buf, int count);
     int coroutine_fn bdrv_co_readv(BlockDriverState *bs, int64_t sector_num,

Also available in: Unified diff

Archipelago » qemu

Revision 8d3b1a2d