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 """Set options for the bdev nvme. This is startup command. 536 537 Args: 538 action_on_timeout: action to take on command time out. Valid values are: none, reset, abort (optional) 539 timeout_us: Timeout for each command, in microseconds. If 0, don't track timeouts (optional) 540 timeout_admin_us: Timeout for each admin command, in microseconds. If 0, treat same as io timeouts (optional) 541 keep_alive_timeout_ms: Keep alive timeout period in millisecond, default is 10s (optional) 542 retry_count: The number of attempts per I/O when an I/O fails (deprecated) (optional) 543 arbitration_burst: The value is expressed as a power of two (optional) 544 low_priority_weight: The number of commands that may be executed from the low priority queue at one time (optional) 545 medium_priority_weight: The number of commands that may be executed from the medium priority queue at one time (optional) 546 high_priority_weight: The number of commands that may be executed from the high priority queue at one time (optional) 547 nvme_adminq_poll_period_us: How often the admin queue is polled for asynchronous events in microseconds (optional) 548 nvme_ioq_poll_period_us: How often to poll I/O queues for completions in microseconds (optional) 549 io_queue_requests: The number of requests allocated for each NVMe I/O queue. Default: 512 (optional) 550 delay_cmd_submit: Enable delayed NVMe command submission to allow batching of multiple commands (optional) 551 transport_retry_count: The number of attempts per I/O in the transport layer when an I/O fails (optional) 552 bdev_retry_count: The number of attempts per I/O in the bdev layer when an I/O fails. -1 means infinite retries. (optional) 553 transport_ack_timeout: Time to wait ack until packet retransmission for RDMA or until closes connection for TCP. 554 Range 0-31 where 0 is driver-specific default value (optional) 555 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 556 -1 means infinite reconnect retries. 0 means no reconnect retry. 557 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 558 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 559 This can be overridden by bdev_nvme_attach_controller. (optional) 560 reconnect_delay_sec: Time to delay a reconnect retry. 561 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 562 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 563 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 564 This can be overridden by bdev_nvme_attach_controller. (optional) 565 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 566 0 means no such timeout. 567 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 568 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. 569 This can be overridden by bdev_nvme_attach_controller. (optional) 570 disable_auto_failback: Disable automatic failback. bdev_nvme_set_preferred_path can be used to do manual failback. 571 By default, immediately failback to the preferred I/O path if it is restored. (optional) 572 generate_uuids: Enable generation of unique identifiers for NVMe bdevs only if they do not provide UUID themselves. 573 These strings are based on device serial number and namespace ID and will always be the same for that device. 574 575 """ 576 params = {} 577 578 if action_on_timeout: 579 params['action_on_timeout'] = action_on_timeout 580 581 if timeout_us is not None: 582 params['timeout_us'] = timeout_us 583 584 if timeout_admin_us is not None: 585 params['timeout_admin_us'] = timeout_admin_us 586 587 if keep_alive_timeout_ms is not None: 588 params['keep_alive_timeout_ms'] = keep_alive_timeout_ms 589 590 if retry_count is not None: 591 print("WARNING: retry_count is deprecated, please use transport_retry_count.") 592 params['retry_count'] = retry_count 593 594 if arbitration_burst is not None: 595 params['arbitration_burst'] = arbitration_burst 596 597 if low_priority_weight is not None: 598 params['low_priority_weight'] = low_priority_weight 599 600 if medium_priority_weight is not None: 601 params['medium_priority_weight'] = medium_priority_weight 602 603 if high_priority_weight is not None: 604 params['high_priority_weight'] = high_priority_weight 605 606 if nvme_adminq_poll_period_us: 607 params['nvme_adminq_poll_period_us'] = nvme_adminq_poll_period_us 608 609 if nvme_ioq_poll_period_us is not None: 610 params['nvme_ioq_poll_period_us'] = nvme_ioq_poll_period_us 611 612 if io_queue_requests is not None: 613 params['io_queue_requests'] = io_queue_requests 614 615 if delay_cmd_submit is not None: 616 params['delay_cmd_submit'] = delay_cmd_submit 617 618 if transport_retry_count is not None: 619 params['transport_retry_count'] = transport_retry_count 620 621 if bdev_retry_count is not None: 622 params['bdev_retry_count'] = bdev_retry_count 623 624 if transport_ack_timeout is not None: 625 params['transport_ack_timeout'] = transport_ack_timeout 626 627 if ctrlr_loss_timeout_sec is not None: 628 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 629 630 if reconnect_delay_sec is not None: 631 params['reconnect_delay_sec'] = reconnect_delay_sec 632 633 if fast_io_fail_timeout_sec is not None: 634 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 635 636 if disable_auto_failback is not None: 637 params['disable_auto_failback'] = disable_auto_failback 638 639 if generate_uuids is not None: 640 params['generate_uuids'] = generate_uuids 641 642 return client.call('bdev_nvme_set_options', params) 643 644 645def bdev_nvme_set_hotplug(client, enable, period_us=None): 646 """Set options for the bdev nvme. This is startup command. 647 648 Args: 649 enable: True to enable hotplug, False to disable. 650 period_us: how often the hotplug is processed for insert and remove events. Set 0 to reset to default. (optional) 651 """ 652 params = {'enable': enable} 653 654 if period_us: 655 params['period_us'] = period_us 656 657 return client.call('bdev_nvme_set_hotplug', params) 658 659 660def bdev_nvme_attach_controller(client, name, trtype, traddr, adrfam=None, trsvcid=None, 661 priority=None, subnqn=None, hostnqn=None, hostaddr=None, 662 hostsvcid=None, prchk_reftag=None, prchk_guard=None, 663 hdgst=None, ddgst=None, fabrics_timeout=None, multipath=None, num_io_queues=None, 664 ctrlr_loss_timeout_sec=None, reconnect_delay_sec=None, 665 fast_io_fail_timeout_sec=None, psk=None): 666 """Construct block device for each NVMe namespace in the attached controller. 667 668 Args: 669 name: bdev name prefix; "n" + namespace ID will be appended to create unique names 670 trtype: transport type ("PCIe", "RDMA", "FC", "TCP") 671 traddr: transport address (PCI BDF or IP address) 672 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 673 trsvcid: transport service ID (port number for IP-based addresses) 674 priority: transport connection priority (Sock priority for TCP-based transports; optional) 675 subnqn: subsystem NQN to connect to (optional) 676 hostnqn: NQN to connect from (optional) 677 hostaddr: host transport address (IP address for IP-based transports, NULL for PCIe or FC; optional) 678 hostsvcid: host transport service ID (port number for IP-based transports, NULL for PCIe or FC; optional) 679 prchk_reftag: Enable checking of PI reference tag for I/O processing (optional) 680 prchk_guard: Enable checking of PI guard for I/O processing (optional) 681 hdgst: Enable TCP header digest (optional) 682 ddgst: Enable TCP data digest (optional) 683 fabrics_timeout: Fabrics connect timeout in us (optional) 684 multipath: The behavior when multiple paths are created ("disable", "failover", or "multipath"; failover if not specified) 685 num_io_queues: The number of IO queues to request during initialization. (optional) 686 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 687 -1 means infinite reconnect retries. 0 means no reconnect retry. 688 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 689 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 690 (optional) 691 reconnect_delay_sec: Time to delay a reconnect retry. 692 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 693 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 694 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 695 (optional) 696 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 697 0 means no such timeout. 698 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 699 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. (optional) 700 psk: Set PSK and enable TCP SSL socket implementation (optional) 701 702 Returns: 703 Names of created block devices. 704 """ 705 params = {'name': name, 706 'trtype': trtype, 707 'traddr': traddr} 708 709 if hostnqn: 710 params['hostnqn'] = hostnqn 711 712 if hostaddr: 713 params['hostaddr'] = hostaddr 714 715 if hostsvcid: 716 params['hostsvcid'] = hostsvcid 717 718 if adrfam: 719 params['adrfam'] = adrfam 720 721 if trsvcid: 722 params['trsvcid'] = trsvcid 723 724 if priority: 725 params['priority'] = priority 726 727 if subnqn: 728 params['subnqn'] = subnqn 729 730 if prchk_reftag: 731 params['prchk_reftag'] = prchk_reftag 732 733 if prchk_guard: 734 params['prchk_guard'] = prchk_guard 735 736 if hdgst: 737 params['hdgst'] = hdgst 738 739 if ddgst: 740 params['ddgst'] = ddgst 741 742 if fabrics_timeout: 743 params['fabrics_connect_timeout_us'] = fabrics_timeout 744 745 if multipath: 746 params['multipath'] = multipath 747 748 if num_io_queues: 749 params['num_io_queues'] = num_io_queues 750 751 if ctrlr_loss_timeout_sec is not None: 752 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 753 754 if reconnect_delay_sec is not None: 755 params['reconnect_delay_sec'] = reconnect_delay_sec 756 757 if fast_io_fail_timeout_sec is not None: 758 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 759 760 if psk: 761 params['psk'] = psk 762 763 return client.call('bdev_nvme_attach_controller', params) 764 765 766def bdev_nvme_detach_controller(client, name, trtype=None, traddr=None, 767 adrfam=None, trsvcid=None, subnqn=None, 768 hostaddr=None, hostsvcid=None): 769 """Detach NVMe controller and delete any associated bdevs. Optionally, 770 If all of the transport ID options are specified, only remove that 771 transport path from the specified controller. If that is the only 772 available path for the controller, this will also result in the 773 controller being detached and the associated bdevs being deleted. 774 775 Args: 776 name: controller name 777 trtype: transport type ("PCIe", "RDMA") 778 traddr: transport address (PCI BDF or IP address) 779 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 780 trsvcid: transport service ID (port number for IP-based addresses) 781 subnqn: subsystem NQN to connect to (optional) 782 hostaddr: Host address (IP address) 783 hostsvcid: transport service ID on host side (port number) 784 """ 785 786 params = {'name': name} 787 788 if trtype: 789 params['trtype'] = trtype 790 791 if traddr: 792 params['traddr'] = traddr 793 794 if adrfam: 795 params['adrfam'] = adrfam 796 797 if trsvcid: 798 params['trsvcid'] = trsvcid 799 800 if subnqn: 801 params['subnqn'] = subnqn 802 803 if hostaddr: 804 params['hostaddr'] = hostaddr 805 806 if hostsvcid: 807 params['hostsvcid'] = hostsvcid 808 809 return client.call('bdev_nvme_detach_controller', params) 810 811 812def bdev_nvme_reset_controller(client, name): 813 """Reset NVMe controller. 814 815 Args: 816 name: controller name 817 """ 818 819 params = {'name': name} 820 821 return client.call('bdev_nvme_reset_controller', params) 822 823 824def bdev_nvme_start_discovery(client, name, trtype, traddr, adrfam=None, trsvcid=None, 825 hostnqn=None, wait_for_attach=None, ctrlr_loss_timeout_sec=None, 826 reconnect_delay_sec=None, fast_io_fail_timeout_sec=None, 827 attach_timeout_ms=None): 828 """Start discovery with the specified discovery subsystem 829 830 Args: 831 name: bdev name prefix; "n" + namespace ID will be appended to create unique names 832 trtype: transport type ("PCIe", "RDMA", "FC", "TCP") 833 traddr: transport address (PCI BDF or IP address) 834 adrfam: address family ("IPv4", "IPv6", "IB", or "FC") 835 trsvcid: transport service ID (port number for IP-based addresses) 836 hostnqn: NQN to connect from (optional) 837 wait_for_attach: Wait to complete RPC until all discovered NVM subsystems have attached (optional) 838 ctrlr_loss_timeout_sec: Time to wait until ctrlr is reconnected before deleting ctrlr. 839 -1 means infinite reconnect retries. 0 means no reconnect retry. 840 If reconnect_delay_sec is zero, ctrlr_loss_timeout_sec has to be zero. 841 If reconnect_delay_sec is non-zero, ctrlr_loss_timeout_sec has to be -1 or not less than reconnect_delay_sec. 842 (optional) 843 reconnect_delay_sec: Time to delay a reconnect retry. 844 If ctrlr_loss_timeout_sec is zero, reconnect_delay_sec has to be zero. 845 If ctrlr_loss_timeout_sec is -1, reconnect_delay_sec has to be non-zero. 846 If ctrlr_loss_timeout_sec is not -1 or zero, reconnect_sec has to be non-zero and less than ctrlr_loss_timeout_sec. 847 (optional) 848 fail_io_fast_timeout_sec: Time to wait until ctrlr is reconnected before failing I/O to ctrlr. 849 0 means no such timeout. 850 If fast_io_fail_timeout_sec is not zero, it has to be not less than reconnect_delay_sec and less than 851 ctrlr_loss_timeout_sec if ctrlr_loss_timeout_sec is not -1. (optional) 852 attach_timeout_ms: Time to wait until the discovery and all discovered NVM subsystems are attached (optional) 853 """ 854 params = {'name': name, 855 'trtype': trtype, 856 'traddr': traddr} 857 858 if hostnqn: 859 params['hostnqn'] = hostnqn 860 861 if adrfam: 862 params['adrfam'] = adrfam 863 864 if trsvcid: 865 params['trsvcid'] = trsvcid 866 867 if wait_for_attach: 868 params['wait_for_attach'] = True 869 870 if attach_timeout_ms is not None: 871 params['attach_timeout_ms'] = attach_timeout_ms 872 873 if ctrlr_loss_timeout_sec is not None: 874 params['ctrlr_loss_timeout_sec'] = ctrlr_loss_timeout_sec 875 876 if reconnect_delay_sec is not None: 877 params['reconnect_delay_sec'] = reconnect_delay_sec 878 879 if fast_io_fail_timeout_sec is not None: 880 params['fast_io_fail_timeout_sec'] = fast_io_fail_timeout_sec 881 882 return client.call('bdev_nvme_start_discovery', params) 883 884 885def bdev_nvme_stop_discovery(client, name): 886 """Stop a previously started discovery service 887 888 Args: 889 name: name of discovery service to start 890 """ 891 params = {'name': name} 892 893 return client.call('bdev_nvme_stop_discovery', params) 894 895 896def bdev_nvme_get_discovery_info(client): 897 """Get information about the automatic discovery 898 """ 899 return client.call('bdev_nvme_get_discovery_info') 900 901 902def bdev_nvme_get_io_paths(client, name): 903 """Display all or the specified NVMe bdev's active I/O paths 904 905 Args: 906 name: Name of the NVMe bdev (optional) 907 908 Returns: 909 List of active I/O paths 910 """ 911 params = {} 912 if name: 913 params['name'] = name 914 return client.call('bdev_nvme_get_io_paths', params) 915 916 917def bdev_nvme_set_preferred_path(client, name, cntlid): 918 """Set the preferred I/O path for an NVMe bdev when in multipath mode 919 920 Args: 921 name: NVMe bdev name 922 cntlid: NVMe-oF controller ID 923 """ 924 925 params = {'name': name, 926 'cntlid': cntlid} 927 928 return client.call('bdev_nvme_set_preferred_path', params) 929 930 931def bdev_nvme_set_multipath_policy(client, name, policy): 932 """Set multipath policy of the NVMe bdev 933 934 Args: 935 name: NVMe bdev name 936 policy: Multipath policy (active_passive or active_active) 937 """ 938 939 params = {'name': name, 940 'policy': policy} 941 942 return client.call('bdev_nvme_set_multipath_policy', params) 943 944 945def bdev_nvme_cuse_register(client, name): 946 """Register CUSE devices on NVMe controller. 947 948 Args: 949 name: Name of the operating NVMe controller 950 """ 951 params = {'name': name} 952 953 return client.call('bdev_nvme_cuse_register', params) 954 955 956def bdev_nvme_cuse_unregister(client, name): 957 """Unregister CUSE devices on NVMe controller. 958 959 Args: 960 name: Name of the operating NVMe controller 961 """ 962 params = {'name': name} 963 964 return client.call('bdev_nvme_cuse_unregister', params) 965 966 967def bdev_zone_block_create(client, name, base_bdev, zone_capacity, optimal_open_zones): 968 """Creates a virtual zone device on top of existing non-zoned bdev. 969 970 Args: 971 name: Zone device name 972 base_bdev: Base Nvme bdev name 973 zone_capacity: Surfaced zone capacity in blocks 974 optimal_open_zones: Number of zones required to reach optimal write speed (optional, default: 1) 975 976 Returns: 977 Name of created block device. 978 """ 979 params = {'name': name, 980 'base_bdev': base_bdev, 981 'zone_capacity': zone_capacity, 982 'optimal_open_zones': optimal_open_zones} 983 984 return client.call('bdev_zone_block_create', params) 985 986 987def bdev_zone_block_delete(client, name): 988 """Remove block zone bdev from the system. 989 990 Args: 991 name: name of block zone bdev to delete 992 """ 993 params = {'name': name} 994 return client.call('bdev_zone_block_delete', params) 995 996 997def bdev_rbd_register_cluster(client, name, user=None, config_param=None, config_file=None, key_file=None): 998 """Create a Rados Cluster object of the Ceph RBD backend. 999 1000 Args: 1001 name: name of Rados Cluster 1002 user: Ceph user name (optional) 1003 config_param: map of config keys to values (optional) 1004 config_file: file path of Ceph configuration file (optional) 1005 key_file: file path of Ceph key file (optional) 1006 1007 Returns: 1008 Name of registered Rados Cluster object. 1009 """ 1010 params = {'name': name} 1011 1012 if user is not None: 1013 params['user_id'] = user 1014 if config_param is not None: 1015 params['config_param'] = config_param 1016 if config_file is not None: 1017 params['config_file'] = config_file 1018 if key_file is not None: 1019 params['key_file'] = key_file 1020 1021 return client.call('bdev_rbd_register_cluster', params) 1022 1023 1024def bdev_rbd_unregister_cluster(client, name): 1025 """Remove Rados cluster object from the system. 1026 1027 Args: 1028 name: name of Rados cluster object to unregister 1029 """ 1030 params = {'name': name} 1031 return client.call('bdev_rbd_unregister_cluster', params) 1032 1033 1034def bdev_rbd_get_clusters_info(client, name): 1035 """Get the cluster(s) info 1036 1037 Args: 1038 name: name of Rados cluster object to query (optional; if omitted, query all clusters) 1039 1040 Returns: 1041 List of registered Rados cluster information objects. 1042 """ 1043 params = {} 1044 if name: 1045 params['name'] = name 1046 return client.call('bdev_rbd_get_clusters_info', params) 1047 1048 1049def bdev_rbd_create(client, pool_name, rbd_name, block_size, name=None, user=None, config=None, cluster_name=None, uuid=None): 1050 """Create a Ceph RBD block device. 1051 1052 Args: 1053 pool_name: Ceph RBD pool name 1054 rbd_name: Ceph RBD image name 1055 block_size: block size of RBD volume 1056 name: name of block device (optional) 1057 user: Ceph user name (optional) 1058 config: map of config keys to values (optional) 1059 cluster_name: Name to identify Rados cluster (optional) 1060 uuid: UUID of block device (optional) 1061 1062 Returns: 1063 Name of created block device. 1064 """ 1065 params = { 1066 'pool_name': pool_name, 1067 'rbd_name': rbd_name, 1068 'block_size': block_size, 1069 } 1070 1071 if name: 1072 params['name'] = name 1073 if user is not None: 1074 params['user_id'] = user 1075 if config is not None: 1076 params['config'] = config 1077 if cluster_name is not None: 1078 params['cluster_name'] = cluster_name 1079 else: 1080 print("WARNING:bdev_rbd_create should be used with specifying -c to have a cluster name after bdev_rbd_register_cluster.") 1081 if uuid is not None: 1082 params['uuid'] = uuid 1083 1084 return client.call('bdev_rbd_create', params) 1085 1086 1087def bdev_rbd_delete(client, name): 1088 """Remove rbd bdev from the system. 1089 1090 Args: 1091 name: name of rbd bdev to delete 1092 """ 1093 params = {'name': name} 1094 return client.call('bdev_rbd_delete', params) 1095 1096 1097def bdev_rbd_resize(client, name, new_size): 1098 """Resize rbd bdev in the system. 1099 1100 Args: 1101 name: name of rbd bdev to resize 1102 new_size: new bdev size of resize operation. The unit is MiB 1103 """ 1104 params = { 1105 'name': name, 1106 'new_size': new_size, 1107 } 1108 return client.call('bdev_rbd_resize', params) 1109 1110 1111def bdev_error_create(client, base_name): 1112 """Construct an error injection block device. 1113 1114 Args: 1115 base_name: base bdev name 1116 """ 1117 params = {'base_name': base_name} 1118 return client.call('bdev_error_create', params) 1119 1120 1121def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_latency, avg_write_latency, p99_write_latency): 1122 """Construct a delay block device. 1123 1124 Args: 1125 base_bdev_name: name of the existing bdev 1126 name: name of block device 1127 avg_read_latency: complete 99% of read ops with this delay 1128 p99_read_latency: complete 1% of read ops with this delay 1129 avg_write_latency: complete 99% of write ops with this delay 1130 p99_write_latency: complete 1% of write ops with this delay 1131 1132 Returns: 1133 Name of created block device. 1134 """ 1135 params = { 1136 'base_bdev_name': base_bdev_name, 1137 'name': name, 1138 'avg_read_latency': avg_read_latency, 1139 'p99_read_latency': p99_read_latency, 1140 'avg_write_latency': avg_write_latency, 1141 'p99_write_latency': p99_write_latency, 1142 } 1143 return client.call('bdev_delay_create', params) 1144 1145 1146def bdev_delay_delete(client, name): 1147 """Remove delay bdev from the system. 1148 1149 Args: 1150 name: name of delay bdev to delete 1151 """ 1152 params = {'name': name} 1153 return client.call('bdev_delay_delete', params) 1154 1155 1156def bdev_delay_update_latency(client, delay_bdev_name, latency_type, latency_us): 1157 """Update the latency value for a delay block device 1158 1159 Args: 1160 delay_bdev_name: name of the delay bdev 1161 latency_type: 'one of: avg_read, avg_write, p99_read, p99_write. No other values accepted.' 1162 latency_us: 'new latency value.' 1163 1164 Returns: 1165 True if successful, or a specific error otherwise. 1166 """ 1167 params = { 1168 'delay_bdev_name': delay_bdev_name, 1169 'latency_type': latency_type, 1170 'latency_us': latency_us, 1171 } 1172 return client.call('bdev_delay_update_latency', params) 1173 1174 1175def bdev_error_delete(client, name): 1176 """Remove error bdev from the system. 1177 1178 Args: 1179 bdev_name: name of error bdev to delete 1180 """ 1181 params = {'name': name} 1182 return client.call('bdev_error_delete', params) 1183 1184 1185def bdev_iscsi_set_options(client, timeout_sec): 1186 """Set options for the bdev iscsi. 1187 1188 Args: 1189 timeout_sec: Timeout for command, in seconds, if 0, don't track timeout 1190 """ 1191 params = {} 1192 1193 if timeout_sec is not None: 1194 params['timeout_sec'] = timeout_sec 1195 1196 return client.call('bdev_iscsi_set_options', params) 1197 1198 1199def bdev_iscsi_create(client, name, url, initiator_iqn): 1200 """Construct an iSCSI block device. 1201 1202 Args: 1203 name: name of block device 1204 url: iSCSI URL 1205 initiator_iqn: IQN name to be used by initiator 1206 1207 Returns: 1208 Name of created block device. 1209 """ 1210 params = { 1211 'name': name, 1212 'url': url, 1213 'initiator_iqn': initiator_iqn, 1214 } 1215 return client.call('bdev_iscsi_create', params) 1216 1217 1218def bdev_iscsi_delete(client, name): 1219 """Remove iSCSI bdev from the system. 1220 1221 Args: 1222 bdev_name: name of iSCSI bdev to delete 1223 """ 1224 params = {'name': name} 1225 return client.call('bdev_iscsi_delete', params) 1226 1227 1228def bdev_pmem_create(client, pmem_file, name): 1229 """Construct a libpmemblk block device. 1230 1231 Args: 1232 pmem_file: path to pmemblk pool file 1233 name: name of block device 1234 1235 Returns: 1236 Name of created block device. 1237 """ 1238 params = { 1239 'pmem_file': pmem_file, 1240 'name': name 1241 } 1242 return client.call('bdev_pmem_create', params) 1243 1244 1245def bdev_pmem_delete(client, name): 1246 """Remove pmem bdev from the system. 1247 1248 Args: 1249 name: name of pmem bdev to delete 1250 """ 1251 params = {'name': name} 1252 return client.call('bdev_pmem_delete', params) 1253 1254 1255def bdev_passthru_create(client, base_bdev_name, name): 1256 """Construct a pass-through block device. 1257 1258 Args: 1259 base_bdev_name: name of the existing bdev 1260 name: name of block device 1261 1262 Returns: 1263 Name of created block device. 1264 """ 1265 params = { 1266 'base_bdev_name': base_bdev_name, 1267 'name': name, 1268 } 1269 return client.call('bdev_passthru_create', params) 1270 1271 1272def bdev_passthru_delete(client, name): 1273 """Remove pass through bdev from the system. 1274 1275 Args: 1276 name: name of pass through bdev to delete 1277 """ 1278 params = {'name': name} 1279 return client.call('bdev_passthru_delete', params) 1280 1281 1282def bdev_opal_create(client, nvme_ctrlr_name, nsid, locking_range_id, range_start, range_length, password): 1283 """Create opal virtual block devices from a base nvme bdev. 1284 1285 Args: 1286 nvme_ctrlr_name: name of the nvme ctrlr 1287 nsid: namespace ID of nvme ctrlr 1288 locking_range_id: locking range ID corresponding to this virtual bdev 1289 range_start: start address of this locking range 1290 range_length: length of this locking range 1291 password: admin password of base nvme bdev 1292 1293 Returns: 1294 Name of the new created block devices. 1295 """ 1296 params = { 1297 'nvme_ctrlr_name': nvme_ctrlr_name, 1298 'nsid': nsid, 1299 'locking_range_id': locking_range_id, 1300 'range_start': range_start, 1301 'range_length': range_length, 1302 'password': password, 1303 } 1304 1305 return client.call('bdev_opal_create', params) 1306 1307 1308def bdev_opal_get_info(client, bdev_name, password): 1309 """Get opal locking range info. 1310 1311 Args: 1312 bdev_name: name of opal vbdev to get info 1313 password: admin password 1314 1315 Returns: 1316 Locking range info. 1317 """ 1318 params = { 1319 'bdev_name': bdev_name, 1320 'password': password, 1321 } 1322 1323 return client.call('bdev_opal_get_info', params) 1324 1325 1326def bdev_opal_delete(client, bdev_name, password): 1327 """Delete opal virtual bdev from the system. 1328 1329 Args: 1330 bdev_name: name of opal vbdev to delete 1331 password: admin password of base nvme bdev 1332 """ 1333 params = { 1334 'bdev_name': bdev_name, 1335 'password': password, 1336 } 1337 1338 return client.call('bdev_opal_delete', params) 1339 1340 1341def bdev_opal_new_user(client, bdev_name, admin_password, user_id, user_password): 1342 """Add a user to opal bdev who can set lock state for this bdev. 1343 1344 Args: 1345 bdev_name: name of opal vbdev 1346 admin_password: admin password 1347 user_id: ID of the user who will be added to this opal bdev 1348 user_password: password set for this user 1349 """ 1350 params = { 1351 'bdev_name': bdev_name, 1352 'admin_password': admin_password, 1353 'user_id': user_id, 1354 'user_password': user_password, 1355 } 1356 1357 return client.call('bdev_opal_new_user', params) 1358 1359 1360def bdev_opal_set_lock_state(client, bdev_name, user_id, password, lock_state): 1361 """set lock state for an opal bdev. 1362 1363 Args: 1364 bdev_name: name of opal vbdev 1365 user_id: ID of the user who will set lock state 1366 password: password of the user 1367 lock_state: lock state to set 1368 """ 1369 params = { 1370 'bdev_name': bdev_name, 1371 'user_id': user_id, 1372 'password': password, 1373 'lock_state': lock_state, 1374 } 1375 1376 return client.call('bdev_opal_set_lock_state', params) 1377 1378 1379def bdev_split_create(client, base_bdev, split_count, split_size_mb=None): 1380 """Create split block devices from a base bdev. 1381 1382 Args: 1383 base_bdev: name of bdev to split 1384 split_count: number of split bdevs to create 1385 split_size_mb: size of each split volume in MiB (optional) 1386 1387 Returns: 1388 List of created block devices. 1389 """ 1390 params = { 1391 'base_bdev': base_bdev, 1392 'split_count': split_count, 1393 } 1394 if split_size_mb: 1395 params['split_size_mb'] = split_size_mb 1396 1397 return client.call('bdev_split_create', params) 1398 1399 1400def bdev_split_delete(client, base_bdev): 1401 """Delete split block devices. 1402 1403 Args: 1404 base_bdev: name of previously split bdev 1405 """ 1406 params = { 1407 'base_bdev': base_bdev, 1408 } 1409 1410 return client.call('bdev_split_delete', params) 1411 1412 1413def bdev_ftl_create(client, name, base_bdev, **kwargs): 1414 """Construct FTL bdev 1415 1416 Args: 1417 name: name of the bdev 1418 base_bdev: name of the base bdev 1419 kwargs: optional parameters 1420 """ 1421 params = {'name': name, 1422 'base_bdev': base_bdev} 1423 for key, value in kwargs.items(): 1424 if value is not None: 1425 params[key] = value 1426 1427 return client.call('bdev_ftl_create', params) 1428 1429 1430def bdev_ftl_load(client, name, base_bdev, **kwargs): 1431 """Load FTL bdev 1432 1433 Args: 1434 name: name of the bdev 1435 base_bdev: name of the base bdev 1436 kwargs: optional parameters 1437 """ 1438 params = {'name': name, 1439 'base_bdev': base_bdev} 1440 for key, value in kwargs.items(): 1441 if value is not None: 1442 params[key] = value 1443 1444 return client.call('bdev_ftl_load', params) 1445 1446 1447def bdev_ftl_unload(client, name, fast_shutdown): 1448 """Unload FTL bdev 1449 1450 Args: 1451 name: name of the bdev 1452 """ 1453 params = {'name': name} 1454 1455 return client.call('bdev_ftl_unload', params) 1456 1457 1458def bdev_ftl_delete(client, name, fast_shutdown): 1459 """Delete FTL bdev 1460 1461 Args: 1462 name: name of the bdev 1463 """ 1464 params = {'name': name, 1465 'fast_shutdown': fast_shutdown} 1466 1467 return client.call('bdev_ftl_delete', params) 1468 1469 1470def bdev_ftl_unmap(client, name, lba, num_blocks): 1471 """FTL unmap 1472 1473 Args: 1474 name: name of the bdev 1475 lba: starting lba to be unmapped 1476 num_blocks: number of blocks to unmap 1477 """ 1478 params = {'name': name, 1479 'lba': lba, 1480 'num_blocks': num_blocks} 1481 1482 return client.call('bdev_ftl_unmap', params) 1483 1484 1485def bdev_ftl_get_stats(client, name): 1486 """get FTL stats 1487 1488 Args: 1489 name: name of the bdev 1490 """ 1491 params = {'name': name} 1492 1493 return client.call('bdev_ftl_get_stats', params) 1494 1495 1496def bdev_get_bdevs(client, name=None, timeout=None): 1497 """Get information about block devices. 1498 1499 Args: 1500 name: bdev name to query (optional; if omitted, query all bdevs) 1501 timeout: time in ms to wait for the bdev with specified name to appear 1502 1503 Returns: 1504 List of bdev information objects. 1505 """ 1506 params = {} 1507 if name: 1508 params['name'] = name 1509 if timeout: 1510 params['timeout'] = timeout 1511 return client.call('bdev_get_bdevs', params) 1512 1513 1514def bdev_get_iostat(client, name=None, per_channel=None): 1515 """Get I/O statistics for block devices. 1516 1517 Args: 1518 name: bdev name to query (optional; if omitted, query all bdevs) 1519 per_channel: display per channel IO stats for specified bdev 1520 1521 Returns: 1522 I/O statistics for the requested block devices. 1523 """ 1524 params = {} 1525 if name: 1526 params['name'] = name 1527 if per_channel: 1528 params['per_channel'] = per_channel 1529 return client.call('bdev_get_iostat', params) 1530 1531 1532def bdev_reset_iostat(client, name=None, mode=None): 1533 """Reset I/O statistics for block devices. 1534 1535 Args: 1536 name: bdev name to reset (optional; if omitted, reset all bdevs) 1537 mode: mode to reset: all, maxmin (optional: if omitted, reset all fields) 1538 """ 1539 params = {} 1540 if name: 1541 params['name'] = name 1542 if mode: 1543 params['mode'] = mode 1544 1545 return client.call('bdev_reset_iostat', params) 1546 1547 1548def bdev_enable_histogram(client, name, enable): 1549 """Control whether histogram is enabled for specified bdev. 1550 1551 Args: 1552 bdev_name: name of bdev 1553 """ 1554 params = {'name': name, "enable": enable} 1555 return client.call('bdev_enable_histogram', params) 1556 1557 1558def bdev_get_histogram(client, name): 1559 """Get histogram for specified bdev. 1560 1561 Args: 1562 bdev_name: name of bdev 1563 """ 1564 params = {'name': name} 1565 return client.call('bdev_get_histogram', params) 1566 1567 1568def bdev_error_inject_error(client, name, io_type, error_type, num, 1569 corrupt_offset, corrupt_value): 1570 """Inject an error via an error bdev. 1571 1572 Args: 1573 name: name of error bdev 1574 io_type: one of "clear", "read", "write", "unmap", "flush", or "all" 1575 error_type: one of "failure", "pending", or "corrupt_data" 1576 num: number of commands to fail 1577 corrupt_offset: offset in bytes to xor with corrupt_value 1578 corrupt_value: value for xor (1-255, 0 is invalid) 1579 """ 1580 params = { 1581 'name': name, 1582 'io_type': io_type, 1583 'error_type': error_type, 1584 } 1585 1586 if num: 1587 params['num'] = num 1588 if corrupt_offset: 1589 params['corrupt_offset'] = corrupt_offset 1590 if corrupt_value: 1591 params['corrupt_value'] = corrupt_value 1592 1593 return client.call('bdev_error_inject_error', params) 1594 1595 1596def bdev_set_qd_sampling_period(client, name, period): 1597 """Enable queue depth tracking on a specified bdev. 1598 1599 Args: 1600 name: name of a bdev on which to track queue depth. 1601 period: period (in microseconds) at which to update the queue depth reading. If set to 0, polling will be disabled. 1602 """ 1603 1604 params = {} 1605 params['name'] = name 1606 params['period'] = period 1607 return client.call('bdev_set_qd_sampling_period', params) 1608 1609 1610def bdev_set_qos_limit( 1611 client, 1612 name, 1613 rw_ios_per_sec=None, 1614 rw_mbytes_per_sec=None, 1615 r_mbytes_per_sec=None, 1616 w_mbytes_per_sec=None): 1617 """Set QoS rate limit on a block device. 1618 1619 Args: 1620 name: name of block device 1621 rw_ios_per_sec: R/W IOs per second limit (>=1000, example: 20000). 0 means unlimited. 1622 rw_mbytes_per_sec: R/W megabytes per second limit (>=10, example: 100). 0 means unlimited. 1623 r_mbytes_per_sec: Read megabytes per second limit (>=10, example: 100). 0 means unlimited. 1624 w_mbytes_per_sec: Write megabytes per second limit (>=10, example: 100). 0 means unlimited. 1625 """ 1626 params = {} 1627 params['name'] = name 1628 if rw_ios_per_sec is not None: 1629 params['rw_ios_per_sec'] = rw_ios_per_sec 1630 if rw_mbytes_per_sec is not None: 1631 params['rw_mbytes_per_sec'] = rw_mbytes_per_sec 1632 if r_mbytes_per_sec is not None: 1633 params['r_mbytes_per_sec'] = r_mbytes_per_sec 1634 if w_mbytes_per_sec is not None: 1635 params['w_mbytes_per_sec'] = w_mbytes_per_sec 1636 return client.call('bdev_set_qos_limit', params) 1637 1638 1639def bdev_nvme_apply_firmware(client, bdev_name, filename): 1640 """Download and commit firmware to NVMe device. 1641 1642 Args: 1643 bdev_name: name of NVMe block device 1644 filename: filename of the firmware to download 1645 """ 1646 params = { 1647 'filename': filename, 1648 'bdev_name': bdev_name, 1649 } 1650 return client.call('bdev_nvme_apply_firmware', params) 1651 1652 1653def bdev_nvme_get_transport_statistics(client): 1654 """Get bdev_nvme poll group transport statistics""" 1655 return client.call('bdev_nvme_get_transport_statistics') 1656 1657 1658def bdev_nvme_get_controller_health_info(client, name): 1659 """Display health log of the required NVMe bdev controller. 1660 1661 Args: 1662 name: name of the required NVMe bdev controller 1663 1664 Returns: 1665 Health log for the requested NVMe bdev controller. 1666 """ 1667 params = {} 1668 params['name'] = name 1669 return client.call('bdev_nvme_get_controller_health_info', params) 1670 1671 1672def bdev_daos_create(client, num_blocks, block_size, pool, cont, name, oclass=None, uuid=None): 1673 """Construct DAOS block device. 1674 1675 Args: 1676 num_blocks: size of block device in blocks 1677 block_size: block size of device; must be a power of 2 and at least 512 1678 name: name of block device (also the name of the backend file on DAOS DFS) 1679 pool: UUID of DAOS pool 1680 cont: UUID of DAOS container 1681 uuid: UUID of block device (optional) 1682 oclass: DAOS object class (optional) 1683 1684 Returns: 1685 Name of created block device. 1686 """ 1687 params = {'num_blocks': num_blocks, 'block_size': block_size, 'pool': pool, 'cont': cont, 'name': name} 1688 if uuid: 1689 params['uuid'] = uuid 1690 if oclass: 1691 params['oclass'] = oclass 1692 return client.call('bdev_daos_create', params) 1693 1694 1695def bdev_daos_delete(client, name): 1696 """Delete DAOS block device. 1697 1698 Args: 1699 bdev_name: name of DAOS bdev to delete 1700 """ 1701 params = {'name': name} 1702 return client.call('bdev_daos_delete', params) 1703 1704 1705def bdev_daos_resize(client, name, new_size): 1706 """Resize DAOS bdev in the system. 1707 Args: 1708 name: name of DAOS bdev to resize 1709 new_size: new bdev size of resize operation. The unit is MiB 1710 """ 1711 params = { 1712 'name': name, 1713 'new_size': new_size, 1714 } 1715 return client.call('bdev_daos_resize', params) 1716