| # SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) |
| # Copyright (c) 2018, Mellanox Technologies. All rights reserved. See COPYING file |
| |
| from libc.stdint cimport uint8_t, uintptr_t |
| |
| from .pyverbs_error import PyverbsUserError, PyverbsRDMAError |
| from pyverbs.utils import gid_str_to_array, gid_str |
| from pyverbs.base import PyverbsRDMAErrno |
| from pyverbs.cmid cimport UDParam |
| cimport pyverbs.libibverbs as v |
| from pyverbs.pd cimport PD |
| from pyverbs.cq cimport WC |
| |
| cdef extern from 'endian.h': |
| unsigned long be64toh(unsigned long host_64bits) |
| |
| |
| cdef class GID(PyverbsObject): |
| """ |
| GID class represents ibv_gid. It enables user to query for GIDs values. |
| """ |
| def __init__(self, val=None): |
| super().__init__() |
| if val is not None: |
| vals = gid_str_to_array(val) |
| |
| for i in range(16): |
| self.gid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| @property |
| def gid(self): |
| """ |
| Expose the inner GID |
| :return: A GID string in an 8 words format: |
| 'xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx' |
| """ |
| return self.__str__() |
| @gid.setter |
| def gid(self, val): |
| """ |
| Sets the inner GID |
| :param val: A GID string in an 8 words format: |
| 'xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:xxxx' |
| :return: None |
| """ |
| self._set_gid(val) |
| |
| def _set_gid(self, val): |
| vals = gid_str_to_array(val) |
| |
| for i in range(16): |
| self.gid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| def __str__(self): |
| return gid_str(self.gid._global.subnet_prefix, |
| self.gid._global.interface_id) |
| |
| |
| cdef class GRH(PyverbsObject): |
| """ |
| Represents ibv_grh struct. Used when creating or initializing an |
| Address Handle from a Work Completion. |
| """ |
| def __init__(self, GID sgid=None, GID dgid=None, version_tclass_flow=0, |
| paylen=0, next_hdr=0, hop_limit=1): |
| """ |
| Initializes a GRH object |
| :param sgid: Source GID |
| :param dgid: Destination GID |
| :param version_tclass_flow: A 32b big endian used to communicate |
| service level e.g. across subnets |
| :param paylen: A 16b big endian that is the packet length in bytes, |
| starting from the first byte after the GRH up to and |
| including the last byte of the ICRC |
| :param next_hdr: An 8b unsigned integer specifying the next header |
| For non-raw packets: 0x1B |
| For raw packets: According to IETF RFC 1700 |
| :param hop_limit: An 8b unsigned integer specifying the number of hops |
| (i.e. routers) that the packet is permitted to take |
| prior to being discarded |
| :return: A GRH object |
| """ |
| super().__init__() |
| self.grh.dgid = dgid.gid |
| self.grh.sgid = sgid.gid |
| self.grh.version_tclass_flow = version_tclass_flow |
| self.grh.paylen = paylen |
| self.grh.next_hdr = next_hdr |
| self.grh.hop_limit = hop_limit |
| |
| @property |
| def dgid(self): |
| return gid_str(self.grh.dgid._global.subnet_prefix, |
| self.grh.dgid._global.interface_id) |
| @dgid.setter |
| def dgid(self, val): |
| vals = gid_str_to_array(val) |
| for i in range(16): |
| self.grh.dgid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| @property |
| def sgid(self): |
| return gid_str(self.grh.sgid._global.subnet_prefix, |
| self.grh.sgid._global.interface_id) |
| @sgid.setter |
| def sgid(self, val): |
| vals = gid_str_to_array(val) |
| for i in range(16): |
| self.grh.sgid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| @property |
| def version_tclass_flow(self): |
| return self.grh.version_tclass_flow |
| |
| @version_tclass_flow.setter |
| def version_tclass_flow(self, val): |
| self.grh.version_tclass_flow = val |
| |
| @property |
| def paylen(self): |
| return self.grh.paylen |
| @paylen.setter |
| def paylen(self, val): |
| self.grh.paylen = val |
| |
| @property |
| def next_hdr(self): |
| return self.grh.next_hdr |
| @next_hdr.setter |
| def next_hdr(self, val): |
| self.grh.next_hdr = val |
| |
| @property |
| def hop_limit(self): |
| return self.grh.hop_limit |
| @hop_limit.setter |
| def hop_limit(self, val): |
| self.grh.hop_limit = val |
| |
| def __str__(self): |
| print_format = '{:22}: {:<20}\n' |
| return print_format.format('DGID', self.dgid) +\ |
| print_format.format('SGID', self.sgid) +\ |
| print_format.format('version tclass flow', self.version_tclass_flow) +\ |
| print_format.format('paylen', self.paylen) +\ |
| print_format.format('next header', self.next_hdr) +\ |
| print_format.format('hop limit', self.hop_limit) |
| |
| |
| cdef class GlobalRoute(PyverbsObject): |
| """ |
| Represents ibv_global_route. Used in Address Handle creation and describes |
| the values to be used in the GRH of the packets that will be sent using |
| this Address Handle. |
| """ |
| def __init__(self, GID dgid=None, flow_label=0, sgid_index=0, hop_limit=1, |
| traffic_class=0): |
| """ |
| Initializes a GlobalRoute object with given parameters. |
| :param dgid: Destination GID |
| :param flow_label: A 20b value. If non-zero, gives a hint to switches |
| and routers that this sequence of packets must be |
| delivered in order |
| :param sgid_index: An index in the port's GID table that identifies the |
| originator of the packet |
| :param hop_limit: An 8b unsigned integer specifying the number of hops |
| (i.e. routers) that the packet is permitted to take |
| prior to being discarded |
| :param traffic_class: An 8b unsigned integer specifying the required |
| delivery priority for routers |
| :return: A GlobalRoute object |
| """ |
| super().__init__() |
| self.gr.dgid=dgid.gid |
| self.gr.flow_label = flow_label |
| self.gr.sgid_index = sgid_index |
| self.gr.hop_limit = hop_limit |
| self.gr.traffic_class = traffic_class |
| |
| @property |
| def dgid(self): |
| return gid_str(self.gr.dgid._global.subnet_prefix, |
| self.gr.dgid._global.interface_id) |
| @dgid.setter |
| def dgid(self, val): |
| vals = gid_str_to_array(val) |
| for i in range(16): |
| self.gr.dgid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| @property |
| def flow_label(self): |
| return self.gr.flow_label |
| @flow_label.setter |
| def flow_label(self, val): |
| self.gr.flow_label = val |
| |
| @property |
| def sgid_index(self): |
| return self.gr.sgid_index |
| @sgid_index.setter |
| def sgid_index(self, val): |
| self.gr.sgid_index = val |
| |
| @property |
| def hop_limit(self): |
| return self.gr.hop_limit |
| @hop_limit.setter |
| def hop_limit(self, val): |
| self.gr.hop_limit = val |
| |
| @property |
| def traffic_class(self): |
| return self.gr.traffic_class |
| @traffic_class.setter |
| def traffic_class(self, val): |
| self.gr.traffic_class = val |
| |
| def __str__(self): |
| print_format = '{:22}: {:<20}\n' |
| return print_format.format('DGID', self.dgid) +\ |
| print_format.format('flow label', self.flow_label) +\ |
| print_format.format('sgid index', self.sgid_index) +\ |
| print_format.format('hop limit', self.hop_limit) +\ |
| print_format.format('traffic class', self.traffic_class) |
| |
| |
| cdef class AHAttr(PyverbsObject): |
| """ Represents ibv_ah_attr struct """ |
| def __init__(self, dlid=0, sl=0, src_path_bits=0, static_rate=0, |
| is_global=0, port_num=1, GlobalRoute gr=None): |
| """ |
| Initializes an AHAttr object. |
| :param dlid: Destination LID, a 16b unsigned integer |
| :param sl: Service level, an 8b unsigned integer |
| :param src_path_bits: When LMC (LID mask count) is used in the port, |
| packets are being sent with the port's base LID, |
| bitwise ORed with the value of the src_path_bits. |
| An 8b unsigned integer |
| :param static_rate: An 8b unsigned integer limiting the rate of packets |
| that are being sent to the subnet |
| :param is_global: If non-zero, GRH information exists in the Address |
| Handle |
| :param port_num: The local physical port from which the packets will be |
| sent |
| :param grh: Attributes of a global routing header. Will only be used if |
| is_global is non zero. |
| :return: An AHAttr object |
| """ |
| super().__init__() |
| self.ah_attr.port_num = port_num |
| self.ah_attr.sl = sl |
| self.ah_attr.src_path_bits = src_path_bits |
| self.ah_attr.dlid = dlid |
| self.ah_attr.static_rate = static_rate |
| self.ah_attr.is_global = is_global |
| # Do not set GRH fields for a non-global AH |
| if is_global: |
| if gr is None: |
| raise PyverbsUserError('Global AH Attr is created but gr parameter is None') |
| self.ah_attr.grh.dgid = gr.gr.dgid |
| self.ah_attr.grh.flow_label = gr.flow_label |
| self.ah_attr.grh.sgid_index = gr.sgid_index |
| self.ah_attr.grh.hop_limit = gr.hop_limit |
| self.ah_attr.grh.traffic_class = gr.traffic_class |
| |
| cdef init_from_ud_param(self, UDParam udparam): |
| """ |
| Initiate the AHAttr from UDParam's ah_attr. |
| :param udparam: UDParam that contains the AHAttr. |
| :return: None |
| """ |
| self.ah_attr = udparam.ud_param.ah_attr |
| |
| @property |
| def port_num(self): |
| return self.ah_attr.port_num |
| @port_num.setter |
| def port_num(self, val): |
| self.ah_attr.port_num = val |
| |
| @property |
| def sl(self): |
| return self.ah_attr.sl |
| @sl.setter |
| def sl(self, val): |
| self.ah_attr.sl = val |
| |
| @property |
| def src_path_bits(self): |
| return self.ah_attr.src_path_bits |
| @src_path_bits.setter |
| def src_path_bits(self, val): |
| self.ah_attr.src_path_bits = val |
| |
| @property |
| def dlid(self): |
| return self.ah_attr.dlid |
| @dlid.setter |
| def dlid(self, val): |
| self.ah_attr.dlid = val |
| |
| @property |
| def static_rate(self): |
| return self.ah_attr.static_rate |
| @static_rate.setter |
| def static_rate(self, val): |
| self.ah_attr.static_rate = val |
| |
| @property |
| def is_global(self): |
| return self.ah_attr.is_global |
| @is_global.setter |
| def is_global(self, val): |
| self.ah_attr.is_global = val |
| |
| @property |
| def dgid(self): |
| if self.ah_attr.is_global: |
| return gid_str(self.ah_attr.grh.dgid._global.subnet_prefix, |
| self.ah_attr.grh.dgid._global.interface_id) |
| @dgid.setter |
| def dgid(self, val): |
| if self.ah_attr.is_global: |
| vals = gid_str_to_array(val) |
| for i in range(16): |
| self.ah_attr.grh.dgid.raw[i] = <uint8_t>int(vals[i],16) |
| |
| @property |
| def flow_label(self): |
| if self.ah_attr.is_global: |
| return self.ah_attr.grh.flow_label |
| @flow_label.setter |
| def flow_label(self, val): |
| self.ah_attr.grh.flow_label = val |
| |
| @property |
| def sgid_index(self): |
| if self.ah_attr.is_global: |
| return self.ah_attr.grh.sgid_index |
| @sgid_index.setter |
| def sgid_index(self, val): |
| self.ah_attr.grh.sgid_index = val |
| |
| @property |
| def hop_limit(self): |
| if self.ah_attr.is_global: |
| return self.ah_attr.grh.hop_limit |
| @hop_limit.setter |
| def hop_limit(self, val): |
| self.ah_attr.grh.hop_limit = val |
| |
| @property |
| def traffic_class(self): |
| if self.ah_attr.is_global: |
| return self.ah_attr.grh.traffic_class |
| @traffic_class.setter |
| def traffic_class(self, val): |
| self.ah_attr.grh.traffic_class = val |
| |
| def __str__(self): |
| print_format = ' {:22}: {:<20}\n' |
| if self.is_global: |
| global_format = print_format.format('dgid', self.dgid) +\ |
| print_format.format('flow label', self.flow_label) +\ |
| print_format.format('sgid index', self.sgid_index) +\ |
| print_format.format('hop limit', self.hop_limit) +\ |
| print_format.format('traffic_class', self.traffic_class) |
| else: |
| global_format = '' |
| return print_format.format('port num', self.port_num) +\ |
| print_format.format('sl', self.sl) +\ |
| print_format.format('source path bits', self.src_path_bits) +\ |
| print_format.format('dlid', self.dlid) +\ |
| print_format.format('static rate', self.static_rate) +\ |
| print_format.format('is global', self.is_global) + global_format |
| |
| |
| cdef class AH(PyverbsCM): |
| def __init__(self, PD pd, **kwargs): |
| """ |
| Initializes an AH object with the given values. |
| Two creation methods are supported: |
| - Creation via AHAttr object (calls ibv_create_ah) |
| - Creation via a WC object (calls ibv_create_ah_from_wc) |
| :param pd: PD object this AH belongs to |
| :param kwargs: Arguments: |
| * *attr* (AHAttr) |
| An AHAttr object (represents ibv_ah_attr struct) |
| * *wc* |
| A WC object to use for AH initialization |
| * *grh* |
| Pointer to GRH object to use for AH initialization (when using |
| wc) |
| * *port_num* |
| Port number to be used for this AH (when using wc) |
| :return: An AH object on success |
| """ |
| super().__init__() |
| if len(kwargs) == 1: |
| # Create AH via ib_create_ah |
| ah_attr = <AHAttr>kwargs['attr'] |
| self.ah = v.ibv_create_ah(pd.pd, &ah_attr.ah_attr) |
| else: |
| # Create AH from WC |
| wc = <WC>kwargs['wc'] |
| grh = <v.ibv_grh*><uintptr_t>kwargs['grh'] |
| port_num = kwargs['port_num'] |
| self.ah = v.ibv_create_ah_from_wc(pd.pd, &wc.wc, grh, port_num) |
| if self.ah == NULL: |
| raise PyverbsRDMAErrno('Failed to create AH') |
| pd.add_ref(self) |
| self.pd = pd |
| |
| def __dealloc__(self): |
| self.close() |
| |
| cpdef close(self): |
| if self.ah != NULL: |
| if self.logger: |
| self.logger.debug('Closing AH') |
| rc = v.ibv_destroy_ah(self.ah) |
| if rc: |
| raise PyverbsRDMAError('Failed to destroy AH', rc) |
| self.ah = NULL |
| self.pd = None |
