[LIBIBMAD] mirror OFED files in svn to assist Windows developers; see README.txt.
authorstansmith <stansmith@ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86>
Tue, 6 Jan 2009 20:04:43 +0000 (20:04 +0000)
committerstansmith <stansmith@ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86>
Tue, 6 Jan 2009 20:04:43 +0000 (20:04 +0000)
[LIBUMAD] added README.txt file to explain source mirror policy.

git-svn-id: svn://openib.tc.cornell.edu/gen1/trunk@1808 ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86

22 files changed:
ulp/libibmad/README.txt [new file with mode: 0644]
ulp/libibmad/dirs [new file with mode: 0644]
ulp/libibmad/include/infiniband/mad.h [new file with mode: 0644]
ulp/libibmad/src/Sources [new file with mode: 0644]
ulp/libibmad/src/dump.c [new file with mode: 0644]
ulp/libibmad/src/fields.c [new file with mode: 0644]
ulp/libibmad/src/gs.c [new file with mode: 0644]
ulp/libibmad/src/ibmad.rc [new file with mode: 0644]
ulp/libibmad/src/ibmad_export.def [new file with mode: 0644]
ulp/libibmad/src/ibmad_exports.src [new file with mode: 0644]
ulp/libibmad/src/ibmad_main.cpp [new file with mode: 0644]
ulp/libibmad/src/mad.c [new file with mode: 0644]
ulp/libibmad/src/makefile [new file with mode: 0644]
ulp/libibmad/src/portid.c [new file with mode: 0644]
ulp/libibmad/src/register.c [new file with mode: 0644]
ulp/libibmad/src/resolve.c [new file with mode: 0644]
ulp/libibmad/src/rpc.c [new file with mode: 0644]
ulp/libibmad/src/sa.c [new file with mode: 0644]
ulp/libibmad/src/serv.c [new file with mode: 0644]
ulp/libibmad/src/smp.c [new file with mode: 0644]
ulp/libibmad/src/vendor.c [new file with mode: 0644]
ulp/libibumad/README.txt [new file with mode: 0644]

