diff options
Diffstat (limited to 'src/spdk/scripts/rpc/bdev.py')
| -rw-r--r-- | src/spdk/scripts/rpc/bdev.py | 1105 |
1 files changed, 1105 insertions, 0 deletions
diff --git a/src/spdk/scripts/rpc/bdev.py b/src/spdk/scripts/rpc/bdev.py new file mode 100644 index 000000000..8c669c0b2 --- /dev/null +++ b/src/spdk/scripts/rpc/bdev.py @@ -0,0 +1,1105 @@ +from .helpers import deprecated_alias + + +@deprecated_alias('set_bdev_options') +def bdev_set_options(client, bdev_io_pool_size=None, bdev_io_cache_size=None, bdev_auto_examine=None): + """Set parameters for the bdev subsystem. + + Args: + bdev_io_pool_size: number of bdev_io structures in shared buffer pool (optional) + bdev_io_cache_size: maximum number of bdev_io structures cached per thread (optional) + bdev_auto_examine: if set to false, the bdev layer will not examine every disks automatically (optional) + """ + params = {} + + if bdev_io_pool_size: + params['bdev_io_pool_size'] = bdev_io_pool_size + if bdev_io_cache_size: + params['bdev_io_cache_size'] = bdev_io_cache_size + if bdev_auto_examine is not None: + params["bdev_auto_examine"] = bdev_auto_examine + + return client.call('bdev_set_options', params) + + +@deprecated_alias('construct_compress_bdev') +def bdev_compress_create(client, base_bdev_name, pm_path, lb_size): + """Construct a compress virtual block device. + + Args: + base_bdev_name: name of the underlying base bdev + pm_path: path to persistent memory + lb_size: logical block size for the compressed vol in bytes. Must be 4K or 512. + + Returns: + Name of created virtual block device. + """ + params = {'base_bdev_name': base_bdev_name, 'pm_path': pm_path, 'lb_size': lb_size} + + return client.call('bdev_compress_create', params) + + +@deprecated_alias('delete_compress_bdev') +def bdev_compress_delete(client, name): + """Delete compress virtual block device. + + Args: + name: name of compress vbdev to delete + """ + params = {'name': name} + return client.call('bdev_compress_delete', params) + + +@deprecated_alias('set_compress_pmd') +def compress_set_pmd(client, pmd): + """Set pmd options for the bdev compress. + + Args: + pmd: 0 = auto-select, 1 = QAT, 2 = ISAL + """ + params = {'pmd': pmd} + + return client.call('compress_set_pmd', params) + + +def bdev_compress_get_orphans(client, name=None): + """Get a list of comp bdevs that do not have a pmem file (aka orphaned). + + Args: + name: comp bdev name to query (optional; if omitted, query all comp bdevs) + + Returns: + List of comp bdev names. + """ + params = {} + if name: + params['name'] = name + return client.call('bdev_compress_get_orphans', params) + + +@deprecated_alias('construct_crypto_bdev') +def bdev_crypto_create(client, base_bdev_name, name, crypto_pmd, key, cipher=None, key2=None): + """Construct a crypto virtual block device. + + Args: + base_bdev_name: name of the underlying base bdev + name: name for the crypto vbdev + crypto_pmd: name of of the DPDK crypto driver to use + key: key + + Returns: + Name of created virtual block device. + """ + params = {'base_bdev_name': base_bdev_name, 'name': name, 'crypto_pmd': crypto_pmd, 'key': key} + if cipher: + params['cipher'] = cipher + if key2: + params['key2'] = key2 + return client.call('bdev_crypto_create', params) + + +@deprecated_alias('delete_crypto_bdev') +def bdev_crypto_delete(client, name): + """Delete crypto virtual block device. + + Args: + name: name of crypto vbdev to delete + """ + params = {'name': name} + return client.call('bdev_crypto_delete', params) + + +@deprecated_alias('construct_ocf_bdev') +def bdev_ocf_create(client, name, mode, cache_bdev_name, core_bdev_name): + """Add an OCF block device + + Args: + name: name of constructed OCF bdev + mode: OCF cache mode: {'wb', 'wt', 'pt', 'wa', 'wi', 'wo'} + cache_bdev_name: name of underlying cache bdev + core_bdev_name: name of underlying core bdev + + Returns: + Name of created block device + """ + params = {'name': name, 'mode': mode, 'cache_bdev_name': cache_bdev_name, 'core_bdev_name': core_bdev_name} + + return client.call('bdev_ocf_create', params) + + +@deprecated_alias('delete_ocf_bdev') +def bdev_ocf_delete(client, name): + """Delete an OCF device + + Args: + name: name of OCF bdev + + """ + params = {'name': name} + + return client.call('bdev_ocf_delete', params) + + +@deprecated_alias('get_ocf_stats') +def bdev_ocf_get_stats(client, name): + """Get statistics of chosen OCF block device + + Args: + name: name of OCF bdev + + Returns: + Statistics as json object + """ + params = {'name': name} + + return client.call('bdev_ocf_get_stats', params) + + +@deprecated_alias('get_ocf_stats') +def bdev_ocf_get_bdevs(client, name=None): + """Get list of OCF devices including unregistered ones + + Args: + name: name of OCF vbdev or name of cache device or name of core device (optional) + + Returns: + Array of OCF devices with their current status + """ + params = None + if name: + params = {'name': name} + return client.call('bdev_ocf_get_bdevs', params) + + +@deprecated_alias('construct_malloc_bdev') +def bdev_malloc_create(client, num_blocks, block_size, name=None, uuid=None): + """Construct a malloc block device. + + Args: + num_blocks: size of block device in blocks + block_size: block size of device; must be a power of 2 and at least 512 + name: name of block device (optional) + uuid: UUID of block device (optional) + + Returns: + Name of created block device. + """ + params = {'num_blocks': num_blocks, 'block_size': block_size} + if name: + params['name'] = name + if uuid: + params['uuid'] = uuid + return client.call('bdev_malloc_create', params) + + +@deprecated_alias('delete_malloc_bdev') +def bdev_malloc_delete(client, name): + """Delete malloc block device. + + Args: + bdev_name: name of malloc bdev to delete + """ + params = {'name': name} + return client.call('bdev_malloc_delete', params) + + +@deprecated_alias('construct_null_bdev') +def bdev_null_create(client, num_blocks, block_size, name, uuid=None, md_size=None, + dif_type=None, dif_is_head_of_md=None): + """Construct a null block device. + + Args: + num_blocks: size of block device in blocks + block_size: block size of device; data part size must be a power of 2 and at least 512 + name: name of block device + uuid: UUID of block device (optional) + md_size: metadata size of device (optional) + dif_type: protection information type (optional) + dif_is_head_of_md: protection information is in the first 8 bytes of metadata (optional) + + Returns: + Name of created block device. + """ + params = {'name': name, 'num_blocks': num_blocks, + 'block_size': block_size} + if uuid: + params['uuid'] = uuid + if md_size: + params['md_size'] = md_size + if dif_type: + params['dif_type'] = dif_type + if dif_is_head_of_md: + params['dif_is_head_of_md'] = dif_is_head_of_md + return client.call('bdev_null_create', params) + + +@deprecated_alias('delete_null_bdev') +def bdev_null_delete(client, name): + """Remove null bdev from the system. + + Args: + name: name of null bdev to delete + """ + params = {'name': name} + return client.call('bdev_null_delete', params) + + +@deprecated_alias('get_raid_bdevs') +def bdev_raid_get_bdevs(client, category): + """Get list of raid bdevs based on category + + Args: + category: any one of all or online or configuring or offline + + Returns: + List of raid bdev names + """ + params = {'category': category} + return client.call('bdev_raid_get_bdevs', params) + + +@deprecated_alias('construct_raid_bdev') +def bdev_raid_create(client, name, raid_level, base_bdevs, strip_size=None, strip_size_kb=None): + """Create raid bdev. Either strip size arg will work but one is required. + + Args: + name: user defined raid bdev name + strip_size (deprecated): strip size of raid bdev in KB, supported values like 8, 16, 32, 64, 128, 256, etc + strip_size_kb: strip size of raid bdev in KB, supported values like 8, 16, 32, 64, 128, 256, etc + raid_level: raid level of raid bdev, supported values 0 + base_bdevs: Space separated names of Nvme bdevs in double quotes, like "Nvme0n1 Nvme1n1 Nvme2n1" + + Returns: + None + """ + params = {'name': name, 'raid_level': raid_level, 'base_bdevs': base_bdevs} + + if strip_size: + params['strip_size'] = strip_size + + if strip_size_kb: + params['strip_size_kb'] = strip_size_kb + + return client.call('bdev_raid_create', params) + + +@deprecated_alias('destroy_raid_bdev') +def bdev_raid_delete(client, name): + """Delete raid bdev + + Args: + name: raid bdev name + + Returns: + None + """ + params = {'name': name} + return client.call('bdev_raid_delete', params) + + +@deprecated_alias('construct_aio_bdev') +def bdev_aio_create(client, filename, name, block_size=None): + """Construct a Linux AIO block device. + + Args: + filename: path to device or file (ex: /dev/sda) + name: name of block device + block_size: block size of device (optional; autodetected if omitted) + + Returns: + Name of created block device. + """ + params = {'name': name, + 'filename': filename} + + if block_size: + params['block_size'] = block_size + + return client.call('bdev_aio_create', params) + + +@deprecated_alias('delete_aio_bdev') +def bdev_aio_delete(client, name): + """Remove aio bdev from the system. + + Args: + bdev_name: name of aio bdev to delete + """ + params = {'name': name} + return client.call('bdev_aio_delete', params) + + +def bdev_uring_create(client, filename, name, block_size=None): + """Create a bdev with Linux io_uring backend. + + Args: + filename: path to device or file (ex: /dev/nvme0n1) + name: name of bdev + block_size: block size of device (optional; autodetected if omitted) + + Returns: + Name of created bdev. + """ + params = {'name': name, + 'filename': filename} + + if block_size: + params['block_size'] = block_size + + return client.call('bdev_uring_create', params) + + +def bdev_uring_delete(client, name): + """Delete a uring bdev. + + Args: + name: name of uring bdev to delete + """ + params = {'name': name} + return client.call('bdev_uring_delete', params) + + +@deprecated_alias('set_bdev_nvme_options') +def bdev_nvme_set_options(client, action_on_timeout=None, timeout_us=None, retry_count=None, + arbitration_burst=None, low_priority_weight=None, + medium_priority_weight=None, high_priority_weight=None, + nvme_adminq_poll_period_us=None, nvme_ioq_poll_period_us=None, io_queue_requests=None, + delay_cmd_submit=None): + """Set options for the bdev nvme. This is startup command. + + Args: + action_on_timeout: action to take on command time out. Valid values are: none, reset, abort (optional) + timeout_us: Timeout for each command, in microseconds. If 0, don't track timeouts (optional) + retry_count: The number of attempts per I/O when an I/O fails (optional) + arbitration_burst: The value is expressed as a power of two (optional) + low_prioity_weight: The number of commands that may be executed from the low priority queue at one time (optional) + medium_prioity_weight: The number of commands that may be executed from the medium priority queue at one time (optional) + high_prioity_weight: The number of commands that may be executed from the high priority queue at one time (optional) + nvme_adminq_poll_period_us: How often the admin queue is polled for asynchronous events in microseconds (optional) + nvme_ioq_poll_period_us: How often to poll I/O queues for completions in microseconds (optional) + io_queue_requests: The number of requests allocated for each NVMe I/O queue. Default: 512 (optional) + delay_cmd_submit: Enable delayed NVMe command submission to allow batching of multiple commands (optional) + """ + params = {} + + if action_on_timeout: + params['action_on_timeout'] = action_on_timeout + + if timeout_us: + params['timeout_us'] = timeout_us + + if retry_count: + params['retry_count'] = retry_count + + if arbitration_burst: + params['arbitration_burst'] = arbitration_burst + + if low_priority_weight: + params['low_priority_weight'] = low_priority_weight + + if medium_priority_weight: + params['medium_priority_weight'] = medium_priority_weight + + if high_priority_weight: + params['high_priority_weight'] = high_priority_weight + + if nvme_adminq_poll_period_us: + params['nvme_adminq_poll_period_us'] = nvme_adminq_poll_period_us + + if nvme_ioq_poll_period_us: + params['nvme_ioq_poll_period_us'] = nvme_ioq_poll_period_us + + if io_queue_requests: + params['io_queue_requests'] = io_queue_requests + + if delay_cmd_submit is not None: + params['delay_cmd_submit'] = delay_cmd_submit + + return client.call('bdev_nvme_set_options', params) + + +@deprecated_alias('set_bdev_nvme_hotplug') +def bdev_nvme_set_hotplug(client, enable, period_us=None): + """Set options for the bdev nvme. This is startup command. + + Args: + enable: True to enable hotplug, False to disable. + period_us: how often the hotplug is processed for insert and remove events. Set 0 to reset to default. (optional) + """ + params = {'enable': enable} + + if period_us: + params['period_us'] = period_us + + return client.call('bdev_nvme_set_hotplug', params) + + +@deprecated_alias('construct_nvme_bdev') +def bdev_nvme_attach_controller(client, name, trtype, traddr, adrfam=None, trsvcid=None, + priority=None, subnqn=None, hostnqn=None, hostaddr=None, + hostsvcid=None, prchk_reftag=None, prchk_guard=None): + """Construct block device for each NVMe namespace in the attached controller. + + Args: + name: bdev name prefix; "n" + namespace ID will be appended to create unique names + trtype: transport type ("PCIe", "RDMA") + traddr: transport address (PCI BDF or IP address) + adrfam: address family ("IPv4", "IPv6", "IB", or "FC") (optional for PCIe) + trsvcid: transport service ID (port number for IP-based addresses; optional for PCIe) + priority: transport connection priority (Sock priority for TCP-based transports; optional) + subnqn: subsystem NQN to connect to (optional) + hostnqn: NQN to connect from (optional) + hostaddr: host transport address (IP address for IP-based transports, NULL for PCIe or FC; optional) + hostsvcid: host transport service ID (port number for IP-based transports, NULL for PCIe or FC; optional) + prchk_reftag: Enable checking of PI reference tag for I/O processing (optional) + prchk_guard: Enable checking of PI guard for I/O processing (optional) + + Returns: + Names of created block devices. + """ + params = {'name': name, + 'trtype': trtype, + 'traddr': traddr} + + if hostnqn: + params['hostnqn'] = hostnqn + + if hostaddr: + params['hostaddr'] = hostaddr + + if hostsvcid: + params['hostsvcid'] = hostsvcid + + if adrfam: + params['adrfam'] = adrfam + + if trsvcid: + params['trsvcid'] = trsvcid + + if priority: + params['priority'] = priority + + if subnqn: + params['subnqn'] = subnqn + + if prchk_reftag: + params['prchk_reftag'] = prchk_reftag + + if prchk_guard: + params['prchk_guard'] = prchk_guard + + return client.call('bdev_nvme_attach_controller', params) + + +@deprecated_alias('delete_nvme_controller') +def bdev_nvme_detach_controller(client, name): + """Detach NVMe controller and delete any associated bdevs. + + Args: + name: controller name + """ + + params = {'name': name} + return client.call('bdev_nvme_detach_controller', params) + + +def bdev_nvme_cuse_register(client, name): + """Register CUSE devices on NVMe controller. + + Args: + name: Name of the operating NVMe controller + """ + params = {'name': name} + + return client.call('bdev_nvme_cuse_register', params) + + +def bdev_nvme_cuse_unregister(client, name): + """Unregister CUSE devices on NVMe controller. + + Args: + name: Name of the operating NVMe controller + """ + params = {'name': name} + + return client.call('bdev_nvme_cuse_unregister', params) + + +def bdev_zone_block_create(client, name, base_bdev, zone_capacity, optimal_open_zones): + """Creates a virtual zone device on top of existing non-zoned bdev. + + Args: + name: Zone device name + base_bdev: Base Nvme bdev name + zone_capacity: Surfaced zone capacity in blocks + optimal_open_zones: Number of zones required to reach optimal write speed (optional, default: 1) + + Returns: + Name of created block device. + """ + params = {'name': name, + 'base_bdev': base_bdev, + 'zone_capacity': zone_capacity, + 'optimal_open_zones': optimal_open_zones} + + return client.call('bdev_zone_block_create', params) + + +def bdev_zone_block_delete(client, name): + """Remove block zone bdev from the system. + + Args: + name: name of block zone bdev to delete + """ + params = {'name': name} + return client.call('bdev_zone_block_delete', params) + + +@deprecated_alias('construct_rbd_bdev') +def bdev_rbd_create(client, pool_name, rbd_name, block_size, name=None, user=None, config=None): + """Create a Ceph RBD block device. + + Args: + pool_name: Ceph RBD pool name + rbd_name: Ceph RBD image name + block_size: block size of RBD volume + name: name of block device (optional) + user: Ceph user name (optional) + config: map of config keys to values (optional) + + Returns: + Name of created block device. + """ + params = { + 'pool_name': pool_name, + 'rbd_name': rbd_name, + 'block_size': block_size, + } + + if name: + params['name'] = name + if user is not None: + params['user_id'] = user + if config is not None: + params['config'] = config + + return client.call('bdev_rbd_create', params) + + +@deprecated_alias('delete_rbd_bdev') +def bdev_rbd_delete(client, name): + """Remove rbd bdev from the system. + + Args: + name: name of rbd bdev to delete + """ + params = {'name': name} + return client.call('bdev_rbd_delete', params) + + +def bdev_rbd_resize(client, name, new_size): + """Resize rbd bdev in the system. + + Args: + name: name of rbd bdev to resize + new_size: new bdev size of resize operation. The unit is MiB + """ + params = { + 'name': name, + 'new_size': new_size, + } + return client.call('bdev_rbd_resize', params) + + +@deprecated_alias('construct_error_bdev') +def bdev_error_create(client, base_name): + """Construct an error injection block device. + + Args: + base_name: base bdev name + """ + params = {'base_name': base_name} + return client.call('bdev_error_create', params) + + +def bdev_delay_create(client, base_bdev_name, name, avg_read_latency, p99_read_latency, avg_write_latency, p99_write_latency): + """Construct a delay block device. + + Args: + base_bdev_name: name of the existing bdev + name: name of block device + avg_read_latency: complete 99% of read ops with this delay + p99_read_latency: complete 1% of read ops with this delay + avg_write_latency: complete 99% of write ops with this delay + p99_write_latency: complete 1% of write ops with this delay + + Returns: + Name of created block device. + """ + params = { + 'base_bdev_name': base_bdev_name, + 'name': name, + 'avg_read_latency': avg_read_latency, + 'p99_read_latency': p99_read_latency, + 'avg_write_latency': avg_write_latency, + 'p99_write_latency': p99_write_latency, + } + return client.call('bdev_delay_create', params) + + +def bdev_delay_delete(client, name): + """Remove delay bdev from the system. + + Args: + name: name of delay bdev to delete + """ + params = {'name': name} + return client.call('bdev_delay_delete', params) + + +def bdev_delay_update_latency(client, delay_bdev_name, latency_type, latency_us): + """Update the latency value for a delay block device + + Args: + delay_bdev_name: name of the delay bdev + latency_type: 'one of: avg_read, avg_write, p99_read, p99_write. No other values accepted.' + latency_us: 'new latency value.' + + Returns: + True if successful, or a specific error otherwise. + """ + params = { + 'delay_bdev_name': delay_bdev_name, + 'latency_type': latency_type, + 'latency_us': latency_us, + } + return client.call('bdev_delay_update_latency', params) + + +@deprecated_alias('delete_error_bdev') +def bdev_error_delete(client, name): + """Remove error bdev from the system. + + Args: + bdev_name: name of error bdev to delete + """ + params = {'name': name} + return client.call('bdev_error_delete', params) + + +@deprecated_alias('construct_iscsi_bdev') +def bdev_iscsi_create(client, name, url, initiator_iqn): + """Construct an iSCSI block device. + + Args: + name: name of block device + url: iSCSI URL + initiator_iqn: IQN name to be used by initiator + + Returns: + Name of created block device. + """ + params = { + 'name': name, + 'url': url, + 'initiator_iqn': initiator_iqn, + } + return client.call('bdev_iscsi_create', params) + + +@deprecated_alias('delete_iscsi_bdev') +def bdev_iscsi_delete(client, name): + """Remove iSCSI bdev from the system. + + Args: + bdev_name: name of iSCSI bdev to delete + """ + params = {'name': name} + return client.call('bdev_iscsi_delete', params) + + +@deprecated_alias('construct_pmem_bdev') +def bdev_pmem_create(client, pmem_file, name): + """Construct a libpmemblk block device. + + Args: + pmem_file: path to pmemblk pool file + name: name of block device + + Returns: + Name of created block device. + """ + params = { + 'pmem_file': pmem_file, + 'name': name + } + return client.call('bdev_pmem_create', params) + + +@deprecated_alias('delete_pmem_bdev') +def bdev_pmem_delete(client, name): + """Remove pmem bdev from the system. + + Args: + name: name of pmem bdev to delete + """ + params = {'name': name} + return client.call('bdev_pmem_delete', params) + + +@deprecated_alias('construct_passthru_bdev') +def bdev_passthru_create(client, base_bdev_name, name): + """Construct a pass-through block device. + + Args: + base_bdev_name: name of the existing bdev + name: name of block device + + Returns: + Name of created block device. + """ + params = { + 'base_bdev_name': base_bdev_name, + 'name': name, + } + return client.call('bdev_passthru_create', params) + + +@deprecated_alias('delete_passthru_bdev') +def bdev_passthru_delete(client, name): + """Remove pass through bdev from the system. + + Args: + name: name of pass through bdev to delete + """ + params = {'name': name} + return client.call('bdev_passthru_delete', params) + + +def bdev_opal_create(client, nvme_ctrlr_name, nsid, locking_range_id, range_start, range_length, password): + """Create opal virtual block devices from a base nvme bdev. + + Args: + nvme_ctrlr_name: name of the nvme ctrlr + nsid: namespace ID of nvme ctrlr + locking_range_id: locking range ID corresponding to this virtual bdev + range_start: start address of this locking range + range_length: length of this locking range + password: admin password of base nvme bdev + + Returns: + Name of the new created block devices. + """ + params = { + 'nvme_ctrlr_name': nvme_ctrlr_name, + 'nsid': nsid, + 'locking_range_id': locking_range_id, + 'range_start': range_start, + 'range_length': range_length, + 'password': password, + } + + return client.call('bdev_opal_create', params) + + +def bdev_opal_get_info(client, bdev_name, password): + """Get opal locking range info. + + Args: + bdev_name: name of opal vbdev to get info + password: admin password + + Returns: + Locking range info. + """ + params = { + 'bdev_name': bdev_name, + 'password': password, + } + + return client.call('bdev_opal_get_info', params) + + +def bdev_opal_delete(client, bdev_name, password): + """Delete opal virtual bdev from the system. + + Args: + bdev_name: name of opal vbdev to delete + password: admin password of base nvme bdev + """ + params = { + 'bdev_name': bdev_name, + 'password': password, + } + + return client.call('bdev_opal_delete', params) + + +def bdev_opal_new_user(client, bdev_name, admin_password, user_id, user_password): + """Add a user to opal bdev who can set lock state for this bdev. + + Args: + bdev_name: name of opal vbdev + admin_password: admin password + user_id: ID of the user who will be added to this opal bdev + user_password: password set for this user + """ + params = { + 'bdev_name': bdev_name, + 'admin_password': admin_password, + 'user_id': user_id, + 'user_password': user_password, + } + + return client.call('bdev_opal_new_user', params) + + +def bdev_opal_set_lock_state(client, bdev_name, user_id, password, lock_state): + """set lock state for an opal bdev. + + Args: + bdev_name: name of opal vbdev + user_id: ID of the user who will set lock state + password: password of the user + lock_state: lock state to set + """ + params = { + 'bdev_name': bdev_name, + 'user_id': user_id, + 'password': password, + 'lock_state': lock_state, + } + + return client.call('bdev_opal_set_lock_state', params) + + +@deprecated_alias('construct_split_vbdev') +def bdev_split_create(client, base_bdev, split_count, split_size_mb=None): + """Create split block devices from a base bdev. + + Args: + base_bdev: name of bdev to split + split_count: number of split bdevs to create + split_size_mb: size of each split volume in MiB (optional) + + Returns: + List of created block devices. + """ + params = { + 'base_bdev': base_bdev, + 'split_count': split_count, + } + if split_size_mb: + params['split_size_mb'] = split_size_mb + + return client.call('bdev_split_create', params) + + +@deprecated_alias('destruct_split_vbdev') +def bdev_split_delete(client, base_bdev): + """Delete split block devices. + + Args: + base_bdev: name of previously split bdev + """ + params = { + 'base_bdev': base_bdev, + } + + return client.call('bdev_split_delete', params) + + +@deprecated_alias('construct_ftl_bdev') +def bdev_ftl_create(client, name, base_bdev, **kwargs): + """Construct FTL bdev + + Args: + name: name of the bdev + base_bdev: name of the base bdev + kwargs: optional parameters + """ + params = {'name': name, + 'base_bdev': base_bdev} + for key, value in kwargs.items(): + if value is not None: + params[key] = value + + return client.call('bdev_ftl_create', params) + + +@deprecated_alias('delete_ftl_bdev') +def bdev_ftl_delete(client, name): + """Delete FTL bdev + + Args: + name: name of the bdev + """ + params = {'name': name} + + return client.call('bdev_ftl_delete', params) + + +def bdev_ocssd_create(client, ctrlr_name, bdev_name, nsid=None, range=None): + """Creates Open Channel zoned bdev on specified Open Channel controller + + Args: + ctrlr_name: name of the OC NVMe controller + bdev_name: name of the bdev to create + nsid: namespace ID + range: parallel unit range + """ + params = {'ctrlr_name': ctrlr_name, + 'bdev_name': bdev_name} + + if nsid is not None: + params['nsid'] = nsid + + if range is not None: + params['range'] = range + + return client.call('bdev_ocssd_create', params) + + +def bdev_ocssd_delete(client, name): + """Deletes Open Channel bdev + + Args: + name: name of the bdev + """ + params = {'name': name} + + return client.call('bdev_ocssd_delete', params) + + +@deprecated_alias('get_bdevs') +def bdev_get_bdevs(client, name=None): + """Get information about block devices. + + Args: + name: bdev name to query (optional; if omitted, query all bdevs) + + Returns: + List of bdev information objects. + """ + params = {} + if name: + params['name'] = name + return client.call('bdev_get_bdevs', params) + + +@deprecated_alias('get_bdevs_iostat') +def bdev_get_iostat(client, name=None): + """Get I/O statistics for block devices. + + Args: + name: bdev name to query (optional; if omitted, query all bdevs) + + Returns: + I/O statistics for the requested block devices. + """ + params = {} + if name: + params['name'] = name + return client.call('bdev_get_iostat', params) + + +@deprecated_alias('enable_bdev_histogram') +def bdev_enable_histogram(client, name, enable): + """Control whether histogram is enabled for specified bdev. + + Args: + bdev_name: name of bdev + """ + params = {'name': name, "enable": enable} + return client.call('bdev_enable_histogram', params) + + +@deprecated_alias('get_bdev_histogram') +def bdev_get_histogram(client, name): + """Get histogram for specified bdev. + + Args: + bdev_name: name of bdev + """ + params = {'name': name} + return client.call('bdev_get_histogram', params) + + +@deprecated_alias('bdev_inject_error') +def bdev_error_inject_error(client, name, io_type, error_type, num=1): + """Inject an error via an error bdev. + + Args: + name: name of error bdev + io_type: one of "clear", "read", "write", "unmap", "flush", or "all" + error_type: one of "failure" or "pending" + num: number of commands to fail + """ + params = { + 'name': name, + 'io_type': io_type, + 'error_type': error_type, + 'num': num, + } + + return client.call('bdev_error_inject_error', params) + + +@deprecated_alias('set_bdev_qd_sampling_period') +def bdev_set_qd_sampling_period(client, name, period): + """Enable queue depth tracking on a specified bdev. + + Args: + name: name of a bdev on which to track queue depth. + period: period (in microseconds) at which to update the queue depth reading. If set to 0, polling will be disabled. + """ + + params = {} + params['name'] = name + params['period'] = period + return client.call('bdev_set_qd_sampling_period', params) + + +@deprecated_alias('set_bdev_qos_limit') +def bdev_set_qos_limit( + client, + name, + rw_ios_per_sec=None, + rw_mbytes_per_sec=None, + r_mbytes_per_sec=None, + w_mbytes_per_sec=None): + """Set QoS rate limit on a block device. + + Args: + name: name of block device + rw_ios_per_sec: R/W IOs per second limit (>=10000, example: 20000). 0 means unlimited. + rw_mbytes_per_sec: R/W megabytes per second limit (>=10, example: 100). 0 means unlimited. + r_mbytes_per_sec: Read megabytes per second limit (>=10, example: 100). 0 means unlimited. + w_mbytes_per_sec: Write megabytes per second limit (>=10, example: 100). 0 means unlimited. + """ + params = {} + params['name'] = name + if rw_ios_per_sec is not None: + params['rw_ios_per_sec'] = rw_ios_per_sec + if rw_mbytes_per_sec is not None: + params['rw_mbytes_per_sec'] = rw_mbytes_per_sec + if r_mbytes_per_sec is not None: + params['r_mbytes_per_sec'] = r_mbytes_per_sec + if w_mbytes_per_sec is not None: + params['w_mbytes_per_sec'] = w_mbytes_per_sec + return client.call('bdev_set_qos_limit', params) + + +@deprecated_alias('apply_firmware') +def bdev_nvme_apply_firmware(client, bdev_name, filename): + """Download and commit firmware to NVMe device. + + Args: + bdev_name: name of NVMe block device + filename: filename of the firmware to download + """ + params = { + 'filename': filename, + 'bdev_name': bdev_name, + } + return client.call('bdev_nvme_apply_firmware', params) |