def get_device(name=None): """Return a :class:`rdma.devices.Device` for the default device if name is ``None``, or for the device described by name. The device string format is one of: =========== =================== Format Example =========== =================== device mlx4_0 Node GUID 0002:c903:0000:1491 =========== =================== :rtype: :class:`rdma.devices.device` :raises rdma.RDMAError: If no matching device is found or name is invalid.""" devices = get_devices() if len(devices) == 0: raise RDMAError("No RDMA devices found.") if name is None: return devices.first() # Port GUID import rdma.devices import rdma.IBA try: guid = IBA.GUID(name) except ValueError: pass else: return rdma.devices.find_node_guid(devices, guid) # Device name string try: return devices[name] except KeyError: raise RDMAError("RDMA device %r not found." % (name))
def set_mad_attr(attr, name, v): try: # Need to use eval because name could have dots in it. arg = eval("attr.%s" % (name)) except AttributeError: raise CmdError("%r is not a valid attribute for %r" % (name, attr)) try: if isinstance(arg, int) or isinstance(arg, long): v = int(v, 0) elif isinstance(arg, IBA.GID): v = IBA.GID(v) elif isinstance(arg, IBA.GUID): v = IBA.GUID(v) elif isinstance(arg, bytearray): v = v.decode("string_escape") if len(v) > len(arg): raise CmdError("String %r is too long, can only be up to %u" % (v, len(arg))) if len(v) < len(arg): v = v + bytearray(len(arg) - len(v)) elif isinstance(arg, list): raise CmdError("Lists currently cannot be set.") else: raise CmdError("Internal Error, I don't know what %s %r is." % (type(arg), arg)) except ValueError as err: raise CmdError("String %r did not parse: %s" % (v, err)) exec "attr.%s = v" % (name)
def find_port_gid(devices, gid): """Search the list *devices* for the end port with *gid*. :returns: (:class:`EndPort`,gid_index) :raises rdma.RDMAError: If no matching device is found.""" # The link local prefix should always be valid if gid.prefix() == IBA.GUID(IBA.GID_DEFAULT_PREFIX): return find_port_guid(devices, gid.guid()), gid if gid.guid() == IBA.GUID(0): raise rdma.RDMAError("RDMA end port %r not found." % (gid)) for I in devices: for J in I.end_ports: try: return (J, J.gids.index(gid)) except ValueError: continue raise rdma.RDMAError("RDMA end port %r not found." % (gid))
def test_fail(self): """Test valid get_end_port calls that fail.""" devices = rdma.get_devices() dev = devices.first() self.assertRaises(rdma.RDMAError, rdma.get_end_port, IBA.GID("::")) self.assertRaises(rdma.RDMAError, rdma.get_end_port, IBA.GUID("0000:0000:0000:0000")) self.assertRaises(rdma.RDMAError, rdma.get_end_port, "xxx") self.assertRaises(rdma.RDMAError, rdma.get_end_port, "%s/99" % (dev.name))
def set_guid(lid,guid,slot): rec = IBA.SAGUIDInfoRecord(); rec_cm = IBA.ComponentMask(rec); rec_cm.blockNum = slot//8; rec_cm.LID = lid; # ComponentMask does not handle this array correctly idx = slot - rec.blockNum*8; rec.GUIDInfo.GUIDBlock[idx] = IBA.GUID(guid); rec_cm.component_mask = rec_cm.component_mask | (1<<(rec.COMPONENT_MASK['GUIDInfo.GUIDBlock'] + idx)); return rec_cm;
def test_subnet(self): "Pickling Subnet objects" sbn = rdma.subnet.Subnet() pinf = IBA.SMPPortInfo() for I in range(1, 100): pinf.LID = I port = sbn.get_port_pinf(pinf, portIdx=0, LID=I) port.portGUID = IBA.GUID(0xDEADBEEF0000 | I) sbn.ports[port.portGUID] = port ret = pickle.dumps(sbn) tmp2 = pickle.loads(ret) self.assertEquals(len(sbn.all_nodes), len(tmp2.all_nodes)) self.assertEquals(sorted(sbn.nodes.keys()), sorted(tmp2.nodes.keys())) self.assertEquals(sorted(sbn.ports.keys()), sorted(tmp2.ports.keys()))
def get_end_port(name=None): """Return a :class:`rdma.devices.EndPort` for the default end port if name is ``None``, or for the end port described by name. The end port string format is one of: =========== =================== Format Example =========== =================== device mlx4_0 (defaults to the first port) device/port mlx4_0/1 Port GID fe80::2:c903:0:1491 Port GUID 0002:c903:0000:1491 =========== =================== :rtype: :class:`rdma.devices.EndPort` :raises rdma.RDMAError: If no matching device is found or name is invalid.""" devices = get_devices() if len(devices) == 0: raise RDMAError("No RDMA devices found.") if name is None: return devices.first().end_ports.first() # Try for a port GID import rdma.devices import rdma.IBA try: gid = IBA.GID(name) except ValueError: pass else: return rdma.devices.find_port_gid(devices, gid)[0] # Port GUID try: guid = IBA.GUID(name) except ValueError: pass else: return rdma.devices.find_port_guid(devices, guid) # Device name string return rdma.devices.find_port_name(devices, name)
def test_guid(self): """Test IBA.GUID class""" pg = IBA.GUID("0002:c903:0000:1491") self.assertEquals(pg, pg) self.assertEquals(pg, IBA.GUID("0002:c903:0000:1491")) self.assertEquals(pg, IBA.GUID(pg))
def __init__(self, o, args, values=None, max_values=0, template=None): self.args = args self.o = o self.debug = args.debug o.verbosity = max(self.debug, getattr(args, "verbosity", 0)) self.end_port = self.get_end_port() if template: if len(values) > max_values: raise CmdError( "Too many arguments, expected no more than %u." % (max_values)) # Special processing for tmpl_target. The target path specified # can choose the local end port, however all specified targets on # the command line must share the same end port. The selection # must also be consistent with the command line arguments. default_end_port = self.end_port require_ep = None require_dev = None if self.args.port is not None: require_ep = default_end_port elif self.args.CA is not None: require_dev = default_end_port.parent for I in range(len(values)): try: tmpl = template[I] v = values[I] if tmpl == tmpl_target: if self.args.addr_direct: # -D 0 is the same as our 0, try: desc = int(v, 0) v = "%u," % (int(v, 0)) except ValueError: pass if self.args.addr_guid: # Will will Parse the infiniband diags hex format # GUIDs if -G is specified. try: v = str(IBA.GUID(int(v, 16))) except ValueError: pass path = tmpl(v, default_end_port, require_dev, require_ep) if self.args.addr_direct and not isinstance( path, rdma.path.IBDRPath): raise ValueError("Not a directed route") if self.args.addr_guid and path.DGID is None: raise ValueError("Not a GUID") if self.args.addr_lid and path.DLID == 0: raise ValueError("Not a LID") values[I] = path if path.end_port is not None: require_ep = path.end_port require_dev = None default_end_port = require_ep else: values[I] = tmpl(v) except ValueError as err: raise CmdError( "Invalid command line argument #%u %r - %s" % (I + 1, values[I], err)) self.end_port = default_end_port self.end_port.sa_path.SMKey = getattr(args, "smkey", 0) if self.debug >= 1: print "D: Using end port %s %s" % (self.end_port, self.end_port.default_gid) if "discovery" in args.__dict__: if (args.discovery is None and (self.end_port.state != IBA.PORT_STATE_ACTIVE or not 0 < self.end_port.lid < IBA.LID_MULTICAST)): args.discovery = "DR" if args.use_sa and args.discovery is not None and args.discovery != "SA": raise CmdError("Can't combine --sa with discovery mode %r" % (args.discovery)) if args.use_sa: args.discovery = "SA" if args.discovery == "SA": args.use_sa = True if args.discovery is None: args.discovery = "LID" if o.verbosity >= 2: self.format_args = { "format": "dump" } else: cmd = str(getattr(o, "current_command", "")) if (cmd.find("saquery") != -1 or cmd.find("ibportstate") != -1): self.format_args = { "header": False, "colon": False, "format": "dotted", "name_map": libib_name_map_saquery, "column": 25, "skip_reserved": False } elif cmd.find("perfquery") != -1: self.format_args = { "header": False, "colon": True, "format": "dotted", "name_map": libib_name_map_perfquery, "dump_list": True } elif cmd.find("smpquery") != -1: self.format_args = { "header": False, "colon": True, "format": "dotted", "name_map": libib_name_map_smpquery } else: self.format_args = { "header": False, "colon": False, "format": "dotted" } if getattr(args, "int_names", True): self.format_args = { "header": False, "colon": False, "format": "dotted" }
def tmpl_port_guid(s): return IBA.GUID(s)
def tmpl_node_guid(s): return IBA.GUID(s)
def struct_dotted(F, s, name_prefix='', dump_list=False, skip_reserved=True, column=33, colon=False, name_map=None): """This tries to emulate the libib structure print format. Members are printed one per line with values aligned on column 32.""" for name, mbits, count in s.MEMBERS: if skip_reserved and name.startswith("reserved_"): continue attr = getattr(s, name) if attr is None: continue cname = name[0].upper() + name[1:] if name_map: cname = name_map.get(cname, cname) # Special automagic decode of format data members based on # attribute ID. if name == "data" and isinstance(s, rdma.binstruct.BinFormat): nattr = IBA.ATTR_TO_STRUCT.get((s.__class__, s.attributeID)) if nattr != None: if nattr.MAD_LENGTH <= len(attr): attr = nattr(attr) if isinstance(attr, rdma.binstruct.BinStruct): struct_dotted(F, attr, "%s%s." % (name_prefix, name), dump_list=dump_list, skip_reserved=skip_reserved, column=column, colon=colon, name_map=name_map) continue if count != 1 and len(attr) == count: ref = attr[0] else: ref = attr conv = None if isinstance(ref, IBA.GID) or isinstance(ref, IBA.GUID): fmt = "%s" else: fmt = IBA.MEMBER_FORMATS.get(name, "%r") if fmt == "hex": fmt = "0x%%0%ux" % ((mbits + 3) // 4) if fmt == "str": fmt = "%s" conv = lambda value: dstr(description(value), quotes=True) if fmt == "gid_prefix": fmt = "%s/64" conv = lambda value: IBA.GID(prefix=value, guid=IBA.GUID(0)) if count != 1 and len(attr) == count and conv == None: if isinstance(attr[0], rdma.binstruct.BinStruct): for I, v in enumerate(attr): struct_dotted(F, v, "%s%s[%u]." % (name_prefix, name, I), dump_list=dump_list, skip_reserved=skip_reserved, column=column, colon=colon, name_map=name_map) continue if mbits > 16 or dump_list: for I, v in enumerate(attr): n = "%s%s[%u]" % (name_prefix, cname, I) if colon: n = n + ":" if conv: v = conv(v) print >> F, ("%s%s" + fmt) % (n, "." * (column - len(n)), v) continue else: attr = "[%s]" % (", ".join( ("%u:" + fmt) % (I, v) for I, v in enumerate(attr))) fmt = "%s" n = "%s%s" % (name_prefix, cname) if colon: n = n + ":" if conv: attr = conv(attr) print >> F, ("%s%s" + fmt) % (n, "." * (column - len(n)), attr)