| # SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) |
| # Copyright (c) 2020 Nvidia. All rights reserved. |
| |
| from pyverbs.pyverbs_error import PyverbsError |
| from libc.string cimport memcpy |
| import socket, struct |
| |
| U32_MASK = 0xffffffff |
| |
| |
| cdef class Spec(PyverbsObject): |
| """ |
| Abstract class for all the specs to derive from. |
| """ |
| def __init__(self): |
| raise NotImplementedError('This class is abstract.') |
| |
| @property |
| def size(self): |
| return self.size |
| |
| cpdef _copy_data(self, unsigned long ptr): |
| """ |
| memcpy the spec to the provided address in proper order. |
| This function must be implemented in each subclass. |
| :param addr: address to copy spec to |
| """ |
| raise NotImplementedError('Must be implemented in subclass.') |
| |
| def __str__(self): |
| return f"{'Spec type':<16}: {self.type_to_str(self.spec_type):<20}\n" \ |
| f"{'Size':<16}: {self.size:<20}\n" |
| |
| @staticmethod |
| def type_to_str(spec_type): |
| types = {v.IBV_FLOW_SPEC_ETH : 'IBV_FLOW_SPEC_ETH', |
| v.IBV_FLOW_SPEC_IPV4_EXT : "IBV_FLOW_SPEC_IPV4_EXT", |
| v.IBV_FLOW_SPEC_IPV6 : "IBV_FLOW_SPEC_IPV6", |
| v.IBV_FLOW_SPEC_TCP : "IBV_FLOW_SPEC_TCP", |
| v.IBV_FLOW_SPEC_UDP : "IBV_FLOW_SPEC_UDP"} |
| res_str = "" |
| if spec_type & v.IBV_FLOW_SPEC_INNER: |
| res_str += 'IBV_FLOW_SPEC_INNER ' |
| try: |
| s_type = spec_type & ~v.IBV_FLOW_SPEC_INNER |
| res_str += types[s_type] |
| except IndexError: |
| raise PyverbsError(f'This type {s_type} is not implemented yet') |
| return res_str |
| |
| @staticmethod |
| def _set_val_mask(default_mask, val=None, val_mask=None): |
| """ |
| If value is given without val_mask, default_mask will be returned. |
| :param default_mask: default mask to set if not provided |
| :param val: user provided value |
| :param val_mask: user provided mask |
| :return: resulting value and mask |
| """ |
| res_val = 0 |
| res_mask = 0 |
| if val is not None: |
| res_val = val |
| res_mask = default_mask if val_mask is None else val_mask |
| return res_val, res_mask |
| |
| |
| cdef class EthSpec(Spec): |
| MAC_LEN = 6 |
| MAC_MASK = ('ff:' * MAC_LEN)[:-1] |
| ZERO_MAC = [0] * MAC_LEN |
| |
| def __init__(self, dst_mac=None, dst_mac_mask=None, src_mac=None, |
| src_mac_mask=None, ether_type=None, ether_type_mask=None, |
| vlan_tag=None, vlan_tag_mask=None, is_inner=0): |
| """ |
| Initialize a EthSpec object over an underlying ibv_flow_spec_eth C |
| object that defines Ethernet header specifications for steering flow to |
| match on. |
| :param dst_mac: destination mac to match on (e.g. 'aa:bb:12:13:14:fe') |
| :param dst_mac_mask: destination mac mask (e.g. 'ff:ff:ff:ff:ff:ff') |
| :param src_mac: source mac to match on |
| :param src_mac_mask: source mac mask |
| :param ether_type: ethertype to match on |
| :param ether_type_mask: ethertype mask |
| :param vlan_tag: VLAN tag to match on |
| :param vlan_tag_mask: VLAN tag mask |
| :param is_inner: is inner spec |
| """ |
| self.spec_type = v.IBV_FLOW_SPEC_ETH |
| if is_inner: |
| self.spec_type |= v.IBV_FLOW_SPEC_INNER |
| self.size = sizeof(v.ibv_flow_spec_eth) |
| self.dst_mac, self.dst_mac_mask = self._set_val_mask(self.MAC_MASK, |
| dst_mac, |
| dst_mac_mask) |
| self.src_mac, self.src_mac_mask = self._set_val_mask(self.MAC_MASK, |
| src_mac, |
| src_mac_mask) |
| self.val.ether_type, self.mask.ether_type = \ |
| map(socket.htons, self._set_val_mask(0xffff, ether_type, |
| ether_type_mask)) |
| self.val.vlan_tag, self.mask.vlan_tag = \ |
| map(socket.htons, self._set_val_mask(0xffff, vlan_tag, |
| vlan_tag_mask)) |
| |
| cdef _mac_to_str(self, unsigned char mac[6]): |
| s = '' |
| if len(mac) == 0: |
| return s |
| # Building string from array |
| # [0xa, 0x1b, 0x2c, 0x3c, 0x4d, 0x5e] -> "0a:1b:2c:3c:4d:5e" |
| for i in range(self.MAC_LEN): |
| s += hex(mac[i])[2:].zfill(2) + ':' |
| return s[:-1] |
| |
| def _set_mac(self, val): |
| mac = EthSpec.ZERO_MAC[:] |
| if val: |
| s = val.split(':') |
| for i in range(self.MAC_LEN): |
| mac[i] = int(s[i], 16) |
| return mac |
| |
| @property |
| def dst_mac(self): |
| return self._mac_to_str(self.val.dst_mac) |
| |
| @dst_mac.setter |
| def dst_mac(self, val): |
| self.val.dst_mac = self._set_mac(val) |
| |
| @property |
| def dst_mac_mask(self): |
| return self._mac_to_str(self.mask.dst_mac) |
| |
| @dst_mac_mask.setter |
| def dst_mac_mask(self, val): |
| self.mask.dst_mac = self._set_mac(val) |
| |
| @property |
| def src_mac(self): |
| return self._mac_to_str(self.val.src_mac) |
| |
| @src_mac.setter |
| def src_mac(self, val): |
| self.val.src_mac = self._set_mac(val) |
| |
| @property |
| def src_mac_mask(self): |
| return self._mac_to_str(self.mask.src_mac) |
| |
| @src_mac_mask.setter |
| def src_mac_mask(self, val): |
| self.mask.src_mac = self._set_mac(val) |
| |
| @property |
| def ether_type(self): |
| return socket.ntohs(self.val.ether_type) |
| |
| @ether_type.setter |
| def ether_type(self, val): |
| self.val.ether_type = socket.htons(val) |
| |
| @property |
| def ether_type_mask(self): |
| return socket.ntohs(self.mask.ether_type) |
| |
| @ether_type_mask.setter |
| def ether_type_mask(self, val): |
| self.mask.ether_type = socket.htons(val) |
| |
| @property |
| def vlan_tag(self): |
| return socket.ntohs(self.val.vlan_tag) |
| |
| @vlan_tag.setter |
| def vlan_tag(self, val): |
| self.val.vlan_tag = socket.htons(val) |
| |
| @property |
| def vlan_tag_mask(self): |
| return socket.ntohs(self.mask.vlan_tag) |
| |
| @vlan_tag_mask.setter |
| def vlan_tag_mask(self, val): |
| self.mask.vlan_tag = socket.htons(val) |
| |
| def __str__(self): |
| return super().__str__() + \ |
| f"{'Src mac':<16}: {self.src_mac:<20} {self.src_mac_mask:<20}\n" \ |
| f"{'Dst mac':<16}: {self.dst_mac:<20} {self.dst_mac_mask:<20}\n" \ |
| f"{'Ether type':<16}: {self.val.ether_type:<20} " \ |
| f"{self.mask.ether_type:<20}\n" \ |
| f"{'Vlan tag':<16}: {self.val.vlan_tag:<20} " \ |
| f"{self.mask.vlan_tag:<20}\n" |
| |
| cpdef _copy_data(self, unsigned long ptr): |
| cdef v.ibv_flow_spec_eth eth |
| eth.size = self.size |
| eth.type = self.spec_type |
| eth.val = self.val |
| eth.mask = self.mask |
| memcpy(<void*>ptr, ð, self.size) |
| |
| cdef class Ipv4ExtSpec(Spec): |
| def __init__(self, dst_ip=None, dst_ip_mask=None, src_ip=None, |
| src_ip_mask=None, proto=None, proto_mask=None, tos=None, |
| tos_mask=None, ttl=None, ttl_mask=None, flags=None, |
| flags_mask=None, is_inner=False): |
| """ |
| Initialize an Ipv4ExtSpec object over an underlying ibv_flow_ipv4_ext C |
| object that defines IPv4 header specifications for steering flow to |
| match on. |
| :param dst_ip: Destination IP to match on (e.g. '1.2.3.4') |
| :param dst_ip_mask: Destination IP mask (e.g. '255.255.255.255') |
| :param src_ip: source IP to match on |
| :param src_ip_mask: Source IP mask |
| :param proto: Protocol to match on |
| :param proto_mask: Protocol mask |
| :param tos: Type of service to match on |
| :param tos_mask: Type of service mask |
| :param ttl: Time to live to match on |
| :param ttl_mask: Time to live mask |
| :param flags: Flags to match on |
| :param flags_mask: Flags mask |
| :param is_inner: Is inner spec |
| """ |
| self.spec_type = v.IBV_FLOW_SPEC_IPV4_EXT |
| if is_inner: |
| self.spec_type |= v.IBV_FLOW_SPEC_INNER |
| self.size = sizeof(v.ibv_flow_spec_ipv4_ext) |
| |
| self.val.dst_ip, self.mask.dst_ip = \ |
| map(socket.htonl, self._set_val_mask(U32_MASK, |
| self._str_to_ip(dst_ip), |
| self._str_to_ip(dst_ip_mask))) |
| self.val.src_ip, self.mask.src_ip = \ |
| map(socket.htonl, self._set_val_mask(U32_MASK, |
| self._str_to_ip(src_ip), |
| self._str_to_ip(src_ip_mask))) |
| self.val.proto, self.mask.proto = self._set_val_mask(0xff, proto, |
| proto_mask) |
| self.val.tos, self.mask.tos = self._set_val_mask(0xff, tos, tos_mask) |
| self.val.ttl, self.mask.ttl = self._set_val_mask(0xff, ttl, ttl_mask) |
| self.val.flags, self.mask.flags = self._set_val_mask(0xff, flags, |
| flags_mask) |
| @staticmethod |
| def _str_to_ip(ip_str): |
| return None if ip_str is None else \ |
| struct.unpack('!L', socket.inet_aton(ip_str))[0] |
| |
| @staticmethod |
| def _ip_to_str(ip): |
| return socket.inet_ntoa(struct.pack('!L', ip)) |
| |
| @property |
| def dst_ip(self): |
| return self._ip_to_str(socket.ntohl(self.val.dst_ip)) |
| |
| @dst_ip.setter |
| def dst_ip(self, val): |
| self.val.dst_ip = socket.htonl(self._str_to_ip(val)) |
| |
| @property |
| def dst_ip_mask(self): |
| return self._ip_to_str(socket.ntohl(self.mask.dst_ip)) |
| |
| @dst_ip_mask.setter |
| def dst_ip_mask(self, val): |
| self.mask.dst_ip = socket.htonl(self._str_to_ip(val)) |
| |
| @property |
| def src_ip(self): |
| return self._ip_to_str(socket.ntohl(self.val.src_ip)) |
| |
| @src_ip.setter |
| def src_ip(self, val): |
| self.val.src_ip = socket.htonl(self._str_to_ip(val)) |
| |
| @property |
| def src_ip_mask(self): |
| return self._ip_to_str(socket.ntohl(self.mask.src_ip)) |
| |
| @src_ip_mask.setter |
| def src_ip_mask(self, val): |
| self.mask.src_ip = socket.htonl(self._str_to_ip(val)) |
| |
| @property |
| def proto(self): |
| return self.val.proto |
| |
| @proto.setter |
| def proto(self, val): |
| self.val.proto = val |
| |
| @property |
| def proto_mask(self): |
| return self.mask.proto |
| |
| @proto_mask.setter |
| def proto_mask(self, val): |
| self.mask.proto = val |
| |
| @property |
| def tos(self): |
| return self.val.tos |
| |
| @tos.setter |
| def tos(self, val): |
| self.val.tos = val |
| |
| @property |
| def tos_mask(self): |
| return self.mask.tos |
| |
| @tos_mask.setter |
| def tos_mask(self, val): |
| self.mask.tos = val |
| |
| @property |
| def ttl(self): |
| return self.val.ttl |
| |
| @ttl.setter |
| def ttl(self, val): |
| self.val.ttl = val |
| |
| @property |
| def ttl_mask(self): |
| return self.mask.ttl |
| |
| @ttl_mask.setter |
| def ttl_mask(self, val): |
| self.mask.ttl = val |
| |
| @property |
| def flags(self): |
| return self.val.flags |
| |
| @flags.setter |
| def flags(self, val): |
| self.val.flags = val |
| |
| @property |
| def flags_mask(self): |
| return self.mask.flags |
| |
| @flags_mask.setter |
| def flags_mask(self, val): |
| self.mask.flags = val |
| |
| def __str__(self): |
| return super().__str__() + \ |
| f"{'Src IP':<16}: {self.src_ip:<20} {self.src_ip_mask:<20}\n" \ |
| f"{'Dst IP':<16}: {self.dst_ip:<20} {self.dst_ip_mask:<20}\n" \ |
| f"{'Proto':<16}: {self.val.proto:<20} {self.mask.proto:<20}\n" \ |
| f"{'ToS':<16}: {self.val.tos:<20} {self.mask.tos:<20}\n" \ |
| f"{'TTL':<16}: {self.val.ttl:<20} {self.mask.ttl:<20}\n" \ |
| f"{'Flags':<16}: {self.val.flags:<20} {self.mask.flags:<20}\n" |
| |
| cpdef _copy_data(self, unsigned long ptr): |
| cdef v.ibv_flow_spec_ipv4_ext ipv4 |
| ipv4.size = self.size |
| ipv4.type = self.spec_type |
| ipv4.val = self.val |
| ipv4.mask = self.mask |
| memcpy(<void*>ptr, &ipv4, self.size) |
| |
| |
| cdef class TcpUdpSpec(Spec): |
| def __init__(self, v.ibv_flow_spec_type spec_type, dst_port=None, |
| dst_port_mask=None, src_port=None, src_port_mask=None, |
| is_inner=False): |
| """ |
| Initialize a TcpUdpSpec object over an underlying ibv_flow_tcp_udp C |
| object that defines TCP or UDP header specifications for steering flow |
| to match on. |
| :param spec_type: IBV_FLOW_SPEC_TCP or IBV_FLOW_SPEC_UDP |
| :param dst_port: Destination port to match on |
| :param dst_port_mask: Destination port mask |
| :param src_port: Source port to match on |
| :param src_port_mask: Source port mask |
| :param is_inner: Is inner spec |
| """ |
| if spec_type is not v.IBV_FLOW_SPEC_TCP and spec_type is not\ |
| v.IBV_FLOW_SPEC_UDP: |
| raise PyverbsError('Spec type must be IBV_FLOW_SPEC_TCP or' |
| ' IBV_FLOW_SPEC_UDP') |
| self.spec_type = spec_type |
| if is_inner: |
| self.spec_type |= v.IBV_FLOW_SPEC_INNER |
| self.size = sizeof(v.ibv_flow_spec_tcp_udp) |
| self.val.dst_port, self.mask.dst_port = \ |
| map(socket.htons, self._set_val_mask(0xffff, dst_port, |
| dst_port_mask)) |
| self.val.src_port, self.mask.src_port = \ |
| map(socket.htons, self._set_val_mask(0xffff, src_port, |
| src_port_mask)) |
| @property |
| def dst_port(self): |
| return socket.ntohs(self.val.dst_port) |
| |
| @dst_port.setter |
| def dst_port(self, val): |
| self.val.dst_port = socket.htons(val) |
| |
| @property |
| def dst_port_mask(self): |
| return socket.ntohs(self.mask.dst_port) |
| |
| @dst_port_mask.setter |
| def dst_port_mask(self, val): |
| self.mask.dst_port = socket.htons(val) |
| |
| @property |
| def src_port(self): |
| return socket.ntohs(self.val.src_port) |
| |
| @src_port.setter |
| def src_port(self, val): |
| self.val.src_port = socket.htons(val) |
| |
| @property |
| def src_port_mask(self): |
| return socket.ntohs(self.mask.src_port) |
| |
| @src_port_mask.setter |
| def src_port_mask(self, val): |
| self.mask.src_port = socket.htons(val) |
| |
| def __str__(self): |
| return super().__str__() + \ |
| f"{'Src port':<16}: {self.src_port:<20} {self.src_port_mask:<20}\n" \ |
| f"{'Dst port':<16}: {self.dst_port:<20} {self.dst_port_mask:<20}\n" |
| |
| cpdef _copy_data(self, unsigned long ptr): |
| cdef v.ibv_flow_spec_tcp_udp tcp_udp |
| tcp_udp.size = self.size |
| tcp_udp.type = self.spec_type |
| tcp_udp.val = self.val |
| tcp_udp.mask = self.mask |
| memcpy(<void*>ptr, &tcp_udp, self.size) |
| |
| |
| cdef class Ipv6Spec(Spec): |
| EMPTY_IPV6 = '::' |
| IPV6_MASK = ("ffff:" * 8)[:-1] |
| FLOW_LABEL_MASK = 0xfffff |
| |
| def __init__(self, dst_ip=None, dst_ip_mask=None, src_ip=None, |
| src_ip_mask=None, flow_label=None, flow_label_mask=None, |
| next_hdr=None, next_hdr_mask=None, traffic_class=None, |
| traffic_class_mask=None, hop_limit=None, hop_limit_mask=None, |
| is_inner=False): |
| """ |
| Initialize an Ipv6Spec object over an underlying ibv_flow_ipv6 C |
| object that defines IPv6 header specifications for steering flow to |
| match on. |
| :param dst_ip: Destination IPv6 to match on (e.g. 'a0a1::a2a3:a4a5:a6a7:a8a9') |
| :param dst_ip_mask: Destination IPv6 mask (e.g. 'ffff::ffff:ffff:ffff:ffff') |
| :param src_ip: Source IPv6 to match on |
| :param src_ip_mask: Source IPv6 mask |
| :param flow_label: Flow label to match on |
| :param flow_label_mask: Flow label mask |
| :param next_hdr: Next header to match on |
| :param next_hdr_mask: Next header mask |
| :param traffic_class: Traffic class to match on |
| :param traffic_class_mask: Traffic class mask |
| :param hop_limit: Hop limit to match on |
| :param hop_limit_mask: Hop limit mask |
| :param is_inner: Is inner spec |
| """ |
| self.spec_type = v.IBV_FLOW_SPEC_IPV6 |
| if is_inner: |
| self.spec_type |= v.IBV_FLOW_SPEC_INNER |
| self.size = sizeof(v.ibv_flow_spec_ipv6) |
| |
| if dst_ip is None: |
| def_dst_ip_mask = self.EMPTY_IPV6 |
| dst_ip = '::' |
| else: |
| def_dst_ip_mask = self.IPV6_MASK |
| |
| if src_ip is None: |
| def_src_ip_mask = self.EMPTY_IPV6 |
| src_ip = '::' |
| else: |
| def_src_ip_mask = self.IPV6_MASK |
| |
| self.dst_ip, self.dst_ip_mask = self._set_val_mask(def_dst_ip_mask, |
| dst_ip, dst_ip_mask) |
| self.src_ip, self.src_ip_mask = self._set_val_mask(def_src_ip_mask, |
| src_ip, src_ip_mask) |
| self.val.flow_label, self.mask.flow_label = \ |
| map(socket.htonl, self._set_val_mask(self.FLOW_LABEL_MASK, |
| flow_label, flow_label_mask)) |
| self.val.next_hdr, self.mask.next_hdr = \ |
| self._set_val_mask(0xff, next_hdr, next_hdr_mask) |
| self.val.traffic_class, self.mask.traffic_class = \ |
| self._set_val_mask(0xff, traffic_class, traffic_class_mask) |
| self.val.hop_limit, self.mask.hop_limit = \ |
| self._set_val_mask(0xff, hop_limit, hop_limit_mask) |
| |
| @property |
| def dst_ip(self): |
| return socket.inet_ntop(socket.AF_INET6, self.val.dst_ip[:16]) |
| |
| @dst_ip.setter |
| def dst_ip(self, val): |
| self.val.dst_ip = socket.inet_pton(socket.AF_INET6, val) |
| |
| @property |
| def dst_ip_mask(self): |
| return socket.inet_ntop(socket.AF_INET6, self.mask.dst_ip[:16]) |
| |
| @dst_ip_mask.setter |
| def dst_ip_mask(self, val): |
| self.mask.dst_ip = socket.inet_pton(socket.AF_INET6, val) |
| |
| @property |
| def src_ip(self): |
| return socket.inet_ntop(socket.AF_INET6, self.val.src_ip[:16]) |
| |
| @src_ip.setter |
| def src_ip(self, val): |
| self.val.src_ip = socket.inet_pton(socket.AF_INET6, val) |
| |
| @property |
| def src_ip_mask(self): |
| return socket.inet_ntop(socket.AF_INET6, self.mask.src_ip[:16]) |
| |
| @src_ip_mask.setter |
| def src_ip_mask(self, val): |
| self.mask.src_ip = socket.inet_pton(socket.AF_INET6, val) |
| |
| @property |
| def flow_label(self): |
| return socket.ntohl(self.val.flow_label) |
| |
| @flow_label.setter |
| def flow_label(self, val): |
| self.val.flow_label = socket.htonl(val) |
| |
| @property |
| def flow_label_mask(self): |
| return socket.ntohl(self.mask.flow_label) |
| |
| @flow_label_mask.setter |
| def flow_label_mask(self, val): |
| self.mask.flow_label = socket.htonl(val) |
| |
| @property |
| def next_hdr(self): |
| return self.val.next_hdr |
| |
| @next_hdr.setter |
| def next_hdr(self, val): |
| self.val.next_hdr = val |
| |
| @property |
| def next_hdr_mask(self): |
| return self.mask.next_hdr |
| |
| @next_hdr_mask.setter |
| def next_hdr_mask(self, val): |
| self.mask.next_hdr = val |
| |
| @property |
| def traffic_class(self): |
| return self.val.traffic_class |
| |
| @traffic_class.setter |
| def traffic_class(self, val): |
| self.val.traffic_class = val |
| |
| @property |
| def traffic_class_mask(self): |
| return self.mask.traffic_class |
| |
| @traffic_class_mask.setter |
| def traffic_class_mask(self, val): |
| self.mask.traffic_class = val |
| |
| @property |
| def hop_limit(self): |
| return self.val.hop_limit |
| |
| @hop_limit.setter |
| def hop_limit(self, val): |
| self.val.hop_limit = val |
| |
| @property |
| def hop_limit_mask(self): |
| return self.mask.hop_limit |
| |
| @hop_limit_mask.setter |
| def hop_limit_mask(self, val): |
| self.mask.hop_limit = val |
| |
| def __str__(self): |
| return super().__str__() + \ |
| f"{'Src IP':<16}: {self.src_ip:<20} {self.src_ip_mask:<20}\n" \ |
| f"{'Dst IP':<16}: {self.dst_ip:<20} {self.dst_ip_mask:<20}\n" \ |
| f"{'Flow label':<16}: {self.flow_label:<20} {self.flow_label_mask:<20}\n" \ |
| f"{'Next header':<16}: {self.next_hdr:<20} {self.next_hdr_mask:<20}\n" \ |
| f"{'Traffic class':<16}: {self.traffic_class:<20} {self.traffic_class_mask:<20}\n" \ |
| f"{'Hop limit':<16}: {self.hop_limit:<20} {self.hop_limit_mask:<20}\n" |
| |
| cpdef _copy_data(self, unsigned long ptr): |
| cdef v.ibv_flow_spec_ipv6 ipv6 |
| ipv6.size = self.size |
| ipv6.type = self.spec_type |
| ipv6.val = self.val |
| ipv6.mask = self.mask |
| memcpy(<void*>ptr, &ipv6, self.size) |
