]>
Commit | Line | Data |
---|---|---|
d8e7d87e MP |
1 | /* |
2 | * QEMU block throttling filter driver infrastructure | |
3 | * | |
4 | * Copyright (c) 2017 Manos Pitsidianakis | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU General Public License as | |
8 | * published by the Free Software Foundation; either version 2 or | |
9 | * (at your option) version 3 of the License. | |
10 | * | |
11 | * This program is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, see <http://www.gnu.org/licenses/>. | |
18 | */ | |
19 | ||
20 | #include "qemu/osdep.h" | |
21 | #include "block/throttle-groups.h" | |
922a01a0 | 22 | #include "qemu/option.h" |
d8e7d87e MP |
23 | #include "qemu/throttle-options.h" |
24 | #include "qapi/error.h" | |
25 | ||
26 | static QemuOptsList throttle_opts = { | |
27 | .name = "throttle", | |
28 | .head = QTAILQ_HEAD_INITIALIZER(throttle_opts.head), | |
29 | .desc = { | |
30 | { | |
31 | .name = QEMU_OPT_THROTTLE_GROUP_NAME, | |
32 | .type = QEMU_OPT_STRING, | |
33 | .help = "Name of the throttle group", | |
34 | }, | |
35 | { /* end of list */ } | |
36 | }, | |
37 | }; | |
38 | ||
39 | static int throttle_configure_tgm(BlockDriverState *bs, | |
40 | ThrottleGroupMember *tgm, | |
41 | QDict *options, Error **errp) | |
42 | { | |
43 | int ret; | |
44 | const char *group_name; | |
45 | Error *local_err = NULL; | |
46 | QemuOpts *opts = qemu_opts_create(&throttle_opts, NULL, 0, &error_abort); | |
47 | ||
48 | qemu_opts_absorb_qdict(opts, options, &local_err); | |
49 | if (local_err) { | |
50 | error_propagate(errp, local_err); | |
51 | ret = -EINVAL; | |
52 | goto fin; | |
53 | } | |
54 | ||
55 | group_name = qemu_opt_get(opts, QEMU_OPT_THROTTLE_GROUP_NAME); | |
56 | if (!group_name) { | |
57 | error_setg(errp, "Please specify a throttle group"); | |
58 | ret = -EINVAL; | |
59 | goto fin; | |
60 | } else if (!throttle_group_exists(group_name)) { | |
61 | error_setg(errp, "Throttle group '%s' does not exist", group_name); | |
62 | ret = -EINVAL; | |
63 | goto fin; | |
64 | } | |
65 | ||
66 | /* Register membership to group with name group_name */ | |
67 | throttle_group_register_tgm(tgm, group_name, bdrv_get_aio_context(bs)); | |
68 | ret = 0; | |
69 | fin: | |
70 | qemu_opts_del(opts); | |
71 | return ret; | |
72 | } | |
73 | ||
74 | static int throttle_open(BlockDriverState *bs, QDict *options, | |
75 | int flags, Error **errp) | |
76 | { | |
77 | ThrottleGroupMember *tgm = bs->opaque; | |
78 | ||
79 | bs->file = bdrv_open_child(NULL, options, "file", bs, | |
80 | &child_file, false, errp); | |
81 | if (!bs->file) { | |
82 | return -EINVAL; | |
83 | } | |
84 | bs->supported_write_flags = bs->file->bs->supported_write_flags; | |
85 | bs->supported_zero_flags = bs->file->bs->supported_zero_flags; | |
86 | ||
87 | return throttle_configure_tgm(bs, tgm, options, errp); | |
88 | } | |
89 | ||
90 | static void throttle_close(BlockDriverState *bs) | |
91 | { | |
92 | ThrottleGroupMember *tgm = bs->opaque; | |
93 | throttle_group_unregister_tgm(tgm); | |
94 | } | |
95 | ||
96 | ||
97 | static int64_t throttle_getlength(BlockDriverState *bs) | |
98 | { | |
99 | return bdrv_getlength(bs->file->bs); | |
100 | } | |
101 | ||
102 | static int coroutine_fn throttle_co_preadv(BlockDriverState *bs, | |
103 | uint64_t offset, uint64_t bytes, | |
104 | QEMUIOVector *qiov, int flags) | |
105 | { | |
106 | ||
107 | ThrottleGroupMember *tgm = bs->opaque; | |
108 | throttle_group_co_io_limits_intercept(tgm, bytes, false); | |
109 | ||
110 | return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); | |
111 | } | |
112 | ||
113 | static int coroutine_fn throttle_co_pwritev(BlockDriverState *bs, | |
114 | uint64_t offset, uint64_t bytes, | |
115 | QEMUIOVector *qiov, int flags) | |
116 | { | |
117 | ThrottleGroupMember *tgm = bs->opaque; | |
118 | throttle_group_co_io_limits_intercept(tgm, bytes, true); | |
119 | ||
120 | return bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags); | |
121 | } | |
122 | ||
123 | static int coroutine_fn throttle_co_pwrite_zeroes(BlockDriverState *bs, | |
124 | int64_t offset, int bytes, | |
125 | BdrvRequestFlags flags) | |
126 | { | |
127 | ThrottleGroupMember *tgm = bs->opaque; | |
128 | throttle_group_co_io_limits_intercept(tgm, bytes, true); | |
129 | ||
130 | return bdrv_co_pwrite_zeroes(bs->file, offset, bytes, flags); | |
131 | } | |
132 | ||
133 | static int coroutine_fn throttle_co_pdiscard(BlockDriverState *bs, | |
134 | int64_t offset, int bytes) | |
135 | { | |
136 | ThrottleGroupMember *tgm = bs->opaque; | |
137 | throttle_group_co_io_limits_intercept(tgm, bytes, true); | |
138 | ||
139 | return bdrv_co_pdiscard(bs->file->bs, offset, bytes); | |
140 | } | |
141 | ||
142 | static int throttle_co_flush(BlockDriverState *bs) | |
143 | { | |
144 | return bdrv_co_flush(bs->file->bs); | |
145 | } | |
146 | ||
147 | static void throttle_detach_aio_context(BlockDriverState *bs) | |
148 | { | |
149 | ThrottleGroupMember *tgm = bs->opaque; | |
150 | throttle_group_detach_aio_context(tgm); | |
151 | } | |
152 | ||
153 | static void throttle_attach_aio_context(BlockDriverState *bs, | |
154 | AioContext *new_context) | |
155 | { | |
156 | ThrottleGroupMember *tgm = bs->opaque; | |
157 | throttle_group_attach_aio_context(tgm, new_context); | |
158 | } | |
159 | ||
160 | static int throttle_reopen_prepare(BDRVReopenState *reopen_state, | |
161 | BlockReopenQueue *queue, Error **errp) | |
162 | { | |
163 | ThrottleGroupMember *tgm; | |
164 | ||
165 | assert(reopen_state != NULL); | |
166 | assert(reopen_state->bs != NULL); | |
167 | ||
168 | reopen_state->opaque = g_new0(ThrottleGroupMember, 1); | |
169 | tgm = reopen_state->opaque; | |
170 | ||
171 | return throttle_configure_tgm(reopen_state->bs, tgm, reopen_state->options, | |
172 | errp); | |
173 | } | |
174 | ||
175 | static void throttle_reopen_commit(BDRVReopenState *reopen_state) | |
176 | { | |
177 | ThrottleGroupMember *old_tgm = reopen_state->bs->opaque; | |
178 | ThrottleGroupMember *new_tgm = reopen_state->opaque; | |
179 | ||
180 | throttle_group_unregister_tgm(old_tgm); | |
181 | g_free(old_tgm); | |
182 | reopen_state->bs->opaque = new_tgm; | |
183 | reopen_state->opaque = NULL; | |
184 | } | |
185 | ||
186 | static void throttle_reopen_abort(BDRVReopenState *reopen_state) | |
187 | { | |
188 | ThrottleGroupMember *tgm = reopen_state->opaque; | |
189 | ||
190 | throttle_group_unregister_tgm(tgm); | |
191 | g_free(tgm); | |
192 | reopen_state->opaque = NULL; | |
193 | } | |
194 | ||
195 | static bool throttle_recurse_is_first_non_filter(BlockDriverState *bs, | |
196 | BlockDriverState *candidate) | |
197 | { | |
198 | return bdrv_recurse_is_first_non_filter(bs->file->bs, candidate); | |
199 | } | |
200 | ||
b867eaa1 MP |
201 | static void coroutine_fn throttle_co_drain_begin(BlockDriverState *bs) |
202 | { | |
203 | ThrottleGroupMember *tgm = bs->opaque; | |
204 | if (atomic_fetch_inc(&tgm->io_limits_disabled) == 0) { | |
205 | throttle_group_restart_tgm(tgm); | |
206 | } | |
207 | } | |
208 | ||
209 | static void coroutine_fn throttle_co_drain_end(BlockDriverState *bs) | |
210 | { | |
211 | ThrottleGroupMember *tgm = bs->opaque; | |
212 | assert(tgm->io_limits_disabled); | |
213 | atomic_dec(&tgm->io_limits_disabled); | |
214 | } | |
215 | ||
d8e7d87e MP |
216 | static BlockDriver bdrv_throttle = { |
217 | .format_name = "throttle", | |
d8e7d87e MP |
218 | .instance_size = sizeof(ThrottleGroupMember), |
219 | ||
a7328ba5 | 220 | .bdrv_open = throttle_open, |
d8e7d87e MP |
221 | .bdrv_close = throttle_close, |
222 | .bdrv_co_flush = throttle_co_flush, | |
223 | ||
224 | .bdrv_child_perm = bdrv_filter_default_perms, | |
225 | ||
226 | .bdrv_getlength = throttle_getlength, | |
227 | ||
228 | .bdrv_co_preadv = throttle_co_preadv, | |
229 | .bdrv_co_pwritev = throttle_co_pwritev, | |
230 | ||
231 | .bdrv_co_pwrite_zeroes = throttle_co_pwrite_zeroes, | |
232 | .bdrv_co_pdiscard = throttle_co_pdiscard, | |
233 | ||
234 | .bdrv_recurse_is_first_non_filter = throttle_recurse_is_first_non_filter, | |
235 | ||
236 | .bdrv_attach_aio_context = throttle_attach_aio_context, | |
237 | .bdrv_detach_aio_context = throttle_detach_aio_context, | |
238 | ||
239 | .bdrv_reopen_prepare = throttle_reopen_prepare, | |
240 | .bdrv_reopen_commit = throttle_reopen_commit, | |
241 | .bdrv_reopen_abort = throttle_reopen_abort, | |
3e4d0e72 | 242 | .bdrv_co_block_status = bdrv_co_block_status_from_file, |
d8e7d87e | 243 | |
b867eaa1 MP |
244 | .bdrv_co_drain_begin = throttle_co_drain_begin, |
245 | .bdrv_co_drain_end = throttle_co_drain_end, | |
246 | ||
d8e7d87e MP |
247 | .is_filter = true, |
248 | }; | |
249 | ||
250 | static void bdrv_throttle_init(void) | |
251 | { | |
252 | bdrv_register(&bdrv_throttle); | |
253 | } | |
254 | ||
255 | block_init(bdrv_throttle_init); |