spdk 25.5__py3-none-any.whl

spdk/__init__.py

@@ -0,0 +1,9 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2021 Intel Corporation.
+#  All rights reserved.
+
+try:
+    # version.py is generated during the build, so ignore it if it doesn't exist
+    from .version import __version__
+except ModuleNotFoundError:
+    __version__ = '0.0'

spdk/rpc/__init__.py

@@ -0,0 +1,240 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2017 Intel Corporation.
+#  All rights reserved.
+
+import json
+import os
+import sys
+
+from io import IOBase as io
+
+from . import accel
+from . import app
+from . import bdev
+from . import blobfs
+from . import compressdev
+from . import fsdev
+from . import env_dpdk
+from . import dsa
+from . import iaa
+from . import ioat
+from . import iscsi
+from . import keyring
+from . import log
+from . import lvol
+from . import nbd
+from . import ublk
+from . import notify
+from . import nvme
+from . import nvmf
+from . import subsystem
+from . import trace
+from . import vhost
+from . import vmd
+from . import sock
+from . import vfio_user
+from . import iobuf
+from . import dpdk_cryptodev
+from . import mlx5
+from . import client as rpc_client
+
+
+def framework_start_init(client):
+    """Start initialization of subsystems"""
+    return client.call('framework_start_init')
+
+
+def framework_wait_init(client):
+    """Block until subsystems have been initialized"""
+    return client.call('framework_wait_init')
+
+
+def framework_disable_cpumask_locks(client):
+    """ Disable CPU core lock files."""
+    return client.call('framework_disable_cpumask_locks')
+
+
+def framework_enable_cpumask_locks(client):
+    """ Enable CPU core lock files."""
+    return client.call('framework_enable_cpumask_locks')
+
+
+def rpc_get_methods(client, current=None, include_aliases=None):
+    """Get list of supported RPC methods.
+    Args:
+        current: Get list of RPC methods only callable in the current state.
+        include_aliases: Include aliases in the list with RPC methods.
+    """
+    params = {}
+
+    if current:
+        params['current'] = current
+    if include_aliases:
+        params['include_aliases'] = include_aliases
+
+    return client.call('rpc_get_methods', params)
+
+
+def spdk_get_version(client):
+    """Get SPDK version"""
+    return client.call('spdk_get_version')
+
+
+def _json_dump(config, fd, indent):
+    if indent is None:
+        indent = 2
+    elif indent < 0:
+        indent = None
+    json.dump(config, fd, indent=indent)
+    fd.write('\n')
+
+
+def _json_load(j):
+    if j == sys.stdin or isinstance(j, io):
+        json_conf = json.load(j)
+    elif os.path.exists(j):
+        with open(j, "r") as j:
+            json_conf = json.load(j)
+    else:
+        json_conf = json.loads(j)
+    return json_conf
+
+
+def save_config(client, fd, indent=2, subsystems=None):
+    """Write current (live) configuration of SPDK subsystems and targets to stdout.
+    Args:
+        fd: opened file descriptor where data will be saved
+        indent: Indent level. Value less than 0 mean compact mode.
+            Default indent level is 2.
+        subsystems: subsystems (and their dependencies) to save
+    """
+    config = {
+        'subsystems': []
+    }
+
+    subsystems_json = client.call('framework_get_subsystems')
+
+    # Build a dictionary of all subsystems to their fully expanded set of
+    # dependencies.
+    dependencies = dict()
+    for elem in subsystems_json:
+        subsystem = elem['subsystem']
+        dependencies[subsystem] = {subsystem}
+        for d in elem['depends_on']:
+            dependencies[subsystem].update(dependencies[d])
+
+    # Build a set of all of the subsystems to print based on the
+    # subsystems parameter.
+    to_print = set()
+    if subsystems is None:
+        to_print = dependencies.keys()
+    else:
+        for s in subsystems.split(','):
+            to_print.update(dependencies[s])
+
+    def _print(x): return x['subsystem'] in to_print
+    for elem in filter(_print, subsystems_json):
+        cfg = {
+            'subsystem': elem['subsystem'],
+            'config': client.call('framework_get_config', {"name": elem['subsystem']})
+        }
+        config['subsystems'].append(cfg)
+
+    _json_dump(config, fd, indent)
+
+
+def load_config(client, fd, include_aliases=False):
+    """Configure SPDK subsystems and targets using JSON RPC read from stdin.
+    Args:
+        fd: opened file descriptor where data will be taken from
+    """
+    json_config = _json_load(fd)
+
+    # remove subsystems with no config
+    subsystems = json_config['subsystems']
+    for subsystem in list(subsystems):
+        if not subsystem['config']:
+            subsystems.remove(subsystem)
+
+    # check if methods in the config file are known
+    allowed_methods = client.call('rpc_get_methods', {'include_aliases': include_aliases})
+    if not subsystems and 'framework_start_init' in allowed_methods:
+        framework_start_init(client)
+        return
+
+    for subsystem in list(subsystems):
+        config = subsystem['config']
+        for elem in list(config):
+            if 'method' not in elem or elem['method'] not in allowed_methods:
+                raise rpc_client.JSONRPCException("Unknown method was included in the config file")
+
+    while subsystems:
+        allowed_methods = client.call('rpc_get_methods', {'current': True,
+                                                          'include_aliases': include_aliases})
+        allowed_found = False
+
+        for subsystem in list(subsystems):
+            config = subsystem['config']
+            for elem in list(config):
+                if 'method' not in elem or elem['method'] not in allowed_methods:
+                    continue
+
+                client.call(**elem)
+                config.remove(elem)
+                allowed_found = True
+
+            if not config:
+                subsystems.remove(subsystem)
+
+        if 'framework_start_init' in allowed_methods:
+            framework_start_init(client)
+            allowed_found = True
+
+        if not allowed_found:
+            break
+
+    if subsystems:
+        print("Some configs were skipped because the RPC state that can call them passed over.")
+
+
+def save_subsystem_config(client, fd, indent=2, name=None):
+    """Write current (live) configuration of SPDK subsystem to stdout.
+    Args:
+        fd: opened file descriptor where data will be saved
+        indent: Indent level. Value less than 0 mean compact mode.
+            Default is indent level 2.
+    """
+    cfg = {
+        'subsystem': name,
+        'config': client.call('framework_get_config', {"name": name})
+    }
+
+    _json_dump(cfg, fd, indent)
+
+
+def load_subsystem_config(client, fd):
+    """Configure SPDK subsystem using JSON RPC read from stdin.
+    Args:
+        fd: opened file descriptor where data will be taken from
+    """
+    subsystem = _json_load(fd)
+
+    if not subsystem['config']:
+        return
+
+    allowed_methods = client.call('rpc_get_methods')
+    config = subsystem['config']
+    for elem in list(config):
+        if 'method' not in elem or elem['method'] not in allowed_methods:
+            raise rpc_client.JSONRPCException("Unknown method was included in the config file")
+
+    allowed_methods = client.call('rpc_get_methods', {'current': True})
+    for elem in list(config):
+        if 'method' not in elem or elem['method'] not in allowed_methods:
+            continue
+
+        client.call(**elem)
+        config.remove(elem)
+
+    if config:
+        print("Some configs were skipped because they cannot be called in the current RPC state.")