diff --git a/ulp/libibmad/README.txt b/ulp/libibmad/README.txt
new file mode 100644 (file)
index 0000000..7c82b7e
--- /dev/null
@@ -0,0 +1,19 @@
+[1-06-09]\r
+\r
+These 'shared' OFED files (shared between Linux and Windows) are mirrored here for the convience\r
+of Windows developers.\r
+\r
+The 'offical' OFED source files are located in the OFED git repository.\r
+\r
+The policy is 'no source file changes' in non-build files (.h & .c) are accepted here.\r
+Any source file changes here will likely be overwritten when refreshed from the OFED git repository.\r
+\r
+The plan here is to have a single Linux and Windows source.\r
+\r
+If you require source file changes, push the changes to the OFED maintainers.\r
+\r
+For continuing policy discussion, please contact sean.hefty@intel.com\r
+\r
+thank you,\r
+\r
+Stan (stan.smith@intel.com)
\ No newline at end of file
diff --git a/ulp/libibmad/dirs b/ulp/libibmad/dirs
new file mode 100644 (file)
index 0000000..b1cbe45
--- /dev/null
@@ -0,0 +1,2 @@
+DIRS =         \\r
+       src
\ No newline at end of file
diff --git a/ulp/libibmad/include/infiniband/mad.h b/ulp/libibmad/include/infiniband/mad.h
new file mode 100644 (file)
index 0000000..b5acdd3
--- /dev/null
@@ -0,0 +1,913 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#ifndef _MAD_H_\r
+#define _MAD_H_\r
+\r
+/* use complib for portability */\r
+#include <complib/cl_types.h>\r
+#include <complib/cl_byteswap.h>\r
+#include <complib/cl_debug.h>\r
+\r
+#ifdef __cplusplus\r
+#  define BEGIN_C_DECLS extern "C" {\r
+#  define END_C_DECLS   }\r
+#else /* !__cplusplus */\r
+#  define BEGIN_C_DECLS\r
+#  define END_C_DECLS\r
+#endif /* __cplusplus */\r
+\r
+BEGIN_C_DECLS\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#define MAD_EXPORT     __declspec(dllexport)\r
+#else\r
+#define MAD_EXPORT     extern\r
+#endif\r
+\r
+#define IB_SUBNET_PATH_HOPS_MAX        64\r
+#define IB_DEFAULT_SUBN_PREFIX 0xfe80000000000000ULL\r
+#define IB_DEFAULT_QP1_QKEY    0x80010000\r
+\r
+#define IB_MAD_SIZE            256\r
+\r
+#define IB_SMP_DATA_OFFS       64\r
+#define IB_SMP_DATA_SIZE       64\r
+\r
+#define IB_VENDOR_RANGE1_DATA_OFFS     24\r
+#define IB_VENDOR_RANGE1_DATA_SIZE     (IB_MAD_SIZE - IB_VENDOR_RANGE1_DATA_OFFS)\r
+\r
+#define IB_VENDOR_RANGE2_DATA_OFFS     40\r
+#define IB_VENDOR_RANGE2_DATA_SIZE     (IB_MAD_SIZE - IB_VENDOR_RANGE2_DATA_OFFS)\r
+\r
+#define IB_SA_DATA_SIZE                200\r
+#define IB_SA_DATA_OFFS                56\r
+\r
+#define IB_PC_DATA_OFFS                64\r
+#define IB_PC_DATA_SZ          (IB_MAD_SIZE - IB_PC_DATA_OFFS)\r
+\r
+#define IB_SA_MCM_RECSZ                53\r
+#define IB_SA_PR_RECSZ         64\r
+\r
+enum MAD_CLASSES {\r
+       IB_SMI_CLASS =          0x1,\r
+       IB_SMI_DIRECT_CLASS =   0x81,\r
+       IB_SA_CLASS =           0x3,\r
+       IB_PERFORMANCE_CLASS =  0x4,\r
+       IB_BOARD_MGMT_CLASS =   0x5,\r
+       IB_DEVICE_MGMT_CLASS =  0x6,\r
+       IB_CM_CLASS =           0x7,\r
+       IB_SNMP_CLASS =         0x8,\r
+       IB_VENDOR_RANGE1_START_CLASS = 0x9,\r
+       IB_VENDOR_RANGE1_END_CLASS = 0x0f,\r
+       IB_CC_CLASS =           0x21,\r
+       IB_VENDOR_RANGE2_START_CLASS = 0x30,\r
+       IB_VENDOR_RANGE2_END_CLASS = 0x4f,\r
+};\r
+\r
+enum MAD_METHODS {\r
+       IB_MAD_METHOD_GET =             0x1,\r
+       IB_MAD_METHOD_SET =             0x2,\r
+       IB_MAD_METHOD_GET_RESPONSE =    0x81,\r
+\r
+       IB_MAD_METHOD_SEND =            0x3,\r
+       IB_MAD_METHOD_TRAP =            0x5,\r
+       IB_MAD_METHOD_TRAP_REPRESS =    0x7,\r
+\r
+       IB_MAD_METHOD_REPORT =          0x6,\r
+       IB_MAD_METHOD_REPORT_RESPONSE = 0x86,\r
+       IB_MAD_METHOD_GET_TABLE =       0x12,\r
+       IB_MAD_METHOD_GET_TABLE_RESPONSE = 0x92,\r
+       IB_MAD_METHOD_GET_TRACE_TABLE = 0x13,\r
+       IB_MAD_METHOD_GET_TRACE_TABLE_RESPONSE = 0x93,\r
+       IB_MAD_METHOD_GETMULTI =        0x14,\r
+       IB_MAD_METHOD_GETMULTI_RESPONSE = 0x94,\r
+       IB_MAD_METHOD_DELETE =          0x15,\r
+       IB_MAD_METHOD_DELETE_RESPONSE = 0x95,\r
+\r
+       IB_MAD_RESPONSE =               0x80,\r
+};\r
+\r
+enum MAD_ATTR_ID {\r
+       CLASS_PORT_INFO = 0x1,\r
+       NOTICE = 0x2,\r
+       INFORM_INFO = 0x3,\r
+};\r
+\r
+enum SMI_ATTR_ID {\r
+       IB_ATTR_NODE_DESC = 0x10,\r
+       IB_ATTR_NODE_INFO = 0x11,\r
+       IB_ATTR_SWITCH_INFO = 0x12,\r
+       IB_ATTR_GUID_INFO = 0x14,\r
+       IB_ATTR_PORT_INFO = 0x15,\r
+       IB_ATTR_PKEY_TBL = 0x16,\r
+       IB_ATTR_SLVL_TABLE = 0x17,\r
+       IB_ATTR_VL_ARBITRATION = 0x18,\r
+       IB_ATTR_LINEARFORWTBL = 0x19,\r
+       IB_ATTR_MULTICASTFORWTBL = 0x1b,\r
+       IB_ATTR_SMINFO = 0x20,\r
+\r
+       IB_ATTR_LAST\r
+};\r
+\r
+enum SA_ATTR_ID {\r
+       IB_SA_ATTR_NOTICE = 0x02,\r
+       IB_SA_ATTR_INFORMINFO = 0x03,\r
+       IB_SA_ATTR_PORTINFORECORD = 0x12,\r
+       IB_SA_ATTR_LINKRECORD = 0x20,\r
+       IB_SA_ATTR_SERVICERECORD = 0x31,\r
+       IB_SA_ATTR_PATHRECORD = 0x35,\r
+       IB_SA_ATTR_MCRECORD = 0x38,\r
+       IB_SA_ATTR_MULTIPATH = 0x3a,\r
+\r
+       IB_SA_ATTR_LAST\r
+};\r
+\r
+enum GSI_ATTR_ID {\r
+       IB_GSI_PORT_SAMPLES_CONTROL = 0x10,\r
+       IB_GSI_PORT_SAMPLES_RESULT = 0x11,\r
+       IB_GSI_PORT_COUNTERS = 0x12,\r
+       IB_GSI_PORT_COUNTERS_EXT = 0x1D,\r
+\r
+       IB_GSI_ATTR_LAST\r
+};\r
+\r
+#define IB_VENDOR_OPENIB_PING_CLASS    (IB_VENDOR_RANGE2_START_CLASS + 2)\r
+#define IB_VENDOR_OPENIB_SYSSTAT_CLASS (IB_VENDOR_RANGE2_START_CLASS + 3)\r
+#define IB_OPENIB_OUI                  (0x001405)\r
+\r
+typedef uint8_t ibmad_gid_t[16];\r
+#ifdef USE_DEPRECATED_IB_GID_T\r
+typedef ibmad_gid_t ib_gid_t __attribute__((deprecated));\r
+#endif\r
+\r
+typedef struct {\r
+       int cnt;\r
+       uint8_t p[IB_SUBNET_PATH_HOPS_MAX];\r
+       uint16_t drslid;\r
+       uint16_t drdlid;\r
+} ib_dr_path_t;\r
+\r
+typedef struct {\r
+       unsigned id;\r
+       unsigned mod;\r
+} ib_attr_t;\r
+\r
+typedef struct {\r
+       int mgtclass;\r
+       int method;\r
+       ib_attr_t attr;\r
+       uint32_t rstatus;       /* return status */\r
+       int dataoffs;\r
+       int datasz;\r
+       uint64_t mkey;\r
+       uint64_t trid;  /* used for out mad if nonzero, return real val */\r
+       uint64_t mask;  /* for sa mads */\r
+       unsigned recsz; /* for sa mads (attribute offset) */\r
+       int timeout;\r
+       uint32_t oui;   /* for vendor range 2 mads */\r
+} ib_rpc_t;\r
+\r
+typedef struct portid {\r
+       int lid;                /* lid or 0 if directed route */\r
+       ib_dr_path_t drpath;\r
+       int grh_present;        /* flag */\r
+       ibmad_gid_t gid;\r
+       uint32_t qp;\r
+       uint32_t qkey;\r
+       uint8_t sl;\r
+       unsigned pkey_idx;\r
+} ib_portid_t;\r
+\r
+typedef void (ib_mad_dump_fn)(char *buf, int bufsz, void *val, int valsz);\r
+\r
+#define IB_FIELD_NAME_LEN      32\r
+\r
+typedef struct ib_field {\r
+       int bitoffs;\r
+       int bitlen;\r
+       char name[IB_FIELD_NAME_LEN];\r
+       ib_mad_dump_fn *def_dump_fn;\r
+} ib_field_t;\r
+\r
+enum MAD_FIELDS {\r
+       IB_NO_FIELD,\r
+\r
+       IB_GID_PREFIX_F,\r
+       IB_GID_GUID_F,\r
+\r
+       /* first MAD word (0-3 bytes) */\r
+       IB_MAD_METHOD_F,\r
+       IB_MAD_RESPONSE_F,\r
+       IB_MAD_CLASSVER_F,\r
+       IB_MAD_MGMTCLASS_F,\r
+       IB_MAD_BASEVER_F,\r
+\r
+       /* second MAD word (4-7 bytes) */\r
+       IB_MAD_STATUS_F,\r
+\r
+       /* DRSMP only */\r
+       IB_DRSMP_HOPCNT_F,\r
+       IB_DRSMP_HOPPTR_F,\r
+       IB_DRSMP_STATUS_F,\r
+       IB_DRSMP_DIRECTION_F,\r
+\r
+       /* words 3,4,5,6 (8-23 bytes) */\r
+       IB_MAD_TRID_F,\r
+       IB_MAD_ATTRID_F,\r
+       IB_MAD_ATTRMOD_F,\r
+\r
+       /* word 7,8 (24-31 bytes) */\r
+       IB_MAD_MKEY_F,\r
+\r
+       /* word 9 (32-37 bytes) */\r
+       IB_DRSMP_DRSLID_F,\r
+       IB_DRSMP_DRDLID_F,\r
+\r
+       /* word 10,11 (36-43 bytes) */\r
+       IB_SA_MKEY_F,\r
+\r
+       /* word 12 (44-47 bytes) */\r
+       IB_SA_ATTROFFS_F,\r
+\r
+       /* word 13,14 (48-55 bytes) */\r
+       IB_SA_COMPMASK_F,\r
+\r
+       /* word 13,14 (56-255 bytes) */\r
+       IB_SA_DATA_F,\r
+\r
+       /* bytes 64 - 127 */\r
+       IB_SM_DATA_F,\r
+\r
+       /* bytes 64 - 256 */\r
+       IB_GS_DATA_F,\r
+\r
+       /* bytes 128 - 191 */\r
+       IB_DRSMP_PATH_F,\r
+\r
+       /* bytes 192 - 255 */\r
+       IB_DRSMP_RPATH_F,\r
+\r
+       /*\r
+        * PortInfo fields:\r
+        */\r
+       IB_PORT_FIRST_F,\r
+       IB_PORT_MKEY_F = IB_PORT_FIRST_F,\r
+       IB_PORT_GID_PREFIX_F,\r
+       IB_PORT_LID_F,\r
+       IB_PORT_SMLID_F,\r
+       IB_PORT_CAPMASK_F,\r
+       IB_PORT_DIAG_F,\r
+       IB_PORT_MKEY_LEASE_F,\r
+       IB_PORT_LOCAL_PORT_F,\r
+       IB_PORT_LINK_WIDTH_ENABLED_F,\r
+       IB_PORT_LINK_WIDTH_SUPPORTED_F,\r
+       IB_PORT_LINK_WIDTH_ACTIVE_F,\r
+       IB_PORT_LINK_SPEED_SUPPORTED_F,\r
+       IB_PORT_STATE_F,\r
+       IB_PORT_PHYS_STATE_F,\r
+       IB_PORT_LINK_DOWN_DEF_F,\r
+       IB_PORT_MKEY_PROT_BITS_F,\r
+       IB_PORT_LMC_F,\r
+       IB_PORT_LINK_SPEED_ACTIVE_F,\r
+       IB_PORT_LINK_SPEED_ENABLED_F,\r
+       IB_PORT_NEIGHBOR_MTU_F,\r
+       IB_PORT_SMSL_F,\r
+       IB_PORT_VL_CAP_F,\r
+       IB_PORT_INIT_TYPE_F,\r
+       IB_PORT_VL_HIGH_LIMIT_F,\r
+       IB_PORT_VL_ARBITRATION_HIGH_CAP_F,\r
+       IB_PORT_VL_ARBITRATION_LOW_CAP_F,\r
+       IB_PORT_INIT_TYPE_REPLY_F,\r
+       IB_PORT_MTU_CAP_F,\r
+       IB_PORT_VL_STALL_COUNT_F,\r
+       IB_PORT_HOQ_LIFE_F,\r
+       IB_PORT_OPER_VLS_F,\r
+       IB_PORT_PART_EN_INB_F,\r
+       IB_PORT_PART_EN_OUTB_F,\r
+       IB_PORT_FILTER_RAW_INB_F,\r
+       IB_PORT_FILTER_RAW_OUTB_F,\r
+       IB_PORT_MKEY_VIOL_F,\r
+       IB_PORT_PKEY_VIOL_F,\r
+       IB_PORT_QKEY_VIOL_F,\r
+       IB_PORT_GUID_CAP_F,\r
+       IB_PORT_CLIENT_REREG_F,\r
+       IB_PORT_SUBN_TIMEOUT_F,\r
+       IB_PORT_RESP_TIME_VAL_F,\r
+       IB_PORT_LOCAL_PHYS_ERR_F,\r
+       IB_PORT_OVERRUN_ERR_F,\r
+       IB_PORT_MAX_CREDIT_HINT_F,\r
+       IB_PORT_LINK_ROUND_TRIP_F,\r
+       IB_PORT_LAST_F,\r
+\r
+       /*\r
+        * NodeInfo fields:\r
+        */\r
+       IB_NODE_FIRST_F,\r
+       IB_NODE_BASE_VERS_F = IB_NODE_FIRST_F,\r
+       IB_NODE_CLASS_VERS_F,\r
+       IB_NODE_TYPE_F,\r
+       IB_NODE_NPORTS_F,\r
+       IB_NODE_SYSTEM_GUID_F,\r
+       IB_NODE_GUID_F,\r
+       IB_NODE_PORT_GUID_F,\r
+       IB_NODE_PARTITION_CAP_F,\r
+       IB_NODE_DEVID_F,\r
+       IB_NODE_REVISION_F,\r
+       IB_NODE_LOCAL_PORT_F,\r
+       IB_NODE_VENDORID_F,\r
+       IB_NODE_LAST_F,\r
+\r
+       /*\r
+        * SwitchInfo fields:\r
+        */\r
+       IB_SW_FIRST_F,\r
+       IB_SW_LINEAR_FDB_CAP_F = IB_SW_FIRST_F,\r
+       IB_SW_RANDOM_FDB_CAP_F,\r
+       IB_SW_MCAST_FDB_CAP_F,\r
+       IB_SW_LINEAR_FDB_TOP_F,\r
+       IB_SW_DEF_PORT_F,\r
+       IB_SW_DEF_MCAST_PRIM_F,\r
+       IB_SW_DEF_MCAST_NOT_PRIM_F,\r
+       IB_SW_LIFE_TIME_F,\r
+       IB_SW_STATE_CHANGE_F,\r
+       IB_SW_LIDS_PER_PORT_F,\r
+       IB_SW_PARTITION_ENFORCE_CAP_F,\r
+       IB_SW_PARTITION_ENF_INB_F,\r
+       IB_SW_PARTITION_ENF_OUTB_F,\r
+       IB_SW_FILTER_RAW_INB_F,\r
+       IB_SW_FILTER_RAW_OUTB_F,\r
+       IB_SW_ENHANCED_PORT0_F,\r
+       IB_SW_LAST_F,\r
+\r
+       /*\r
+        * SwitchLinearForwardingTable fields:\r
+        */\r
+       IB_LINEAR_FORW_TBL_F,\r
+\r
+       /*\r
+        * SwitchMulticastForwardingTable fields:\r
+        */\r
+       IB_MULTICAST_FORW_TBL_F,\r
+\r
+       /*\r
+        * NodeDescription fields:\r
+        */\r
+       IB_NODE_DESC_F,\r
+\r
+       /*\r
+        * Notice/Trap fields\r
+        */\r
+       IB_NOTICE_IS_GENERIC_F,\r
+       IB_NOTICE_TYPE_F,\r
+       IB_NOTICE_PRODUCER_F,\r
+       IB_NOTICE_TRAP_NUMBER_F,\r
+       IB_NOTICE_ISSUER_LID_F,\r
+       IB_NOTICE_TOGGLE_F,\r
+       IB_NOTICE_COUNT_F,\r
+       IB_NOTICE_DATA_DETAILS_F,\r
+       IB_NOTICE_DATA_LID_F,\r
+       IB_NOTICE_DATA_144_LID_F,\r
+       IB_NOTICE_DATA_144_CAPMASK_F,\r
+\r
+       /*\r
+        * GS Performance\r
+        */\r
+       IB_PC_FIRST_F,\r
+       IB_PC_PORT_SELECT_F = IB_PC_FIRST_F,\r
+       IB_PC_COUNTER_SELECT_F,\r
+       IB_PC_ERR_SYM_F,\r
+       IB_PC_LINK_RECOVERS_F,\r
+       IB_PC_LINK_DOWNED_F,\r
+       IB_PC_ERR_RCV_F,\r
+       IB_PC_ERR_PHYSRCV_F,\r
+       IB_PC_ERR_SWITCH_REL_F,\r
+       IB_PC_XMT_DISCARDS_F,\r
+       IB_PC_ERR_XMTCONSTR_F,\r
+       IB_PC_ERR_RCVCONSTR_F,\r
+       IB_PC_ERR_LOCALINTEG_F,\r
+       IB_PC_ERR_EXCESS_OVR_F,\r
+       IB_PC_VL15_DROPPED_F,\r
+       IB_PC_XMT_BYTES_F,\r
+       IB_PC_RCV_BYTES_F,\r
+       IB_PC_XMT_PKTS_F,\r
+       IB_PC_RCV_PKTS_F,\r
+       IB_PC_LAST_F,\r
+\r
+       /*\r
+        * SMInfo\r
+        */\r
+       IB_SMINFO_GUID_F,\r
+       IB_SMINFO_KEY_F,\r
+       IB_SMINFO_ACT_F,\r
+       IB_SMINFO_PRIO_F,\r
+       IB_SMINFO_STATE_F,\r
+\r
+       /*\r
+        * SA RMPP\r
+        */\r
+       IB_SA_RMPP_VERS_F,\r
+       IB_SA_RMPP_TYPE_F,\r
+       IB_SA_RMPP_RESP_F,\r
+       IB_SA_RMPP_FLAGS_F,\r
+       IB_SA_RMPP_STATUS_F,\r
+\r
+       /* data1 */\r
+       IB_SA_RMPP_D1_F,\r
+       IB_SA_RMPP_SEGNUM_F,\r
+       /* data2 */\r
+       IB_SA_RMPP_D2_F,\r
+       IB_SA_RMPP_LEN_F,               /* DATA: Payload len */\r
+       IB_SA_RMPP_NEWWIN_F,            /* ACK: new window last */\r
+\r
+       /*\r
+        * SA Multi Path rec\r
+        */\r
+       IB_SA_MP_NPATH_F,\r
+       IB_SA_MP_NSRC_F,\r
+       IB_SA_MP_NDEST_F,\r
+       IB_SA_MP_GID0_F,\r
+\r
+       /*\r
+        * SA Path rec\r
+        */\r
+       IB_SA_PR_DGID_F,\r
+       IB_SA_PR_SGID_F,\r
+       IB_SA_PR_DLID_F,\r
+       IB_SA_PR_SLID_F,\r
+       IB_SA_PR_NPATH_F,\r
+\r
+       /*\r
+        * MC Member rec\r
+        */\r
+       IB_SA_MCM_MGID_F,\r
+       IB_SA_MCM_PORTGID_F,\r
+       IB_SA_MCM_QKEY_F,\r
+       IB_SA_MCM_MLID_F,\r
+       IB_SA_MCM_SL_F,\r
+       IB_SA_MCM_MTU_F,\r
+       IB_SA_MCM_RATE_F,\r
+       IB_SA_MCM_TCLASS_F,\r
+       IB_SA_MCM_PKEY_F,\r
+       IB_SA_MCM_FLOW_LABEL_F,\r
+       IB_SA_MCM_JOIN_STATE_F,\r
+       IB_SA_MCM_PROXY_JOIN_F,\r
+\r
+       /*\r
+        * Service record\r
+        */\r
+       IB_SA_SR_ID_F,\r
+       IB_SA_SR_GID_F,\r
+       IB_SA_SR_PKEY_F,\r
+       IB_SA_SR_LEASE_F,\r
+       IB_SA_SR_KEY_F,\r
+       IB_SA_SR_NAME_F,\r
+       IB_SA_SR_DATA_F,\r
+\r
+       /*\r
+        * ATS SM record - within SA_SR_DATA\r
+        */\r
+       IB_ATS_SM_NODE_ADDR_F,\r
+       IB_ATS_SM_MAGIC_KEY_F,\r
+       IB_ATS_SM_NODE_TYPE_F,\r
+       IB_ATS_SM_NODE_NAME_F,\r
+\r
+       /*\r
+        * SLTOVL MAPPING TABLE\r
+        */\r
+       IB_SLTOVL_MAPPING_TABLE_F,\r
+\r
+       /*\r
+        * VL ARBITRATION TABLE\r
+        */\r
+       IB_VL_ARBITRATION_TABLE_F,\r
+\r
+       /*\r
+        * IB vendor class range 2\r
+        */\r
+       IB_VEND2_OUI_F,\r
+       IB_VEND2_DATA_F,\r
+\r
+       /*\r
+        * PortCountersExtended\r
+        */\r
+       IB_PC_EXT_FIRST_F,\r
+       IB_PC_EXT_PORT_SELECT_F = IB_PC_EXT_FIRST_F,\r
+       IB_PC_EXT_COUNTER_SELECT_F,\r
+       IB_PC_EXT_XMT_BYTES_F,\r
+       IB_PC_EXT_RCV_BYTES_F,\r
+       IB_PC_EXT_XMT_PKTS_F,\r
+       IB_PC_EXT_RCV_PKTS_F,\r
+       IB_PC_EXT_XMT_UPKTS_F,\r
+       IB_PC_EXT_RCV_UPKTS_F,\r
+       IB_PC_EXT_XMT_MPKTS_F,\r
+       IB_PC_EXT_RCV_MPKTS_F,\r
+       IB_PC_EXT_LAST_F,\r
+\r
+       /*\r
+        * GUIDInfo fields\r
+        */\r
+       IB_GUID_GUID0_F,\r
+\r
+       IB_FIELD_LAST_  /* must be last */\r
+};\r
+\r
+/*\r
+ * SA RMPP section\r
+ */\r
+enum RMPP_TYPE_ENUM {\r
+       IB_RMPP_TYPE_NONE,\r
+       IB_RMPP_TYPE_DATA,\r
+       IB_RMPP_TYPE_ACK,\r
+       IB_RMPP_TYPE_STOP,\r
+       IB_RMPP_TYPE_ABORT,\r
+};\r
+\r
+enum RMPP_FLAGS_ENUM {\r
+       IB_RMPP_FLAG_ACTIVE = 1 << 0,\r
+       IB_RMPP_FLAG_FIRST = 1 << 1,\r
+       IB_RMPP_FLAG_LAST = 1 << 2,\r
+};\r
+\r
+typedef struct {\r
+       int type;\r
+       int flags;\r
+       int status;\r
+       union {\r
+               uint32_t u;\r
+               uint32_t segnum;\r
+       } d1;\r
+       union {\r
+               uint32_t u;\r
+               uint32_t len;\r
+               uint32_t newwin;\r
+       } d2;\r
+} ib_rmpp_hdr_t;\r
+\r
+enum SA_SIZES_ENUM {\r
+       SA_HEADER_SZ = 20,\r
+};\r
+\r
+typedef struct ib_sa_call {\r
+       unsigned attrid;\r
+       unsigned mod;\r
+       uint64_t mask;\r
+       unsigned method;\r
+\r
+       uint64_t trid;  /* used for out mad if nonzero, return real val */\r
+       unsigned recsz; /* return field */\r
+       ib_rmpp_hdr_t rmpp;\r
+} ib_sa_call_t;\r
+\r
+typedef struct ib_vendor_call {\r
+       unsigned method;\r
+       unsigned mgmt_class;\r
+       unsigned attrid;\r
+       unsigned mod;\r
+       uint32_t oui;\r
+       unsigned timeout;\r
+       ib_rmpp_hdr_t rmpp;\r
+} ib_vendor_call_t;\r
+\r
+#define IB_MIN_UCAST_LID       1\r
+#define IB_MAX_UCAST_LID       (0xc000-1)\r
+#define IB_MIN_MCAST_LID       0xc000\r
+#define IB_MAX_MCAST_LID       (0xffff-1)\r
+\r
+#define IB_LID_VALID(lid)      ((lid) >= IB_MIN_UCAST_LID && lid <= IB_MAX_UCAST_LID)\r
+#define IB_MLID_VALID(lid)     ((lid) >= IB_MIN_MCAST_LID && lid <= IB_MAX_MCAST_LID)\r
+\r
+#define MAD_DEF_RETRIES                3\r
+#define MAD_DEF_TIMEOUT_MS     1000\r
+\r
+enum {\r
+       IB_DEST_LID,\r
+       IB_DEST_DRPATH,\r
+       IB_DEST_GUID,\r
+       IB_DEST_DRSLID,\r
+};\r
+\r
+enum {\r
+       IB_NODE_CA = 1,\r
+       IB_NODE_SWITCH,\r
+       IB_NODE_ROUTER,\r
+       NODE_RNIC,\r
+\r
+       IB_NODE_MAX = NODE_RNIC\r
+};\r
+\r
+/******************************************************************************/\r
+\r
+/* portid.c */\r
+MAD_EXPORT char * portid2str(ib_portid_t *portid);\r
+MAD_EXPORT int portid2portnum(ib_portid_t *portid);\r
+MAD_EXPORT int str2drpath(ib_dr_path_t *path, char *routepath, int drslid, int drdlid);\r
+MAD_EXPORT char * drpath2str(ib_dr_path_t *path, char *dstr, size_t dstr_size);\r
+\r
+static inline int\r
+ib_portid_set(ib_portid_t *portid, int lid, int qp, int qkey)\r
+{\r
+       portid->lid = lid;\r
+       portid->qp = qp;\r
+       portid->qkey = qkey;\r
+       portid->grh_present = 0;\r
+\r
+       return 0;\r
+}\r
+\r
+/* fields.c */\r
+extern ib_field_t ib_mad_f[];\r
+\r
+void _set_field(void *buf, int base_offs, ib_field_t *f, uint32_t val);\r
+uint32_t _get_field(void *buf, int base_offs, ib_field_t *f);\r
+void _set_array(void *buf, int base_offs, ib_field_t *f, void *val);\r
+void _get_array(void *buf, int base_offs, ib_field_t *f, void *val);\r
+void _set_field64(void *buf, int base_offs, ib_field_t *f, uint64_t val);\r
+uint64_t _get_field64(void *buf, int base_offs, ib_field_t *f);\r
+\r
+/* mad.c */\r
+MAD_EXPORT uint32_t mad_get_field(void *buf, int base_offs, int field);\r
+MAD_EXPORT void mad_set_field(void *buf, int base_offs, int field, uint32_t val);\r
+/* field must be byte aligned */\r
+MAD_EXPORT uint64_t mad_get_field64(void *buf, int base_offs, int field);\r
+MAD_EXPORT void mad_set_field64(void *buf, int base_offs, int field, uint64_t val);\r
+MAD_EXPORT void mad_set_array(void *buf, int base_offs, int field, void *val);\r
+MAD_EXPORT void mad_get_array(void *buf, int base_offs, int field, void *val);\r
+MAD_EXPORT void        mad_decode_field(uint8_t *buf, int field, void *val);\r
+MAD_EXPORT void        mad_encode_field(uint8_t *buf, int field, void *val);\r
+MAD_EXPORT void        *mad_encode(void *buf, ib_rpc_t *rpc, ib_dr_path_t *drpath, void *data);\r
+MAD_EXPORT uint64_t mad_trid(void);\r
+MAD_EXPORT int mad_build_pkt(void *umad, ib_rpc_t *rpc, ib_portid_t *dport, \r
+                             ib_rmpp_hdr_t *rmpp, void *data);\r
+\r
+/* register.c */\r
+MAD_EXPORT int mad_register_port_client(int port_id, int mgmt, \r
+                                        uint8_t rmpp_version);\r
+MAD_EXPORT int mad_register_client(int mgmt, uint8_t rmpp_version);\r
+MAD_EXPORT int mad_register_server(int mgmt, uint8_t rmpp_version,\r
+                                   long method_mask[16/sizeof(long)],\r
+                                   uint32_t class_oui);\r
+MAD_EXPORT int mad_class_agent(int mgmt);\r
+MAD_EXPORT int mad_agent_class(int agent);\r
+\r
+/* serv.c */\r
+MAD_EXPORT int mad_send(ib_rpc_t *rpc, ib_portid_t *dport, \r
+                        ib_rmpp_hdr_t *rmpp, void *data);\r
+MAD_EXPORT void * mad_receive(void *umad, int timeout);\r
+MAD_EXPORT int mad_respond(void *umad, ib_portid_t *portid, uint32_t rstatus);\r
+MAD_EXPORT void * mad_alloc(void);\r
+MAD_EXPORT void        mad_free(void *umad);\r
+\r
+/* vendor.c */\r
+MAD_EXPORT uint8_t *ib_vendor_call(void *data, ib_portid_t *portid,\r
+                                  ib_vendor_call_t *call);\r
+\r
+static inline int\r
+mad_is_vendor_range1(int mgmt)\r
+{\r
+       return mgmt >= 0x9 && mgmt <= 0xf;\r
+}\r
+\r
+static inline int\r
+mad_is_vendor_range2(int mgmt) \r
+{\r
+       return mgmt >= 0x30 && mgmt <= 0x4f;\r
+}\r
+\r
+/* rpc.c */\r
+MAD_EXPORT int madrpc_portid(void);\r
+MAD_EXPORT int madrpc_set_retries(int retries);\r
+MAD_EXPORT int madrpc_set_timeout(int timeout);\r
+MAD_EXPORT void madrpc_init(char *dev_name, int dev_port, \r
+                           int *mgmt_classes, int num_classes);\r
+MAD_EXPORT void        madrpc_show_errors(int set);\r
+void * madrpc(ib_rpc_t *rpc, ib_portid_t *dport, \r
+             void *payload, void *rcvdata);\r
+void * madrpc_rmpp(ib_rpc_t *rpc, ib_portid_t *dport, \r
+                  ib_rmpp_hdr_t *rmpp, void *data);\r
+\r
+void madrpc_save_mad(void *madbuf, int len);\r
+void madrpc_lock(void);\r
+void madrpc_unlock(void);\r
+void * mad_rpc_open_port(char *dev_name, int dev_port, \r
+                        int *mgmt_classes, int num_classes);\r
+void mad_rpc_close_port(void *ibmad_port);\r
+void * mad_rpc(const void *ibmad_port, ib_rpc_t *rpc, \r
+              ib_portid_t *dport, void *payload, \r
+              void *rcvdata);\r
+void * mad_rpc_rmpp(const void *ibmad_port, ib_rpc_t *rpc, \r
+                   ib_portid_t *dport, ib_rmpp_hdr_t *rmpp, \r
+                   void *data);\r
+\r
+/* smp.c */\r
+MAD_EXPORT uint8_t * smp_query(void *buf, ib_portid_t *id, unsigned attrid, \r
+                              unsigned mod, unsigned timeout);\r
+MAD_EXPORT uint8_t * smp_set(void *buf, ib_portid_t *id, unsigned attrid, \r
+                            unsigned mod, unsigned timeout);\r
+uint8_t * smp_query_via(void *buf, ib_portid_t *id, unsigned attrid,\r
+                       unsigned mod, unsigned timeout, const void *srcport);\r
+uint8_t * smp_set_via(void *buf, ib_portid_t *id, unsigned attrid, unsigned mod,\r
+                     unsigned timeout, const void *srcport);\r
+\r
+inline static uint8_t *\r
+safe_smp_query(void *rcvbuf, ib_portid_t *portid, unsigned attrid, unsigned mod,\r
+              unsigned timeout)\r
+{\r
+       uint8_t *p;\r
+\r
+       madrpc_lock();\r
+       p = smp_query(rcvbuf, portid, attrid, mod, timeout);\r
+       madrpc_unlock();\r
+\r
+       return p;\r
+}\r
+\r
+inline static uint8_t *\r
+safe_smp_set(void *rcvbuf, ib_portid_t *portid, unsigned attrid, unsigned mod,\r
+            unsigned timeout)\r
+{\r
+       uint8_t *p;\r
+\r
+       madrpc_lock();\r
+       p = smp_set(rcvbuf, portid, attrid, mod, timeout);\r
+       madrpc_unlock();\r
+\r
+       return p;\r
+}\r
+\r
+/* sa.c */\r
+uint8_t * sa_call(void *rcvbuf, ib_portid_t *portid, ib_sa_call_t *sa,\r
+                 unsigned timeout);\r
+uint8_t * sa_rpc_call(const void *ibmad_port, void *rcvbuf, ib_portid_t *portid,\r
+                      ib_sa_call_t *sa, unsigned timeout);\r
+MAD_EXPORT int ib_path_query(ibmad_gid_t srcgid, ibmad_gid_t destgid, \r
+                            ib_portid_t *sm_id, void *buf); /* returns lid */\r
+int ib_path_query_via(const void *srcport, ibmad_gid_t srcgid,\r
+                         ibmad_gid_t destgid, ib_portid_t *sm_id, void *buf);\r
+\r
+inline static uint8_t *\r
+safe_sa_call(void *rcvbuf, ib_portid_t *portid, ib_sa_call_t *sa,\r
+            unsigned timeout)\r
+{\r
+       uint8_t *p;\r
+\r
+       madrpc_lock();\r
+       p = sa_call(rcvbuf, portid, sa, timeout);\r
+       madrpc_unlock();\r
+\r
+       return p;\r
+}\r
+\r
+/* resolve.c */\r
+MAD_EXPORT int ib_resolve_smlid(ib_portid_t *sm_id, int timeout);\r
+MAD_EXPORT int ib_resolve_guid(ib_portid_t *portid, uint64_t *guid,\r
+                              ib_portid_t *sm_id, int timeout);\r
+MAD_EXPORT int ib_resolve_portid_str(ib_portid_t *portid, char *addr_str,\r
+                                    int dest_type, ib_portid_t *sm_id);\r
+MAD_EXPORT int ib_resolve_self(ib_portid_t *portid, int *portnum, \r
+                              ibmad_gid_t *gid);\r
+int ib_resolve_smlid_via(ib_portid_t *sm_id, int timeout,\r
+                        const void *srcport);\r
+int ib_resolve_guid_via(ib_portid_t *portid, uint64_t *guid,\r
+                       ib_portid_t *sm_id, int timeout,\r
+                       const void *srcport);\r
+int ib_resolve_portid_str_via(ib_portid_t *portid, char *addr_str,\r
+                             int dest_type, ib_portid_t *sm_id,\r
+                             const void *srcport);\r
+int ib_resolve_self_via(ib_portid_t *portid, int *portnum, ibmad_gid_t *gid,\r
+                       const void *srcport);\r
+\r
+/* gs.c */\r
+MAD_EXPORT uint8_t *perf_classportinfo_query(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                 unsigned timeout);\r
+MAD_EXPORT uint8_t *port_performance_query(void *rcvbuf, ib_portid_t *dest, int port,\r
+                               unsigned timeout);\r
+MAD_EXPORT uint8_t *port_performance_reset(void *rcvbuf, ib_portid_t *dest, int port,\r
+                               unsigned mask, unsigned timeout);\r
+MAD_EXPORT uint8_t *port_performance_ext_query(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned timeout);\r
+MAD_EXPORT uint8_t *port_performance_ext_reset(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned mask, unsigned timeout);\r
+MAD_EXPORT uint8_t *port_samples_control_query(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned timeout);\r
+MAD_EXPORT uint8_t *port_samples_result_query(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                  unsigned timeout);\r
+\r
+uint8_t *perf_classportinfo_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                 unsigned timeout, const void *srcport);\r
+uint8_t *port_performance_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                               unsigned timeout, const void *srcport);\r
+uint8_t *port_performance_reset_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                               unsigned mask, unsigned timeout, const void *srcport);\r
+uint8_t *port_performance_ext_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned timeout, const void *srcport);\r
+uint8_t *port_performance_ext_reset_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned mask, unsigned timeout, const void *srcport);\r
+uint8_t *port_samples_control_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                   unsigned timeout, const void *srcport);\r
+uint8_t *port_samples_result_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                                  unsigned timeout, const void *srcport);\r
+/* dump.c */\r
+ib_mad_dump_fn\r
+       MAD_EXPORT mad_dump_int, mad_dump_uint, mad_dump_hex, mad_dump_rhex,\r
+       mad_dump_bitfield, mad_dump_array, mad_dump_string,\r
+       mad_dump_linkwidth, mad_dump_linkwidthsup, mad_dump_linkwidthen,\r
+       mad_dump_linkdowndefstate,\r
+       mad_dump_linkspeed, mad_dump_linkspeedsup, mad_dump_linkspeeden,\r
+       mad_dump_portstate, mad_dump_portstates,\r
+       mad_dump_physportstate, mad_dump_portcapmask,\r
+       mad_dump_mtu, mad_dump_vlcap, mad_dump_opervls,\r
+       mad_dump_node_type,\r
+       mad_dump_sltovl, mad_dump_vlarbitration,\r
+       mad_dump_nodedesc, mad_dump_nodeinfo, mad_dump_portinfo, mad_dump_switchinfo,\r
+       mad_dump_perfcounters, mad_dump_perfcounters_ext;\r
+\r
+int    _mad_dump(ib_mad_dump_fn *fn, char *name, void *val, int valsz);\r
+char * _mad_dump_field(ib_field_t *f, char *name, char *buf, int bufsz,\r
+                       void *val);\r
+int    _mad_print_field(ib_field_t *f, char *name, void *val, int valsz);\r
+char * _mad_dump_val(ib_field_t *f, char *buf, int bufsz, void *val);\r
+\r
+static inline int\r
+mad_print_field(int field, char *name, void *val)\r
+{\r
+       if (field <= IB_NO_FIELD || field >= IB_FIELD_LAST_)\r
+               return -1;\r
+       return _mad_print_field(ib_mad_f + field, name, val, 0);\r
+}\r
+\r
+static inline char *\r
+mad_dump_field(int field, char *buf, int bufsz, void *val)\r
+{\r
+       if (field <= IB_NO_FIELD || field >= IB_FIELD_LAST_)\r
+               return 0;\r
+       return _mad_dump_field(ib_mad_f + field, 0, buf, bufsz, val);\r
+}\r
+\r
+static inline char *\r
+mad_dump_val(int field, char *buf, int bufsz, void *val)\r
+{\r
+       if (field <= IB_NO_FIELD || field >= IB_FIELD_LAST_)\r
+               return 0;\r
+       return _mad_dump_val(ib_mad_f + field, buf, bufsz, val);\r
+}\r
+\r
+extern int ibdebug;\r
+\r
+/* remove libibcommon dependencies, use complib */\r
+\r
+/* dump.c */\r
+MAD_EXPORT void xdump(FILE *file, char *msg, void *p, int size);\r
+\r
+/** printf style debugging MACRO's, map to cl_msg_out */\r
+#if !defined(IBWARN) \r
+#define IBWARN(fmt, ...) cl_msg_out(fmt, ## __VA_ARGS__)\r
+#endif \r
+#if !defined(IBPANIC)\r
+#define IBPANIC(fmt, ...) \\r
+{ \\r
+        cl_msg_out(fmt, ## __VA_ARGS__); \\r
+        CL_ASSERT(0); \\r
+}\r
+#endif \r
\r
+/** align value \a l to \a size (ceil) */\r
+#if !defined(ALIGN) \r
+#define ALIGN(l, size) (((l) + ((size) - 1)) / (size) * (size))\r
+#endif \r
\r
+/** align value \a l to \a sizeof 32 bit int (ceil) */\r
+#if !defined(ALIGN32) \r
+#define ALIGN32(l) (ALIGN((l), sizeof(uint32))) \r
+#endif\r
+\r
+\r
+END_C_DECLS\r
+\r
+#endif /* _MAD_H_ */\r
diff --git a/ulp/libibmad/src/Sources b/ulp/libibmad/src/Sources
new file mode 100644 (file)
index 0000000..94ee9c8
--- /dev/null
@@ -0,0 +1,48 @@
+!if $(FREEBUILD)\r
+TARGETNAME = libibmad\r
+!else\r
+TARGETNAME = libibmadd\r
+!endif\r
+\r
+TARGETPATH = ..\..\..\bin\user\obj$(BUILD_ALT_DIR)\r
+TARGETTYPE = DYNLINK\r
+\r
+DLLDEF = $(OBJ_PATH)\$O\ibmad_exports.def\r
+\r
+DLLENTRY = DllMain\r
+USE_MSVCRT=1\r
+\r
+SOURCES = \\r
+       ibmad.rc \\r
+       ibmad_main.cpp \\r
+       dump.c \\r
+       fields.c \\r
+       gs.c \\r
+       mad.c \\r
+       portid.c \\r
+       register.c \\r
+       resolve.c \\r
+       rpc.c \\r
+       sa.c \\r
+       serv.c \\r
+       smp.c \\r
+       vendor.c\r
+       \r
+INCLUDES = ..\include\infiniband;..\..\libibverbs\include;..\..\libibumad\include;..\..\..\inc;..\..\..\inc\user;\r
+\r
+USER_C_FLAGS = $(USER_C_FLAGS) -DEXPORT_IBMAD_SYMBOLS\r
+\r
+TARGETLIBS = \\r
+       $(SDK_LIB_PATH)\kernel32.lib    \\r
+       $(SDK_LIB_PATH)\uuid.lib        \\r
+       $(SDK_LIB_PATH)\ws2_32.lib      \\r
+       $(SDK_LIB_PATH)\advapi32.lib    \\r
+       $(SDK_LIB_PATH)\user32.lib      \\r
+       $(SDK_LIB_PATH)\ole32.lib       \\r
+!if $(FREEBUILD)\r
+       $(TARGETPATH)\*\complib.lib     \\r
+       $(TARGETPATH)\*\libibumad.lib   \r
+!else\r
+       $(TARGETPATH)\*\complibd.lib    \\r
+       $(TARGETPATH)\*\libibumadd.lib  \r
+!endif\r
diff --git a/ulp/libibmad/src/dump.c b/ulp/libibmad/src/dump.c
new file mode 100644 (file)
index 0000000..afccb57
--- /dev/null
@@ -0,0 +1,815 @@
+/*\r
+ * Copyright (c) 2004-2008 Voltaire Inc.  All rights reserved.\r
+ * Copyright (c) 2007 Xsigo Systems Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+#include <string.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#define snprintf _snprintf\r
+#else\r
+#include <stdint.h>\r
+#include <unistd.h>\r
+#include <inttypes.h>\r
+#include <netinet/in.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+#include <complib/cl_types.h>\r
+\r
+MAD_EXPORT void\r
+xdump(FILE *file, char *msg, void *p, int size)\r
+{\r
+#define HEX(x)  ((x) < 10 ? '0' + (x) : 'a' + ((x) -10))\r
+        uint8_t *cp = p;\r
+        int i;\r
+\r
+       if (msg)\r
+               fputs(msg, file);\r
+\r
+        for (i = 0; i < size;) {\r
+                fputc(HEX(*cp >> 4), file);\r
+                fputc(HEX(*cp & 0xf), file);\r
+                if (++i >= size)\r
+                        break;\r
+                fputc(HEX(cp[1] >> 4), file);\r
+                fputc(HEX(cp[1] & 0xf), file);\r
+                if ((++i) % 16)\r
+                        fputc(' ', file);\r
+                else\r
+                        fputc('\n', file);\r
+                cp += 2;\r
+        }\r
+        if (i % 16) {\r
+                fputc('\n', file);\r
+        }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_int(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       switch (valsz) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "%d", *(uint8_t *)val);\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "%d", *(uint16_t *)val);\r
+               break;\r
+       case 3:\r
+       case 4:\r
+               snprintf(buf, bufsz, "%d", *(uint32_t *)val);\r
+               break;\r
+       case 5:\r
+       case 6:\r
+       case 7:\r
+       case 8:\r
+               snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *)val);\r
+               break;\r
+       default:\r
+               IBWARN("bad int sz %d", valsz);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_uint(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       switch (valsz) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "%u", *(uint8_t *)val);\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "%u", *(uint16_t *)val);\r
+               break;\r
+       case 3:\r
+       case 4:\r
+               snprintf(buf, bufsz, "%u", *(uint32_t *)val);\r
+               break;\r
+       case 5:\r
+       case 6:\r
+       case 7:\r
+       case 8:\r
+               snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *)val);\r
+               break;\r
+       default:\r
+               IBWARN("bad int sz %u", valsz);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_hex(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       switch (valsz) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "0x%02x", *(uint8_t *)val);\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "0x%04x", *(uint16_t *)val);\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "0x%06x", *(uint32_t *)val & 0xffffff);\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "0x%08x", *(uint32_t *)val);\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "0x%010" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffULL);\r
+               break;\r
+       case 6:\r
+               snprintf(buf, bufsz, "0x%012" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffULL);\r
+               break;\r
+       case 7:\r
+               snprintf(buf, bufsz, "0x%014" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffffULL);\r
+               break;\r
+       case 8:\r
+               snprintf(buf, bufsz, "0x%016" PRIx64, *(uint64_t *)val);\r
+               break;\r
+       default:\r
+               IBWARN("bad int sz %d", valsz);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_rhex(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       switch (valsz) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "%02x", *(uint8_t *)val);\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "%04x", *(uint16_t *)val);\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "%06x", *(uint32_t *)val & 0xffffff);\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "%08x", *(uint32_t *)val);\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "%010" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffULL);\r
+               break;\r
+       case 6:\r
+               snprintf(buf, bufsz, "%012" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffULL);\r
+               break;\r
+       case 7:\r
+               snprintf(buf, bufsz, "%014" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffffULL);\r
+               break;\r
+       case 8:\r
+               snprintf(buf, bufsz, "%016" PRIx64, *(uint64_t *)val);\r
+               break;\r
+       default:\r
+               IBWARN("bad int sz %d", valsz);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkwidth(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int width = *(int *)val;\r
+\r
+       switch (width) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "1X");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "4X");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "8X");\r
+               break;\r
+       case 8:\r
+               snprintf(buf, bufsz, "12X");\r
+               break;\r
+       default:\r
+               IBWARN("bad width %d", width);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+static void\r
+dump_linkwidth(char *buf, int bufsz, int width)\r
+{\r
+       int n = 0;\r
+\r
+       if (width & 0x1)\r
+               n += snprintf(buf + n, bufsz - n, "1X or ");\r
+       if (n < bufsz && (width & 0x2))\r
+               n += snprintf(buf + n, bufsz - n, "4X or ");\r
+       if (n < bufsz && (width & 0x4))\r
+               n += snprintf(buf + n, bufsz - n, "8X or ");\r
+       if (n < bufsz && (width & 0x8))\r
+               n += snprintf(buf + n, bufsz - n, "12X or ");\r
+\r
+       if (n >= bufsz)\r
+               return;\r
+       else if (width == 0 || (width >> 4))\r
+               snprintf(buf + n, bufsz - n, "undefined (%d)", width);\r
+       else if (bufsz > 3)\r
+               buf[n-4] = '\0';\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkwidthsup(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int width = *(int *)val;\r
+\r
+       dump_linkwidth(buf, bufsz, width);\r
+\r
+       switch(width) {\r
+       case 1:\r
+       case 3:\r
+       case 7:\r
+       case 11:\r
+       case 15:\r
+               break;\r
+\r
+       default:\r
+               if (!(width >> 4))\r
+                       snprintf(buf + strlen(buf), bufsz - strlen(buf),\r
+                                " (IBA extension)");\r
+               break;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkwidthen(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int width = *(int *)val;\r
+\r
+       dump_linkwidth(buf, bufsz, width);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkspeed(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int speed = *(int *)val;\r
+\r
+       switch (speed) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "2.5 Gbps");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "5.0 Gbps");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "10.0 Gbps");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "undefined (%d)", speed);\r
+               break;\r
+       }\r
+}\r
+\r
+static void\r
+dump_linkspeed(char *buf, int bufsz, int speed)\r
+{\r
+       int n = 0;\r
+\r
+       if (speed & 0x1)\r
+               n += snprintf(buf + n, bufsz - n, "2.5 Gbps or ");\r
+       if (n < bufsz && (speed & 0x2))\r
+               n += snprintf(buf + n, bufsz - n, "5.0 Gbps or ");\r
+       if (n < bufsz && (speed & 0x4))\r
+               n += snprintf(buf + n, bufsz - n, "10.0 Gbps or ");\r
+\r
+       if (n >= bufsz)\r
+               return;\r
+       else if (speed == 0 || (speed >> 3)) {\r
+               n += snprintf(buf + n, bufsz - n, "undefined (%d)", speed);\r
+               if (n >= bufsz)\r
+                       return;\r
+       } else if (bufsz > 3) {\r
+               buf[n-4] = '\0';\r
+               n -= 4;\r
+       }\r
+\r
+       switch (speed) {\r
+       case 1:\r
+       case 3:\r
+       case 5:\r
+       case 7:\r
+               break;\r
+       default:\r
+               if (!(speed >> 3))\r
+                       snprintf(buf + n, bufsz - n, " (IBA extension)");\r
+               break;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkspeedsup(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int speed = *(int *)val;\r
+\r
+       dump_linkspeed(buf, bufsz, speed);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkspeeden(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int speed = *(int *)val;\r
+\r
+       dump_linkspeed(buf, bufsz, speed);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_portstate(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int state = *(int *)val;\r
+\r
+       switch (state) {\r
+       case 0:\r
+               snprintf(buf, bufsz, "NoChange");\r
+               break;\r
+       case 1:\r
+               snprintf(buf, bufsz, "Down");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "Initialize");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "Armed");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "Active");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", state);\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_linkdowndefstate(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int state = *(int *)val;\r
+\r
+       switch(state) {\r
+       case 0:\r
+               snprintf(buf, bufsz, "NoChange");\r
+               break;\r
+       case 1:\r
+               snprintf(buf, bufsz, "Sleep");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "Polling");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", state);\r
+               break;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_physportstate(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int state = *(int *)val;\r
+\r
+       switch (state) {\r
+       case 0:\r
+               snprintf(buf, bufsz, "NoChange");\r
+               break;\r
+       case 1:\r
+               snprintf(buf, bufsz, "Sleep");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "Polling");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "Disabled");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "PortConfigurationTraining");\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "LinkUp");\r
+               break;\r
+       case 6:\r
+               snprintf(buf, bufsz, "LinkErrorRecovery");\r
+               break;\r
+       case 7:\r
+               snprintf(buf, bufsz, "PhyTest");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", state);\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_mtu(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int mtu = *(int *)val;\r
+\r
+       switch (mtu) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "256");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "512");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "1024");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "2048");\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "4096");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", mtu);\r
+               buf[0] = 0;\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_vlcap(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int vlcap = *(int *)val;\r
+\r
+       switch (vlcap) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "VL0");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "VL0-1");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "VL0-3");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "VL0-7");\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "VL0-14");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", vlcap);\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_opervls(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int opervls = *(int *)val;\r
+\r
+       switch (opervls) {\r
+       case 0:\r
+               snprintf(buf, bufsz, "No change");\r
+               break;\r
+       case 1:\r
+               snprintf(buf, bufsz, "VL0");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "VL0-1");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "VL0-3");\r
+               break;\r
+       case 4:\r
+               snprintf(buf, bufsz, "VL0-7");\r
+               break;\r
+       case 5:\r
+               snprintf(buf, bufsz, "VL0-14");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)", opervls);\r
+       }\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_portcapmask(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       unsigned mask = *(unsigned *)val;\r
+       char *s = buf;\r
+\r
+       s += sprintf(s, "0x%x\n", mask);\r
+       if (mask & (1 << 1))\r
+               s += sprintf(s, "\t\t\t\tIsSM\n");\r
+       if (mask & (1 << 2))\r
+               s += sprintf(s, "\t\t\t\tIsNoticeSupported\n");\r
+       if (mask & (1 << 3))\r
+               s += sprintf(s, "\t\t\t\tIsTrapSupported\n");\r
+       if (mask & (1 << 5))\r
+               s += sprintf(s, "\t\t\t\tIsAutomaticMigrationSupported\n");\r
+       if (mask & (1 << 6))\r
+               s += sprintf(s, "\t\t\t\tIsSLMappingSupported\n");\r
+       if (mask & (1 << 7))\r
+               s += sprintf(s, "\t\t\t\tIsMKeyNVRAM\n");\r
+       if (mask & (1 << 8))\r
+               s += sprintf(s, "\t\t\t\tIsPKeyNVRAM\n");\r
+       if (mask & (1 << 9))\r
+               s += sprintf(s, "\t\t\t\tIsLedInfoSupported\n");\r
+       if (mask & (1 << 10))\r
+               s += sprintf(s, "\t\t\t\tIsSMdisabled\n");\r
+       if (mask & (1 << 11))\r
+               s += sprintf(s, "\t\t\t\tIsSystemImageGUIDsupported\n");\r
+       if (mask & (1 << 12))\r
+               s += sprintf(s, "\t\t\t\tIsPkeySwitchExternalPortTrapSupported\n");\r
+       if (mask & (1 << 16))\r
+               s += sprintf(s, "\t\t\t\tIsCommunicatonManagementSupported\n");\r
+       if (mask & (1 << 17))\r
+               s += sprintf(s, "\t\t\t\tIsSNMPTunnelingSupported\n");\r
+       if (mask & (1 << 18))\r
+               s += sprintf(s, "\t\t\t\tIsReinitSupported\n");\r
+       if (mask & (1 << 19))\r
+               s += sprintf(s, "\t\t\t\tIsDeviceManagementSupported\n");\r
+       if (mask & (1 << 20))\r
+               s += sprintf(s, "\t\t\t\tIsVendorClassSupported\n");\r
+       if (mask & (1 << 21))\r
+               s += sprintf(s, "\t\t\t\tIsDRNoticeSupported\n");\r
+       if (mask & (1 << 22))\r
+               s += sprintf(s, "\t\t\t\tIsCapabilityMaskNoticeSupported\n");\r
+       if (mask & (1 << 23))\r
+               s += sprintf(s, "\t\t\t\tIsBootManagementSupported\n");\r
+       if (mask & (1 << 24))\r
+               s += sprintf(s, "\t\t\t\tIsLinkRoundTripLatencySupported\n");\r
+       if (mask & (1 << 25))\r
+               s += sprintf(s, "\t\t\t\tIsClientRegistrationSupported\n");\r
+\r
+       if (s != buf)\r
+               *(--s) = 0;\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_bitfield(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       snprintf(buf, bufsz, "0x%x", *(uint32_t *)val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_array(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       uint8_t *p = val, *e;\r
+       char *s = buf;\r
+\r
+       if (bufsz < valsz*2)\r
+               valsz = bufsz/2;\r
+\r
+       for (p = val, e = p + valsz; p < e; p++, s += 2)\r
+               sprintf(s, "%02x", *p);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_string(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       if (bufsz < valsz)\r
+               valsz = bufsz;\r
+\r
+       snprintf(buf, valsz, "'%s'", (char *)val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_node_type(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       int nodetype = *(int*)val;\r
+\r
+       switch (nodetype) {\r
+       case 1:\r
+               snprintf(buf, bufsz, "Channel Adapter");\r
+               break;\r
+       case 2:\r
+               snprintf(buf, bufsz, "Switch");\r
+               break;\r
+       case 3:\r
+               snprintf(buf, bufsz, "Router");\r
+               break;\r
+       default:\r
+               snprintf(buf, bufsz, "?(%d)?", nodetype);\r
+               break;\r
+       }\r
+}\r
+\r
+#define IB_MAX_NUM_VLS 16\r
+#define IB_MAX_NUM_VLS_TO_U8 ((IB_MAX_NUM_VLS)/2)\r
+\r
+typedef struct _ib_slvl_table {\r
+       uint8_t vl_by_sl_num[IB_MAX_NUM_VLS_TO_U8];\r
+} ib_slvl_table_t;\r
+\r
+static inline void\r
+ib_slvl_get_i(ib_slvl_table_t *tbl, int i, uint8_t *vl)\r
+{\r
+       *vl = (tbl->vl_by_sl_num[i >> 1] >> ((!(i&1)) << 2)) & 0xf;\r
+}\r
+\r
+#define IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK 32\r
+\r
+typedef struct _ib_vl_arb_table {\r
+       struct {\r
+               uint8_t res_vl;\r
+               uint8_t weight;\r
+       } vl_entry[IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK];\r
+} ib_vl_arb_table_t;\r
+\r
+static inline void\r
+ib_vl_arb_get_vl(uint8_t res_vl, uint8_t *const vl )\r
+{\r
+       *vl = res_vl & 0x0F;\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_sltovl(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       ib_slvl_table_t* p_slvl_tbl = val;\r
+       uint8_t vl;\r
+       int i, n = 0;\r
+       n = snprintf(buf, bufsz, "|");\r
+       for (i = 0; i < 16; i++) {\r
+               ib_slvl_get_i(p_slvl_tbl, i, &vl);\r
+               n += snprintf(buf + n, bufsz - n, "%2u|", vl);\r
+               if (n >= bufsz)\r
+                       break;\r
+       }\r
+       snprintf(buf + n, bufsz - n, "\n");\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_vlarbitration(char *buf, int bufsz, void *val, int num)\r
+{\r
+       ib_vl_arb_table_t* p_vla_tbl = val;\r
+       int i, n;\r
+       uint8_t vl;\r
+\r
+       num /= sizeof(p_vla_tbl->vl_entry[0]);\r
+\r
+       n = snprintf(buf, bufsz, "\nVL    : |");\r
+       if (n >= bufsz)\r
+               return;\r
+       for (i = 0; i < num; i++) {\r
+               ib_vl_arb_get_vl(p_vla_tbl->vl_entry[i].res_vl, &vl);\r
+               n += snprintf(buf + n, bufsz - n, "0x%-2X|", vl);\r
+               if (n >= bufsz)\r
+                       return;\r
+       }\r
+\r
+       n += snprintf(buf + n, bufsz - n, "\nWEIGHT: |");\r
+       if (n >= bufsz)\r
+               return;\r
+       for (i = 0; i < num; i++) {\r
+               n += snprintf(buf + n, bufsz - n, "0x%-2X|",\r
+                             p_vla_tbl->vl_entry[i].weight);\r
+               if (n >= bufsz)\r
+                       return;\r
+       }\r
+\r
+       snprintf(buf + n, bufsz - n, "\n");\r
+}\r
+\r
+static int\r
+_dump_fields(char *buf, int bufsz, void *data, int start, int end)\r
+{\r
+       char val[64];\r
+       char *s = buf;\r
+       int n, field;\r
+\r
+       for (field = start; field < end && bufsz > 0; field++) {\r
+               mad_decode_field(data, field, val);\r
+               if (!mad_dump_field(field, s, bufsz, val))\r
+                       return -1;\r
+               n = strlen(s);\r
+               s += n;\r
+               *s++ = '\n';\r
+               *s = 0;\r
+               n++;\r
+               bufsz -= n;\r
+       }\r
+\r
+       return (int)(s - buf);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_nodedesc(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       strncpy(buf, val, bufsz);\r
+\r
+       if (valsz < bufsz)\r
+               buf[valsz] = 0;\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_nodeinfo(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_NODE_FIRST_F, IB_NODE_LAST_F);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_portinfo(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_PORT_FIRST_F, IB_PORT_LAST_F);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_portstates(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_PORT_STATE_F, IB_PORT_LINK_DOWN_DEF_F);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_switchinfo(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_SW_FIRST_F, IB_SW_LAST_F);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_perfcounters(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_PC_FIRST_F, IB_PC_LAST_F);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_dump_perfcounters_ext(char *buf, int bufsz, void *val, int valsz)\r
+{\r
+       _dump_fields(buf, bufsz, val, IB_PC_EXT_FIRST_F, IB_PC_EXT_LAST_F);\r
+}\r
+\r
+/************************/\r
+\r
+char *\r
+_mad_dump_val(ib_field_t *f, char *buf, int bufsz, void *val)\r
+{\r
+       f->def_dump_fn(buf, bufsz, val, ALIGN(f->bitlen, 8) / 8);\r
+       buf[bufsz - 1] = 0;\r
+\r
+       return buf;\r
+}\r
+\r
+char *\r
+_mad_dump_field(ib_field_t *f, char *name, char *buf, int bufsz, void *val)\r
+{\r
+       char dots[128];\r
+       int l, n;\r
+\r
+       if (bufsz <= 32)\r
+               return 0;               /* buf too small */\r
+\r
+       if (!name)\r
+               name = f->name;\r
+\r
+       l = strlen(name);\r
+       if (l < 32) {\r
+               memset(dots, '.', 32 - l);\r
+               dots[32 - l] = 0;\r
+       }\r
+\r
+       n = snprintf(buf, bufsz, "%s:%s", name, dots);\r
+       _mad_dump_val(f, buf + n, bufsz - n, val);\r
+       buf[bufsz - 1] = 0;\r
+\r
+       return buf;\r
+}\r
+\r
+int\r
+_mad_dump(ib_mad_dump_fn *fn, char *name, void *val, int valsz)\r
+{\r
+       ib_field_t f;\r
+       char buf[512];\r
+\r
+       memset(&f, 0, sizeof(f));\r
+       f.def_dump_fn = fn; \r
+       f.bitlen = valsz * 8;\r
+\r
+       return printf("%s\n", _mad_dump_field(&f, name, buf, sizeof buf, val));\r
+}\r
+\r
+int\r
+_mad_print_field(ib_field_t *f, char *name, void *val, int valsz)\r
+{\r
+       return _mad_dump(f->def_dump_fn, name ? name : f->name, val, valsz ? valsz : ALIGN(f->bitlen, 8) / 8);\r
+}\r
+\r
diff --git a/ulp/libibmad/src/fields.c b/ulp/libibmad/src/fields.c
new file mode 100644 (file)
index 0000000..bbae49b
--- /dev/null
@@ -0,0 +1,480 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#else\r
+#include <unistd.h>\r
+#include <string.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+\r
+/*\r
+ * BITSOFFS and BE_OFFS are required due the fact that the bit offsets are inconsistently\r
+ * encoded in the IB spec - IB headers are encoded such that the bit offsets\r
+ * are in big endian convention (BE_OFFS), while the SMI/GSI queries data fields bit\r
+ * offsets are specified using real bit offset (?!)\r
+ * The following macros normalize everything to big endian offsets.\r
+ */\r
+#define BITSOFFS(o, w) (((o) & ~31) | ((32 - ((o) & 31) - (w)))), (w)\r
+#define BE_OFFS(o, w)  (o), (w)\r
+#define BE_TO_BITSOFFS(o, w)   (((o) & ~31) | ((32 - ((o) & 31) - (w))))\r
+\r
+ib_field_t ib_mad_f [] = {\r
+       {0, 0},         /* IB_NO_FIELD - reserved as invalid */\r
+\r
+       {0, 64, "GidPrefix", mad_dump_rhex},\r
+       {64, 64, "GidGuid", mad_dump_rhex},\r
+\r
+       /*\r
+        * MAD: common MAD fields (IB spec 13.4.2)\r
+        * SMP: Subnet Management packets - lid routed (IB spec 14.2.1.1)\r
+        * DSMP: Subnet Management packets - direct route (IB spec 14.2.1.2)\r
+        * SA: Subnet Administration packets (IB spec 15.2.1.1)\r
+        */\r
+\r
+       /* first MAD word (0-3 bytes) */\r
+       {BE_OFFS(0, 7), "MadMethod", mad_dump_hex}, /* TODO: add dumper */\r
+       {BE_OFFS(7, 1), "MadIsResponse", mad_dump_uint}, /* TODO: add dumper */\r
+       {BE_OFFS(8, 8), "MadClassVersion", mad_dump_uint},\r
+       {BE_OFFS(16, 8), "MadMgmtClass", mad_dump_uint},  /* TODO: add dumper */\r
+       {BE_OFFS(24, 8), "MadBaseVersion", mad_dump_uint},\r
+\r
+       /* second MAD word (4-7 bytes) */\r
+       {BE_OFFS(48, 16), "MadStatus", mad_dump_hex}, /* TODO: add dumper */\r
+\r
+       /* DR SMP only */\r
+       {BE_OFFS(32, 8), "DrSmpHopCnt", mad_dump_uint},\r
+       {BE_OFFS(40, 8), "DrSmpHopPtr", mad_dump_uint},\r
+       {BE_OFFS(48, 15), "DrSmpStatus", mad_dump_hex}, /* TODO: add dumper */\r
+       {BE_OFFS(63, 1), "DrSmpDirection", mad_dump_uint}, /* TODO: add dumper */\r
+\r
+       /* words 3,4,5,6 (8-23 bytes) */\r
+       {64, 64, "MadTRID", mad_dump_hex},\r
+       {BE_OFFS(144, 16), "MadAttr", mad_dump_hex}, /* TODO: add dumper */\r
+       {160, 32, "MadModifier", mad_dump_hex}, /* TODO: add dumper */\r
+\r
+       /* word 7,8 (24-31 bytes) */\r
+       {196, 64, "MadMkey", mad_dump_hex},\r
+\r
+       /* word 9 (32-37 bytes) */\r
+       {BE_OFFS(256, 16), "DrSmpDLID", mad_dump_hex},\r
+       {BE_OFFS(272, 16), "DrSmpSLID", mad_dump_hex},\r
+\r
+       /* word 10,11 (36-43 bytes) */\r
+       {0, 0},         /* IB_SA_MKEY_F - reserved as invalid */\r
+\r
+       /* word 12 (44-47 bytes) */\r
+       {BE_OFFS(46*8, 16), "SaAttrOffs", mad_dump_uint},\r
+\r
+       /* word 13,14 (48-55 bytes) */\r
+       {48*8, 64, "SaCompMask", mad_dump_hex},\r
+\r
+       /* word 13,14 (56-255 bytes) */\r
+       {56*8, (256-56)*8, "SaData", mad_dump_hex},\r
+\r
+       /* bytes 64 - 127 */\r
+       {0, 0},         /* IB_SM_DATA_F - reserved as invalid */\r
+       \r
+       /* bytes 64 - 256 */\r
+       {64*8, (256-64) * 8, "GsData", mad_dump_hex},\r
+       \r
+       /* bytes 128 - 191 */\r
+       {1024, 512, "DrSmpPath", mad_dump_hex},\r
+       \r
+       /* bytes 192 - 255 */\r
+       {1536, 512, "DrSmpRetPath", mad_dump_hex},\r
+       \r
+       /*\r
+        * PortInfo fields:\r
+        */\r
+       {0, 64, "Mkey", mad_dump_hex},\r
+       {64, 64, "GidPrefix", mad_dump_hex},\r
+       {BITSOFFS(128, 16), "Lid", mad_dump_hex},\r
+       {BITSOFFS(144, 16), "SMLid", mad_dump_hex},\r
+       {160, 32, "CapMask", mad_dump_portcapmask},\r
+       {BITSOFFS(192, 16), "DiagCode", mad_dump_hex},\r
+       {BITSOFFS(208, 16), "MkeyLeasePeriod", mad_dump_uint},\r
+       {BITSOFFS(224, 8), "LocalPort", mad_dump_uint},\r
+       {BITSOFFS(232, 8), "LinkWidthEnabled", mad_dump_linkwidthen},\r
+       {BITSOFFS(240, 8), "LinkWidthSupported", mad_dump_linkwidthsup},\r
+       {BITSOFFS(248, 8), "LinkWidthActive", mad_dump_linkwidth},\r
+       {BITSOFFS(256, 4), "LinkSpeedSupported", mad_dump_linkspeedsup},\r
+       {BITSOFFS(260, 4), "LinkState", mad_dump_portstate},\r
+       {BITSOFFS(264, 4), "PhysLinkState", mad_dump_physportstate},\r
+       {BITSOFFS(268, 4), "LinkDownDefState", mad_dump_linkdowndefstate},\r
+       {BITSOFFS(272, 2), "ProtectBits", mad_dump_uint},\r
+       {BITSOFFS(277, 3), "LMC", mad_dump_uint},\r
+       {BITSOFFS(280, 4), "LinkSpeedActive", mad_dump_linkspeed},\r
+       {BITSOFFS(284, 4), "LinkSpeedEnabled", mad_dump_linkspeeden},\r
+       {BITSOFFS(288, 4), "NeighborMTU", mad_dump_mtu},\r
+       {BITSOFFS(292, 4), "SMSL", mad_dump_uint},\r
+       {BITSOFFS(296, 4), "VLCap", mad_dump_vlcap},\r
+       {BITSOFFS(300, 4), "InitType", mad_dump_hex},\r
+       {BITSOFFS(304, 8), "VLHighLimit", mad_dump_uint},\r
+       {BITSOFFS(312, 8), "VLArbHighCap", mad_dump_uint},\r
+       {BITSOFFS(320, 8), "VLArbLowCap", mad_dump_uint},\r
+       {BITSOFFS(328, 4), "InitReply", mad_dump_hex},\r
+       {BITSOFFS(332, 4), "MtuCap", mad_dump_mtu},\r
+       {BITSOFFS(336, 3), "VLStallCount", mad_dump_uint},\r
+       {BITSOFFS(339, 5), "HoqLife", mad_dump_uint},\r
+       {BITSOFFS(344, 4), "OperVLs", mad_dump_opervls},\r
+       {BITSOFFS(348, 1), "PartEnforceInb", mad_dump_uint},\r
+       {BITSOFFS(349, 1), "PartEnforceOutb", mad_dump_uint},\r
+       {BITSOFFS(350, 1), "FilterRawInb", mad_dump_uint},\r
+       {BITSOFFS(351, 1), "FilterRawOutb", mad_dump_uint},\r
+       {BITSOFFS(352, 16), "MkeyViolations", mad_dump_uint},\r
+       {BITSOFFS(368, 16), "PkeyViolations", mad_dump_uint},\r
+       {BITSOFFS(384, 16), "QkeyViolations", mad_dump_uint},\r
+       {BITSOFFS(400, 8), "GuidCap", mad_dump_uint},\r
+       {BITSOFFS(408, 1), "ClientReregister", mad_dump_uint},\r
+       {BITSOFFS(411, 5), "SubnetTimeout", mad_dump_uint},\r
+       {BITSOFFS(419, 5), "RespTimeVal", mad_dump_uint},\r
+       {BITSOFFS(424, 4), "LocalPhysErr", mad_dump_uint},\r
+       {BITSOFFS(428, 4), "OverrunErr", mad_dump_uint},\r
+       {BITSOFFS(432, 16), "MaxCreditHint", mad_dump_uint},\r
+       {BITSOFFS(456, 24), "RoundTrip", mad_dump_uint},\r
+       {0, 0},         /* IB_PORT_LAST_F */\r
+\r
+       /*\r
+        * NodeInfo fields:\r
+        */\r
+       {BITSOFFS(0,8), "BaseVers", mad_dump_uint},\r
+       {BITSOFFS(8,8), "ClassVers", mad_dump_uint},\r
+       {BITSOFFS(16,8), "NodeType", mad_dump_node_type},\r
+       {BITSOFFS(24,8), "NumPorts", mad_dump_uint},\r
+       {32, 64, "SystemGuid", mad_dump_hex},\r
+       {96, 64, "Guid", mad_dump_hex},\r
+       {160, 64, "PortGuid", mad_dump_hex},\r
+       {BITSOFFS(224,16), "PartCap", mad_dump_uint},\r
+       {BITSOFFS(240,16), "DevId", mad_dump_hex},\r
+       {256, 32, "Revision", mad_dump_hex},\r
+       {BITSOFFS(288,8), "LocalPort", mad_dump_uint},\r
+       {BITSOFFS(296,24), "VendorId", mad_dump_hex},\r
+       {0, 0},         /* IB_NODE_LAST_F */\r
+\r
+\r
+       /*\r
+        * SwitchInfo fields:\r
+        */\r
+       {BITSOFFS(0, 16), "LinearFdbCap", mad_dump_uint},\r
+       {BITSOFFS(16, 16), "RandomFdbCap", mad_dump_uint},\r
+       {BITSOFFS(32, 16), "McastFdbCap", mad_dump_uint},\r
+       {BITSOFFS(48, 16), "LinearFdbTop", mad_dump_uint},\r
+       {BITSOFFS(64, 8), "DefPort", mad_dump_uint},\r
+       {BITSOFFS(72, 8), "DefMcastPrimPort", mad_dump_uint},\r
+       {BITSOFFS(80, 8), "DefMcastNotPrimPort", mad_dump_uint},\r
+       {BITSOFFS(88, 5), "LifeTime", mad_dump_uint},\r
+       {BITSOFFS(93, 1), "StateChange", mad_dump_uint},\r
+       {BITSOFFS(96,16), "LidsPerPort", mad_dump_uint},\r
+       {BITSOFFS(112, 16), "PartEnforceCap", mad_dump_uint},\r
+       {BITSOFFS(128, 1), "InboundPartEnf", mad_dump_uint},\r
+       {BITSOFFS(129, 1), "OutboundPartEnf", mad_dump_uint},\r
+       {BITSOFFS(130, 1), "FilterRawInbound", mad_dump_uint},\r
+       {BITSOFFS(131, 1), "FilterRawOutbound", mad_dump_uint},\r
+       {BITSOFFS(132, 1), "EnhancedPort0", mad_dump_uint},\r
+       {0, 0},         /* IB_SW_LAST_F */\r
+\r
+       /*\r
+        * SwitchLinearForwardingTable fields:\r
+        */\r
+       {0, 512, "LinearForwTbl", mad_dump_array},\r
+\r
+       /*\r
+        * SwitchMulticastForwardingTable fields:\r
+        */\r
+       {0, 512, "MulticastForwTbl", mad_dump_array},\r
+\r
+       /*\r
+        * NodeDescription fields:\r
+        */\r
+       {0, 64*8, "NodeDesc", mad_dump_string},\r
+\r
+       /*\r
+        * Notice/Trap fields\r
+        */\r
+       {BITSOFFS(0, 1), "NoticeIsGeneric", mad_dump_uint},\r
+       {BITSOFFS(1, 7), "NoticeType", mad_dump_uint},\r
+       {BITSOFFS(8, 24), "NoticeProducerType", mad_dump_node_type},\r
+       {BITSOFFS(32, 16), "NoticeTrapNumber", mad_dump_uint},\r
+       {BITSOFFS(48, 16), "NoticeIssuerLID", mad_dump_uint},\r
+       {BITSOFFS(64, 1), "NoticeToggle", mad_dump_uint},\r
+       {BITSOFFS(65, 15), "NoticeCount", mad_dump_uint},\r
+       {80, 432, "NoticeDataDetails", mad_dump_array},\r
+       {BITSOFFS(80, 16), "NoticeDataLID", mad_dump_uint},\r
+       {BITSOFFS(96, 16), "NoticeDataTrap144LID", mad_dump_uint},\r
+       {BITSOFFS(128, 32), "NoticeDataTrap144CapMask", mad_dump_uint},\r
+\r
+       /*\r
+        * Port counters\r
+        */\r
+       {BITSOFFS(8, 8), "PortSelect", mad_dump_uint},\r
+       {BITSOFFS(16, 16), "CounterSelect", mad_dump_hex},\r
+       {BITSOFFS(32, 16), "SymbolErrors", mad_dump_uint},\r
+       {BITSOFFS(48, 8), "LinkRecovers", mad_dump_uint},\r
+       {BITSOFFS(56, 8), "LinkDowned", mad_dump_uint},\r
+       {BITSOFFS(64, 16), "RcvErrors", mad_dump_uint},\r
+       {BITSOFFS(80, 16), "RcvRemotePhysErrors", mad_dump_uint},\r
+       {BITSOFFS(96, 16), "RcvSwRelayErrors", mad_dump_uint},\r
+       {BITSOFFS(112, 16), "XmtDiscards", mad_dump_uint},\r
+       {BITSOFFS(128, 8), "XmtConstraintErrors", mad_dump_uint},\r
+       {BITSOFFS(136, 8), "RcvConstraintErrors", mad_dump_uint},\r
+       {BITSOFFS(152, 4), "LinkIntegrityErrors", mad_dump_uint},\r
+       {BITSOFFS(156, 4), "ExcBufOverrunErrors", mad_dump_uint},\r
+       {BITSOFFS(176, 16), "VL15Dropped", mad_dump_uint},\r
+       {192, 32, "XmtData", mad_dump_uint},\r
+       {224, 32, "RcvData", mad_dump_uint},\r
+       {256, 32, "XmtPkts", mad_dump_uint},\r
+       {288, 32, "RcvPkts", mad_dump_uint},\r
+       {0, 0},         /* IB_PC_LAST_F */\r
+\r
+       /*\r
+        * SMInfo\r
+        */\r
+       {0, 64, "SmInfoGuid", mad_dump_hex},\r
+       {64, 64, "SmInfoKey", mad_dump_hex},\r
+       {128, 32, "SmActivity", mad_dump_uint},\r
+       {BITSOFFS(160, 4), "SmPriority", mad_dump_uint},\r
+       {BITSOFFS(164, 4), "SmState", mad_dump_uint},\r
+\r
+       /*\r
+        * SA RMPP\r
+        */\r
+       {BE_OFFS(24*8+24, 8), "RmppVers", mad_dump_uint},\r
+       {BE_OFFS(24*8+16, 8), "RmppType", mad_dump_uint},\r
+       {BE_OFFS(24*8+11, 5), "RmppResp", mad_dump_uint},\r
+       {BE_OFFS(24*8+8, 3), "RmppFlags", mad_dump_hex},\r
+       {BE_OFFS(24*8+0, 8), "RmppStatus", mad_dump_hex},\r
+\r
+       /* data1 */\r
+       {28*8, 32, "RmppData1", mad_dump_hex},\r
+       {28*8, 32, "RmppSegNum", mad_dump_uint},\r
+       /* data2 */\r
+       {32*8, 32, "RmppData2", mad_dump_hex},\r
+       {32*8, 32, "RmppPayload", mad_dump_uint},\r
+       {32*8, 32, "RmppNewWin", mad_dump_uint},\r
+       \r
+       /*\r
+        * SA Get Multi Path\r
+        */\r
+       {BITSOFFS(41,7), "MultiPathNumPath", mad_dump_uint},\r
+       {BITSOFFS(120,8), "MultiPathNumSrc", mad_dump_uint},\r
+       {BITSOFFS(128,8), "MultiPathNumDest", mad_dump_uint},\r
+       {192, 128, "MultiPathGid", mad_dump_array},\r
+\r
+       /*\r
+        * SA Path rec\r
+        */\r
+       {64, 128, "PathRecDGid", mad_dump_array},\r
+       {192, 128, "PathRecSGid", mad_dump_array},\r
+       {BITSOFFS(320,16), "PathRecDLid", mad_dump_hex},\r
+       {BITSOFFS(336,16), "PathRecSLid", mad_dump_hex},\r
+       {BITSOFFS(393,7), "PathRecNumPath", mad_dump_uint},\r
+\r
+       /*\r
+        * MC Member rec\r
+        */\r
+       {0, 128, "McastMemMGid", mad_dump_array},\r
+       {128, 128, "McastMemPortGid", mad_dump_array},\r
+       {256, 32, "McastMemQkey", mad_dump_hex},\r
+       {BITSOFFS(288, 16), "McastMemMLid", mad_dump_hex},\r
+       {BITSOFFS(352, 4), "McastMemSL", mad_dump_uint},\r
+       {BITSOFFS(306, 6), "McastMemMTU", mad_dump_uint},\r
+       {BITSOFFS(338, 6), "McastMemRate", mad_dump_uint},\r
+       {BITSOFFS(312, 8), "McastMemTClass", mad_dump_uint},\r
+       {BITSOFFS(320, 16), "McastMemPkey", mad_dump_uint},\r
+       {BITSOFFS(356, 20), "McastMemFlowLbl", mad_dump_uint},\r
+       {BITSOFFS(388, 4), "McastMemJoinState", mad_dump_uint},\r
+       {BITSOFFS(392, 1), "McastMemProxyJoin", mad_dump_uint},\r
+\r
+       /*\r
+        * Service record\r
+        */\r
+       {0, 64, "ServRecID", mad_dump_hex},\r
+       {64, 128, "ServRecGid", mad_dump_array},\r
+       {BITSOFFS(192, 16), "ServRecPkey", mad_dump_hex},\r
+       {224, 32, "ServRecLease", mad_dump_hex},\r
+       {256, 128, "ServRecKey", mad_dump_hex},\r
+       {384, 512, "ServRecName", mad_dump_string},\r
+       {896, 512, "ServRecData", mad_dump_array},      /* ATS for example */\r
+\r
+       /*\r
+        * ATS SM record - within SA_SR_DATA\r
+        */\r
+       {12*8, 32, "ATSNodeAddr", mad_dump_hex},\r
+       {BITSOFFS(16*8, 16), "ATSMagicKey", mad_dump_hex},\r
+       {BITSOFFS(18*8, 16), "ATSNodeType", mad_dump_hex},\r
+       {32*8, 32*8, "ATSNodeName", mad_dump_string},\r
+\r
+       /*\r
+        * SLTOVL MAPPING TABLE\r
+        */\r
+       {0, 64, "SLToVLMap", mad_dump_hex},\r
+\r
+       /*\r
+        * VL ARBITRATION TABLE\r
+        */\r
+       {0, 512, "VLArbTbl", mad_dump_array},\r
+\r
+       /*\r
+        * IB vendor classes range 2\r
+        */\r
+       {BE_OFFS(36*8, 24), "OUI", mad_dump_array},\r
+       {40*8, (256-40)*8, "Vendor2Data", mad_dump_array},\r
+\r
+       /*\r
+        * Extended port counters\r
+        */\r
+       {BITSOFFS(8, 8), "PortSelect", mad_dump_uint},\r
+       {BITSOFFS(16, 16), "CounterSelect", mad_dump_hex},\r
+       {64, 64, "PortXmitData", mad_dump_uint},\r
+       {128, 64, "PortRcvData", mad_dump_uint},\r
+       {192, 64, "PortXmitPkts", mad_dump_uint},\r
+       {256, 64, "PortRcvPkts", mad_dump_uint},\r
+       {320, 64, "PortUnicastXmitPkts", mad_dump_uint},\r
+       {384, 64, "PortUnicastRcvPkts", mad_dump_uint},\r
+       {448, 64, "PortMulticastXmitPkts", mad_dump_uint},\r
+       {512, 64, "PortMulticastRcvPkts", mad_dump_uint},\r
+       {0, 0},         /* IB_PC_EXT_LAST_F */\r
+\r
+       /*\r
+        * GUIDInfo fields\r
+        */\r
+       {0, 64, "GUID0", mad_dump_hex},\r
+       {0, 0}          /* IB_FIELD_LAST_ */\r
+\r
+};\r
+\r
+void\r
+_set_field64(void *buf, int base_offs, ib_field_t *f, uint64_t val)\r
+{\r
+       uint64_t nval;\r
+\r
+       nval = cl_hton64(val);\r
+       memcpy((char *)buf + base_offs + f->bitoffs / 8, &nval, sizeof(uint64_t));\r
+}\r
+\r
+uint64_t\r
+_get_field64(void *buf, int base_offs, ib_field_t *f)\r
+{\r
+       uint64_t val;\r
+       memcpy(&val, ((char *)buf + base_offs + f->bitoffs / 8), sizeof(uint64_t));\r
+       return cl_ntoh64(val);\r
+}\r
+\r
+void\r
+_set_field(void *buf, int base_offs, ib_field_t *f, uint32_t val)\r
+{\r
+       int prebits = (8 - (f->bitoffs & 7)) & 7;\r
+       int postbits = (f->bitoffs + f->bitlen) & 7;\r
+       int bytelen = f->bitlen / 8;\r
+       unsigned idx = base_offs + f->bitoffs / 8;\r
+       char *p = (char *)buf;\r
+\r
+       if (!bytelen && (f->bitoffs & 7) + f->bitlen < 8) {\r
+               p[3^idx] &= ~((((1 << f->bitlen) - 1)) << (f->bitoffs & 7));\r
+               p[3^idx] |= (val & ((1 << f->bitlen) - 1)) << (f->bitoffs & 7);\r
+               return;\r
+       }\r
+\r
+       if (prebits) {  /* val lsb in byte msb */\r
+               p[3^idx] &= (1 << (8 - prebits)) - 1;\r
+               p[3^idx++] |= (val & ((1 << prebits) - 1)) << (8 - prebits);\r
+               val >>= prebits;\r
+       }\r
+\r
+       /* BIG endian byte order */\r
+       for (; bytelen--; val >>= 8)\r
+               p[3^idx++] = val & 0xff;\r
+\r
+       if (postbits) { /* val msb in byte lsb */\r
+               p[3^idx] &= ~((1 << postbits) - 1);\r
+               p[3^idx] |= val;\r
+       }\r
+}\r
+\r
+uint32_t\r
+_get_field(void *buf, int base_offs, ib_field_t *f)\r
+{\r
+       int prebits = (8 - (f->bitoffs & 7)) & 7;\r
+       int postbits = (f->bitoffs + f->bitlen) & 7;\r
+       int bytelen = f->bitlen / 8;\r
+       unsigned idx = base_offs + f->bitoffs / 8;\r
+       uint8_t *p = (uint8_t *)buf;\r
+       uint32_t val = 0, v = 0, i;\r
+\r
+       if (!bytelen && (f->bitoffs & 7) + f->bitlen < 8)\r
+               return (p[3^idx] >> (f->bitoffs & 7)) & ((1 << f->bitlen) - 1);\r
+\r
+       if (prebits)    /* val lsb from byte msb */\r
+               v = p[3^idx++] >> (8 - prebits);\r
+\r
+       if (postbits) { /* val msb from byte lsb */\r
+               i = base_offs + (f->bitoffs + f->bitlen) / 8;\r
+               val = (p[3^i] & ((1 << postbits) - 1));\r
+       }\r
+\r
+       /* BIG endian byte order */\r
+       for (idx += bytelen - 1; bytelen--; idx--)\r
+               val = (val << 8) | p[3^idx];\r
+\r
+       return (val << prebits) | v;\r
+}\r
+\r
+/* field must be byte aligned */\r
+void\r
+_set_array(void *buf, int base_offs, ib_field_t *f, void *val)\r
+{\r
+       int bitoffs = f->bitoffs;\r
+\r
+       if (f->bitlen < 32)\r
+               bitoffs = BE_TO_BITSOFFS(bitoffs, f->bitlen);\r
+\r
+       memcpy((uint8_t *)buf + base_offs + bitoffs / 8, val, f->bitlen / 8);\r
+}\r
+\r
+void\r
+_get_array(void *buf, int base_offs, ib_field_t *f, void *val)\r
+{\r
+       int bitoffs = f->bitoffs;\r
+\r
+       if (f->bitlen < 32)\r
+               bitoffs = BE_TO_BITSOFFS(bitoffs, f->bitlen);\r
+\r
+       memcpy(val, (uint8_t *)buf + base_offs + bitoffs / 8, f->bitlen / 8);\r
+}\r
diff --git a/ulp/libibmad/src/gs.c b/ulp/libibmad/src/gs.c
new file mode 100644 (file)
index 0000000..0a6bd8b
--- /dev/null
@@ -0,0 +1,243 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#else\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include "mad.h"\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+static uint8_t *\r
+pma_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+             unsigned timeout, unsigned id, const void *srcport)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+       int lid = dest->lid;\r
+\r
+       DEBUG("lid %d port %d", lid, port);\r
+\r
+       if (lid == -1) {\r
+               IBWARN("only lid routed is supported");\r
+               return 0;\r
+       }\r
+\r
+       rpc.mgtclass = IB_PERFORMANCE_CLASS;\r
+       rpc.method = IB_MAD_METHOD_GET;\r
+       rpc.attr.id = id;\r
+\r
+       /* Same for attribute IDs */\r
+       mad_set_field(rcvbuf, 0, IB_PC_PORT_SELECT_F, port);\r
+       rpc.attr.mod = 0;\r
+       rpc.timeout = timeout;\r
+       rpc.datasz = IB_PC_DATA_SZ;\r
+       rpc.dataoffs = IB_PC_DATA_OFFS;\r
+\r
+       dest->qp = 1;\r
+       if (!dest->qkey)\r
+               dest->qkey = IB_DEFAULT_QP1_QKEY;\r
+\r
+       if (srcport) {\r
+               return mad_rpc(srcport, &rpc, dest, rcvbuf, rcvbuf);\r
+       } else {\r
+               return madrpc(&rpc, dest, rcvbuf, rcvbuf);\r
+       }\r
+}\r
+\r
+uint8_t *\r
+pma_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout, unsigned id)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout, id, NULL);\r
+}\r
+\r
+uint8_t *\r
+perf_classportinfo_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                            unsigned timeout, const void *srcport)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout, CLASS_PORT_INFO,\r
+                            srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+perf_classportinfo_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)\r
+{\r
+       return pma_query(rcvbuf, dest, port, timeout, CLASS_PORT_INFO);\r
+}\r
+\r
+uint8_t *\r
+port_performance_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                          unsigned timeout, const void *srcport)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout,\r
+                            IB_GSI_PORT_COUNTERS, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_performance_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)\r
+{\r
+       return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_COUNTERS);\r
+}\r
+\r
+static uint8_t *\r
+performance_reset_via(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,\r
+                     unsigned timeout, unsigned id, const void *srcport)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+       int lid = dest->lid;\r
+\r
+       DEBUG("lid %d port %d mask 0x%x", lid, port, mask);\r
+\r
+       if (lid == -1) {\r
+               IBWARN("only lid routed is supported");\r
+               return 0;\r
+       }\r
+\r
+       if (!mask)\r
+               mask = ~0;\r
+\r
+       rpc.mgtclass = IB_PERFORMANCE_CLASS;\r
+       rpc.method = IB_MAD_METHOD_SET;\r
+       rpc.attr.id = id;\r
+\r
+       memset(rcvbuf, 0, IB_MAD_SIZE);\r
+\r
+       /* Same for attribute IDs */\r
+       mad_set_field(rcvbuf, 0, IB_PC_PORT_SELECT_F, port);\r
+       mad_set_field(rcvbuf, 0, IB_PC_COUNTER_SELECT_F, mask);\r
+       rpc.attr.mod = 0;\r
+       rpc.timeout = timeout;\r
+       rpc.datasz = IB_PC_DATA_SZ;\r
+       rpc.dataoffs = IB_PC_DATA_OFFS;\r
+       dest->qp = 1;\r
+       if (!dest->qkey)\r
+               dest->qkey = IB_DEFAULT_QP1_QKEY;\r
+\r
+       if (srcport) {\r
+               return mad_rpc(srcport, &rpc, dest, rcvbuf, rcvbuf);\r
+       } else {\r
+               return madrpc(&rpc, dest, rcvbuf, rcvbuf);\r
+       }\r
+}\r
+\r
+static uint8_t *\r
+performance_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,\r
+                 unsigned timeout, unsigned id)\r
+{\r
+       return performance_reset_via(rcvbuf, dest, port, mask, timeout,\r
+                                    id, NULL);\r
+}\r
+\r
+uint8_t *\r
+port_performance_reset_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                          unsigned mask, unsigned timeout, const void *srcport)\r
+{\r
+       return performance_reset_via(rcvbuf, dest, port, mask, timeout,\r
+                                    IB_GSI_PORT_COUNTERS, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_performance_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,\r
+                      unsigned timeout)\r
+{\r
+       return performance_reset(rcvbuf, dest, port, mask, timeout, IB_GSI_PORT_COUNTERS);\r
+}\r
+\r
+uint8_t *\r
+port_performance_ext_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                              unsigned timeout, const void *srcport)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout,\r
+                            IB_GSI_PORT_COUNTERS_EXT, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_performance_ext_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)\r
+{\r
+       return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_COUNTERS_EXT);\r
+}\r
+\r
+uint8_t *\r
+port_performance_ext_reset_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                              unsigned mask, unsigned timeout,\r
+                              const void *srcport)\r
+{\r
+       return performance_reset_via(rcvbuf, dest, port, mask, timeout,\r
+                                    IB_GSI_PORT_COUNTERS_EXT, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_performance_ext_reset(void *rcvbuf, ib_portid_t *dest, int port, unsigned mask,\r
+                          unsigned timeout)\r
+{\r
+       return performance_reset(rcvbuf, dest, port, mask, timeout, IB_GSI_PORT_COUNTERS_EXT);\r
+}\r
+\r
+uint8_t *\r
+port_samples_control_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                              unsigned timeout, const void *srcport)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout,\r
+                            IB_GSI_PORT_SAMPLES_CONTROL, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_samples_control_query(void *rcvbuf, ib_portid_t *dest, int port, unsigned timeout)\r
+{\r
+       return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_SAMPLES_CONTROL);\r
+}\r
+\r
+uint8_t *\r
+port_samples_result_query_via(void *rcvbuf, ib_portid_t *dest, int port,\r
+                             unsigned timeout, const void *srcport)\r
+{\r
+       return pma_query_via(rcvbuf, dest, port, timeout,\r
+                            IB_GSI_PORT_SAMPLES_RESULT, srcport);\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+port_samples_result_query(void *rcvbuf, ib_portid_t *dest, int port,  unsigned timeout)\r
+{\r
+       return pma_query(rcvbuf, dest, port, timeout, IB_GSI_PORT_SAMPLES_RESULT);\r
+}\r
diff --git a/ulp/libibmad/src/ibmad.rc b/ulp/libibmad/src/ibmad.rc
new file mode 100644 (file)
index 0000000..d449110
--- /dev/null
@@ -0,0 +1,46 @@
+/*\r
+ * Copyright (c) 2008 Intel Corporation.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenIB.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+\r
+#include <oib_ver.h>\r
+\r
+#define VER_FILETYPE                   VFT_DLL\r
+#define VER_FILESUBTYPE                        VFT2_UNKNOWN\r
+\r
+#ifdef DBG\r
+#define VER_FILEDESCRIPTION_STR                "LibIbMad (Debug)"\r
+#define VER_INTERNALNAME_STR           "LibIbMadd.dll"\r
+#define VER_ORIGINALFILENAME_STR       "LibIbMadd.dll"\r
+#else\r
+#define VER_FILEDESCRIPTION_STR                "LibIbMad"\r
+#define VER_INTERNALNAME_STR           "LibIbMad.dll"\r
+#define VER_ORIGINALFILENAME_STR       "LibIbMad.dll"\r
+#endif\r
+\r
+#include <common.ver>\r
diff --git a/ulp/libibmad/src/ibmad_export.def b/ulp/libibmad/src/ibmad_export.def
new file mode 100644 (file)
index 0000000..8258d30
--- /dev/null
@@ -0,0 +1,34 @@
+/*\r
+ * Copyright (c) 2008 Intel Corporation. All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenIB.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+LIBRARY        LIBIBMAD.DLL\r
+\r
+EXPORTS\r
+       DllCanUnloadNow         PRIVATE\r
+       DllGetClassObject       PRIVATE\r
diff --git a/ulp/libibmad/src/ibmad_exports.src b/ulp/libibmad/src/ibmad_exports.src
new file mode 100644 (file)
index 0000000..9fcb759
--- /dev/null
@@ -0,0 +1,54 @@
+#if DBG\r
+LIBRARY libibmadd.dll\r
+#else\r
+LIBRARY libibmad.dll\r
+#endif\r
+\r
+#ifndef _WIN64\r
+EXPORTS\r
+       mad_set_field;\r
+       mad_get_field;\r
+       mad_set_array;\r
+       mad_get_array;\r
+       mad_set_field64;\r
+       mad_get_field64;\r
+       mad_decode_field;\r
+       mad_encode_field;\r
+       mad_encode;\r
+       mad_trid;\r
+       mad_build_pkt;\r
+       mad_register_port_client;\r
+       mad_register_client;\r
+       mad_register_server;\r
+       mad_class_agent;\r
+       mad_agent_class;\r
+       mad_send;\r
+       mad_receive;\r
+       mad_respond;\r
+       mad_alloc;\r
+       mad_free;\r
+       madrpc_portid;\r
+       madrpc_init;\r
+       madrpc_set_retries;\r
+       madrpc_set_timeout;\r
+       madrpc_show_errors;\r
+       smp_query;\r
+       smp_set;\r
+       ib_vendor_call;\r
+       ib_path_query;\r
+       ib_resolve_smlid;\r
+       ib_resolve_guid;\r
+       ib_resolve_portid_str;\r
+       ib_resolve_self;\r
+       perf_classportinfo_query;\r
+       port_performance_query;\r
+       port_performance_reset;\r
+       port_performance_ext_query;\r
+       port_performance_ext_reset;\r
+       port_samples_control_query;\r
+       port_samples_result_query;\r
+       portid2str;\r
+       portid2portnum;\r
+       str2drpath;\r
+       drpath2str;\r
+#endif\r
diff --git a/ulp/libibmad/src/ibmad_main.cpp b/ulp/libibmad/src/ibmad_main.cpp
new file mode 100644 (file)
index 0000000..f57d13c
--- /dev/null
@@ -0,0 +1,39 @@
+/*\r
+ * Copyright (c) 2008 Intel Corporation. All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenIB.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#include <windows.h>\r
+\r
+BOOLEAN WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)\r
+{\r
+       UNREFERENCED_PARAMETER(hInstance);\r
+       UNREFERENCED_PARAMETER(dwReason);\r
+       UNREFERENCED_PARAMETER(lpReserved);\r
+\r
+       return TRUE;\r
+}\r
diff --git a/ulp/libibmad/src/mad.c b/ulp/libibmad/src/mad.c
new file mode 100644 (file)
index 0000000..fba2109
--- /dev/null
@@ -0,0 +1,255 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#include <time.h>\r
+#define getpid GetCurrentProcessId\r
+#else\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+MAD_EXPORT uint32_t\r
+mad_get_field(void *buf, int base_offs, int field)\r
+{\r
+       return _get_field(buf, base_offs, ib_mad_f + field);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_set_field(void *buf, int base_offs, int field, uint32_t val)\r
+{\r
+       _set_field(buf, base_offs, ib_mad_f + field, val);\r
+}\r
+\r
+/* field must be byte aligned */\r
+MAD_EXPORT uint64_t\r
+mad_get_field64(void *buf, int base_offs, int field)\r
+{\r
+       return _get_field64(buf, base_offs, ib_mad_f + field);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_set_field64(void *buf, int base_offs, int field, uint64_t val)\r
+{\r
+       _set_field64(buf, base_offs, ib_mad_f + field, val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_set_array(void *buf, int base_offs, int field, void *val)\r
+{\r
+       _set_array(buf, base_offs, ib_mad_f + field, val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_get_array(void *buf, int base_offs, int field, void *val)\r
+{\r
+       _get_array(buf, base_offs, ib_mad_f + field, val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_decode_field(uint8_t *buf, int field, void *val)\r
+{\r
+       ib_field_t *f = ib_mad_f + field;\r
+\r
+       if (!field) {\r
+               *(int *)val = *(int *)buf;\r
+               return;\r
+       }\r
+       if (f->bitlen <= 32) {\r
+               *(uint32_t *)val = _get_field(buf, 0, f);\r
+               return;\r
+       }\r
+       if (f->bitlen == 64) {\r
+               *(uint64_t *)val = _get_field64(buf, 0, f);\r
+               return;\r
+       }\r
+       _get_array(buf, 0, f, val);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_encode_field(uint8_t *buf, int field, void *val)\r
+{\r
+       ib_field_t *f = ib_mad_f + field;\r
+\r
+       if (!field) {\r
+               *(int *)buf = *(int *)val;\r
+               return;\r
+       }\r
+       if (f->bitlen <= 32) {\r
+               _set_field(buf, 0, f, *(uint32_t *)val);\r
+               return;\r
+       }\r
+       if (f->bitlen == 64) {\r
+               _set_field64(buf, 0, f, *(uint64_t *)val);\r
+               return;\r
+       }\r
+       _set_array(buf, 0, f, val);\r
+}\r
+\r
+MAD_EXPORT uint64_t\r
+mad_trid(void)\r
+{\r
+       static uint64_t base;\r
+       static uint64_t trid;\r
+       uint64_t next;\r
+\r
+       if (!base) {\r
+               srand((int)time(0)*getpid());\r
+               base = rand();\r
+               trid = rand();\r
+       }\r
+       next = ++trid | (base << 32);\r
+       return next;\r
+}\r
+\r
+MAD_EXPORT void *\r
+mad_encode(void *buf, ib_rpc_t *rpc, ib_dr_path_t *drpath, void *data)\r
+{\r
+       int is_resp = rpc->method & IB_MAD_RESPONSE;\r
+\r
+       /* first word */\r
+       mad_set_field(buf, 0, IB_MAD_METHOD_F, rpc->method);\r
+       mad_set_field(buf, 0, IB_MAD_RESPONSE_F, is_resp ? 1 : 0);\r
+       mad_set_field(buf, 0, IB_MAD_CLASSVER_F, rpc->mgtclass == IB_SA_CLASS ? 2 : 1);\r
+       mad_set_field(buf, 0, IB_MAD_MGMTCLASS_F, rpc->mgtclass);\r
+       mad_set_field(buf, 0, IB_MAD_BASEVER_F, 1);\r
+\r
+       /* second word */\r
+       if (rpc->mgtclass == IB_SMI_DIRECT_CLASS) {\r
+               if (!drpath) {\r
+                       IBWARN("encoding dr mad without drpath (null)");\r
+                       return 0;\r
+               }\r
+               mad_set_field(buf, 0, IB_DRSMP_HOPCNT_F, drpath->cnt);\r
+               mad_set_field(buf, 0, IB_DRSMP_HOPPTR_F, is_resp ? drpath->cnt + 1 : 0x0);\r
+               mad_set_field(buf, 0, IB_DRSMP_STATUS_F, rpc->rstatus);\r
+               mad_set_field(buf, 0, IB_DRSMP_DIRECTION_F, is_resp ? 1 : 0);   /* out */\r
+       } else\r
+               mad_set_field(buf, 0, IB_MAD_STATUS_F, rpc->rstatus);\r
+\r
+       /* words 3,4,5,6 */\r
+       if (!rpc->trid)\r
+               rpc->trid = mad_trid();\r
+\r
+       mad_set_field64(buf, 0, IB_MAD_TRID_F, rpc->trid);\r
+       mad_set_field(buf, 0, IB_MAD_ATTRID_F, rpc->attr.id);\r
+       mad_set_field(buf, 0, IB_MAD_ATTRMOD_F, rpc->attr.mod);\r
+\r
+       /* words 7,8 */\r
+       mad_set_field(buf, 0, IB_MAD_MKEY_F, (uint32_t)(rpc->mkey >> 32));\r
+       mad_set_field(buf, 4, IB_MAD_MKEY_F, (uint32_t)(rpc->mkey & 0xffffffff));\r
+\r
+       if (rpc->mgtclass == IB_SMI_DIRECT_CLASS) {\r
+               /* word 9 */\r
+               mad_set_field(buf, 0, IB_DRSMP_DRDLID_F, drpath->drdlid ? drpath->drdlid : 0xffff);\r
+               mad_set_field(buf, 0, IB_DRSMP_DRSLID_F, drpath->drslid ? drpath->drslid : 0xffff);\r
+\r
+               /* bytes 128 - 256 - by default should be zero due to memset*/\r
+               if (is_resp)\r
+                       mad_set_array(buf, 0, IB_DRSMP_RPATH_F, drpath->p);\r
+               else\r
+                       mad_set_array(buf, 0, IB_DRSMP_PATH_F, drpath->p);\r
+       }\r
+\r
+       if (rpc->mgtclass == IB_SA_CLASS)\r
+               mad_set_field64(buf, 0, IB_SA_COMPMASK_F, rpc->mask);\r
+\r
+       if (data)\r
+               memcpy((char *)buf + rpc->dataoffs, data, rpc->datasz);\r
+\r
+       /* vendor mads range 2 */\r
+       if (mad_is_vendor_range2(rpc->mgtclass))\r
+               mad_set_field(buf, 0, IB_VEND2_OUI_F, rpc->oui);\r
+\r
+       return (uint8_t *)buf + IB_MAD_SIZE;\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_build_pkt(void *umad, ib_rpc_t *rpc, ib_portid_t *dport,\r
+             ib_rmpp_hdr_t *rmpp, void *data)\r
+{\r
+       uint8_t *p, *mad;\r
+       int lid_routed = rpc->mgtclass != IB_SMI_DIRECT_CLASS;\r
+       int is_smi = (rpc->mgtclass == IB_SMI_CLASS ||\r
+                     rpc->mgtclass == IB_SMI_DIRECT_CLASS);\r
+       struct ib_mad_addr addr;\r
+\r
+       if (!is_smi)\r
+               umad_set_addr(umad, dport->lid, dport->qp, dport->sl, dport->qkey);\r
+       else if (lid_routed)\r
+               umad_set_addr(umad, dport->lid, dport->qp, 0, 0);\r
+       else\r
+               if ((dport->drpath.drslid != 0xffff) && (dport->lid > 0))\r
+                       umad_set_addr(umad, dport->lid, 0, 0, 0);\r
+               else\r
+                       umad_set_addr(umad, 0xffff, 0, 0, 0);\r
+\r
+       if (dport->grh_present && !is_smi) {\r
+               addr.grh_present = 1;\r
+               memcpy(addr.gid, dport->gid, 16);\r
+               addr.hop_limit = 0xff;\r
+               addr.traffic_class = 0;\r
+               addr.flow_label = 0;\r
+               umad_set_grh(umad, &addr);\r
+       } else\r
+               umad_set_grh(umad, 0);\r
+       umad_set_pkey(umad, is_smi ? 0 : dport->pkey_idx);\r
+\r
+       mad = umad_get_mad(umad);\r
+       p = mad_encode(mad, rpc, lid_routed ? 0 : &dport->drpath, data);\r
+\r
+       if (!is_smi && rmpp) {\r
+               mad_set_field(mad, 0, IB_SA_RMPP_VERS_F, 1);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_TYPE_F, rmpp->type);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_RESP_F, 0x3f);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_FLAGS_F, rmpp->flags);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_STATUS_F, rmpp->status);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_D1_F, rmpp->d1.u);\r
+               mad_set_field(mad, 0, IB_SA_RMPP_D2_F, rmpp->d2.u);\r
+       }\r
+\r
+       return ((int)(p - mad));\r
+}\r
diff --git a/ulp/libibmad/src/makefile b/ulp/libibmad/src/makefile
new file mode 100644 (file)
index 0000000..bffacaa
--- /dev/null
@@ -0,0 +1,7 @@
+#\r
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source\r
+# file to this component.  This file merely indirects to the real make file\r
+# that is shared by all the driver components of the OpenIB Windows project.\r
+#\r
+\r
+!INCLUDE ..\..\..\inc\openib.def\r
diff --git a/ulp/libibmad/src/portid.c b/ulp/libibmad/src/portid.c
new file mode 100644 (file)
index 0000000..8751cfe
--- /dev/null
@@ -0,0 +1,175 @@
+/*\r
+ * Copyright (c) 2004-2008 Voltaire Inc.  All rights reserved.\r
+ * Copyright (c) 2008 Intel Corporation.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#include <ws2tcpip.h>\r
+#define snprintf _snprintf\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#include <string.h>\r
+#include <inttypes.h>\r
+#include <arpa/inet.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+#if defined(_WIN32) || defined(_WIN64)  \r
+const char * _inet_ntop(int family, const void *addr, char *dst, size_t len)\r
+{\r
+       if (family == AF_INET)\r
+       {\r
+               struct sockaddr_in in;\r
+               in.sin_family = AF_INET;\r
+               memcpy(&in.sin_addr, addr, 4);\r
+               if (getnameinfo((struct sockaddr *)&in,\r
+                               (socklen_t) (sizeof(struct sockaddr_in)),\r
+                               dst, len, NULL, 0, NI_NUMERICHOST))\r
+                       return NULL;\r
+       }\r
+       else if (family == AF_INET6)\r
+       {\r
+               struct sockaddr_in6 in6;\r
+               memset(&in6, 0, sizeof in6);\r
+               in6.sin6_family = AF_INET;\r
+               memcpy(&in6.sin6_addr, addr, sizeof(struct in_addr6));\r
+\r
+               /* if no ipv6 support return simple IPv6 format rule:\r
+                * A series of "0's in a 16bit block can be represented by "0" \r
+                */\r
+               if (getnameinfo((struct sockaddr *)&in6, (socklen_t) (sizeof in6),\r
+                                dst, len, NULL, 0, NI_NUMERICHOST)) \r
+               {\r
+                       char tmp[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"];\r
+                       int i, n=0;\r
+                                       \r
+                       if (len < sizeof(tmp))\r
+                               return NULL;\r
+\r
+                       for (i = 0; i < 8; i++) \r
+                               n += sprintf(tmp+n, "%s%x", \r
+                                            i?":":"",\r
+                                            ntohs(((unsigned short*)addr)[i]));\r
+                       tmp[n]='\0';\r
+                       strcpy(dst, tmp);\r
+               }\r
+       }\r
+       return dst;\r
+}\r
+#define inet_ntop _inet_ntop\r
+#endif\r
+\r
+MAD_EXPORT int\r
+portid2portnum(ib_portid_t *portid)\r
+{\r
+       if (portid->lid > 0)\r
+               return -1;\r
+\r
+       if (portid->drpath.cnt == 0)\r
+               return 0;\r
+\r
+       return portid->drpath.p[(portid->drpath.cnt-1)];\r
+}\r
+\r
+MAD_EXPORT char *\r
+portid2str(ib_portid_t *portid)\r
+{\r
+       static char buf[1024] = "local";\r
+       int n = 0;\r
+\r
+       if (portid->lid > 0) {\r
+               n += sprintf(buf + n, "Lid %d", portid->lid);\r
+               if (portid->grh_present) {\r
+                       char gid[sizeof "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"];\r
+                       if (inet_ntop(AF_INET6, portid->gid, gid, sizeof(gid)))\r
+                               n += sprintf(buf + n, " Gid %s", gid);\r
+               }\r
+               if (portid->drpath.cnt)\r
+                       n += sprintf(buf + n, " ");\r
+               else\r
+                       return buf;\r
+       }\r
+       n += sprintf(buf + n, "DR path ");\r
+       drpath2str(&(portid->drpath), buf + n, sizeof(buf) - n);\r
+\r
+       return buf;\r
+}\r
+\r
+MAD_EXPORT int\r
+str2drpath(ib_dr_path_t *path, char *routepath, int drslid, int drdlid)\r
+{\r
+       char *s, *str = routepath;\r
+\r
+       path->cnt = -1;\r
+\r
+       DEBUG("DR str: %s", routepath);\r
+       while (str && *str) {\r
+               if ((s = strchr(str, ',')))\r
+                       *s = 0;\r
+               path->p[++path->cnt] = (uint8_t)atoi(str);\r
+               if (!s)\r
+                       break;\r
+               str = s+1;\r
+       }\r
+\r
+       path->drdlid = drdlid ? drdlid : 0xffff;\r
+       path->drslid = drslid ? drslid : 0xffff;\r
+\r
+       return path->cnt;\r
+}\r
+\r
+MAD_EXPORT char *\r
+drpath2str(ib_dr_path_t *path, char *dstr, size_t dstr_size)\r
+{\r
+       int i = 0;\r
+       int rc = snprintf(dstr, dstr_size, "slid %d; dlid %d; %d",\r
+               path->drslid, path->drdlid, path->p[0]);\r
+       if (rc >= (int) dstr_size)\r
+               return dstr;\r
+       for (i = 1; i <= path->cnt; i++) {\r
+               rc += snprintf(dstr+rc, dstr_size-rc, ",%d", path->p[i]);\r
+               if (rc >= (int) dstr_size)\r
+                       break;\r
+       }\r
+       return (dstr);\r
+}\r
diff --git a/ulp/libibmad/src/register.c b/ulp/libibmad/src/register.c
new file mode 100644 (file)
index 0000000..856c69c
--- /dev/null
@@ -0,0 +1,203 @@
+/*\r
+ * Copyright (c) 2004,2005 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include "mad.h"\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+#define MAX_CLASS      256\r
+#define MAX_AGENTS     256\r
+\r
+static int class_agent[MAX_CLASS];\r
+static int agent_class[MAX_AGENTS];\r
+\r
+static int\r
+register_agent(int agent, int mclass)\r
+{\r
+       static int initialized;\r
+\r
+       if (!initialized) {\r
+               initialized++;\r
+               memset(class_agent, 0xff, sizeof class_agent);\r
+               memset(agent_class, 0xff, sizeof agent_class);\r
+       }\r
+\r
+       if (mclass < 0 || mclass >= MAX_CLASS ||\r
+           agent < 0 || agent >= MAX_AGENTS) {\r
+               DEBUG("bad mgmt class %d or agent %d", mclass, agent);\r
+               return -1;\r
+       }\r
+\r
+       class_agent[mclass] = agent;\r
+       agent_class[agent] = mclass;\r
+\r
+       return 0;\r
+}\r
+\r
+static int\r
+mgmt_class_vers(int mgmt_class)\r
+{\r
+       if ((mgmt_class >= IB_VENDOR_RANGE1_START_CLASS &&\r
+            mgmt_class <= IB_VENDOR_RANGE1_END_CLASS) ||\r
+           (mgmt_class >= IB_VENDOR_RANGE2_START_CLASS &&\r
+            mgmt_class <= IB_VENDOR_RANGE2_END_CLASS))\r
+               return 1;\r
+\r
+       switch(mgmt_class) {\r
+               case IB_SMI_CLASS:\r
+               case IB_SMI_DIRECT_CLASS:\r
+                       return 1;\r
+               case IB_SA_CLASS:\r
+                       return 2;\r
+               case IB_PERFORMANCE_CLASS:\r
+                       return 1;\r
+               case IB_DEVICE_MGMT_CLASS:\r
+                       return 1;\r
+               case IB_CC_CLASS:\r
+                       return 2;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_class_agent(int mgmt)\r
+{\r
+       if (mgmt < 1 || mgmt > MAX_CLASS)\r
+               return -1;\r
+       return class_agent[mgmt];\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_agent_class(int agent)\r
+{\r
+       if (agent < 1 || agent > MAX_AGENTS)\r
+               return -1;\r
+       return agent_class[agent];\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_register_port_client(int port_id, int mgmt, uint8_t rmpp_version)\r
+{\r
+       int vers, agent;\r
+\r
+       if ((vers = mgmt_class_vers(mgmt)) <= 0) {\r
+               DEBUG("Unknown class %d mgmt_class", mgmt);\r
+               return -1;\r
+       }\r
+       if ((agent = umad_register(port_id, mgmt,\r
+                                  vers, rmpp_version, 0)) < 0) {\r
+               DEBUG("Can't register agent for class %d", mgmt);\r
+               return -1;\r
+       }\r
+\r
+       if (mgmt < 0 || mgmt >= MAX_CLASS || agent >= MAX_AGENTS) {\r
+               DEBUG("bad mgmt class %d or agent %d", mgmt, agent);\r
+               return -1;\r
+       }\r
+\r
+       return agent;\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_register_client(int mgmt, uint8_t rmpp_version)\r
+{\r
+       int agent;\r
+\r
+       agent = mad_register_port_client(madrpc_portid(), mgmt, rmpp_version);\r
+       if (agent < 0)\r
+               return agent;\r
+\r
+       return register_agent(agent, mgmt);\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_register_server(int mgmt, uint8_t rmpp_version,\r
+                   long method_mask[], uint32_t class_oui)\r
+{\r
+       long class_method_mask[16/sizeof(long)];\r
+       uint8_t oui[3];\r
+       int agent, vers, mad_portid;\r
+\r
+       if (method_mask)\r
+               memcpy(class_method_mask, method_mask, sizeof class_method_mask);\r
+       else\r
+               memset(class_method_mask, 0xff, sizeof(class_method_mask));\r
+\r
+       if ((mad_portid = madrpc_portid()) < 0)\r
+               return -1;\r
+\r
+       if (class_agent[mgmt] >= 0) {\r
+               DEBUG("Class 0x%x already registered", mgmt);\r
+               return -1;\r
+       }\r
+       if ((vers = mgmt_class_vers(mgmt)) <= 0) {\r
+               DEBUG("Unknown class 0x%x mgmt_class", mgmt);\r
+               return -1;\r
+       }\r
+       if (mgmt >= IB_VENDOR_RANGE2_START_CLASS &&\r
+           mgmt <= IB_VENDOR_RANGE2_END_CLASS) {\r
+               oui[0] = (class_oui >> 16) & 0xff;\r
+               oui[1] = (class_oui >> 8) & 0xff;\r
+               oui[2] = class_oui & 0xff;\r
+               if ((agent = umad_register_oui(mad_portid, mgmt, rmpp_version,\r
+                                              oui, class_method_mask)) < 0) {\r
+                       DEBUG("Can't register agent for class %d", mgmt);\r
+                       return -1;\r
+               }\r
+       } else if ((agent = umad_register(mad_portid, mgmt, vers, rmpp_version,\r
+                                         class_method_mask)) < 0) {\r
+               DEBUG("Can't register agent for class %d", mgmt);\r
+               return -1;\r
+       }\r
+\r
+       if (register_agent(agent, mgmt) < 0)\r
+               return -1;\r
+\r
+       return agent;\r
+}\r
diff --git a/ulp/libibmad/src/resolve.c b/ulp/libibmad/src/resolve.c
new file mode 100644 (file)
index 0000000..d567557
--- /dev/null
@@ -0,0 +1,193 @@
+/*\r
+ * Copyright (c) 2004-2006 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#define strtoull _strtoui64\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <string.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+int\r
+ib_resolve_smlid_via(ib_portid_t *sm_id, int timeout, const void *srcport)\r
+{\r
+       ib_portid_t self = {0};\r
+       uint8_t portinfo[64];\r
+       int lid;\r
+\r
+       memset(sm_id, 0, sizeof(*sm_id));\r
+\r
+       if (!smp_query_via(portinfo, &self, IB_ATTR_PORT_INFO,\r
+                          0, 0, srcport))\r
+               return -1;\r
+\r
+       mad_decode_field(portinfo, IB_PORT_SMLID_F, &lid);\r
+\r
+       return ib_portid_set(sm_id, lid, 0, 0);\r
+}\r
+\r
+MAD_EXPORT int\r
+ib_resolve_smlid(ib_portid_t *sm_id, int timeout)\r
+{\r
+       return ib_resolve_smlid_via(sm_id, timeout, NULL);\r
+}\r
+\r
+int\r
+ib_resolve_guid_via(ib_portid_t *portid, uint64_t *guid, ib_portid_t *sm_id, int timeout, const void *srcport)\r
+{\r
+       ib_portid_t sm_portid;\r
+       char buf[IB_SA_DATA_SIZE] = {0};\r
+\r
+       if (!sm_id) {\r
+               sm_id = &sm_portid;\r
+               if (ib_resolve_smlid_via(sm_id, timeout, srcport) < 0)\r
+                       return -1;\r
+       }\r
+       if (*(uint64_t*)&portid->gid == 0)\r
+               mad_set_field64(portid->gid, 0, IB_GID_PREFIX_F, IB_DEFAULT_SUBN_PREFIX);\r
+       if (guid)\r
+               mad_set_field64(portid->gid, 0, IB_GID_GUID_F, *guid);\r
+\r
+       if ((portid->lid = ib_path_query_via(srcport, portid->gid, portid->gid, sm_id, buf)) < 0)\r
+               return -1;\r
+\r
+       return 0;\r
+}\r
+\r
+MAD_EXPORT int\r
+ib_resolve_guid(ib_portid_t *portid, uint64_t *guid, ib_portid_t *sm_id, int timeout)\r
+{\r
+       return ib_resolve_guid_via(portid, guid, sm_id, timeout, NULL);\r
+}\r
+\r
+int\r
+ib_resolve_portid_str_via(ib_portid_t *portid, char *addr_str, int dest_type, ib_portid_t *sm_id, const void *srcport)\r
+{\r
+       uint64_t guid;\r
+       int lid;\r
+       char *routepath;\r
+       ib_portid_t selfportid = {0};\r
+       int selfport = 0;\r
+\r
+       switch (dest_type) {\r
+       case IB_DEST_LID:\r
+               lid = strtol(addr_str, 0, 0);\r
+               if (!IB_LID_VALID(lid))\r
+                       return -1;\r
+               return ib_portid_set(portid, lid, 0, 0);\r
+\r
+       case IB_DEST_DRPATH:\r
+               if (str2drpath(&portid->drpath, addr_str, 0, 0) < 0)\r
+                       return -1;\r
+               return 0;\r
+\r
+       case IB_DEST_GUID:\r
+               if (!(guid = strtoull(addr_str, 0, 0)))\r
+                       return -1;\r
+\r
+               /* keep guid in portid? */\r
+               return ib_resolve_guid_via(portid, &guid, sm_id, 0, srcport);\r
+\r
+       case IB_DEST_DRSLID:\r
+               lid = strtol(addr_str, &routepath, 0);\r
+               routepath++;\r
+               if (!IB_LID_VALID(lid))\r
+                       return -1;\r
+               ib_portid_set(portid, lid, 0, 0);\r
+\r
+               /* handle DR parsing and set DrSLID to local lid */\r
+               if (ib_resolve_self_via(&selfportid, &selfport, 0, srcport) < 0)\r
+                       return -1;\r
+               if (str2drpath(&portid->drpath, routepath, selfportid.lid, 0) < 0)\r
+                       return -1;\r
+               return 0;\r
+\r
+       default:\r
+               IBWARN("bad dest_type %d", dest_type);\r
+       }\r
+\r
+       return -1;\r
+}\r
+\r
+MAD_EXPORT int\r
+ib_resolve_portid_str(ib_portid_t *portid, char *addr_str, int dest_type, ib_portid_t *sm_id)\r
+{\r
+       return ib_resolve_portid_str_via(portid, addr_str, dest_type,\r
+                                        sm_id, NULL);\r
+}\r
+\r
+int\r
+ib_resolve_self_via(ib_portid_t *portid, int *portnum, ibmad_gid_t *gid,\r
+                   const void *srcport)\r
+{\r
+       ib_portid_t self = {0};\r
+       uint8_t portinfo[64];\r
+       uint8_t nodeinfo[64];\r
+       uint64_t guid, prefix;\r
+\r
+       if (!smp_query_via(nodeinfo, &self, IB_ATTR_NODE_INFO, 0, 0, srcport))\r
+               return -1;\r
+\r
+       if (!smp_query_via(portinfo, &self, IB_ATTR_PORT_INFO, 0, 0, srcport))\r
+               return -1;\r
+\r
+       mad_decode_field(portinfo, IB_PORT_LID_F, &portid->lid);\r
+       mad_decode_field(portinfo, IB_PORT_GID_PREFIX_F, &prefix);\r
+       mad_decode_field(nodeinfo, IB_NODE_PORT_GUID_F, &guid);\r
+\r
+       if (portnum)\r
+               mad_decode_field(nodeinfo, IB_NODE_LOCAL_PORT_F, portnum);\r
+       if (gid) {\r
+               mad_encode_field(*gid, IB_GID_PREFIX_F, &prefix);\r
+               mad_encode_field(*gid, IB_GID_GUID_F, &guid);\r
+       }\r
+       return 0;\r
+}\r
+\r
+MAD_EXPORT int\r
+ib_resolve_self(ib_portid_t *portid, int *portnum, ibmad_gid_t *gid)\r
+{\r
+       return ib_resolve_self_via (portid, portnum, gid, NULL);\r
+}\r
diff --git a/ulp/libibmad/src/rpc.c b/ulp/libibmad/src/rpc.c
new file mode 100644 (file)
index 0000000..aa01f54
--- /dev/null
@@ -0,0 +1,406 @@
+/*\r
+ * Copyright (c) 2004-2006 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <errno.h>\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include "mad.h"\r
+#include <complib/cl_passivelock.h>\r
+\r
+#define MAX_CLASS 256\r
+\r
+struct ibmad_port {\r
+       int port_id;  /* file descriptor returned by umad_open() */\r
+       int class_agents[MAX_CLASS]; /* class2agent mapper */\r
+};\r
+\r
+int ibdebug;\r
+\r
+static int mad_portid = -1;\r
+static int iberrs;\r
+\r
+static int madrpc_retries = MAD_DEF_RETRIES;\r
+static int def_madrpc_timeout = MAD_DEF_TIMEOUT_MS;\r
+static void *save_mad;\r
+static int save_mad_len = 256;\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+#define ERRS   if (iberrs || ibdebug)  IBWARN\r
+\r
+#define MAD_TID(mad)   (*((uint64_t *)((char *)(mad) + 8)))\r
+\r
+MAD_EXPORT void\r
+madrpc_show_errors(int set)\r
+{\r
+       iberrs = set;\r
+}\r
+\r
+void\r
+madrpc_save_mad(void *madbuf, int len)\r
+{\r
+       save_mad = madbuf;\r
+       save_mad_len = len;\r
+}\r
+\r
+MAD_EXPORT int\r
+madrpc_set_retries(int retries)\r
+{\r
+       if (retries > 0)\r
+               madrpc_retries = retries;\r
+       return madrpc_retries;\r
+}\r
+\r
+MAD_EXPORT int\r
+madrpc_set_timeout(int timeout)\r
+{\r
+       def_madrpc_timeout = timeout;\r
+       return 0;\r
+}\r
+\r
+int\r
+madrpc_def_timeout(void)\r
+{\r
+       return def_madrpc_timeout;\r
+}\r
+\r
+MAD_EXPORT int\r
+madrpc_portid(void)\r
+{\r
+       return mad_portid;\r
+}\r
+\r
+static int\r
+_do_madrpc(int port_id, void *sndbuf, void *rcvbuf, int agentid, int len,\r
+          int timeout)\r
+{\r
+       uint32_t trid; /* only low 32 bits */\r
+       int retries;\r
+       int length, status;\r
+\r
+       if (!timeout)\r
+               timeout = def_madrpc_timeout;\r
+\r
+       if (ibdebug > 1) {\r
+               IBWARN(">>> sending: len %d pktsz %zu", len, umad_size() + len);\r
+               xdump(stderr, "send buf\n", sndbuf, umad_size() + len);\r
+       }\r
+\r
+       if (save_mad) {\r
+               memcpy(save_mad, umad_get_mad(sndbuf),\r
+                      save_mad_len < len ? save_mad_len : len);\r
+               save_mad = 0;\r
+       }\r
+\r
+       trid = (uint32_t)mad_get_field64(umad_get_mad(sndbuf), 0, IB_MAD_TRID_F);\r
+\r
+       for (retries = 0; retries < madrpc_retries; retries++) {\r
+               if (retries) {\r
+                       ERRS("retry %d (timeout %d ms)", retries, timeout);\r
+               }\r
+\r
+               length = len;\r
+               if (umad_send(port_id, agentid, sndbuf, length, timeout, 0) < 0) {\r
+                       IBWARN("send failed; %m");\r
+                       return -1;\r
+               }\r
+\r
+               /* Use same timeout on receive side just in case */\r
+               /* send packet is lost somewhere. */\r
+               do {\r
+                       if (umad_recv(port_id, rcvbuf, &length, timeout) < 0) {\r
+                               IBWARN("recv failed: %m");\r
+                               return -1;\r
+                       }\r
+\r
+                       if (ibdebug > 1) {\r
+                               IBWARN("rcv buf:");\r
+                               xdump(stderr, "rcv buf\n", umad_get_mad(rcvbuf), IB_MAD_SIZE);\r
+                       }\r
+               } while ((uint32_t)mad_get_field64(umad_get_mad(rcvbuf), 0, IB_MAD_TRID_F) != trid);\r
+\r
+               status = umad_status(rcvbuf);\r
+               if (!status)\r
+                       return length;          /* done */\r
+               if (status == ENOMEM)\r
+                       return length;\r
+       }\r
+\r
+       ERRS("timeout after %d retries, %d ms", retries, timeout * retries);\r
+       return -1;\r
+}\r
+\r
+void *\r
+mad_rpc(const void *port_id, ib_rpc_t *rpc, ib_portid_t *dport, void *payload,\r
+       void *rcvdata)\r
+{\r
+       const struct ibmad_port *p = port_id;\r
+       int status, len;\r
+       uint8_t sndbuf[1024], rcvbuf[1024], *mad;\r
+\r
+       len = 0;\r
+       memset(sndbuf, 0, umad_size() + IB_MAD_SIZE);\r
+\r
+       if ((len = mad_build_pkt(sndbuf, rpc, dport, 0, payload)) < 0)\r
+               return 0;\r
+\r
+       if ((len = _do_madrpc(p->port_id, sndbuf, rcvbuf,\r
+                             p->class_agents[rpc->mgtclass],\r
+                             len, rpc->timeout)) < 0) {\r
+               IBWARN("_do_madrpc failed; dport (%s)", portid2str(dport));\r
+               return 0;\r
+       }\r
+\r
+       mad = umad_get_mad(rcvbuf);\r
+\r
+       if ((status = mad_get_field(mad, 0, IB_DRSMP_STATUS_F)) != 0) {\r
+               ERRS("MAD completed with error status 0x%x; dport (%s)",\r
+                       status, portid2str(dport));\r
+               return 0;\r
+       }\r
+\r
+       if (ibdebug) {\r
+               IBWARN("data offs %d sz %d", rpc->dataoffs, rpc->datasz);\r
+               xdump(stderr, "mad data\n", mad + rpc->dataoffs, rpc->datasz);\r
+       }\r
+\r
+       if (rcvdata)\r
+               memcpy(rcvdata, mad + rpc->dataoffs, rpc->datasz);\r
+\r
+       return rcvdata;\r
+}\r
+\r
+void *\r
+mad_rpc_rmpp(const void *port_id, ib_rpc_t *rpc, ib_portid_t *dport,\r
+            ib_rmpp_hdr_t *rmpp, void *data)\r
+{\r
+       const struct ibmad_port *p = port_id;\r
+       int status, len;\r
+       uint8_t sndbuf[1024], rcvbuf[1024], *mad;\r
+\r
+       memset(sndbuf, 0, umad_size() + IB_MAD_SIZE);\r
+\r
+       DEBUG("rmpp %p data %p", rmpp, data);\r
+\r
+       if ((len = mad_build_pkt(sndbuf, rpc, dport, rmpp, data)) < 0)\r
+               return 0;\r
+\r
+       if ((len = _do_madrpc(p->port_id, sndbuf, rcvbuf,\r
+                             p->class_agents[rpc->mgtclass],\r
+                             len, rpc->timeout)) < 0) {\r
+               IBWARN("_do_madrpc failed; dport (%s)", portid2str(dport));\r
+               return 0;\r
+       }\r
+\r
+       mad = umad_get_mad(rcvbuf);\r
+\r
+       if ((status = mad_get_field(mad, 0, IB_MAD_STATUS_F)) != 0) {\r
+               ERRS("MAD completed with error status 0x%x; dport (%s)",\r
+                       status, portid2str(dport));\r
+               return 0;\r
+       }\r
+\r
+       if (ibdebug) {\r
+               IBWARN("data offs %d sz %d", rpc->dataoffs, rpc->datasz);\r
+               xdump(stderr, "rmpp mad data\n", mad + rpc->dataoffs,\r
+                     rpc->datasz);\r
+       }\r
+\r
+       if (rmpp) {\r
+               rmpp->flags = mad_get_field(mad, 0, IB_SA_RMPP_FLAGS_F);\r
+               if ((rmpp->flags & 0x3) &&\r
+                   mad_get_field(mad, 0, IB_SA_RMPP_VERS_F) != 1) {\r
+                       IBWARN("bad rmpp version");\r
+                       return 0;\r
+               }\r
+               rmpp->type = mad_get_field(mad, 0, IB_SA_RMPP_TYPE_F);\r
+               rmpp->status = mad_get_field(mad, 0, IB_SA_RMPP_STATUS_F);\r
+               DEBUG("rmpp type %d status %d", rmpp->type, rmpp->status);\r
+               rmpp->d1.u = mad_get_field(mad, 0, IB_SA_RMPP_D1_F);\r
+               rmpp->d2.u = mad_get_field(mad, 0, IB_SA_RMPP_D2_F);\r
+       }\r
+\r
+       if (data)\r
+               memcpy(data, mad + rpc->dataoffs, rpc->datasz);\r
+\r
+       rpc->recsz = mad_get_field(mad, 0, IB_SA_ATTROFFS_F);\r
+\r
+       return data;\r
+}\r
+\r
+void *\r
+madrpc(ib_rpc_t *rpc, ib_portid_t *dport, void *payload, void *rcvdata)\r
+{\r
+       struct ibmad_port port;\r
+\r
+       port.port_id = mad_portid;\r
+       port.class_agents[rpc->mgtclass] = mad_class_agent(rpc->mgtclass);\r
+       return mad_rpc(&port, rpc, dport, payload, rcvdata);\r
+}\r
+\r
+void *\r
+madrpc_rmpp(ib_rpc_t *rpc, ib_portid_t *dport, ib_rmpp_hdr_t *rmpp, void *data)\r
+{\r
+       struct ibmad_port port;\r
+\r
+       port.port_id = mad_portid;\r
+       port.class_agents[rpc->mgtclass] = mad_class_agent(rpc->mgtclass);\r
+       return mad_rpc_rmpp(&port, rpc, dport, rmpp, data);\r
+}\r
+\r
+static cl_plock_t rpclock;\r
+\r
+void\r
+madrpc_lock(void)\r
+{\r
+       cl_plock_acquire(&rpclock);\r
+}\r
+\r
+void\r
+madrpc_unlock(void)\r
+{\r
+       cl_plock_release(&rpclock);\r
+}\r
+\r
+MAD_EXPORT void\r
+madrpc_init(char *dev_name, int dev_port, int *mgmt_classes, int num_classes)\r
+{\r
+       if (umad_init() < 0)\r
+               IBPANIC("can't init UMAD library");\r
+\r
+       if ((mad_portid = umad_open_port(dev_name, dev_port)) < 0)\r
+               IBPANIC("can't open UMAD port (%s:%d)", dev_name, dev_port);\r
+\r
+       if (num_classes >= MAX_CLASS)\r
+               IBPANIC("too many classes %d requested", num_classes);\r
+\r
+       while (num_classes--) {\r
+               uint8_t rmpp_version = 0;\r
+               int mgmt = *mgmt_classes++;\r
+\r
+               if (mgmt == IB_SA_CLASS)\r
+                       rmpp_version = 1;\r
+               if (mad_register_client(mgmt, rmpp_version) < 0)\r
+                       IBPANIC("client_register for mgmt class %d failed", mgmt);\r
+       }\r
+       cl_plock_init(&rpclock);\r
+}\r
+\r
+void *\r
+mad_rpc_open_port(char *dev_name, int dev_port,\r
+                 int *mgmt_classes, int num_classes)\r
+{\r
+       struct ibmad_port *p;\r
+       int port_id;\r
+\r
+       if (num_classes >= MAX_CLASS) {\r
+               IBWARN("too many classes %d requested", num_classes);\r
+               errno = EINVAL;\r
+               return NULL;\r
+       }\r
+\r
+       if (umad_init() < 0) {\r
+               IBWARN("can't init UMAD library");\r
+               errno = ENODEV;\r
+               return NULL;\r
+       }\r
+\r
+       p = malloc(sizeof(*p));\r
+       if (!p) {\r
+               errno = ENOMEM;\r
+               return NULL;\r
+       }\r
+       memset(p, 0, sizeof(*p));\r
+\r
+       if ((port_id = umad_open_port(dev_name, dev_port)) < 0) {\r
+               IBWARN("can't open UMAD port (%s:%d)", dev_name, dev_port);\r
+               if (!errno)\r
+                       errno = EIO;\r
+               free(p);\r
+               return NULL;\r
+       }\r
+\r
+       while (num_classes--) {\r
+               uint8_t rmpp_version = 0;\r
+               int mgmt = *mgmt_classes++;\r
+               int agent;\r
+\r
+               if (mgmt == IB_SA_CLASS)\r
+                       rmpp_version = 1;\r
+               if (mgmt < 0 || mgmt >= MAX_CLASS ||\r
+                   (agent = mad_register_port_client(port_id, mgmt,\r
+                                                     rmpp_version)) < 0) {\r
+                       IBWARN("client_register for mgmt %d failed", mgmt);\r
+                       if(!errno)\r
+                               errno = EINVAL;\r
+                       umad_close_port(port_id);\r
+                       free(p);\r
+                       return NULL;\r
+               }\r
+               p->class_agents[mgmt] = agent;\r
+       }\r
+\r
+       p->port_id = port_id;\r
+       return p;\r
+}\r
+\r
+void\r
+mad_rpc_close_port(void *port_id)\r
+{\r
+       struct ibmad_port *p = port_id;\r
+\r
+       umad_close_port(p->port_id);\r
+       free(p);\r
+}\r
+\r
+uint8_t *\r
+sa_call(void *rcvbuf, ib_portid_t *portid, ib_sa_call_t *sa, unsigned timeout)\r
+{\r
+       struct ibmad_port port;\r
+\r
+       port.port_id = mad_portid;\r
+       port.class_agents[IB_SA_CLASS] = mad_class_agent(IB_SA_CLASS);\r
+       return sa_rpc_call(&port, rcvbuf, portid, sa, timeout);\r
+}\r
diff --git a/ulp/libibmad/src/sa.c b/ulp/libibmad/src/sa.c
new file mode 100644 (file)
index 0000000..ae973e1
--- /dev/null
@@ -0,0 +1,153 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <string.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+uint8_t *\r
+sa_rpc_call(const void *ibmad_port, void *rcvbuf, ib_portid_t *portid,\r
+           ib_sa_call_t *sa, unsigned timeout)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+       uint8_t *p;\r
+\r
+       DEBUG("attr 0x%x mod 0x%x route %s", sa->attrid, sa->mod,\r
+             portid2str(portid));\r
+\r
+       if (portid->lid <= 0) {\r
+               IBWARN("only lid routes are supported");\r
+               return 0;\r
+       }\r
+\r
+       rpc.mgtclass = IB_SA_CLASS;\r
+       rpc.method = sa->method;\r
+       rpc.attr.id = sa->attrid;\r
+       rpc.attr.mod = sa->mod;\r
+       rpc.mask = sa->mask;\r
+       rpc.timeout = timeout;\r
+       rpc.datasz = IB_SA_DATA_SIZE;\r
+       rpc.dataoffs = IB_SA_DATA_OFFS;\r
+       rpc.trid = sa->trid;\r
+\r
+       portid->qp = 1;\r
+       if (!portid->qkey)\r
+               portid->qkey = IB_DEFAULT_QP1_QKEY;\r
+\r
+       p = mad_rpc_rmpp(ibmad_port, &rpc, portid, 0/*&sa->rmpp*/, rcvbuf);     /* TODO: RMPP */\r
+\r
+       sa->recsz = rpc.recsz;\r
+\r
+       return p;\r
+}\r
+\r
+/* PathRecord */\r
+#define IB_PR_COMPMASK_DGID                            (1ull<<2)\r
+#define IB_PR_COMPMASK_SGID                            (1ull<<3)\r
+#define IB_PR_COMPMASK_DLID                            (1ull<<4)\r
+#define        IB_PR_COMPMASK_SLID                             (1ull<<5)\r
+#define        IB_PR_COMPMASK_RAWTRAFIC                        (1ull<<6)\r
+#define        IB_PR_COMPMASK_RESV0                            (1ull<<7)\r
+#define        IB_PR_COMPMASK_FLOWLABEL                        (1ull<<8)\r
+#define        IB_PR_COMPMASK_HOPLIMIT                         (1ull<<9)\r
+#define        IB_PR_COMPMASK_TCLASS                           (1ull<<10)\r
+#define        IB_PR_COMPMASK_REVERSIBLE                       (1ull<<11)\r
+#define        IB_PR_COMPMASK_NUMBPATH                         (1ull<<12)\r
+#define        IB_PR_COMPMASK_PKEY                             (1ull<<13)\r
+#define        IB_PR_COMPMASK_RESV1                            (1ull<<14)\r
+#define        IB_PR_COMPMASK_SL                               (1ull<<15)\r
+#define        IB_PR_COMPMASK_MTUSELEC                         (1ull<<16)\r
+#define        IB_PR_COMPMASK_MTU                              (1ull<<17)\r
+#define        IB_PR_COMPMASK_RATESELEC                        (1ull<<18)\r
+#define        IB_PR_COMPMASK_RATE                             (1ull<<19)\r
+#define        IB_PR_COMPMASK_PKTLIFETIMESELEC                 (1ull<<20)\r
+#define        IB_PR_COMPMASK_PKTLIFETIME                      (1ull<<21)\r
+#define        IB_PR_COMPMASK_PREFERENCE                       (1ull<<22)\r
+\r
+#define IB_PR_DEF_MASK (IB_PR_COMPMASK_DGID |\\r
+                       IB_PR_COMPMASK_SGID |\\r
+                       IB_PR_COMPMASK_NUMBPATH)\r
+\r
+int\r
+ib_path_query_via(const void *srcport, ibmad_gid_t srcgid, ibmad_gid_t destgid, ib_portid_t *sm_id, void *buf)\r
+{\r
+       int npath;\r
+       ib_sa_call_t sa = {0};\r
+       uint8_t *p;\r
+       int dlid;\r
+\r
+       npath = 1;                      /* only MAD_METHOD_GET is supported */\r
+       memset(&sa, 0, sizeof sa);\r
+       sa.method = IB_MAD_METHOD_GET;\r
+       sa.attrid = IB_SA_ATTR_PATHRECORD;\r
+       sa.mask = IB_PR_DEF_MASK;\r
+       sa.trid = mad_trid();\r
+\r
+       memset(buf, 0, IB_SA_PR_RECSZ);\r
+\r
+       mad_encode_field(buf, IB_SA_PR_NPATH_F, &npath);\r
+       mad_encode_field(buf, IB_SA_PR_DGID_F, destgid);\r
+       mad_encode_field(buf, IB_SA_PR_SGID_F, srcgid);\r
+\r
+       if (srcport) {\r
+               p = sa_rpc_call (srcport, buf, sm_id, &sa, 0);\r
+       } else {\r
+               p = safe_sa_call(buf, sm_id, &sa, 0);\r
+       }\r
+       if (!p) {\r
+               IBWARN("sa call path_query failed");\r
+               return -1;\r
+       }\r
+\r
+       mad_decode_field(p, IB_SA_PR_DLID_F, &dlid);\r
+       return dlid;\r
+}\r
+\r
+MAD_EXPORT int\r
+ib_path_query(ibmad_gid_t srcgid, ibmad_gid_t destgid, ib_portid_t *sm_id, void *buf)\r
+{\r
+       return ib_path_query_via (NULL, srcgid, destgid, sm_id, buf);\r
+}\r
diff --git a/ulp/libibmad/src/serv.c b/ulp/libibmad/src/serv.c
new file mode 100644 (file)
index 0000000..5437720
--- /dev/null
@@ -0,0 +1,184 @@
+/*\r
+ * Copyright (c) 2004,2005 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#else\r
+#include <unistd.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#include <string.h>\r
+#include <netinet/in.h>\r
+#endif\r
+\r
+#include <infiniband/umad.h>\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+MAD_EXPORT int\r
+mad_send(ib_rpc_t *rpc, ib_portid_t *dport, ib_rmpp_hdr_t *rmpp, void *data)\r
+{\r
+       uint8_t pktbuf[1024];\r
+       void *umad = pktbuf;\r
+\r
+       memset(pktbuf, 0, umad_size());\r
+\r
+       DEBUG("rmpp %p data %p", rmpp, data);\r
+\r
+       if (mad_build_pkt(umad, rpc, dport, rmpp, data) < 0)\r
+               return 0;\r
+\r
+       if (ibdebug) {\r
+               IBWARN("data offs %d sz %d", rpc->dataoffs, rpc->datasz);\r
+               xdump(stderr, "mad send data\n",\r
+                       (char *)umad_get_mad(umad) + rpc->dataoffs, rpc->datasz);\r
+       }\r
+\r
+       if (umad_send(madrpc_portid(), mad_class_agent(rpc->mgtclass),\r
+                     umad, IB_MAD_SIZE, rpc->timeout, 0) < 0) {\r
+               IBWARN("send failed; %m");\r
+               return -1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+MAD_EXPORT int\r
+mad_respond(void *umad, ib_portid_t *portid, uint32_t rstatus)\r
+{\r
+       uint8_t *mad = umad_get_mad(umad);\r
+       ib_mad_addr_t *mad_addr;\r
+       ib_rpc_t rpc = {0};\r
+       ib_portid_t rport;\r
+       int is_smi;\r
+\r
+       if (!portid) {\r
+               if (!(mad_addr = umad_get_mad_addr(umad)))\r
+                       return -1;\r
+\r
+               memset(&rport, 0, sizeof(rport));\r
+\r
+               rport.lid = ntohs(mad_addr->lid);\r
+               rport.qp = ntohl(mad_addr->qpn);\r
+               rport.qkey = ntohl(mad_addr->qkey);\r
+               rport.sl = mad_addr->sl;\r
+\r
+               portid = &rport;\r
+       }\r
+\r
+       DEBUG("dest %s", portid2str(portid));\r
+\r
+       rpc.mgtclass = mad_get_field(mad, 0, IB_MAD_MGMTCLASS_F);\r
+\r
+       rpc.method = mad_get_field(mad, 0, IB_MAD_METHOD_F);\r
+       if (rpc.method == IB_MAD_METHOD_SET)\r
+               rpc.method = IB_MAD_METHOD_GET;\r
+       if (rpc.method != IB_MAD_METHOD_SEND)\r
+               rpc.method |= IB_MAD_RESPONSE;\r
+\r
+       rpc.attr.id = mad_get_field(mad, 0, IB_MAD_ATTRID_F);\r
+       rpc.attr.mod = mad_get_field(mad, 0, IB_MAD_ATTRMOD_F);\r
+       if (rpc.mgtclass == IB_SA_CLASS)\r
+               rpc.recsz = mad_get_field(mad, 0, IB_SA_ATTROFFS_F);\r
+       if (mad_is_vendor_range2(rpc.mgtclass))\r
+               rpc.oui = mad_get_field(mad, 0, IB_VEND2_OUI_F);\r
+\r
+       rpc.trid = mad_get_field64(mad, 0, IB_MAD_TRID_F);\r
+\r
+       /* cleared by default: timeout, datasz, dataoffs, mkey, mask */\r
+\r
+       is_smi = rpc.mgtclass == IB_SMI_CLASS ||\r
+                rpc.mgtclass == IB_SMI_DIRECT_CLASS;\r
+\r
+       if (is_smi)\r
+               portid->qp = 0;\r
+       else if (!portid->qp)\r
+                portid->qp = 1;\r
+\r
+       if (!portid->qkey && portid->qp == 1)\r
+               portid->qkey = IB_DEFAULT_QP1_QKEY;\r
+\r
+       DEBUG("qp 0x%x class 0x%x method %d attr 0x%x mod 0x%x datasz %d off %d qkey %x",\r
+               portid->qp, rpc.mgtclass, rpc.method, rpc.attr.id, rpc.attr.mod,\r
+               rpc.datasz, rpc.dataoffs, portid->qkey);\r
+\r
+       if (mad_build_pkt(umad, &rpc, portid, 0, 0) < 0)\r
+               return -1;\r
+\r
+       if (ibdebug > 1)\r
+               xdump(stderr, "mad respond pkt\n", mad, IB_MAD_SIZE);\r
+\r
+       if (umad_send(madrpc_portid(), mad_class_agent(rpc.mgtclass), umad,\r
+                     IB_MAD_SIZE, rpc.timeout, 0) < 0) {\r
+               DEBUG("send failed; %m");\r
+               return -1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+MAD_EXPORT void *\r
+mad_receive(void *umad, int timeout)\r
+{\r
+       void *mad = umad ? umad : umad_alloc(1, umad_size() + IB_MAD_SIZE);\r
+       int agent;\r
+       int length = IB_MAD_SIZE;\r
+\r
+       if ((agent = umad_recv(madrpc_portid(), mad,\r
+                              &length, timeout)) < 0) {\r
+               if (!umad)\r
+                       umad_free(mad);\r
+               DEBUG("recv failed: %m");\r
+               return 0;\r
+       }\r
+\r
+       return mad;\r
+}\r
+\r
+MAD_EXPORT void *\r
+mad_alloc(void)\r
+{\r
+       return umad_alloc(1, umad_size() + IB_MAD_SIZE);\r
+}\r
+\r
+MAD_EXPORT void\r
+mad_free(void *umad)\r
+{\r
+       umad_free(umad);\r
+}\r
diff --git a/ulp/libibmad/src/smp.c b/ulp/libibmad/src/smp.c
new file mode 100644 (file)
index 0000000..6cadbb1
--- /dev/null
@@ -0,0 +1,124 @@
+/*\r
+ * Copyright (c) 2004-2007 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#include <winsock2.h>\r
+#else\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+uint8_t *\r
+smp_set_via(void *data, ib_portid_t *portid, unsigned attrid, unsigned mod, unsigned timeout, const void *srcport)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+\r
+       DEBUG("attr 0x%x mod 0x%x route %s", attrid, mod, portid2str(portid));\r
+       if ((portid->lid <= 0) ||\r
+           (portid->drpath.drslid == 0xffff) ||\r
+           (portid->drpath.drdlid == 0xffff))\r
+               rpc.mgtclass = IB_SMI_DIRECT_CLASS;     /* direct SMI */\r
+       else\r
+               rpc.mgtclass = IB_SMI_CLASS;            /* Lid routed SMI */\r
+\r
+       rpc.method = IB_MAD_METHOD_SET;\r
+       rpc.attr.id = attrid;\r
+       rpc.attr.mod = mod;\r
+       rpc.timeout = timeout;\r
+       rpc.datasz = IB_SMP_DATA_SIZE;\r
+       rpc.dataoffs = IB_SMP_DATA_OFFS;\r
+\r
+       portid->sl = 0;\r
+       portid->qp = 0;\r
+\r
+       if (srcport) {\r
+               return mad_rpc(srcport, &rpc, portid, data, data);\r
+       } else {\r
+               return madrpc(&rpc, portid, data, data);\r
+       }\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+smp_set(void *data, ib_portid_t *portid, unsigned attrid, unsigned mod, unsigned timeout)\r
+{\r
+       return smp_set_via(data, portid, attrid, mod, timeout, NULL);\r
+}\r
+\r
+uint8_t *\r
+smp_query_via(void *rcvbuf, ib_portid_t *portid, unsigned attrid, unsigned mod,\r
+             unsigned timeout, const void *srcport)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+\r
+       DEBUG("attr 0x%x mod 0x%x route %s", attrid, mod, portid2str(portid));\r
+       rpc.method = IB_MAD_METHOD_GET;\r
+       rpc.attr.id = attrid;\r
+       rpc.attr.mod = mod;\r
+       rpc.timeout = timeout;\r
+       rpc.datasz = IB_SMP_DATA_SIZE;\r
+       rpc.dataoffs = IB_SMP_DATA_OFFS;\r
+\r
+       if ((portid->lid <= 0) ||\r
+           (portid->drpath.drslid == 0xffff) ||\r
+           (portid->drpath.drdlid == 0xffff))\r
+               rpc.mgtclass = IB_SMI_DIRECT_CLASS;     /* direct SMI */\r
+       else\r
+               rpc.mgtclass = IB_SMI_CLASS;            /* Lid routed SMI */\r
+\r
+       portid->sl = 0;\r
+       portid->qp = 0;\r
+\r
+       if (srcport) {\r
+               return mad_rpc(srcport, &rpc, portid, 0, rcvbuf);\r
+       } else {\r
+               return madrpc(&rpc, portid, 0, rcvbuf);\r
+       }\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+smp_query(void *rcvbuf, ib_portid_t *portid, unsigned attrid, unsigned mod,\r
+         unsigned timeout)\r
+{\r
+       return smp_query_via(rcvbuf, portid, attrid, mod, timeout, NULL);\r
+}\r
diff --git a/ulp/libibmad/src/vendor.c b/ulp/libibmad/src/vendor.c
new file mode 100644 (file)
index 0000000..cc2357b
--- /dev/null
@@ -0,0 +1,100 @@
+/*\r
+ * Copyright (c) 2004,2005 Voltaire Inc.  All rights reserved.\r
+ *\r
+ * This software is available to you under the OpenFabrics.org BSD license\r
+ * below:\r
+ *\r
+ *     Redistribution and use in source and binary forms, with or\r
+ *     without modification, are permitted provided that the following\r
+ *     conditions are met:\r
+ *\r
+ *      - Redistributions of source code must retain the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer.\r
+ *\r
+ *      - Redistributions in binary form must reproduce the above\r
+ *        copyright notice, this list of conditions and the following\r
+ *        disclaimer in the documentation and/or other materials\r
+ *        provided with the distribution.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
+ * SOFTWARE.\r
+ */\r
+\r
+\r
+#if HAVE_CONFIG_H\r
+#  include <config.h>\r
+#endif /* HAVE_CONFIG_H */\r
+\r
+#include <stdio.h>\r
+#include <stdlib.h>\r
+\r
+#if defined(_WIN32) || defined(_WIN64)\r
+#include <windows.h>\r
+#else\r
+#include <unistd.h>\r
+#include <string.h>\r
+#include <pthread.h>\r
+#include <sys/time.h>\r
+#endif\r
+\r
+#include <mad.h>\r
+\r
+#undef DEBUG\r
+#define DEBUG  if (ibdebug)    IBWARN\r
+\r
+static inline int\r
+response_expected(int method)\r
+{\r
+       return method == IB_MAD_METHOD_GET ||\r
+               method == IB_MAD_METHOD_SET ||\r
+               method == IB_MAD_METHOD_TRAP;\r
+}\r
+\r
+MAD_EXPORT uint8_t *\r
+ib_vendor_call(void *data, ib_portid_t *portid, ib_vendor_call_t *call)\r
+{\r
+       ib_rpc_t rpc = {0};\r
+       int range1 = 0, resp_expected;\r
+\r
+       DEBUG("route %s data %p", portid2str(portid), data);\r
+       if (portid->lid <= 0)\r
+               return 0;       /* no direct SMI */\r
+\r
+       if (!(range1 = mad_is_vendor_range1(call->mgmt_class)) &&\r
+           !(mad_is_vendor_range2(call->mgmt_class)))\r
+               return 0;\r
+\r
+       resp_expected = response_expected(call->method);\r
+\r
+       rpc.mgtclass = call->mgmt_class;\r
+\r
+       rpc.method = call->method;\r
+       rpc.attr.id = call->attrid;\r
+       rpc.attr.mod = call->mod;\r
+       rpc.timeout = resp_expected ? call->timeout : 0;\r
+       rpc.datasz = range1 ? IB_VENDOR_RANGE1_DATA_SIZE : IB_VENDOR_RANGE2_DATA_SIZE;\r
+       rpc.dataoffs = range1 ? IB_VENDOR_RANGE1_DATA_OFFS : IB_VENDOR_RANGE2_DATA_OFFS;\r
+\r
+       if (!range1)\r
+               rpc.oui = call->oui;\r
+\r
+       DEBUG("class 0x%x method 0x%x attr 0x%x mod 0x%x datasz %d off %d res_ex %d",\r
+               rpc.mgtclass, rpc.method, rpc.attr.id, rpc.attr.mod,\r
+               rpc.datasz, rpc.dataoffs, resp_expected);\r
+\r
+       portid->qp = 1;\r
+       if (!portid->qkey)\r
+               portid->qkey = IB_DEFAULT_QP1_QKEY;\r
+\r
+       if (resp_expected)\r
+               return madrpc_rmpp(&rpc, portid, 0, data);              /* FIXME: no RMPP for now */\r
+\r
+       return mad_send(&rpc, portid, 0, data) < 0 ? 0 : data;          /* FIXME: no RMPP for now */\r
+}\r
diff --git a/ulp/libibumad/README.txt b/ulp/libibumad/README.txt
new file mode 100644 (file)
index 0000000..7c82b7e
--- /dev/null
@@ -0,0 +1,19 @@
+[1-06-09]\r
+\r
+These 'shared' OFED files (shared between Linux and Windows) are mirrored here for the convience\r
+of Windows developers.\r
+\r
+The 'offical' OFED source files are located in the OFED git repository.\r
+\r
+The policy is 'no source file changes' in non-build files (.h & .c) are accepted here.\r
+Any source file changes here will likely be overwritten when refreshed from the OFED git repository.\r
+\r
+The plan here is to have a single Linux and Windows source.\r
+\r
+If you require source file changes, push the changes to the OFED maintainers.\r
+\r
+For continuing policy discussion, please contact sean.hefty@intel.com\r
+\r
+thank you,\r
+\r
+Stan (stan.smith@intel.com)
\ No newline at end of file