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