1 /* 2 * QMP command handlers specific to the system emulators 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or 7 * later. See the COPYING file in the top-level directory. 8 * 9 * This file incorporates work covered by the following copyright and 10 * permission notice: 11 * 12 * Copyright (c) 2003-2008 Fabrice Bellard 13 * 14 * Permission is hereby granted, free of charge, to any person obtaining a copy 15 * of this software and associated documentation files (the "Software"), to deal 16 * in the Software without restriction, including without limitation the rights 17 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 18 * copies of the Software, and to permit persons to whom the Software is 19 * furnished to do so, subject to the following conditions: 20 * 21 * The above copyright notice and this permission notice shall be included in 22 * all copies or substantial portions of the Software. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 30 * THE SOFTWARE. 31 */ 32 33 #include "qemu/osdep.h" 34 35 #include "block/block_int.h" 36 #include "qapi/error.h" 37 #include "qapi/qapi-commands-block.h" 38 #include "qapi/qmp/qdict.h" 39 #include "sysemu/block-backend.h" 40 #include "sysemu/blockdev.h" 41 42 static BlockBackend *qmp_get_blk(const char *blk_name, const char *qdev_id, 43 Error **errp) 44 { 45 BlockBackend *blk; 46 47 if (!blk_name == !qdev_id) { 48 error_setg(errp, "Need exactly one of 'device' and 'id'"); 49 return NULL; 50 } 51 52 if (qdev_id) { 53 blk = blk_by_qdev_id(qdev_id, errp); 54 } else { 55 blk = blk_by_name(blk_name); 56 if (blk == NULL) { 57 error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND, 58 "Device '%s' not found", blk_name); 59 } 60 } 61 62 return blk; 63 } 64 65 /* 66 * Attempt to open the tray of @device. 67 * If @force, ignore its tray lock. 68 * Else, if the tray is locked, don't open it, but ask the guest to open it. 69 * On error, store an error through @errp and return -errno. 70 * If @device does not exist, return -ENODEV. 71 * If it has no removable media, return -ENOTSUP. 72 * If it has no tray, return -ENOSYS. 73 * If the guest was asked to open the tray, return -EINPROGRESS. 74 * Else, return 0. 75 */ 76 static int do_open_tray(const char *blk_name, const char *qdev_id, 77 bool force, Error **errp) 78 { 79 BlockBackend *blk; 80 const char *device = qdev_id ?: blk_name; 81 bool locked; 82 83 blk = qmp_get_blk(blk_name, qdev_id, errp); 84 if (!blk) { 85 return -ENODEV; 86 } 87 88 if (!blk_dev_has_removable_media(blk)) { 89 error_setg(errp, "Device '%s' is not removable", device); 90 return -ENOTSUP; 91 } 92 93 if (!blk_dev_has_tray(blk)) { 94 error_setg(errp, "Device '%s' does not have a tray", device); 95 return -ENOSYS; 96 } 97 98 if (blk_dev_is_tray_open(blk)) { 99 return 0; 100 } 101 102 locked = blk_dev_is_medium_locked(blk); 103 if (locked) { 104 blk_dev_eject_request(blk, force); 105 } 106 107 if (!locked || force) { 108 blk_dev_change_media_cb(blk, false, &error_abort); 109 } 110 111 if (locked && !force) { 112 error_setg(errp, "Device '%s' is locked and force was not specified, " 113 "wait for tray to open and try again", device); 114 return -EINPROGRESS; 115 } 116 117 return 0; 118 } 119 120 void qmp_blockdev_open_tray(const char *device, 121 const char *id, 122 bool has_force, bool force, 123 Error **errp) 124 { 125 Error *local_err = NULL; 126 int rc; 127 128 if (!has_force) { 129 force = false; 130 } 131 rc = do_open_tray(device, id, force, &local_err); 132 if (rc && rc != -ENOSYS && rc != -EINPROGRESS) { 133 error_propagate(errp, local_err); 134 return; 135 } 136 error_free(local_err); 137 } 138 139 void qmp_blockdev_close_tray(const char *device, 140 const char *id, 141 Error **errp) 142 { 143 BlockBackend *blk; 144 Error *local_err = NULL; 145 146 blk = qmp_get_blk(device, id, errp); 147 if (!blk) { 148 return; 149 } 150 151 if (!blk_dev_has_removable_media(blk)) { 152 error_setg(errp, "Device '%s' is not removable", device ?: id); 153 return; 154 } 155 156 if (!blk_dev_has_tray(blk)) { 157 /* Ignore this command on tray-less devices */ 158 return; 159 } 160 161 if (!blk_dev_is_tray_open(blk)) { 162 return; 163 } 164 165 blk_dev_change_media_cb(blk, true, &local_err); 166 if (local_err) { 167 error_propagate(errp, local_err); 168 return; 169 } 170 } 171 172 static void GRAPH_UNLOCKED 173 blockdev_remove_medium(const char *device, const char *id, Error **errp) 174 { 175 BlockBackend *blk; 176 BlockDriverState *bs; 177 bool has_attached_device; 178 179 GLOBAL_STATE_CODE(); 180 181 blk = qmp_get_blk(device, id, errp); 182 if (!blk) { 183 return; 184 } 185 186 /* For BBs without a device, we can exchange the BDS tree at will */ 187 has_attached_device = blk_get_attached_dev(blk); 188 189 if (has_attached_device && !blk_dev_has_removable_media(blk)) { 190 error_setg(errp, "Device '%s' is not removable", device ?: id); 191 return; 192 } 193 194 if (has_attached_device && blk_dev_has_tray(blk) && 195 !blk_dev_is_tray_open(blk)) 196 { 197 error_setg(errp, "Tray of device '%s' is not open", device ?: id); 198 return; 199 } 200 201 bs = blk_bs(blk); 202 if (!bs) { 203 return; 204 } 205 206 bdrv_graph_rdlock_main_loop(); 207 if (bdrv_op_is_blocked(bs, BLOCK_OP_TYPE_EJECT, errp)) { 208 bdrv_graph_rdunlock_main_loop(); 209 return; 210 } 211 bdrv_graph_rdunlock_main_loop(); 212 213 blk_remove_bs(blk); 214 215 if (!blk_dev_has_tray(blk)) { 216 /* For tray-less devices, blockdev-open-tray is a no-op (or may not be 217 * called at all); therefore, the medium needs to be ejected here. 218 * Do it after blk_remove_bs() so blk_is_inserted(blk) returns the @load 219 * value passed here (i.e. false). */ 220 blk_dev_change_media_cb(blk, false, &error_abort); 221 } 222 } 223 224 void qmp_blockdev_remove_medium(const char *id, Error **errp) 225 { 226 blockdev_remove_medium(NULL, id, errp); 227 } 228 229 static void qmp_blockdev_insert_anon_medium(BlockBackend *blk, 230 BlockDriverState *bs, Error **errp) 231 { 232 Error *local_err = NULL; 233 bool has_device; 234 int ret; 235 236 /* For BBs without a device, we can exchange the BDS tree at will */ 237 has_device = blk_get_attached_dev(blk); 238 239 if (has_device && !blk_dev_has_removable_media(blk)) { 240 error_setg(errp, "Device is not removable"); 241 return; 242 } 243 244 if (has_device && blk_dev_has_tray(blk) && !blk_dev_is_tray_open(blk)) { 245 error_setg(errp, "Tray of the device is not open"); 246 return; 247 } 248 249 if (blk_bs(blk)) { 250 error_setg(errp, "There already is a medium in the device"); 251 return; 252 } 253 254 ret = blk_insert_bs(blk, bs, errp); 255 if (ret < 0) { 256 return; 257 } 258 259 if (!blk_dev_has_tray(blk)) { 260 /* For tray-less devices, blockdev-close-tray is a no-op (or may not be 261 * called at all); therefore, the medium needs to be pushed into the 262 * slot here. 263 * Do it after blk_insert_bs() so blk_is_inserted(blk) returns the @load 264 * value passed here (i.e. true). */ 265 blk_dev_change_media_cb(blk, true, &local_err); 266 if (local_err) { 267 error_propagate(errp, local_err); 268 blk_remove_bs(blk); 269 return; 270 } 271 } 272 } 273 274 static void blockdev_insert_medium(const char *device, const char *id, 275 const char *node_name, Error **errp) 276 { 277 BlockBackend *blk; 278 BlockDriverState *bs; 279 280 GRAPH_RDLOCK_GUARD_MAINLOOP(); 281 282 blk = qmp_get_blk(device, id, errp); 283 if (!blk) { 284 return; 285 } 286 287 bs = bdrv_find_node(node_name); 288 if (!bs) { 289 error_setg(errp, "Node '%s' not found", node_name); 290 return; 291 } 292 293 if (bdrv_has_blk(bs)) { 294 error_setg(errp, "Node '%s' is already in use", node_name); 295 return; 296 } 297 298 qmp_blockdev_insert_anon_medium(blk, bs, errp); 299 } 300 301 void qmp_blockdev_insert_medium(const char *id, const char *node_name, 302 Error **errp) 303 { 304 blockdev_insert_medium(NULL, id, node_name, errp); 305 } 306 307 void qmp_blockdev_change_medium(const char *device, 308 const char *id, 309 const char *filename, 310 const char *format, 311 bool has_force, bool force, 312 bool has_read_only, 313 BlockdevChangeReadOnlyMode read_only, 314 Error **errp) 315 { 316 BlockBackend *blk; 317 BlockDriverState *medium_bs = NULL; 318 int bdrv_flags; 319 bool detect_zeroes; 320 int rc; 321 QDict *options = NULL; 322 Error *err = NULL; 323 324 blk = qmp_get_blk(device, id, errp); 325 if (!blk) { 326 goto fail; 327 } 328 329 if (blk_bs(blk)) { 330 blk_update_root_state(blk); 331 } 332 333 bdrv_flags = blk_get_open_flags_from_root_state(blk); 334 bdrv_flags &= ~(BDRV_O_TEMPORARY | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | 335 BDRV_O_PROTOCOL | BDRV_O_AUTO_RDONLY); 336 337 if (!has_read_only) { 338 read_only = BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN; 339 } 340 341 switch (read_only) { 342 case BLOCKDEV_CHANGE_READ_ONLY_MODE_RETAIN: 343 break; 344 345 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_ONLY: 346 bdrv_flags &= ~BDRV_O_RDWR; 347 break; 348 349 case BLOCKDEV_CHANGE_READ_ONLY_MODE_READ_WRITE: 350 bdrv_flags |= BDRV_O_RDWR; 351 break; 352 353 default: 354 abort(); 355 } 356 357 options = qdict_new(); 358 detect_zeroes = blk_get_detect_zeroes_from_root_state(blk); 359 qdict_put_str(options, "detect-zeroes", detect_zeroes ? "on" : "off"); 360 361 if (format) { 362 qdict_put_str(options, "driver", format); 363 } 364 365 medium_bs = bdrv_open(filename, NULL, options, bdrv_flags, errp); 366 367 if (!medium_bs) { 368 goto fail; 369 } 370 371 rc = do_open_tray(device, id, force, &err); 372 if (rc && rc != -ENOSYS) { 373 error_propagate(errp, err); 374 goto fail; 375 } 376 error_free(err); 377 err = NULL; 378 379 blockdev_remove_medium(device, id, &err); 380 if (err) { 381 error_propagate(errp, err); 382 goto fail; 383 } 384 385 qmp_blockdev_insert_anon_medium(blk, medium_bs, &err); 386 if (err) { 387 error_propagate(errp, err); 388 goto fail; 389 } 390 391 qmp_blockdev_close_tray(device, id, errp); 392 393 fail: 394 /* If the medium has been inserted, the device has its own reference, so 395 * ours must be relinquished; and if it has not been inserted successfully, 396 * the reference must be relinquished anyway */ 397 bdrv_unref(medium_bs); 398 } 399 400 void qmp_eject(const char *device, const char *id, 401 bool has_force, bool force, Error **errp) 402 { 403 Error *local_err = NULL; 404 int rc; 405 406 if (!has_force) { 407 force = false; 408 } 409 410 rc = do_open_tray(device, id, force, &local_err); 411 if (rc && rc != -ENOSYS) { 412 error_propagate(errp, local_err); 413 return; 414 } 415 error_free(local_err); 416 417 blockdev_remove_medium(device, id, errp); 418 } 419 420 /* throttling disk I/O limits */ 421 void qmp_block_set_io_throttle(BlockIOThrottle *arg, Error **errp) 422 { 423 ThrottleConfig cfg; 424 BlockDriverState *bs; 425 BlockBackend *blk; 426 427 blk = qmp_get_blk(arg->device, arg->id, errp); 428 if (!blk) { 429 return; 430 } 431 432 bs = blk_bs(blk); 433 if (!bs) { 434 error_setg(errp, "Device has no medium"); 435 return; 436 } 437 438 throttle_config_init(&cfg); 439 cfg.buckets[THROTTLE_BPS_TOTAL].avg = arg->bps; 440 cfg.buckets[THROTTLE_BPS_READ].avg = arg->bps_rd; 441 cfg.buckets[THROTTLE_BPS_WRITE].avg = arg->bps_wr; 442 443 cfg.buckets[THROTTLE_OPS_TOTAL].avg = arg->iops; 444 cfg.buckets[THROTTLE_OPS_READ].avg = arg->iops_rd; 445 cfg.buckets[THROTTLE_OPS_WRITE].avg = arg->iops_wr; 446 447 if (arg->has_bps_max) { 448 cfg.buckets[THROTTLE_BPS_TOTAL].max = arg->bps_max; 449 } 450 if (arg->has_bps_rd_max) { 451 cfg.buckets[THROTTLE_BPS_READ].max = arg->bps_rd_max; 452 } 453 if (arg->has_bps_wr_max) { 454 cfg.buckets[THROTTLE_BPS_WRITE].max = arg->bps_wr_max; 455 } 456 if (arg->has_iops_max) { 457 cfg.buckets[THROTTLE_OPS_TOTAL].max = arg->iops_max; 458 } 459 if (arg->has_iops_rd_max) { 460 cfg.buckets[THROTTLE_OPS_READ].max = arg->iops_rd_max; 461 } 462 if (arg->has_iops_wr_max) { 463 cfg.buckets[THROTTLE_OPS_WRITE].max = arg->iops_wr_max; 464 } 465 466 if (arg->has_bps_max_length) { 467 cfg.buckets[THROTTLE_BPS_TOTAL].burst_length = arg->bps_max_length; 468 } 469 if (arg->has_bps_rd_max_length) { 470 cfg.buckets[THROTTLE_BPS_READ].burst_length = arg->bps_rd_max_length; 471 } 472 if (arg->has_bps_wr_max_length) { 473 cfg.buckets[THROTTLE_BPS_WRITE].burst_length = arg->bps_wr_max_length; 474 } 475 if (arg->has_iops_max_length) { 476 cfg.buckets[THROTTLE_OPS_TOTAL].burst_length = arg->iops_max_length; 477 } 478 if (arg->has_iops_rd_max_length) { 479 cfg.buckets[THROTTLE_OPS_READ].burst_length = arg->iops_rd_max_length; 480 } 481 if (arg->has_iops_wr_max_length) { 482 cfg.buckets[THROTTLE_OPS_WRITE].burst_length = arg->iops_wr_max_length; 483 } 484 485 if (arg->has_iops_size) { 486 cfg.op_size = arg->iops_size; 487 } 488 489 if (!throttle_is_valid(&cfg, errp)) { 490 return; 491 } 492 493 if (throttle_enabled(&cfg)) { 494 /* Enable I/O limits if they're not enabled yet, otherwise 495 * just update the throttling group. */ 496 if (!blk_get_public(blk)->throttle_group_member.throttle_state) { 497 blk_io_limits_enable(blk, arg->group ?: arg->device ?: arg->id); 498 } else if (arg->group) { 499 blk_io_limits_update_group(blk, arg->group); 500 } 501 /* Set the new throttling configuration */ 502 blk_set_io_limits(blk, &cfg); 503 } else if (blk_get_public(blk)->throttle_group_member.throttle_state) { 504 /* If all throttling settings are set to 0, disable I/O limits */ 505 blk_io_limits_disable(blk); 506 } 507 } 508 509 void qmp_block_latency_histogram_set( 510 const char *id, 511 bool has_boundaries, uint64List *boundaries, 512 bool has_boundaries_read, uint64List *boundaries_read, 513 bool has_boundaries_write, uint64List *boundaries_write, 514 bool has_boundaries_append, uint64List *boundaries_append, 515 bool has_boundaries_flush, uint64List *boundaries_flush, 516 Error **errp) 517 { 518 BlockBackend *blk = qmp_get_blk(NULL, id, errp); 519 BlockAcctStats *stats; 520 int ret; 521 522 if (!blk) { 523 return; 524 } 525 526 stats = blk_get_stats(blk); 527 528 if (!has_boundaries && !has_boundaries_read && !has_boundaries_write && 529 !has_boundaries_flush) 530 { 531 block_latency_histograms_clear(stats); 532 return; 533 } 534 535 if (has_boundaries || has_boundaries_read) { 536 ret = block_latency_histogram_set( 537 stats, BLOCK_ACCT_READ, 538 has_boundaries_read ? boundaries_read : boundaries); 539 if (ret) { 540 error_setg(errp, "Device '%s' set read boundaries fail", id); 541 return; 542 } 543 } 544 545 if (has_boundaries || has_boundaries_write) { 546 ret = block_latency_histogram_set( 547 stats, BLOCK_ACCT_WRITE, 548 has_boundaries_write ? boundaries_write : boundaries); 549 if (ret) { 550 error_setg(errp, "Device '%s' set write boundaries fail", id); 551 return; 552 } 553 } 554 555 if (has_boundaries || has_boundaries_append) { 556 ret = block_latency_histogram_set( 557 stats, BLOCK_ACCT_ZONE_APPEND, 558 has_boundaries_append ? boundaries_append : boundaries); 559 if (ret) { 560 error_setg(errp, "Device '%s' set append write boundaries fail", id); 561 return; 562 } 563 } 564 565 if (has_boundaries || has_boundaries_flush) { 566 ret = block_latency_histogram_set( 567 stats, BLOCK_ACCT_FLUSH, 568 has_boundaries_flush ? boundaries_flush : boundaries); 569 if (ret) { 570 error_setg(errp, "Device '%s' set flush boundaries fail", id); 571 return; 572 } 573 } 574 } 575