blob: cd4784f053078315a8abe0656746631380676c29 [file] [log] [blame]
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +02001/*
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"
Paolo Bonzini83c90892012-12-17 18:19:49 +010029#include "monitor/monitor.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010030#include "block/block.h"
31#include "block/blockjob.h"
32#include "block/block_int.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010033#include "qapi/qmp/qjson.h"
Paolo Bonzini737e1502012-12-17 18:19:44 +010034#include "block/coroutine.h"
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020035#include "qmp-commands.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010036#include "qemu/timer.h"
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020037
Fam Zheng3fc4b102013-10-08 17:29:38 +080038void *block_job_create(const BlockJobDriver *driver, BlockDriverState *bs,
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020039 int64_t speed, BlockDriverCompletionFunc *cb,
40 void *opaque, Error **errp)
41{
42 BlockJob *job;
43
44 if (bs->job || bdrv_in_use(bs)) {
45 error_set(errp, QERR_DEVICE_IN_USE, bdrv_get_device_name(bs));
46 return NULL;
47 }
Fam Zhengfa510eb2013-08-23 09:14:51 +080048 bdrv_ref(bs);
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020049 bdrv_set_in_use(bs, 1);
50
Fam Zheng3fc4b102013-10-08 17:29:38 +080051 job = g_malloc0(driver->instance_size);
52 job->driver = driver;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020053 job->bs = bs;
54 job->cb = cb;
55 job->opaque = opaque;
56 job->busy = true;
57 bs->job = job;
58
59 /* Only set speed when necessary to avoid NotSupported error */
60 if (speed != 0) {
61 Error *local_err = NULL;
62
63 block_job_set_speed(job, speed, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +010064 if (local_err) {
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020065 bs->job = NULL;
66 g_free(job);
67 bdrv_set_in_use(bs, 0);
68 error_propagate(errp, local_err);
69 return NULL;
70 }
71 }
72 return job;
73}
74
Paolo Bonzini65f46322012-10-18 16:49:20 +020075void block_job_completed(BlockJob *job, int ret)
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020076{
77 BlockDriverState *bs = job->bs;
78
79 assert(bs->job == job);
80 job->cb(job->opaque, ret);
81 bs->job = NULL;
82 g_free(job);
83 bdrv_set_in_use(bs, 0);
84}
85
86void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
87{
88 Error *local_err = NULL;
89
Fam Zheng3fc4b102013-10-08 17:29:38 +080090 if (!job->driver->set_speed) {
Cole Robinson0b15abf2014-03-21 19:42:27 -040091 error_set(errp, QERR_UNSUPPORTED);
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020092 return;
93 }
Fam Zheng3fc4b102013-10-08 17:29:38 +080094 job->driver->set_speed(job, speed, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +010095 if (local_err) {
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +020096 error_propagate(errp, local_err);
97 return;
98 }
99
100 job->speed = speed;
101}
102
Paolo Bonziniaeae8832012-10-18 16:49:21 +0200103void block_job_complete(BlockJob *job, Error **errp)
104{
Fam Zheng3fc4b102013-10-08 17:29:38 +0800105 if (job->paused || job->cancelled || !job->driver->complete) {
Paolo Bonziniaeae8832012-10-18 16:49:21 +0200106 error_set(errp, QERR_BLOCK_JOB_NOT_READY, job->bs->device_name);
107 return;
108 }
109
Fam Zheng3fc4b102013-10-08 17:29:38 +0800110 job->driver->complete(job, errp);
Paolo Bonziniaeae8832012-10-18 16:49:21 +0200111}
112
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200113void block_job_pause(BlockJob *job)
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200114{
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200115 job->paused = true;
116}
117
118bool block_job_is_paused(BlockJob *job)
119{
120 return job->paused;
121}
122
123void block_job_resume(BlockJob *job)
124{
125 job->paused = false;
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200126 block_job_iostatus_reset(job);
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200127 if (job->co && !job->busy) {
128 qemu_coroutine_enter(job->co, NULL);
129 }
130}
131
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200132void block_job_cancel(BlockJob *job)
133{
134 job->cancelled = true;
135 block_job_resume(job);
136}
137
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200138bool block_job_is_cancelled(BlockJob *job)
139{
140 return job->cancelled;
141}
142
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200143void block_job_iostatus_reset(BlockJob *job)
144{
145 job->iostatus = BLOCK_DEVICE_IO_STATUS_OK;
Fam Zheng3fc4b102013-10-08 17:29:38 +0800146 if (job->driver->iostatus_reset) {
147 job->driver->iostatus_reset(job);
Paolo Bonzini3bd293c2012-10-18 16:49:27 +0200148 }
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200149}
150
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200151struct BlockCancelData {
152 BlockJob *job;
153 BlockDriverCompletionFunc *cb;
154 void *opaque;
155 bool cancelled;
156 int ret;
157};
158
159static void block_job_cancel_cb(void *opaque, int ret)
160{
161 struct BlockCancelData *data = opaque;
162
163 data->cancelled = block_job_is_cancelled(data->job);
164 data->ret = ret;
165 data->cb(data->opaque, ret);
166}
167
168int block_job_cancel_sync(BlockJob *job)
169{
170 struct BlockCancelData data;
171 BlockDriverState *bs = job->bs;
172
173 assert(bs->job == job);
174
175 /* Set up our own callback to store the result and chain to
176 * the original callback.
177 */
178 data.job = job;
179 data.cb = job->cb;
180 data.opaque = job->opaque;
181 data.ret = -EINPROGRESS;
182 job->cb = block_job_cancel_cb;
183 job->opaque = &data;
184 block_job_cancel(job);
185 while (data.ret == -EINPROGRESS) {
186 qemu_aio_wait();
187 }
188 return (data.cancelled && data.ret == 0) ? -ECANCELED : data.ret;
189}
190
Alex Bligh7483d1e2013-08-21 16:03:05 +0100191void block_job_sleep_ns(BlockJob *job, QEMUClockType type, int64_t ns)
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200192{
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200193 assert(job->busy);
194
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200195 /* Check cancellation *before* setting busy = false, too! */
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200196 if (block_job_is_cancelled(job)) {
197 return;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200198 }
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200199
200 job->busy = false;
201 if (block_job_is_paused(job)) {
202 qemu_coroutine_yield();
203 } else {
Alex Bligh7483d1e2013-08-21 16:03:05 +0100204 co_sleep_ns(type, ns);
Paolo Bonzini8acc72a2012-09-28 17:22:50 +0200205 }
206 job->busy = true;
Paolo Bonzini2f0c9fe2012-09-28 17:22:47 +0200207}
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200208
209BlockJobInfo *block_job_query(BlockJob *job)
210{
211 BlockJobInfo *info = g_new0(BlockJobInfo, 1);
Fam Zheng79e14bf2013-10-08 17:29:40 +0800212 info->type = g_strdup(BlockJobType_lookup[job->driver->job_type]);
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200213 info->device = g_strdup(bdrv_get_device_name(job->bs));
214 info->len = job->len;
215 info->busy = job->busy;
216 info->paused = job->paused;
217 info->offset = job->offset;
218 info->speed = job->speed;
219 info->io_status = job->iostatus;
Paolo Bonzini30e628b2012-09-28 17:22:48 +0200220 return info;
221}
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200222
223static void block_job_iostatus_set_err(BlockJob *job, int error)
224{
225 if (job->iostatus == BLOCK_DEVICE_IO_STATUS_OK) {
226 job->iostatus = error == ENOSPC ? BLOCK_DEVICE_IO_STATUS_NOSPACE :
227 BLOCK_DEVICE_IO_STATUS_FAILED;
228 }
229}
230
231
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200232QObject *qobject_from_block_job(BlockJob *job)
233{
234 return qobject_from_jsonf("{ 'type': %s,"
235 "'device': %s,"
236 "'len': %" PRId64 ","
237 "'offset': %" PRId64 ","
238 "'speed': %" PRId64 " }",
Fam Zheng79e14bf2013-10-08 17:29:40 +0800239 BlockJobType_lookup[job->driver->job_type],
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200240 bdrv_get_device_name(job->bs),
241 job->len,
242 job->offset,
243 job->speed);
244}
245
246void block_job_ready(BlockJob *job)
247{
248 QObject *data = qobject_from_block_job(job);
249 monitor_protocol_event(QEVENT_BLOCK_JOB_READY, data);
250 qobject_decref(data);
251}
252
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200253BlockErrorAction block_job_error_action(BlockJob *job, BlockDriverState *bs,
254 BlockdevOnError on_err,
255 int is_read, int error)
256{
257 BlockErrorAction action;
258
259 switch (on_err) {
260 case BLOCKDEV_ON_ERROR_ENOSPC:
261 action = (error == ENOSPC) ? BDRV_ACTION_STOP : BDRV_ACTION_REPORT;
262 break;
263 case BLOCKDEV_ON_ERROR_STOP:
264 action = BDRV_ACTION_STOP;
265 break;
266 case BLOCKDEV_ON_ERROR_REPORT:
267 action = BDRV_ACTION_REPORT;
268 break;
269 case BLOCKDEV_ON_ERROR_IGNORE:
270 action = BDRV_ACTION_IGNORE;
271 break;
272 default:
273 abort();
274 }
275 bdrv_emit_qmp_error_event(job->bs, QEVENT_BLOCK_JOB_ERROR, action, is_read);
276 if (action == BDRV_ACTION_STOP) {
277 block_job_pause(job);
278 block_job_iostatus_set_err(job, error);
279 if (bs != job->bs) {
280 bdrv_iostatus_set_err(bs, error);
281 }
282 }
283 return action;
284}