]>
Commit | Line | Data |
---|---|---|
1 | From d7b0ad8cf8ef0aad35b0549128003dbb49b8386d Mon Sep 17 00:00:00 2001 | |
2 | From: Wolfgang Bumiller <w.bumiller@proxmox.com> | |
3 | Date: Fri, 9 Sep 2016 15:21:19 +0200 | |
4 | Subject: [PATCH 41/47] savevm-async updates | |
5 | ||
6 | --- | |
7 | savevm-async.c | 79 +++++++++++++++++++++++++++++----------------------------- | |
8 | 1 file changed, 39 insertions(+), 40 deletions(-) | |
9 | ||
10 | diff --git a/savevm-async.c b/savevm-async.c | |
11 | index 46c1be7..2f4766c 100644 | |
12 | --- a/savevm-async.c | |
13 | +++ b/savevm-async.c | |
14 | @@ -20,6 +20,8 @@ | |
15 | ||
16 | /* #define DEBUG_SAVEVM_STATE */ | |
17 | ||
18 | +#define NOT_DONE 0x7fffffff /* used while emulated sync operation in progress */ | |
19 | + | |
20 | #ifdef DEBUG_SAVEVM_STATE | |
21 | #define DPRINTF(fmt, ...) \ | |
22 | do { printf("savevm-async: " fmt, ## __VA_ARGS__); } while (0) | |
23 | @@ -38,7 +40,7 @@ enum { | |
24 | ||
25 | ||
26 | static struct SnapshotState { | |
27 | - BlockDriverState *bs; | |
28 | + BlockBackend *target; | |
29 | size_t bs_pos; | |
30 | int state; | |
31 | Error *error; | |
32 | @@ -99,17 +101,17 @@ static int save_snapshot_cleanup(void) | |
33 | ret = qemu_fclose(snap_state.file); | |
34 | } | |
35 | ||
36 | - if (snap_state.bs) { | |
37 | + if (snap_state.target) { | |
38 | /* try to truncate, but ignore errors (will fail on block devices). | |
39 | * note: bdrv_read() need whole blocks, so we round up | |
40 | */ | |
41 | size_t size = (snap_state.bs_pos + BDRV_SECTOR_SIZE) & BDRV_SECTOR_MASK; | |
42 | - bdrv_truncate(snap_state.bs, size); | |
43 | - bdrv_op_unblock_all(snap_state.bs, snap_state.blocker); | |
44 | + blk_truncate(snap_state.target, size); | |
45 | + blk_op_unblock_all(snap_state.target, snap_state.blocker); | |
46 | error_free(snap_state.blocker); | |
47 | snap_state.blocker = NULL; | |
48 | - bdrv_unref(snap_state.bs); | |
49 | - snap_state.bs = NULL; | |
50 | + blk_unref(snap_state.target); | |
51 | + snap_state.target = NULL; | |
52 | } | |
53 | ||
54 | return ret; | |
55 | @@ -151,21 +153,22 @@ static void save_snapshot_completed(void) | |
56 | static int block_state_close(void *opaque) | |
57 | { | |
58 | snap_state.file = NULL; | |
59 | - return bdrv_flush(snap_state.bs); | |
60 | + return blk_flush(snap_state.target); | |
61 | } | |
62 | ||
63 | -static ssize_t block_state_put_buffer(void *opaque, const uint8_t *buf, | |
64 | - int64_t pos, size_t size) | |
65 | +static ssize_t block_state_writev_buffer(void *opaque, struct iovec *iov, | |
66 | + int iovcnt, int64_t pos) | |
67 | { | |
68 | - ssize_t ret; | |
69 | - | |
70 | - assert(pos == snap_state.bs_pos); | |
71 | + int ret; | |
72 | + QEMUIOVector qiov; | |
73 | ||
74 | - if ((ret = bdrv_pwrite(snap_state.bs, snap_state.bs_pos, buf, size)) > 0) { | |
75 | - snap_state.bs_pos += ret; | |
76 | + qemu_iovec_init_external(&qiov, iov, iovcnt); | |
77 | + ret = blk_co_pwritev(snap_state.target, pos, qiov.size, &qiov, 0); | |
78 | + if (ret < 0) { | |
79 | + return ret; | |
80 | } | |
81 | - | |
82 | - return ret; | |
83 | + snap_state.bs_pos += qiov.size; | |
84 | + return qiov.size; | |
85 | } | |
86 | ||
87 | static int store_and_stop(void) { | |
88 | @@ -227,7 +230,7 @@ static void process_savevm_co(void *opaque) | |
89 | /* stop the VM if we get to the end of available space, | |
90 | * or if pending_size is just a few MB | |
91 | */ | |
92 | - maxlen = bdrv_getlength(snap_state.bs) - 30*1024*1024; | |
93 | + maxlen = blk_getlength(snap_state.target) - 30*1024*1024; | |
94 | if ((pending_size < 100000) || | |
95 | ((snap_state.bs_pos + pending_size) >= maxlen)) { | |
96 | if (store_and_stop()) | |
97 | @@ -244,7 +247,7 @@ static void process_savevm_co(void *opaque) | |
98 | } | |
99 | ||
100 | static const QEMUFileOps block_file_ops = { | |
101 | - .put_buffer = block_state_put_buffer, | |
102 | + .writev_buffer = block_state_writev_buffer, | |
103 | .close = block_state_close, | |
104 | }; | |
105 | ||
106 | @@ -254,7 +257,6 @@ void qmp_savevm_start(bool has_statefile, const char *statefile, Error **errp) | |
107 | Error *local_err = NULL; | |
108 | ||
109 | int bdrv_oflags = BDRV_O_RDWR | BDRV_O_RESIZE | BDRV_O_NO_FLUSH; | |
110 | - int ret; | |
111 | ||
112 | if (snap_state.state != SAVE_STATE_DONE) { | |
113 | error_set(errp, ERROR_CLASS_GENERIC_ERROR, | |
114 | @@ -284,13 +286,11 @@ void qmp_savevm_start(bool has_statefile, const char *statefile, Error **errp) | |
115 | } | |
116 | ||
117 | /* Open the image */ | |
118 | - snap_state.bs = bdrv_new(); | |
119 | - | |
120 | QDict *options = NULL; | |
121 | options = qdict_new(); | |
122 | qdict_put(options, "driver", qstring_from_str("raw")); | |
123 | - ret = bdrv_open(&snap_state.bs, statefile, NULL, options, bdrv_oflags, &local_err); | |
124 | - if (ret < 0) { | |
125 | + snap_state.target = blk_new_open(statefile, NULL, options, bdrv_oflags, &local_err); | |
126 | + if (!snap_state.target) { | |
127 | error_set(errp, ERROR_CLASS_GENERIC_ERROR, "failed to open '%s'", statefile); | |
128 | goto restart; | |
129 | } | |
130 | @@ -304,9 +304,9 @@ void qmp_savevm_start(bool has_statefile, const char *statefile, Error **errp) | |
131 | ||
132 | ||
133 | error_setg(&snap_state.blocker, "block device is in use by savevm"); | |
134 | - bdrv_op_block_all(snap_state.bs, snap_state.blocker); | |
135 | + blk_op_block_all(snap_state.target, snap_state.blocker); | |
136 | ||
137 | - Coroutine *co = qemu_coroutine_create(process_savevm_co); | |
138 | + Coroutine *co = qemu_coroutine_create(process_savevm_co, NULL); | |
139 | qemu_coroutine_enter(co); | |
140 | ||
141 | return; | |
142 | @@ -457,8 +457,8 @@ void qmp_delete_drive_snapshot(const char *device, const char *name, | |
143 | static ssize_t loadstate_get_buffer(void *opaque, uint8_t *buf, int64_t pos, | |
144 | size_t size) | |
145 | { | |
146 | - BlockDriverState *bs = (BlockDriverState *)opaque; | |
147 | - int64_t maxlen = bdrv_getlength(bs); | |
148 | + BlockBackend *be = opaque; | |
149 | + int64_t maxlen = blk_getlength(be); | |
150 | if (pos > maxlen) { | |
151 | return -EIO; | |
152 | } | |
153 | @@ -468,7 +468,7 @@ static ssize_t loadstate_get_buffer(void *opaque, uint8_t *buf, int64_t pos, | |
154 | if (size == 0) { | |
155 | return 0; | |
156 | } | |
157 | - return bdrv_pread(bs, pos, buf, size); | |
158 | + return blk_pread(be, pos, buf, size); | |
159 | } | |
160 | ||
161 | static const QEMUFileOps loadstate_file_ops = { | |
162 | @@ -477,28 +477,27 @@ static const QEMUFileOps loadstate_file_ops = { | |
163 | ||
164 | int load_state_from_blockdev(const char *filename) | |
165 | { | |
166 | - BlockDriverState *bs = NULL; | |
167 | + BlockBackend *be; | |
168 | Error *local_err = NULL; | |
169 | Error *blocker = NULL; | |
170 | ||
171 | QEMUFile *f; | |
172 | - int ret; | |
173 | + int ret = -EINVAL; | |
174 | ||
175 | - bs = bdrv_new(); | |
176 | - ret = bdrv_open(&bs, filename, NULL, NULL, 0, &local_err); | |
177 | - error_setg(&blocker, "block device is in use by load state"); | |
178 | - bdrv_op_block_all(bs, blocker); | |
179 | + be = blk_new_open(filename, NULL, NULL, 0, &local_err); | |
180 | ||
181 | - if (ret < 0) { | |
182 | + if (!be) { | |
183 | error_report("Could not open VM state file"); | |
184 | goto the_end; | |
185 | } | |
186 | ||
187 | + error_setg(&blocker, "block device is in use by load state"); | |
188 | + blk_op_block_all(be, blocker); | |
189 | + | |
190 | /* restore the VM state */ | |
191 | - f = qemu_fopen_ops(bs, &loadstate_file_ops); | |
192 | + f = qemu_fopen_ops(be, &loadstate_file_ops); | |
193 | if (!f) { | |
194 | error_report("Could not open VM state file"); | |
195 | - ret = -EINVAL; | |
196 | goto the_end; | |
197 | } | |
198 | ||
199 | @@ -515,10 +514,10 @@ int load_state_from_blockdev(const char *filename) | |
200 | ret = 0; | |
201 | ||
202 | the_end: | |
203 | - if (bs) { | |
204 | - bdrv_op_unblock_all(bs, blocker); | |
205 | + if (be) { | |
206 | + blk_op_unblock_all(be, blocker); | |
207 | error_free(blocker); | |
208 | - bdrv_unref(bs); | |
209 | + blk_unref(be); | |
210 | } | |
211 | return ret; | |
212 | } | |
213 | -- | |
214 | 2.1.4 | |
215 |