1 /* 2 * Image streaming 3 * 4 * Copyright IBM, Corp. 2011 5 * 6 * Authors: 7 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU LGPL, version 2 or later. 10 * See the COPYING.LIB file in the top-level directory. 11 * 12 */ 13 14 #include "trace.h" 15 #include "block/block_int.h" 16 #include "block/blockjob.h" 17 #include "qemu/ratelimit.h" 18 19 enum { 20 /* 21 * Size of data buffer for populating the image file. This should be large 22 * enough to process multiple clusters in a single call, so that populating 23 * contiguous regions of the image is efficient. 24 */ 25 STREAM_BUFFER_SIZE = 512 * 1024, /* in bytes */ 26 }; 27 28 #define SLICE_TIME 100000000ULL /* ns */ 29 30 typedef struct StreamBlockJob { 31 BlockJob common; 32 RateLimit limit; 33 BlockDriverState *base; 34 BlockdevOnError on_error; 35 char backing_file_id[1024]; 36 } StreamBlockJob; 37 38 static int coroutine_fn stream_populate(BlockDriverState *bs, 39 int64_t sector_num, int nb_sectors, 40 void *buf) 41 { 42 struct iovec iov = { 43 .iov_base = buf, 44 .iov_len = nb_sectors * BDRV_SECTOR_SIZE, 45 }; 46 QEMUIOVector qiov; 47 48 qemu_iovec_init_external(&qiov, &iov, 1); 49 50 /* Copy-on-read the unallocated clusters */ 51 return bdrv_co_copy_on_readv(bs, sector_num, nb_sectors, &qiov); 52 } 53 54 static void close_unused_images(BlockDriverState *top, BlockDriverState *base, 55 const char *base_id) 56 { 57 BlockDriverState *intermediate; 58 intermediate = top->backing_hd; 59 60 /* Must assign before bdrv_delete() to prevent traversing dangling pointer 61 * while we delete backing image instances. 62 */ 63 top->backing_hd = base; 64 65 while (intermediate) { 66 BlockDriverState *unused; 67 68 /* reached base */ 69 if (intermediate == base) { 70 break; 71 } 72 73 unused = intermediate; 74 intermediate = intermediate->backing_hd; 75 unused->backing_hd = NULL; 76 bdrv_unref(unused); 77 } 78 } 79 80 static void coroutine_fn stream_run(void *opaque) 81 { 82 StreamBlockJob *s = opaque; 83 BlockDriverState *bs = s->common.bs; 84 BlockDriverState *base = s->base; 85 int64_t sector_num, end; 86 int error = 0; 87 int ret = 0; 88 int n = 0; 89 void *buf; 90 91 s->common.len = bdrv_getlength(bs); 92 if (s->common.len < 0) { 93 block_job_completed(&s->common, s->common.len); 94 return; 95 } 96 97 end = s->common.len >> BDRV_SECTOR_BITS; 98 buf = qemu_blockalign(bs, STREAM_BUFFER_SIZE); 99 100 /* Turn on copy-on-read for the whole block device so that guest read 101 * requests help us make progress. Only do this when copying the entire 102 * backing chain since the copy-on-read operation does not take base into 103 * account. 104 */ 105 if (!base) { 106 bdrv_enable_copy_on_read(bs); 107 } 108 109 for (sector_num = 0; sector_num < end; sector_num += n) { 110 uint64_t delay_ns = 0; 111 bool copy; 112 113 wait: 114 /* Note that even when no rate limit is applied we need to yield 115 * with no pending I/O here so that bdrv_drain_all() returns. 116 */ 117 block_job_sleep_ns(&s->common, QEMU_CLOCK_REALTIME, delay_ns); 118 if (block_job_is_cancelled(&s->common)) { 119 break; 120 } 121 122 copy = false; 123 124 ret = bdrv_is_allocated(bs, sector_num, 125 STREAM_BUFFER_SIZE / BDRV_SECTOR_SIZE, &n); 126 if (ret == 1) { 127 /* Allocated in the top, no need to copy. */ 128 } else if (ret >= 0) { 129 /* Copy if allocated in the intermediate images. Limit to the 130 * known-unallocated area [sector_num, sector_num+n). */ 131 ret = bdrv_is_allocated_above(bs->backing_hd, base, 132 sector_num, n, &n); 133 134 /* Finish early if end of backing file has been reached */ 135 if (ret == 0 && n == 0) { 136 n = end - sector_num; 137 } 138 139 copy = (ret == 1); 140 } 141 trace_stream_one_iteration(s, sector_num, n, ret); 142 if (copy) { 143 if (s->common.speed) { 144 delay_ns = ratelimit_calculate_delay(&s->limit, n); 145 if (delay_ns > 0) { 146 goto wait; 147 } 148 } 149 ret = stream_populate(bs, sector_num, n, buf); 150 } 151 if (ret < 0) { 152 BlockErrorAction action = 153 block_job_error_action(&s->common, s->common.bs, s->on_error, 154 true, -ret); 155 if (action == BDRV_ACTION_STOP) { 156 n = 0; 157 continue; 158 } 159 if (error == 0) { 160 error = ret; 161 } 162 if (action == BDRV_ACTION_REPORT) { 163 break; 164 } 165 } 166 ret = 0; 167 168 /* Publish progress */ 169 s->common.offset += n * BDRV_SECTOR_SIZE; 170 } 171 172 if (!base) { 173 bdrv_disable_copy_on_read(bs); 174 } 175 176 /* Do not remove the backing file if an error was there but ignored. */ 177 ret = error; 178 179 if (!block_job_is_cancelled(&s->common) && sector_num == end && ret == 0) { 180 const char *base_id = NULL, *base_fmt = NULL; 181 if (base) { 182 base_id = s->backing_file_id; 183 if (base->drv) { 184 base_fmt = base->drv->format_name; 185 } 186 } 187 ret = bdrv_change_backing_file(bs, base_id, base_fmt); 188 close_unused_images(bs, base, base_id); 189 } 190 191 qemu_vfree(buf); 192 block_job_completed(&s->common, ret); 193 } 194 195 static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp) 196 { 197 StreamBlockJob *s = container_of(job, StreamBlockJob, common); 198 199 if (speed < 0) { 200 error_set(errp, QERR_INVALID_PARAMETER, "speed"); 201 return; 202 } 203 ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE, SLICE_TIME); 204 } 205 206 static const BlockJobDriver stream_job_driver = { 207 .instance_size = sizeof(StreamBlockJob), 208 .job_type = BLOCK_JOB_TYPE_STREAM, 209 .set_speed = stream_set_speed, 210 }; 211 212 void stream_start(BlockDriverState *bs, BlockDriverState *base, 213 const char *base_id, int64_t speed, 214 BlockdevOnError on_error, 215 BlockDriverCompletionFunc *cb, 216 void *opaque, Error **errp) 217 { 218 StreamBlockJob *s; 219 220 if ((on_error == BLOCKDEV_ON_ERROR_STOP || 221 on_error == BLOCKDEV_ON_ERROR_ENOSPC) && 222 !bdrv_iostatus_is_enabled(bs)) { 223 error_set(errp, QERR_INVALID_PARAMETER, "on-error"); 224 return; 225 } 226 227 s = block_job_create(&stream_job_driver, bs, speed, cb, opaque, errp); 228 if (!s) { 229 return; 230 } 231 232 s->base = base; 233 if (base_id) { 234 pstrcpy(s->backing_file_id, sizeof(s->backing_file_id), base_id); 235 } 236 237 s->on_error = on_error; 238 s->common.co = qemu_coroutine_create(stream_run); 239 trace_stream_start(bs, base, s, s->common.co, opaque); 240 qemu_coroutine_enter(s->common.co, s); 241 } 242