spdk/rpc/accel.py

@@ -0,0 +1,132 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2022 Intel Corporation.
+#  All rights reserved.
+#
+
+from spdk.rpc.helpers import deprecated_alias
+
+
+def accel_get_opc_assignments(client):
+    """Get list of opcode name to module assignments.
+    """
+    return client.call('accel_get_opc_assignments')
+
+
+@deprecated_alias('accel_get_engine_info')
+def accel_get_module_info(client):
+    """Get list of valid module names and their operations.
+    """
+    return client.call('accel_get_module_info')
+
+
+def accel_assign_opc(client, opname, module):
+    """Manually assign an operation to a module.
+
+    Args:
+        opname: name of operation
+        module: name of module
+    """
+    params = {
+        'opname': opname,
+        'module': module,
+    }
+
+    return client.call('accel_assign_opc', params)
+
+
+def accel_crypto_key_create(client, cipher, key, key2, tweak_mode, name):
+    """Create Data Encryption Key Identifier.
+
+    Args:
+        cipher: cipher
+        key: key
+        key2: key2
+        tweak_mode: tweak mode
+        name: key name
+    """
+    params = {
+        'cipher': cipher,
+        'key': key,
+        'name': name,
+    }
+    if key2 is not None:
+        params['key2'] = key2
+    if tweak_mode is not None:
+        params['tweak_mode'] = tweak_mode
+
+    return client.call('accel_crypto_key_create', params)
+
+
+def accel_crypto_key_destroy(client, key_name):
+    """Destroy Data Encryption Key.
+
+    Args:
+        key_name: key name
+    """
+    params = {
+        'key_name': key_name
+    }
+
+    return client.call('accel_crypto_key_destroy', params)
+
+
+def accel_crypto_keys_get(client, key_name):
+    """Get a list of the crypto keys.
+
+    Args:
+        key_name: Get information about a specific key
+    """
+    params = {}
+
+    if key_name is not None:
+        params['key_name'] = key_name
+
+    return client.call('accel_crypto_keys_get', params)
+
+
+def accel_set_driver(client, name):
+    """Select accel platform driver to execute operation chains.
+
+    Args:
+        name: name of the driver
+    """
+    return client.call('accel_set_driver', {'name': name})
+
+
+def accel_set_options(client, small_cache_size, large_cache_size,
+                      task_count, sequence_count, buf_count):
+    """Set accel framework's options."""
+    params = {}
+
+    if small_cache_size is not None:
+        params['small_cache_size'] = small_cache_size
+    if large_cache_size is not None:
+        params['large_cache_size'] = large_cache_size
+    if task_count is not None:
+        params['task_count'] = task_count
+    if sequence_count is not None:
+        params['sequence_count'] = sequence_count
+    if buf_count is not None:
+        params['buf_count'] = buf_count
+
+    return client.call('accel_set_options', params)
+
+
+def accel_get_stats(client):
+    """Get accel framework's statistics"""
+
+    return client.call('accel_get_stats')
+
+
+def accel_error_inject_error(client, opcode, type, count=None, interval=None, errcode=None):
+    """Inject an error to processing accel operation"""
+    params = {}
+    if count is not None:
+        params['count'] = count
+    if interval is not None:
+        params['interval'] = interval
+    if errcode is not None:
+        params['errcode'] = errcode
+
+    return client.call('accel_error_inject_error',
+                       {'opcode': opcode, 'type': type, **params})

