1 /* 2 * QEMU System Emulator block driver 3 * 4 * Copyright (c) 2011 IBM Corp. 5 * Copyright (c) 2012 Red Hat, Inc. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a copy 8 * of this software and associated documentation files (the "Software"), to deal 9 * in the Software without restriction, including without limitation the rights 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the Software, and to permit persons to whom the Software is 12 * furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 * THE SOFTWARE. 24 */ 25 26 #include "config-host.h" 27 #include "qemu-common.h" 28 #include "trace.h" 29 #include "block/block.h" 30 #include "block/blockjob.h" 31 #include "block/block_int.h" 32 #include "qapi/qmp/qjson.h" 33 #include "block/coroutine.h" 34 #include "qmp-commands.h" 35 #include "qemu/timer.h" 36 #include "qapi-event.h" 37 38 void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs, 39 int64_t speed, BlockCompletionFunc *cb, 40 void *opaque, Error **errp) 41 { 42 BlockJob *job; 43 44 if (bs->job) { 45 error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs)); 46 return NULL; 47 } 48 bdrv_ref(bs); 49 job = g_malloc0(driver->instance_size); 50 error_setg(&job->blocker, "block device is in use by block job: %s", 51 BlockJobType_lookup[driver->job_type]); 52 bdrv_op_block_all(bs, job->blocker); 53 54 job->driver = driver; 55 job->bs = bs; 56 job->cb = cb; 57 job->opaque = opaque; 58 job->busy = true; 59 bs->job = job; 60 61 /* Only set speed when necessary to avoid NotSupported error */ 62 if (speed != 0) { 63 Error *local_err = NULL; 64 65 block_job_set_speed(job, speed, &local_err); 66 if (local_err) { 67 bs->job = NULL; 68 bdrv_op_unblock_all(bs, job->blocker); 69 error_free(job->blocker); 70 g_free(job); 71 error_propagate(errp, local_err); 72 return NULL; 73 } 74 } 75 return job; 76 } 77 78 void block_job_completed(BlockJob *job, int ret) 79 { 80 BlockDriverState *bs = job->bs; 81 82 assert(bs->job == job); 83 job->cb(job->opaque, ret); 84 bs->job = NULL; 85 bdrv_op_unblock_all(bs, job->blocker); 86 error_free(job->blocker); 87 g_free(job); 88 } 89 90 void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp) 91 { 92 Error *local_err = NULL; 93 94 if (!job->driver->set_speed) { 95 error_set(errp, QERR_UNSUPPORTED); 96 return; 97 } 98 job->driver->set_speed(job, speed, &local_err); 99 if (local_err) { 100 error_propagate(errp, local_err); 101 return; 102 } 103 104 job->speed = speed; 105 } 106 107 void block_job_complete(BlockJob *job, Error **errp) 108 { 109 if (job->paused || job->cancelled || !job->driver->complete) { 110 error_set(errp, QERR_BLOCK_JOB_NOT_READY, 111 bdrv_get_device_name(job->bs)); 112 return; 113 } 114 115 job->driver->complete(job, errp); 116 } 117 118 void block_job_pause(BlockJob *job) 119 { 120 job->paused = true; 121 } 122 123 bool block_job_is_paused(BlockJob *job) 124 { 125 return job->paused; 126 } 127 128 void block_job_resume(BlockJob *job) 129 { 130 job->paused = false; 131 block_job_iostatus_reset(job); 132 if (job->co && !job->busy) { 133 qemu_coroutine_enter(job->co, NULL); 134 } 135 } 136 137 void block_job_cancel(BlockJob *job) 138 { 139 job->cancelled = true; 140 block_job_resume(job); 141 } 142 143 bool block_job_is_cancelled(BlockJob *job) 144 { 145 return job->cancelled; 146 } 147 148 void block_job_iostatus_reset(BlockJob *job) 149 { 150 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK; 151 if (job->driver->iostatus_reset) { 152 job->driver->iostatus_reset(job); 153 } 154 } 155 156 struct BlockFinishData { 157 BlockJob *job; 158 BlockCompletionFunc *cb; 159 void *opaque; 160 bool cancelled; 161 int ret; 162 }; 163 164 static void block_job_finish_cb(void *opaque, int ret) 165 { 166 struct BlockFinishData *data = opaque; 167 168 data->cancelled = block_job_is_cancelled(data->job); 169 data->ret = ret; 170 data->cb(data->opaque, ret); 171 } 172 173 static int block_job_finish_sync(BlockJob *job, 174 void (*finish)(BlockJob *, Error **errp), 175 Error **errp) 176 { 177 struct BlockFinishData data; 178 BlockDriverState *bs = job->bs; 179 Error *local_err = NULL; 180 181 assert(bs->job == job); 182 183 /* Set up our own callback to store the result and chain to 184 * the original callback. 185 */ 186 data.job = job; 187 data.cb = job->cb; 188 data.opaque = job->opaque; 189 data.ret = -EINPROGRESS; 190 job->cb = block_job_finish_cb; 191 job->opaque = &data; 192 finish(job, &local_err); 193 if (local_err) { 194 error_propagate(errp, local_err); 195 return -EBUSY; 196 } 197 while (data.ret == -EINPROGRESS) { 198 aio_poll(bdrv_get_aio_context(bs), true); 199 } 200 return (data.cancelled && data.ret == 0) ? -ECANCELED : data.ret; 201 } 202 203 /* A wrapper around block_job_cancel() taking an Error ** parameter so it may be 204 * used with block_job_finish_sync() without the need for (rather nasty) 205 * function pointer casts there. */ 206 static void block_job_cancel_err(BlockJob *job, Error **errp) 207 { 208 block_job_cancel(job); 209 } 210 211 int block_job_cancel_sync(BlockJob *job) 212 { 213 return block_job_finish_sync(job, &block_job_cancel_err, NULL); 214 } 215 216 int block_job_complete_sync(BlockJob *job, Error **errp) 217 { 218 return block_job_finish_sync(job, &block_job_complete, errp); 219 } 220 221 void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns) 222 { 223 assert(job->busy); 224 225 /* Check cancellation *before* setting busy = false, too! */ 226 if (block_job_is_cancelled(job)) { 227 return; 228 } 229 230 job->busy = false; 231 if (block_job_is_paused(job)) { 232 qemu_coroutine_yield(); 233 } else { 234 co_aio_sleep_ns(bdrv_get_aio_context(job->bs), type, ns); 235 } 236 job->busy = true; 237 } 238 239 void block_job_yield(BlockJob *job) 240 { 241 assert(job->busy); 242 243 /* Check cancellation *before* setting busy = false, too! */ 244 if (block_job_is_cancelled(job)) { 245 return; 246 } 247 248 job->busy = false; 249 qemu_coroutine_yield(); 250 job->busy = true; 251 } 252 253 BlockJobInfo *block_job_query(BlockJob *job) 254 { 255 BlockJobInfo *info = g_new0(BlockJobInfo, 1); 256 info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]); 257 info->device = g_strdup(bdrv_get_device_name(job->bs)); 258 info->len = job->len; 259 info->busy = job->busy; 260 info->paused = job->paused; 261 info->offset = job->offset; 262 info->speed = job->speed; 263 info->io_status = job->iostatus; 264 info->ready = job->ready; 265 return info; 266 } 267 268 static void block_job_iostatus_set_err(BlockJob *job, int error) 269 { 270 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) { 271 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE : 272 BLOCK_DEVICE_IO_STATUS_FAILED; 273 } 274 } 275 276 void block_job_event_cancelled(BlockJob *job) 277 { 278 qapi_event_send_block_job_cancelled(job->driver->job_type, 279 bdrv_get_device_name(job->bs), 280 job->len, 281 job->offset, 282 job->speed, 283 &error_abort); 284 } 285 286 void block_job_event_completed(BlockJob *job, const char *msg) 287 { 288 qapi_event_send_block_job_completed(job->driver->job_type, 289 bdrv_get_device_name(job->bs), 290 job->len, 291 job->offset, 292 job->speed, 293 !!msg, 294 msg, 295 &error_abort); 296 } 297 298 void block_job_event_ready(BlockJob *job) 299 { 300 job->ready = true; 301 302 qapi_event_send_block_job_ready(job->driver->job_type, 303 bdrv_get_device_name(job->bs), 304 job->len, 305 job->offset, 306 job->speed, &error_abort); 307 } 308 309 BlockErrorAction block_job_error_action(BlockJob *job, BlockDriverState *bs, 310 BlockdevOnError on_err, 311 int is_read, int error) 312 { 313 BlockErrorAction action; 314 315 switch (on_err) { 316 case BLOCKDEV_ON_ERROR_ENOSPC: 317 action = (error == ENOSPC) ? 318 BLOCK_ERROR_ACTION_STOP : BLOCK_ERROR_ACTION_REPORT; 319 break; 320 case BLOCKDEV_ON_ERROR_STOP: 321 action = BLOCK_ERROR_ACTION_STOP; 322 break; 323 case BLOCKDEV_ON_ERROR_REPORT: 324 action = BLOCK_ERROR_ACTION_REPORT; 325 break; 326 case BLOCKDEV_ON_ERROR_IGNORE: 327 action = BLOCK_ERROR_ACTION_IGNORE; 328 break; 329 default: 330 abort(); 331 } 332 qapi_event_send_block_job_error(bdrv_get_device_name(job->bs), 333 is_read ? IO_OPERATION_TYPE_READ : 334 IO_OPERATION_TYPE_WRITE, 335 action, &error_abort); 336 if (action == BLOCK_ERROR_ACTION_STOP) { 337 block_job_pause(job); 338 block_job_iostatus_set_err(job, error); 339 if (bs != job->bs) { 340 bdrv_iostatus_set_err(bs, error); 341 } 342 } 343 return action; 344 } 345 346 typedef struct { 347 BlockJob *job; 348 QEMUBH *bh; 349 AioContext *aio_context; 350 BlockJobDeferToMainLoopFn *fn; 351 void *opaque; 352 } BlockJobDeferToMainLoopData; 353 354 static void block_job_defer_to_main_loop_bh(void *opaque) 355 { 356 BlockJobDeferToMainLoopData *data = opaque; 357 AioContext *aio_context; 358 359 qemu_bh_delete(data->bh); 360 361 /* Prevent race with block_job_defer_to_main_loop() */ 362 aio_context_acquire(data->aio_context); 363 364 /* Fetch BDS AioContext again, in case it has changed */ 365 aio_context = bdrv_get_aio_context(data->job->bs); 366 aio_context_acquire(aio_context); 367 368 data->fn(data->job, data->opaque); 369 370 aio_context_release(aio_context); 371 372 aio_context_release(data->aio_context); 373 374 g_free(data); 375 } 376 377 void block_job_defer_to_main_loop(BlockJob *job, 378 BlockJobDeferToMainLoopFn *fn, 379 void *opaque) 380 { 381 BlockJobDeferToMainLoopData *data = g_malloc(sizeof(*data)); 382 data->job = job; 383 data->bh = qemu_bh_new(block_job_defer_to_main_loop_bh, data); 384 data->aio_context = bdrv_get_aio_context(job->bs); 385 data->fn = fn; 386 data->opaque = opaque; 387 388 qemu_bh_schedule(data->bh); 389 } 390