1# SPDX-License-Identifier: BSD-3-Clause 2# Copyright (C) 2017 Intel Corporation. 3# All rights reserved. 4 5 6def bdev_set_options(client, bdev_io_pool_size=None, bdev_io_cache_size=None, bdev_auto_examine=None, 7 small_buf_pool_size=None, large_buf_pool_size=None): 8 """Set parameters for the bdev subsystem. 9 10 Args: 11 bdev_io_pool_size: number of bdev_io structures in shared buffer pool (optional) 12 bdev_io_cache_size: maximum number of bdev_io structures cached per thread (optional) 13 bdev_auto_examine: if set to false, the bdev layer will not examine every disks automatically (optional) 14 small_buf_pool_size: maximum number of small buffer (8KB buffer) pool size (optional) 15 large_buf_pool_size: maximum number of large buffer (64KB buffer) pool size (optional) 16 """ 17 params = {} 18 19 if bdev_io_pool_size: 20 params['bdev_io_pool_size'] = bdev_io_pool_size 21 if bdev_io_cache_size: 22 params['bdev_io_cache_size'] = bdev_io_cache_size 23 if bdev_auto_examine is not None: 24 params["bdev_auto_examine"] = bdev_auto_examine 25 if small_buf_pool_size: 26 params['small_buf_pool_size'] = small_buf_pool_size 27 if large_buf_pool_size: 28 params['large_buf_pool_size'] = large_buf_pool_size 29 return client.call('bdev_set_options', params) 30 31 32def bdev_examine(client, name): 33 """Examine a bdev manually. If the bdev does not exist yet when this RPC is called, 34 it will be examined when it is created 35 36 Args: 37 name: name of the bdev 38 """ 39 params = { 40 'name': name 41 } 42 return client.call('bdev_examine', params) 43 44 45def bdev_wait_for_examine(client): 46 """Report when all bdevs have been examined 47 """ 48 return client.call('bdev_wait_for_examine') 49 50 51def bdev_compress_create(client, base_bdev_name, pm_path, lb_size): 52 """Construct a compress virtual block device. 53 54 Args: 55 base_bdev_name: name of the underlying base bdev 56 pm_path: path to persistent memory 57 lb_size: logical block size for the compressed vol in bytes. Must be 4K or 512. 58 59 Returns: 60 Name of created virtual block device. 61 """ 62 params = {'base_bdev_name': base_bdev_name, 'pm_path': pm_path} 63 64 if lb_size: 65 params['lb_size'] = lb_size 66 67 return client.call('bdev_compress_create', params) 68 69 70def bdev_compress_delete(client, name): 71 """Delete compress virtual block device. 72 73 Args: 74 name: name of compress vbdev to delete 75 """ 76 params = {'name': name} 77 return client.call('bdev_compress_delete', params) 78 79 80def bdev_compress_set_pmd(client, pmd): 81 """Set pmd options for the bdev compress. 82 83 Args: 84 pmd: 0 = auto-select, 1 = QAT, 2 = ISAL, 3 = mlx5_pci 85 """ 86 params = {'pmd': pmd} 87 88 return client.call('bdev_compress_set_pmd', params) 89 90 91def bdev_compress_get_orphans(client, name=None): 92 """Get a list of comp bdevs that do not have a pmem file (aka orphaned). 93 94 Args: 95 name: comp bdev name to query (optional; if omitted, query all comp bdevs) 96 97 Returns: 98 List of comp bdev names. 99 """ 100 params = {} 101 if name: 102 params['name'] = name 103 return client.call('bdev_compress_get_orphans', params) 104 105 106def bdev_crypto_create(client, base_bdev_name, name, crypto_pmd, key, cipher=None, key2=None): 107 """Construct a crypto virtual block device. 108 109 Args: 110 base_bdev_name: name of the underlying base bdev 111 name: name for the crypto vbdev 112 crypto_pmd: name of of the DPDK crypto driver to use 113 key: key 114 115 Returns: 116 Name of created virtual block device. 117 """ 118 params = {'base_bdev_name': base_bdev_name, 'name': name, 'crypto_pmd': crypto_pmd, 'key': key} 119 if cipher: 120 params['cipher'] = cipher 121 if key2: 122 params['key2'] = key2 123 return client.call('bdev_crypto_create', params) 124 125 126def bdev_crypto_delete(client, name): 127 """Delete crypto virtual block device. 128 129 Args: 130 name: name of crypto vbdev to delete 131 """ 132 params = {'name': name} 133 return client.call('bdev_crypto_delete', params) 134 135 136def bdev_ocf_create(client, name, mode, cache_line_size, cache_bdev_name, core_bdev_name): 137 """Add an OCF block device 138 139 Args: 140 name: name of constructed OCF bdev 141 mode: OCF cache mode: {'wb', 'wt', 'pt', 'wa', 'wi', 'wo'} 142 cache_line_size: OCF cache line size. The unit is KiB: {4, 8, 16, 32, 64} 143 cache_bdev_name: name of underlying cache bdev 144 core_bdev_name: name of underlying core bdev 145 146 Returns: 147 Name of created block device 148 """ 149 params = { 150 'name': name, 151 'mode': mode, 152 'cache_bdev_name': cache_bdev_name, 153 'core_bdev_name': core_bdev_name, 154 } 155 156 if cache_line_size: 157 params['cache_line_size'] = cache_line_size 158 159 return client.call('bdev_ocf_create', params) 160 161 162def bdev_ocf_delete(client, name): 163 """Delete an OCF device 164 165 Args: 166 name: name of OCF bdev 167 168 """ 169 params = {'name': name} 170 171 return client.call('bdev_ocf_delete', params) 172 173 174def bdev_ocf_get_stats(client, name): 175 """Get statistics of chosen OCF block device 176 177 Args: 178 name: name of OCF bdev 179 180 Returns: 181 Statistics as json object 182 """ 183 params = {'name': name} 184 185 return client.call('bdev_ocf_get_stats', params) 186 187 188def bdev_ocf_get_bdevs(client, name=None): 189 """Get list of OCF devices including unregistered ones 190 191 Args: 192 name: name of OCF vbdev or name of cache device or name of core device (optional) 193 194 Returns: 195 Array of OCF devices with their current status 196 """ 197 params = None 198 if name: 199 params = {'name': name} 200 return client.call('bdev_ocf_get_bdevs', params) 201 202 203def bdev_ocf_set_cache_mode(client, name, mode): 204 """Set cache mode of OCF block device 205 206 Args: 207 name: name of OCF bdev 208 mode: OCF cache mode: {'wb', 'wt', 'pt', 'wa', 'wi', 'wo'} 209 210 Returns: 211 New cache mode name 212 """ 213 params = { 214 'name': name, 215 'mode': mode, 216 } 217 218 return client.call('bdev_ocf_set_cache_mode', params) 219 220 221def bdev_ocf_set_seqcutoff(client, name, policy, threshold, promotion_count): 222 """Set sequential cutoff parameters on all cores for the given OCF cache device 223 224 Args: 225 name: Name of OCF cache bdev 226 policy: Sequential cutoff policy 227 threshold: Activation threshold [KiB] (optional) 228 promotion_count: Promotion request count (optional) 229 """ 230 params = { 231 'name': name, 232 'policy': policy, 233 } 234 if threshold: 235 params['threshold'] = threshold 236 if promotion_count: 237 params['promotion_count'] = promotion_count 238 239 return client.call('bdev_ocf_set_seqcutoff', params) 240 241 242def bdev_ocf_flush_start(client, name): 243 """Start flushing OCF cache device 244 245 Args: 246 name: name of OCF bdev 247 """ 248 params = { 249 'name': name, 250 } 251 252 return client.call('bdev_ocf_flush_start', params) 253 254 255def bdev_ocf_flush_status(client, name): 256 """Get flush status of OCF cache device 257 258 Args: 259 name: name of OCF bdev 260 261 Returns: 262 Flush status 263 """ 264 params = { 265 'name': name, 266 } 267 268 return client.call('bdev_ocf_flush_status', params) 269 270 271def bdev_malloc_create(client, num_blocks, block_size, name=None, uuid=None, optimal_io_boundary=None, 272 md_size=None, md_interleave=None, dif_type=None, dif_is_head_of_md=None): 273 """Construct a malloc block device. 274 275 Args: 276 num_blocks: size of block device in blocks 277 block_size: Data block size of device; must be a power of 2 and at least 512 278 name: name of block device (optional) 279 uuid: UUID of block device (optional) 280 optimal_io_boundary: Split on optimal IO boundary, in number of blocks, default 0 (disabled, optional) 281 md_size: metadata size of device (0, 8, 16, 32, 64, or 128), default 0 (optional) 282 md_interleave: metadata location, interleaved if set, and separated if omitted (optional) 283 dif_type: protection information type (optional) 284 dif_is_head_of_md: protection information is in the first 8 bytes of metadata (optional) 285 286 Returns: 287 Name of created block device. 288 """ 289 params = {'num_blocks': num_blocks, 'block_size': block_size} 290 if name: 291 params['name'] = name 292 if uuid: 293 params['uuid'] = uuid 294 if optimal_io_boundary: 295 params['optimal_io_boundary'] = optimal_io_boundary 296 if md_size: 297 params['md_size'] = md_size 298 if md_interleave: 299 params['md_interleave'] = md_interleave 300 if dif_type: 301 params['dif_type'] = dif_type 302 if dif_is_head_of_md: 303 params['dif_is_head_of_md'] = dif_is_head_of_md 304 305 return client.call('bdev_malloc_create', params) 306 307 308def bdev_malloc_delete(client, name): 309 """Delete malloc block device. 310 311 Args: 312 bdev_name: name of malloc bdev to delete 313 """ 314 params = {'name': name} 315 return client.call('bdev_malloc_delete', params) 316 317 318def bdev_null_create(client, num_blocks, block_size, name, uuid=None, md_size=None, 319 dif_type=None, dif_is_head_of_md=None): 320 """Construct a null block device. 321 322 Args: 323 num_blocks: size of block device in blocks 324 block_size: block size of device; data part size must be a power of 2 and at least 512 325 name: name of block device 326 uuid: UUID of block device (optional) 327 md_size: metadata size of device (optional) 328 dif_type: protection information type (optional) 329 dif_is_head_of_md: protection information is in the first 8 bytes of metadata (optional) 330 331 Returns: 332 Name of created block device. 333 """ 334 params = {'name': name, 'num_blocks': num_blocks, 335 'block_size': block_size} 336 if uuid: 337 params['uuid'] = uuid 338 if md_size: 339 params['md_size'] = md_size 340 if dif_type: 341 params['dif_type'] = dif_type 342 if dif_is_head_of_md: 343 params['dif_is_head_of_md'] = dif_is_head_of_md 344 return client.call('bdev_null_create', params) 345 346 347def bdev_null_delete(client, name): 348 """Remove null bdev from the system. 349 350 Args: 351 name: name of null bdev to delete 352 """ 353 params = {'name': name} 354 return client.call('bdev_null_delete', params) 355 356 357def bdev_null_resize(client, name, new_size): 358 """Resize null bdev in the system. 359 360 Args: 361 name: name of null bdev to resize 362 new_size: new bdev size of resize operation. The unit is MiB 363 """ 364 params = { 365 'name': name, 366 'new_size': new_size, 367 } 368 return client.call('bdev_null_resize', params) 369 370 371def bdev_raid_get_bdevs(client, category): 372 """Get list of raid bdevs based on category 373 374 Args: 375 category: any one of all or online or configuring or offline 376 377 Returns: 378 List of raid bdev details 379 """ 380 params = {'category': category} 381 return client.call('bdev_raid_get_bdevs', params) 382 383 384def bdev_raid_create(client, name, raid_level, base_bdevs, strip_size=None, strip_size_kb=None): 385 """Create raid bdev. Either strip size arg will work but one is required. 386 387 Args: 388 name: user defined raid bdev name 389 strip_size (deprecated): strip size of raid bdev in KB, supported values like 8, 16, 32, 64, 128, 256, etc 390 strip_size_kb: strip size of raid bdev in KB, supported values like 8, 16, 32, 64, 128, 256, etc 391 raid_level: raid level of raid bdev, supported values 0 392 base_bdevs: Space separated names of Nvme bdevs in double quotes, like "Nvme0n1 Nvme1n1 Nvme2n1" 393 394 Returns: 395 None 396 """ 397 params = {'name': name, 'raid_level': raid_level, 'base_bdevs': base_bdevs} 398 399 if strip_size: 400 params['strip_size'] = strip_size 401 402 if strip_size_kb: 403 params['strip_size_kb'] = strip_size_kb 404 405 return client.call('bdev_raid_create', params) 406 407 408def bdev_raid_delete(client, name): 409 """Delete raid bdev 410 411 Args: 412 name: raid bdev name 413 414 Returns: 415 None 416 """ 417 params = {'name': name} 418 return client.call('bdev_raid_delete', params) 419 420 421def bdev_aio_create(client, filename, name, block_size=None, readonly=False): 422 """Construct a Linux AIO block device. 423 424 Args: 425 filename: path to device or file (ex: /dev/sda) 426 name: name of block device 427 block_size: block size of device (optional; autodetected if omitted) 428 readonly: set aio bdev as read-only 429 430 Returns: 431 Name of created block device. 432 """ 433 params = {'name': name, 434 'filename': filename} 435 436 if block_size: 437 params['block_size'] = block_size 438 439 if readonly: 440 params['readonly'] = readonly 441 442 return client.call('bdev_aio_create', params) 443 444 445def bdev_aio_rescan(client, name): 446 """Rescan a Linux AIO block device. 447 448 Args: 449 bdev_name: name of aio bdev to delete 450 """ 451 params = {'name': name} 452 return client.call('bdev_aio_rescan', params) 453 454 455def bdev_aio_delete(client, name): 456 """Remove aio bdev from the system. 457 458 Args: 459 bdev_name: name of aio bdev to delete 460 """ 461 params = {'name': name} 462 return client.call('bdev_aio_delete', params) 463 464 465def bdev_uring_create(client, filename, name, block_size=None): 466 """Create a bdev with Linux io_uring backend. 467 468 Args: 469 filename: path to device or file (ex: /dev/nvme0n1) 470 name: name of bdev 471 block_size: block size of device (optional; autodetected if omitted) 472 473 Returns: 474 Name of created bdev. 475 """ 476 params = {'name': name, 477 'filename': filename} 478 479 if block_size: 480 params['block_size'] = block_size 481 482 return client.call('bdev_uring_create', params) 483 484 485def bdev_uring_delete(client, name): 486 """Delete a uring bdev. 487 488 Args: 489 name: name of uring bdev to delete 490 """ 491 params = {'name': name} 492 return client.call('bdev_uring_delete', params) 493 494 495def bdev_xnvme_create(client, filename, name, io_mechanism, conserve_cpu=None): 496 """Create a bdev with xNVMe backend. 497 498 Args: 499 filename: path to device or file (ex: /dev/nvme0n1) 500 name: name of xNVMe bdev to create 501 io_mechanism: I/O mechanism to use (ex: io_uring, io_uring_cmd, etc.) 502 conserve_cpu: Whether or not to conserve CPU when polling (default: False) 503 504 Returns: 505 Name of created bdev. 506 """ 507 params = { 508 'name': name, 509 'filename': filename, 510 'io_mechanism': io_mechanism, 511 } 512 if conserve_cpu: 513 params['conserve_cpu'] = conserve_cpu 514 515 return client.call('bdev_xnvme_create', params) 516 517 518def bdev_xnvme_delete(client, name): 519 """Delete a xNVMe bdev. 520 521 Args: 522 name: name of xNVMe bdev to delete 523 """ 524 params = {'name': name} 525 return client.call('bdev_xnvme_delete', params) 526 527 528def bdev_nvme_set_options(client, action_on_timeout=None, timeout_us=None, timeout_admin_us=None, 529 keep_alive_timeout_ms=None, retry_count=None, arbitration_burst=None, 530 low_priority_weight=None, medium_priority_weight=None, high_priority_weight=None, 531 nvme_adminq_poll_period_us=None, nvme_ioq_poll_period_us=None, io_queue_requests=None, 532 delay_cmd_submit=None, transport_retry_count=None, bdev_retry_count=None, 533 transport_ack_timeout=None, ctrlr_loss_timeout_sec=None, reconnect_delay_sec=None, 534 fast_io_fail_timeout_sec=None, disable_auto_failback=None, generate_uuids=None, 535 transport_tos=None, nvme_error_stat=None): 536 """Set options for the bdev nvme. This is startup command. 537 538 Args: 539 action_on_timeout: action to take on command time out. Valid values are: none, reset, abort (optional) 540 timeout_us: Timeout for each command, in microseconds. If 0, don't track timeouts (optional) 541 timeout_admin_us: Timeout for each admin command, in microseconds. If 0, treat same as io timeouts (optional) 542 keep_alive_timeout_ms: Keep alive timeout period in millisecond, default is 10s (optional) 543 retry_count: The number of attempts per I/O when an I/O fails (deprecated) (optional) 544 arbitration_burst: The value is expressed as a power of two (optional) 545 low_priority_weight: The number of commands that may be executed from the low priority queue at one time (optional) 546 medium_priority_weight: The number of commands that may be executed from the medium priority queue at one time (optional) 547 high_priority_weight: The number of commands that may be executed from the high priority queue at one time (optional) 548 nvme_adminq_poll_period_us: How often the admin queue is polled for asynchronous events in microseconds (optional) 549 nvme_ioq_poll_period_us: How often to poll I/O queues for completions in microseconds (optional) 550 io_queue_requests: The number of requests allocated for each NVMe I/O queue. Default: 512 (optional) 551 delay_cmd_submit: Enable delayed NVMe command submission to allow batching of multiple commands (optional) 552 transport_retry_count: The number of attempts per I/O in the transport layer when an I/O fails (optional) 553 bdev_retry_count: The number of attempts per I/O in the bdev layer when an I/O fails. -1 means infinite retries. (optional) 554 transport_ack_timeout: Time to wait ack until packet retransmission for RDMA or until closes connection for TCP. 555 Range 0-31 where 0 is driver-specific default value (optional) 556 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 557 -1 means infinite reconnect retries. 0 means no reconnect retry. 558 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 559 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 560 This can be overridden by bdev_nvme_attach_controller. (optional) 561 reconnect_delay_sec: Time to delay a reconnect retry. 562 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 563 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 564 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 565 This can be overridden by bdev_nvme_attach_controller. (optional) 566 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 567 0 means no such timeout. 568 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 569 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. 570 This can be overridden by bdev_nvme_attach_controller. (optional) 571 disable_auto_failback: Disable automatic failback. bdev_nvme_set_preferred_path can be used to do manual failback. 572 By default, immediately failback to the preferred I/O path if it is restored. (optional) 573 generate_uuids: Enable generation of unique identifiers for NVMe bdevs only if they do not provide UUID themselves. 574 These strings are based on device serial number and namespace ID and will always be the same for that device. 575 transport_tos: IPv4 Type of Service value. Only applicable for RDMA transports. 576 The default is 0 which means no TOS is applied. (optional) 577 nvme_error_stat: Enable collecting NVMe error counts. (optional) 578 579 """ 580 params = {} 581 582 if action_on_timeout: 583 params['action_on_timeout'] = action_on_timeout 584 585 if timeout_us is not None: 586 params['timeout_us'] = timeout_us 587 588 if timeout_admin_us is not None: 589 params['timeout_admin_us'] = timeout_admin_us 590 591 if keep_alive_timeout_ms is not None: 592 params['keep_alive_timeout_ms'] = keep_alive_timeout_ms 593 594 if retry_count is not None: 595 print("WARNING: retry_count is deprecated, please use transport_retry_count.") 596 params['retry_count'] = retry_count 597 598 if arbitration_burst is not None: 599 params['arbitration_burst'] = arbitration_burst 600 601 if low_priority_weight is not None: 602 params['low_priority_weight'] = low_priority_weight 603 604 if medium_priority_weight is not None: 605 params['medium_priority_weight'] = medium_priority_weight 606 607 if high_priority_weight is not None: 608 params['high_priority_weight'] = high_priority_weight 609 610 if nvme_adminq_poll_period_us: 611 params['nvme_adminq_poll_period_us'] = nvme_adminq_poll_period_us 612 613 if nvme_ioq_poll_period_us is not None: 614 params['nvme_ioq_poll_period_us'] = nvme_ioq_poll_period_us 615 616 if io_queue_requests is not None: 617 params['io_queue_requests'] = io_queue_requests 618 619 if delay_cmd_submit is not None: 620 params['delay_cmd_submit'] = delay_cmd_submit 621 622 if transport_retry_count is not None: 623 params['transport_retry_count'] = transport_retry_count 624 625 if bdev_retry_count is not None: 626 params['bdev_retry_count'] = bdev_retry_count 627 628 if transport_ack_timeout is not None: 629 params['transport_ack_timeout'] = transport_ack_timeout 630 631 if ctrlr_loss_timeout_sec is not None: 632 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 633 634 if reconnect_delay_sec is not None: 635 params['reconnect_delay_sec'] = reconnect_delay_sec 636 637 if fast_io_fail_timeout_sec is not None: 638 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 639 640 if disable_auto_failback is not None: 641 params['disable_auto_failback'] = disable_auto_failback 642 643 if generate_uuids is not None: 644 params['generate_uuids'] = generate_uuids 645 646 if transport_tos is not None: 647 params['transport_tos'] = transport_tos 648 649 if nvme_error_stat is not None: 650 params['nvme_error_stat'] = nvme_error_stat 651 652 return client.call('bdev_nvme_set_options', params) 653 654 655def bdev_nvme_set_hotplug(client, enable, period_us=None): 656 """Set options for the bdev nvme. This is startup command. 657 658 Args: 659 enable: True to enable hotplug, False to disable. 660 period_us: how often the hotplug is processed for insert and remove events. Set 0 to reset to default. (optional) 661 """ 662 params = {'enable': enable} 663 664 if period_us: 665 params['period_us'] = period_us 666 667 return client.call('bdev_nvme_set_hotplug', params) 668 669 670def bdev_nvme_attach_controller(client, name, trtype, traddr, adrfam=None, trsvcid=None, 671 priority=None, subnqn=None, hostnqn=None, hostaddr=None, 672 hostsvcid=None, prchk_reftag=None, prchk_guard=None, 673 hdgst=None, ddgst=None, fabrics_timeout=None, multipath=None, num_io_queues=None, 674 ctrlr_loss_timeout_sec=None, reconnect_delay_sec=None, 675 fast_io_fail_timeout_sec=None, psk=None): 676 """Construct block device for each NVMe namespace in the attached controller. 677 678 Args: 679 name: bdev name prefix; "n" + namespace ID will be appended to create unique names 680 trtype: transport type ("PCIe", "RDMA", "FC", "TCP") 681 traddr: transport address (PCI BDF or IP address) 682 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 683 trsvcid: transport service ID (port number for IP-based addresses) 684 priority: transport connection priority (Sock priority for TCP-based transports; optional) 685 subnqn: subsystem NQN to connect to (optional) 686 hostnqn: NQN to connect from (optional) 687 hostaddr: host transport address (IP address for IP-based transports, NULL for PCIe or FC; optional) 688 hostsvcid: host transport service ID (port number for IP-based transports, NULL for PCIe or FC; optional) 689 prchk_reftag: Enable checking of PI reference tag for I/O processing (optional) 690 prchk_guard: Enable checking of PI guard for I/O processing (optional) 691 hdgst: Enable TCP header digest (optional) 692 ddgst: Enable TCP data digest (optional) 693 fabrics_timeout: Fabrics connect timeout in us (optional) 694 multipath: The behavior when multiple paths are created ("disable", "failover", or "multipath"; failover if not specified) 695 num_io_queues: The number of IO queues to request during initialization. (optional) 696 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 697 -1 means infinite reconnect retries. 0 means no reconnect retry. 698 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 699 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 700 (optional) 701 reconnect_delay_sec: Time to delay a reconnect retry. 702 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 703 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 704 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 705 (optional) 706 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 707 0 means no such timeout. 708 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 709 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. (optional) 710 psk: Set PSK and enable TCP SSL socket implementation (optional) 711 712 Returns: 713 Names of created block devices. 714 """ 715 params = {'name': name, 716 'trtype': trtype, 717 'traddr': traddr} 718 719 if hostnqn: 720 params['hostnqn'] = hostnqn 721 722 if hostaddr: 723 params['hostaddr'] = hostaddr 724 725 if hostsvcid: 726 params['hostsvcid'] = hostsvcid 727 728 if adrfam: 729 params['adrfam'] = adrfam 730 731 if trsvcid: 732 params['trsvcid'] = trsvcid 733 734 if priority: 735 params['priority'] = priority 736 737 if subnqn: 738 params['subnqn'] = subnqn 739 740 if prchk_reftag: 741 params['prchk_reftag'] = prchk_reftag 742 743 if prchk_guard: 744 params['prchk_guard'] = prchk_guard 745 746 if hdgst: 747 params['hdgst'] = hdgst 748 749 if ddgst: 750 params['ddgst'] = ddgst 751 752 if fabrics_timeout: 753 params['fabrics_connect_timeout_us'] = fabrics_timeout 754 755 if multipath: 756 params['multipath'] = multipath 757 758 if num_io_queues: 759 params['num_io_queues'] = num_io_queues 760 761 if ctrlr_loss_timeout_sec is not None: 762 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 763 764 if reconnect_delay_sec is not None: 765 params['reconnect_delay_sec'] = reconnect_delay_sec 766 767 if fast_io_fail_timeout_sec is not None: 768 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 769 770 if psk: 771 params['psk'] = psk 772 773 return client.call('bdev_nvme_attach_controller', params) 774 775 776def bdev_nvme_detach_controller(client, name, trtype=None, traddr=None, 777 adrfam=None, trsvcid=None, subnqn=None, 778 hostaddr=None, hostsvcid=None): 779 """Detach NVMe controller and delete any associated bdevs. Optionally, 780 If all of the transport ID options are specified, only remove that 781 transport path from the specified controller. If that is the only 782 available path for the controller, this will also result in the 783 controller being detached and the associated bdevs being deleted. 784 785 Args: 786 name: controller name 787 trtype: transport type ("PCIe", "RDMA") 788 traddr: transport address (PCI BDF or IP address) 789 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 790 trsvcid: transport service ID (port number for IP-based addresses) 791 subnqn: subsystem NQN to connect to (optional) 792 hostaddr: Host address (IP address) 793 hostsvcid: transport service ID on host side (port number) 794 """ 795 796 params = {'name': name} 797 798 if trtype: 799 params['trtype'] = trtype 800 801 if traddr: 802 params['traddr'] = traddr 803 804 if adrfam: 805 params['adrfam'] = adrfam 806 807 if trsvcid: 808 params['trsvcid'] = trsvcid 809 810 if subnqn: 811 params['subnqn'] = subnqn 812 813 if hostaddr: 814 params['hostaddr'] = hostaddr 815 816 if hostsvcid: 817 params['hostsvcid'] = hostsvcid 818 819 return client.call('bdev_nvme_detach_controller', params) 820 821 822def bdev_nvme_reset_controller(client, name): 823 """Reset NVMe controller. 824 825 Args: 826 name: controller name 827 """ 828 829 params = {'name': name} 830 831 return client.call('bdev_nvme_reset_controller', params) 832 833 834def bdev_nvme_start_discovery(client, name, trtype, traddr, adrfam=None, trsvcid=None, 835 hostnqn=None, wait_for_attach=None, ctrlr_loss_timeout_sec=None, 836 reconnect_delay_sec=None, fast_io_fail_timeout_sec=None, 837 attach_timeout_ms=None): 838 """Start discovery with the specified discovery subsystem 839 840 Args: 841 name: bdev name prefix; "n" + namespace ID will be appended to create unique names 842 trtype: transport type ("PCIe", "RDMA", "FC", "TCP") 843 traddr: transport address (PCI BDF or IP address) 844 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 845 trsvcid: transport service ID (port number for IP-based addresses) 846 hostnqn: NQN to connect from (optional) 847 wait_for_attach: Wait to complete RPC until all discovered NVM subsystems have attached (optional) 848 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 849 -1 means infinite reconnect retries. 0 means no reconnect retry. 850 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 851 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 852 (optional) 853 reconnect_delay_sec: Time to delay a reconnect retry. 854 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 855 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 856 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 857 (optional) 858 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 859 0 means no such timeout. 860 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 861 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. (optional) 862 attach_timeout_ms: Time to wait until the discovery and all discovered NVM subsystems are attached (optional) 863 """ 864 params = {'name': name, 865 'trtype': trtype, 866 'traddr': traddr} 867 868 if hostnqn: 869 params['hostnqn'] = hostnqn 870 871 if adrfam: 872 params['adrfam'] = adrfam 873 874 if trsvcid: 875 params['trsvcid'] = trsvcid 876 877 if wait_for_attach: 878 params['wait_for_attach'] = True 879 880 if attach_timeout_ms is not None: 881 params['attach_timeout_ms'] = attach_timeout_ms 882 883 if ctrlr_loss_timeout_sec is not None: 884 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 885 886 if reconnect_delay_sec is not None: 887 params['reconnect_delay_sec'] = reconnect_delay_sec 888 889 if fast_io_fail_timeout_sec is not None: 890 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 891 892 return client.call('bdev_nvme_start_discovery', params) 893 894 895def bdev_nvme_stop_discovery(client, name): 896 """Stop a previously started discovery service 897 898 Args: 899 name: name of discovery service to start 900 """ 901 params = {'name': name} 902 903 return client.call('bdev_nvme_stop_discovery', params) 904 905 906def bdev_nvme_get_discovery_info(client): 907 """Get information about the automatic discovery 908 """ 909 return client.call('bdev_nvme_get_discovery_info') 910 911 912def bdev_nvme_get_io_paths(client, name): 913 """Display all or the specified NVMe bdev's active I/O paths 914 915 Args: 916 name: Name of the NVMe bdev (optional) 917 918 Returns: 919 List of active I/O paths 920 """ 921 params = {} 922 if name: 923 params['name'] = name 924 return client.call('bdev_nvme_get_io_paths', params) 925 926 927def bdev_nvme_set_preferred_path(client, name, cntlid): 928 """Set the preferred I/O path for an NVMe bdev when in multipath mode 929 930 Args: 931 name: NVMe bdev name 932 cntlid: NVMe-oF controller ID 933 """ 934 935 params = {'name': name, 936 'cntlid': cntlid} 937 938 return client.call('bdev_nvme_set_preferred_path', params) 939 940 941def bdev_nvme_set_multipath_policy(client, name, policy): 942 """Set multipath policy of the NVMe bdev 943 944 Args: 945 name: NVMe bdev name 946 policy: Multipath policy (active_passive or active_active) 947 """ 948 949 params = {'name': name, 950 'policy': policy} 951 952 return client.call('bdev_nvme_set_multipath_policy', params) 953 954 955def bdev_nvme_cuse_register(client, name): 956 """Register CUSE devices on NVMe controller. 957 958 Args: 959 name: Name of the operating NVMe controller 960 """ 961 params = {'name': name} 962 963 return client.call('bdev_nvme_cuse_register', params) 964 965 966def bdev_nvme_cuse_unregister(client, name): 967 """Unregister CUSE devices on NVMe controller. 968 969 Args: 970 name: Name of the operating NVMe controller 971 """ 972 params = {'name': name} 973 974 return client.call('bdev_nvme_cuse_unregister', params) 975 976 977def bdev_zone_block_create(client, name, base_bdev, zone_capacity, optimal_open_zones): 978 """Creates a virtual zone device on top of existing non-zoned bdev. 979 980 Args: 981 name: Zone device name 982 base_bdev: Base Nvme bdev name 983 zone_capacity: Surfaced zone capacity in blocks 984 optimal_open_zones: Number of zones required to reach optimal write speed (optional, default: 1) 985 986 Returns: 987 Name of created block device. 988 """ 989 params = {'name': name, 990 'base_bdev': base_bdev, 991 'zone_capacity': zone_capacity, 992 'optimal_open_zones': optimal_open_zones} 993 994 return client.call('bdev_zone_block_create', params) 995 996 997def bdev_zone_block_delete(client, name): 998 """Remove block zone bdev from the system. 999 1000 Args: 1001 name: name of block zone bdev to delete 1002 """ 1003 params = {'name': name} 1004 return client.call('bdev_zone_block_delete', params) 1005 1006 1007def bdev_rbd_register_cluster(client, name, user=None, config_param=None, config_file=None, key_file=None): 1008 """Create a Rados Cluster object of the Ceph RBD backend. 1009 1010 Args: 1011 name: name of Rados Cluster 1012 user: Ceph user name (optional) 1013 config_param: map of config keys to values (optional) 1014 config_file: file path of Ceph configuration file (optional) 1015 key_file: file path of Ceph key file (optional) 1016 1017 Returns: 1018 Name of registered Rados Cluster object. 1019 """ 1020 params = {'name': name} 1021 1022 if user is not None: 1023 params['user_id'] = user 1024 if config_param is not None: 1025 params['config_param'] = config_param 1026 if config_file is not None: 1027 params['config_file'] = config_file 1028 if key_file is not None: 1029 params['key_file'] = key_file 1030 1031 return client.call('bdev_rbd_register_cluster', params) 1032 1033 1034def bdev_rbd_unregister_cluster(client, name): 1035 """Remove Rados cluster object from the system. 1036 1037 Args: 1038 name: name of Rados cluster object to unregister 1039 """ 1040 params = {'name': name} 1041 return client.call('bdev_rbd_unregister_cluster', params) 1042 1043 1044def bdev_rbd_get_clusters_info(client, name): 1045 """Get the cluster(s) info 1046 1047 Args: 1048 name: name of Rados cluster object to query (optional; if omitted, query all clusters) 1049 1050 Returns: 1051 List of registered Rados cluster information objects. 1052 """ 1053 params = {} 1054 if name: 1055 params['name'] = name 1056 return client.call('bdev_rbd_get_clusters_info', params) 1057 1058 1059def bdev_rbd_create(client, pool_name, rbd_name, block_size, name=None, user=None, config=None, cluster_name=None, uuid=None): 1060 """Create a Ceph RBD block device. 1061 1062 Args: 1063 pool_name: Ceph RBD pool name 1064 rbd_name: Ceph RBD image name 1065 block_size: block size of RBD volume 1066 name: name of block device (optional) 1067 user: Ceph user name (optional) 1068 config: map of config keys to values (optional) 1069 cluster_name: Name to identify Rados cluster (optional) 1070 uuid: UUID of block device (optional) 1071 1072 Returns: 1073 Name of created block device. 1074 """ 1075 params = { 1076 'pool_name': pool_name, 1077 'rbd_name': rbd_name, 1078 'block_size': block_size, 1079 } 1080 1081 if name: 1082 params['name'] = name 1083 if user is not None: 1084 params['user_id'] = user 1085 if config is not None: 1086 params['config'] = config 1087 if cluster_name is not None: 1088 params['cluster_name'] = cluster_name 1089 else: 1090 print("WARNING:bdev_rbd_create should be used with specifying -c to have a cluster name after bdev_rbd_register_cluster.") 1091 if uuid is not None: 1092 params['uuid'] = uuid 1093 1094 return client.call('bdev_rbd_create', params) 1095 1096 1097def bdev_rbd_delete(client, name): 1098 """Remove rbd bdev from the system. 1099 1100 Args: 1101 name: name of rbd bdev to delete 1102 """ 1103 params = {'name': name} 1104 return client.call('bdev_rbd_delete', params) 1105 1106 1107def bdev_rbd_resize(client, name, new_size): 1108 """Resize rbd bdev in the system. 1109 1110 Args: 1111 name: name of rbd bdev to resize 1112 new_size: new bdev size of resize operation. The unit is MiB 1113 """ 1114 params = { 1115 'name': name, 1116 'new_size': new_size, 1117 } 1118 return client.call('bdev_rbd_resize', params) 1119 1120 1121def bdev_error_create(client, base_name): 1122 """Construct an error injection block device. 1123 1124 Args: 1125 base_name: base bdev name 1126 """ 1127 params = {'base_name': base_name} 1128 return client.call('bdev_error_create', params) 1129 1130 1131def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_latency, avg_write_latency, p99_write_latency): 1132 """Construct a delay block device. 1133 1134 Args: 1135 base_bdev_name: name of the existing bdev 1136 name: name of block device 1137 avg_read_latency: complete 99% of read ops with this delay 1138 p99_read_latency: complete 1% of read ops with this delay 1139 avg_write_latency: complete 99% of write ops with this delay 1140 p99_write_latency: complete 1% of write ops with this delay 1141 1142 Returns: 1143 Name of created block device. 1144 """ 1145 params = { 1146 'base_bdev_name': base_bdev_name, 1147 'name': name, 1148 'avg_read_latency': avg_read_latency, 1149 'p99_read_latency': p99_read_latency, 1150 'avg_write_latency': avg_write_latency, 1151 'p99_write_latency': p99_write_latency, 1152 } 1153 return client.call('bdev_delay_create', params) 1154 1155 1156def bdev_delay_delete(client, name): 1157 """Remove delay bdev from the system. 1158 1159 Args: 1160 name: name of delay bdev to delete 1161 """ 1162 params = {'name': name} 1163 return client.call('bdev_delay_delete', params) 1164 1165 1166def bdev_delay_update_latency(client, delay_bdev_name, latency_type, latency_us): 1167 """Update the latency value for a delay block device 1168 1169 Args: 1170 delay_bdev_name: name of the delay bdev 1171 latency_type: 'one of: avg_read, avg_write, p99_read, p99_write. No other values accepted.' 1172 latency_us: 'new latency value.' 1173 1174 Returns: 1175 True if successful, or a specific error otherwise. 1176 """ 1177 params = { 1178 'delay_bdev_name': delay_bdev_name, 1179 'latency_type': latency_type, 1180 'latency_us': latency_us, 1181 } 1182 return client.call('bdev_delay_update_latency', params) 1183 1184 1185def bdev_error_delete(client, name): 1186 """Remove error bdev from the system. 1187 1188 Args: 1189 bdev_name: name of error bdev to delete 1190 """ 1191 params = {'name': name} 1192 return client.call('bdev_error_delete', params) 1193 1194 1195def bdev_iscsi_set_options(client, timeout_sec): 1196 """Set options for the bdev iscsi. 1197 1198 Args: 1199 timeout_sec: Timeout for command, in seconds, if 0, don't track timeout 1200 """ 1201 params = {} 1202 1203 if timeout_sec is not None: 1204 params['timeout_sec'] = timeout_sec 1205 1206 return client.call('bdev_iscsi_set_options', params) 1207 1208 1209def bdev_iscsi_create(client, name, url, initiator_iqn): 1210 """Construct an iSCSI block device. 1211 1212 Args: 1213 name: name of block device 1214 url: iSCSI URL 1215 initiator_iqn: IQN name to be used by initiator 1216 1217 Returns: 1218 Name of created block device. 1219 """ 1220 params = { 1221 'name': name, 1222 'url': url, 1223 'initiator_iqn': initiator_iqn, 1224 } 1225 return client.call('bdev_iscsi_create', params) 1226 1227 1228def bdev_iscsi_delete(client, name): 1229 """Remove iSCSI bdev from the system. 1230 1231 Args: 1232 bdev_name: name of iSCSI bdev to delete 1233 """ 1234 params = {'name': name} 1235 return client.call('bdev_iscsi_delete', params) 1236 1237 1238def bdev_pmem_create(client, pmem_file, name): 1239 """Construct a libpmemblk block device. 1240 1241 Args: 1242 pmem_file: path to pmemblk pool file 1243 name: name of block device 1244 1245 Returns: 1246 Name of created block device. 1247 """ 1248 params = { 1249 'pmem_file': pmem_file, 1250 'name': name 1251 } 1252 return client.call('bdev_pmem_create', params) 1253 1254 1255def bdev_pmem_delete(client, name): 1256 """Remove pmem bdev from the system. 1257 1258 Args: 1259 name: name of pmem bdev to delete 1260 """ 1261 params = {'name': name} 1262 return client.call('bdev_pmem_delete', params) 1263 1264 1265def bdev_passthru_create(client, base_bdev_name, name): 1266 """Construct a pass-through block device. 1267 1268 Args: 1269 base_bdev_name: name of the existing bdev 1270 name: name of block device 1271 1272 Returns: 1273 Name of created block device. 1274 """ 1275 params = { 1276 'base_bdev_name': base_bdev_name, 1277 'name': name, 1278 } 1279 return client.call('bdev_passthru_create', params) 1280 1281 1282def bdev_passthru_delete(client, name): 1283 """Remove pass through bdev from the system. 1284 1285 Args: 1286 name: name of pass through bdev to delete 1287 """ 1288 params = {'name': name} 1289 return client.call('bdev_passthru_delete', params) 1290 1291 1292def bdev_opal_create(client, nvme_ctrlr_name, nsid, locking_range_id, range_start, range_length, password): 1293 """Create opal virtual block devices from a base nvme bdev. 1294 1295 Args: 1296 nvme_ctrlr_name: name of the nvme ctrlr 1297 nsid: namespace ID of nvme ctrlr 1298 locking_range_id: locking range ID corresponding to this virtual bdev 1299 range_start: start address of this locking range 1300 range_length: length of this locking range 1301 password: admin password of base nvme bdev 1302 1303 Returns: 1304 Name of the new created block devices. 1305 """ 1306 params = { 1307 'nvme_ctrlr_name': nvme_ctrlr_name, 1308 'nsid': nsid, 1309 'locking_range_id': locking_range_id, 1310 'range_start': range_start, 1311 'range_length': range_length, 1312 'password': password, 1313 } 1314 1315 return client.call('bdev_opal_create', params) 1316 1317 1318def bdev_opal_get_info(client, bdev_name, password): 1319 """Get opal locking range info. 1320 1321 Args: 1322 bdev_name: name of opal vbdev to get info 1323 password: admin password 1324 1325 Returns: 1326 Locking range info. 1327 """ 1328 params = { 1329 'bdev_name': bdev_name, 1330 'password': password, 1331 } 1332 1333 return client.call('bdev_opal_get_info', params) 1334 1335 1336def bdev_opal_delete(client, bdev_name, password): 1337 """Delete opal virtual bdev from the system. 1338 1339 Args: 1340 bdev_name: name of opal vbdev to delete 1341 password: admin password of base nvme bdev 1342 """ 1343 params = { 1344 'bdev_name': bdev_name, 1345 'password': password, 1346 } 1347 1348 return client.call('bdev_opal_delete', params) 1349 1350 1351def bdev_opal_new_user(client, bdev_name, admin_password, user_id, user_password): 1352 """Add a user to opal bdev who can set lock state for this bdev. 1353 1354 Args: 1355 bdev_name: name of opal vbdev 1356 admin_password: admin password 1357 user_id: ID of the user who will be added to this opal bdev 1358 user_password: password set for this user 1359 """ 1360 params = { 1361 'bdev_name': bdev_name, 1362 'admin_password': admin_password, 1363 'user_id': user_id, 1364 'user_password': user_password, 1365 } 1366 1367 return client.call('bdev_opal_new_user', params) 1368 1369 1370def bdev_opal_set_lock_state(client, bdev_name, user_id, password, lock_state): 1371 """set lock state for an opal bdev. 1372 1373 Args: 1374 bdev_name: name of opal vbdev 1375 user_id: ID of the user who will set lock state 1376 password: password of the user 1377 lock_state: lock state to set 1378 """ 1379 params = { 1380 'bdev_name': bdev_name, 1381 'user_id': user_id, 1382 'password': password, 1383 'lock_state': lock_state, 1384 } 1385 1386 return client.call('bdev_opal_set_lock_state', params) 1387 1388 1389def bdev_split_create(client, base_bdev, split_count, split_size_mb=None): 1390 """Create split block devices from a base bdev. 1391 1392 Args: 1393 base_bdev: name of bdev to split 1394 split_count: number of split bdevs to create 1395 split_size_mb: size of each split volume in MiB (optional) 1396 1397 Returns: 1398 List of created block devices. 1399 """ 1400 params = { 1401 'base_bdev': base_bdev, 1402 'split_count': split_count, 1403 } 1404 if split_size_mb: 1405 params['split_size_mb'] = split_size_mb 1406 1407 return client.call('bdev_split_create', params) 1408 1409 1410def bdev_split_delete(client, base_bdev): 1411 """Delete split block devices. 1412 1413 Args: 1414 base_bdev: name of previously split bdev 1415 """ 1416 params = { 1417 'base_bdev': base_bdev, 1418 } 1419 1420 return client.call('bdev_split_delete', params) 1421 1422 1423def bdev_ftl_create(client, name, base_bdev, **kwargs): 1424 """Construct FTL bdev 1425 1426 Args: 1427 name: name of the bdev 1428 base_bdev: name of the base bdev 1429 kwargs: optional parameters 1430 """ 1431 params = {'name': name, 1432 'base_bdev': base_bdev} 1433 for key, value in kwargs.items(): 1434 if value is not None: 1435 params[key] = value 1436 1437 return client.call('bdev_ftl_create', params) 1438 1439 1440def bdev_ftl_load(client, name, base_bdev, **kwargs): 1441 """Load FTL bdev 1442 1443 Args: 1444 name: name of the bdev 1445 base_bdev: name of the base bdev 1446 kwargs: optional parameters 1447 """ 1448 params = {'name': name, 1449 'base_bdev': base_bdev} 1450 for key, value in kwargs.items(): 1451 if value is not None: 1452 params[key] = value 1453 1454 return client.call('bdev_ftl_load', params) 1455 1456 1457def bdev_ftl_unload(client, name, fast_shutdown): 1458 """Unload FTL bdev 1459 1460 Args: 1461 name: name of the bdev 1462 """ 1463 params = {'name': name} 1464 1465 return client.call('bdev_ftl_unload', params) 1466 1467 1468def bdev_ftl_delete(client, name, fast_shutdown): 1469 """Delete FTL bdev 1470 1471 Args: 1472 name: name of the bdev 1473 """ 1474 params = {'name': name, 1475 'fast_shutdown': fast_shutdown} 1476 1477 return client.call('bdev_ftl_delete', params) 1478 1479 1480def bdev_ftl_unmap(client, name, lba, num_blocks): 1481 """FTL unmap 1482 1483 Args: 1484 name: name of the bdev 1485 lba: starting lba to be unmapped 1486 num_blocks: number of blocks to unmap 1487 """ 1488 params = {'name': name, 1489 'lba': lba, 1490 'num_blocks': num_blocks} 1491 1492 return client.call('bdev_ftl_unmap', params) 1493 1494 1495def bdev_ftl_get_stats(client, name): 1496 """get FTL stats 1497 1498 Args: 1499 name: name of the bdev 1500 """ 1501 params = {'name': name} 1502 1503 return client.call('bdev_ftl_get_stats', params) 1504 1505 1506def bdev_get_bdevs(client, name=None, timeout=None): 1507 """Get information about block devices. 1508 1509 Args: 1510 name: bdev name to query (optional; if omitted, query all bdevs) 1511 timeout: time in ms to wait for the bdev with specified name to appear 1512 1513 Returns: 1514 List of bdev information objects. 1515 """ 1516 params = {} 1517 if name: 1518 params['name'] = name 1519 if timeout: 1520 params['timeout'] = timeout 1521 return client.call('bdev_get_bdevs', params) 1522 1523 1524def bdev_get_iostat(client, name=None, per_channel=None): 1525 """Get I/O statistics for block devices. 1526 1527 Args: 1528 name: bdev name to query (optional; if omitted, query all bdevs) 1529 per_channel: display per channel IO stats for specified bdev 1530 1531 Returns: 1532 I/O statistics for the requested block devices. 1533 """ 1534 params = {} 1535 if name: 1536 params['name'] = name 1537 if per_channel: 1538 params['per_channel'] = per_channel 1539 return client.call('bdev_get_iostat', params) 1540 1541 1542def bdev_reset_iostat(client, name=None, mode=None): 1543 """Reset I/O statistics for block devices. 1544 1545 Args: 1546 name: bdev name to reset (optional; if omitted, reset all bdevs) 1547 mode: mode to reset: all, maxmin (optional: if omitted, reset all fields) 1548 """ 1549 params = {} 1550 if name: 1551 params['name'] = name 1552 if mode: 1553 params['mode'] = mode 1554 1555 return client.call('bdev_reset_iostat', params) 1556 1557 1558def bdev_enable_histogram(client, name, enable): 1559 """Control whether histogram is enabled for specified bdev. 1560 1561 Args: 1562 bdev_name: name of bdev 1563 """ 1564 params = {'name': name, "enable": enable} 1565 return client.call('bdev_enable_histogram', params) 1566 1567 1568def bdev_get_histogram(client, name): 1569 """Get histogram for specified bdev. 1570 1571 Args: 1572 bdev_name: name of bdev 1573 """ 1574 params = {'name': name} 1575 return client.call('bdev_get_histogram', params) 1576 1577 1578def bdev_error_inject_error(client, name, io_type, error_type, num, 1579 corrupt_offset, corrupt_value): 1580 """Inject an error via an error bdev. 1581 1582 Args: 1583 name: name of error bdev 1584 io_type: one of "clear", "read", "write", "unmap", "flush", or "all" 1585 error_type: one of "failure", "pending", or "corrupt_data" 1586 num: number of commands to fail 1587 corrupt_offset: offset in bytes to xor with corrupt_value 1588 corrupt_value: value for xor (1-255, 0 is invalid) 1589 """ 1590 params = { 1591 'name': name, 1592 'io_type': io_type, 1593 'error_type': error_type, 1594 } 1595 1596 if num: 1597 params['num'] = num 1598 if corrupt_offset: 1599 params['corrupt_offset'] = corrupt_offset 1600 if corrupt_value: 1601 params['corrupt_value'] = corrupt_value 1602 1603 return client.call('bdev_error_inject_error', params) 1604 1605 1606def bdev_set_qd_sampling_period(client, name, period): 1607 """Enable queue depth tracking on a specified bdev. 1608 1609 Args: 1610 name: name of a bdev on which to track queue depth. 1611 period: period (in microseconds) at which to update the queue depth reading. If set to 0, polling will be disabled. 1612 """ 1613 1614 params = {} 1615 params['name'] = name 1616 params['period'] = period 1617 return client.call('bdev_set_qd_sampling_period', params) 1618 1619 1620def bdev_set_qos_limit( 1621 client, 1622 name, 1623 rw_ios_per_sec=None, 1624 rw_mbytes_per_sec=None, 1625 r_mbytes_per_sec=None, 1626 w_mbytes_per_sec=None): 1627 """Set QoS rate limit on a block device. 1628 1629 Args: 1630 name: name of block device 1631 rw_ios_per_sec: R/W IOs per second limit (>=1000, example: 20000). 0 means unlimited. 1632 rw_mbytes_per_sec: R/W megabytes per second limit (>=10, example: 100). 0 means unlimited. 1633 r_mbytes_per_sec: Read megabytes per second limit (>=10, example: 100). 0 means unlimited. 1634 w_mbytes_per_sec: Write megabytes per second limit (>=10, example: 100). 0 means unlimited. 1635 """ 1636 params = {} 1637 params['name'] = name 1638 if rw_ios_per_sec is not None: 1639 params['rw_ios_per_sec'] = rw_ios_per_sec 1640 if rw_mbytes_per_sec is not None: 1641 params['rw_mbytes_per_sec'] = rw_mbytes_per_sec 1642 if r_mbytes_per_sec is not None: 1643 params['r_mbytes_per_sec'] = r_mbytes_per_sec 1644 if w_mbytes_per_sec is not None: 1645 params['w_mbytes_per_sec'] = w_mbytes_per_sec 1646 return client.call('bdev_set_qos_limit', params) 1647 1648 1649def bdev_nvme_apply_firmware(client, bdev_name, filename): 1650 """Download and commit firmware to NVMe device. 1651 1652 Args: 1653 bdev_name: name of NVMe block device 1654 filename: filename of the firmware to download 1655 """ 1656 params = { 1657 'filename': filename, 1658 'bdev_name': bdev_name, 1659 } 1660 return client.call('bdev_nvme_apply_firmware', params) 1661 1662 1663def bdev_nvme_get_transport_statistics(client): 1664 """Get bdev_nvme poll group transport statistics""" 1665 return client.call('bdev_nvme_get_transport_statistics') 1666 1667 1668def bdev_nvme_get_controller_health_info(client, name): 1669 """Display health log of the required NVMe bdev controller. 1670 1671 Args: 1672 name: name of the required NVMe bdev controller 1673 1674 Returns: 1675 Health log for the requested NVMe bdev controller. 1676 """ 1677 params = {} 1678 params['name'] = name 1679 return client.call('bdev_nvme_get_controller_health_info', params) 1680 1681 1682def bdev_daos_create(client, num_blocks, block_size, pool, cont, name, oclass=None, uuid=None): 1683 """Construct DAOS block device. 1684 1685 Args: 1686 num_blocks: size of block device in blocks 1687 block_size: block size of device; must be a power of 2 and at least 512 1688 name: name of block device (also the name of the backend file on DAOS DFS) 1689 pool: UUID of DAOS pool 1690 cont: UUID of DAOS container 1691 uuid: UUID of block device (optional) 1692 oclass: DAOS object class (optional) 1693 1694 Returns: 1695 Name of created block device. 1696 """ 1697 params = {'num_blocks': num_blocks, 'block_size': block_size, 'pool': pool, 'cont': cont, 'name': name} 1698 if uuid: 1699 params['uuid'] = uuid 1700 if oclass: 1701 params['oclass'] = oclass 1702 return client.call('bdev_daos_create', params) 1703 1704 1705def bdev_daos_delete(client, name): 1706 """Delete DAOS block device. 1707 1708 Args: 1709 bdev_name: name of DAOS bdev to delete 1710 """ 1711 params = {'name': name} 1712 return client.call('bdev_daos_delete', params) 1713 1714 1715def bdev_daos_resize(client, name, new_size): 1716 """Resize DAOS bdev in the system. 1717 Args: 1718 name: name of DAOS bdev to resize 1719 new_size: new bdev size of resize operation. The unit is MiB 1720 """ 1721 params = { 1722 'name': name, 1723 'new_size': new_size, 1724 } 1725 return client.call('bdev_daos_resize', params) 1726