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