spdk/rpc/app.py

@@ -0,0 +1,142 @@
+#  SPDX-License-Identifier: BSD-3-Clause
+#  Copyright (C) 2017 Intel Corporation.
+#  All rights reserved.
+
+
+def spdk_kill_instance(client, sig_name):
+    """Send a signal to the SPDK process.
+
+    Args:
+        sig_name: signal to send ("SIGINT", "SIGTERM", "SIGQUIT", "SIGHUP", or "SIGKILL")
+    """
+    params = {'sig_name': sig_name}
+    return client.call('spdk_kill_instance', params)
+
+
+def framework_monitor_context_switch(client, enabled=None):
+    """Query or set state of context switch monitoring.
+
+    Args:
+        enabled: True to enable monitoring; False to disable monitoring; None to query (optional)
+
+    Returns:
+        Current context switch monitoring state (after applying enabled flag).
+    """
+    params = {}
+    if enabled is not None:
+        params['enabled'] = enabled
+    return client.call('framework_monitor_context_switch', params)
+
+
+def framework_get_reactors(client):
+    """Query list of all reactors.
+
+    Returns:
+        List of all reactors.
+    """
+    return client.call('framework_get_reactors')
+
+
+def framework_set_scheduler(client, name, period=None, load_limit=None, core_limit=None,
+                            core_busy=None, mappings=None):
+    """Select threads scheduler that will be activated and its period.
+
+    Args:
+        name: Name of a scheduler
+        period: Scheduler period in microseconds
+    Returns:
+        True or False
+    """
+    params = {'name': name}
+    if period is not None:
+        params['period'] = period
+    if load_limit is not None:
+        params['load_limit'] = load_limit
+    if core_limit is not None:
+        params['core_limit'] = core_limit
+    if core_busy is not None:
+        params['core_busy'] = core_busy
+    if mappings is not None:
+        params['mappings'] = mappings
+    return client.call('framework_set_scheduler', params)
+
+
+def framework_get_scheduler(client):
+    """Query currently set scheduler.
+
+    Returns:
+        Name, period (in microseconds) of currently set scheduler and name of currently set governor.
+    """
+    return client.call('framework_get_scheduler')
+
+
+def framework_get_governor(client):
+    """Query current governor data.
+
+    Returns:
+        Name of currently set governor, available frequencies and currently set frequency of the CPU cores.
+    """
+    return client.call('framework_get_governor')
+
+
+def scheduler_set_options(client, scheduling_core=None, isolated_core_mask=None):
+    params = {}
+    if isolated_core_mask is not None:
+        params['isolated_core_mask'] = isolated_core_mask
+    if scheduling_core is not None:
+        params['scheduling_core'] = scheduling_core
+    return client.call('scheduler_set_options', params)
+
+
+def thread_get_stats(client):
+    """Query threads statistics.
+
+    Returns:
+        Current threads statistics.
+    """
+    return client.call('thread_get_stats')
+
+
+def thread_set_cpumask(client, id, cpumask):
+    """Set the cpumask of the thread whose ID matches to the specified value.
+
+    Args:
+        id: thread ID
+        cpumask: cpumask for this thread
+
+    Returns:
+        True or False
+    """
+    params = {'id': id, 'cpumask': cpumask}
+    return client.call('thread_set_cpumask', params)
+
+
+def log_enable_timestamps(client, enabled):
+    """Enable or disable timestamps.
+
+    Args:
+        value: on or off
+
+    Returns:
+        None
+    """
+    params = {'enabled': enabled}
+    return client.call('log_enable_timestamps', params)
+
+
+def thread_get_pollers(client):
+    """Query current pollers.
+
+    Returns:
+        Current pollers.
+    """
+    return client.call('thread_get_pollers')
+
+
+def thread_get_io_channels(client):
+    """Query current IO channels.
+
+    Returns:
+        Current IO channels.
+    """
+    return client.call('thread_get_io_channels')