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)
