contrib/ofed/libibumad/umad_str.c

   1 /*
   2  * Copyright (c) 2004, 2005, 2010 Intel Corporation.  All rights reserved.
   3  * Copyright (c) 2013 Lawrence Livermore National Security. All rights reserved.
   4  * Copyright (c) 2014 Mellanox Technologies LTD. All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  *
  34  */
  35
  36 #include <stdio.h>
  37 #include <infiniband/endian.h>
  38 #include <infiniband/umad.h>
  39 #include <infiniband/umad_types.h>
  40 #include <infiniband/umad_sm.h>
  41 #include <infiniband/umad_sa.h>
  42 #include <infiniband/umad_cm.h>
  43 #include "umad_str.h"
  44
  45 const char * umad_class_str(uint8_t mgmt_class)
  46 {
  47         switch (mgmt_class) {
  48                 case UMAD_CLASS_SUBN_LID_ROUTED:
  49                 case UMAD_CLASS_SUBN_DIRECTED_ROUTE:
  50                         return("Subn");
  51                 case UMAD_CLASS_SUBN_ADM:
  52                         return("SubnAdm");
  53                 case UMAD_CLASS_PERF_MGMT:
  54                         return("Perf");
  55                 case UMAD_CLASS_BM:
  56                         return("BM");
  57                 case UMAD_CLASS_DEVICE_MGMT:
  58                         return("DevMgt");
  59                 case UMAD_CLASS_CM:
  60                         return("ComMgt");
  61                 case UMAD_CLASS_SNMP:
  62                         return("SNMP");
  63                 case UMAD_CLASS_DEVICE_ADM:
  64                         return("DevAdm");
  65                 case UMAD_CLASS_BOOT_MGMT:
  66                         return("BootMgt");
  67                 case UMAD_CLASS_BIS:
  68                         return("BIS");
  69                 case UMAD_CLASS_CONG_MGMT:
  70                         return("CongestionManagment");
  71                 default:
  72                         break;
  73         }
  74
  75         if ((UMAD_CLASS_VENDOR_RANGE1_START <= mgmt_class
  76                 && mgmt_class <= UMAD_CLASS_VENDOR_RANGE1_END)
  77             || (UMAD_CLASS_VENDOR_RANGE2_START <= mgmt_class
  78                 && mgmt_class <= UMAD_CLASS_VENDOR_RANGE2_END))
  79                 return("Vendor");
  80
  81         if (UMAD_CLASS_APPLICATION_START <= mgmt_class
  82             && mgmt_class <= UMAD_CLASS_APPLICATION_END) {
  83                 return("Application");
  84         }
  85         return ("<unknown>");
  86 }
  87
  88 static const char * umad_common_method_str(uint8_t method)
  89 {
  90         switch(method) {
  91                 case UMAD_METHOD_GET:
  92                         return ("Get");
  93                 case UMAD_METHOD_SET:
  94                         return ("Set");
  95                 case UMAD_METHOD_GET_RESP:
  96                         return ("GetResp");
  97                 case UMAD_METHOD_SEND:
  98                         return ("Send");
  99                 case UMAD_METHOD_TRAP:
 100                         return ("Trap");
 101                 case UMAD_METHOD_REPORT:
 102                         return ("Report");
 103                 case UMAD_METHOD_REPORT_RESP:
 104                         return ("ReportResp");
 105                 case UMAD_METHOD_TRAP_REPRESS:
 106                         return ("TrapRepress");
 107                 default:
 108                         return ("<unknown");
 109         }
 110 }
 111
 112 static const char * umad_sa_method_str(uint8_t method)
 113 {
 114         switch(method) {
 115                 case UMAD_SA_METHOD_GET_TABLE:
 116                         return ("GetTable");
 117                 case UMAD_SA_METHOD_GET_TABLE_RESP:
 118                         return ("GetTableResp");
 119                 case UMAD_SA_METHOD_DELETE:
 120                         return ("Delete");
 121                 case UMAD_SA_METHOD_DELETE_RESP:
 122                         return ("DeleteResp");
 123                 case UMAD_SA_METHOD_GET_MULTI:
 124                         return ("GetMulti");
 125                 case UMAD_SA_METHOD_GET_MULTI_RESP:
 126                         return ("GetMultiResp");
 127                 case UMAD_SA_METHOD_GET_TRACE_TABLE:
 128                         return ("GetTraceTable");
 129                 default:
 130                         return (umad_common_method_str(method));
 131         }
 132 }
 133
 134 const char * umad_method_str(uint8_t mgmt_class, uint8_t method)
 135 {
 136         if (mgmt_class == UMAD_CLASS_SUBN_ADM)
 137                 return(umad_sa_method_str(method));
 138
 139         return (umad_common_method_str(method));
 140 }
 141
 142 const char * umad_common_mad_status_str(__be16 _status)
 143 {
 144         uint16_t status = be16toh(_status);
 145
 146         if (status & UMAD_STATUS_BUSY)
 147                 return ("Busy");
 148
 149         if (status & UMAD_STATUS_REDIRECT)
 150                 return ("Redirection required");
 151
 152         switch(status & UMAD_STATUS_INVALID_FIELD_MASK) {
 153                 case UMAD_STATUS_BAD_VERSION:
 154                         return ("Bad Version");
 155                 case UMAD_STATUS_METHOD_NOT_SUPPORTED:
 156                         return ("Method not supported");
 157                 case UMAD_STATUS_ATTR_NOT_SUPPORTED:
 158                         return ("Method/Attribute combo not supported");
 159                 case UMAD_STATUS_INVALID_ATTR_VALUE:
 160                         return ("Invalid attribute/modifier field");
 161         }
 162         return ("Success");
 163 }
 164
 165 const char * umad_sa_mad_status_str(__be16 _status)
 166 {
 167         uint16_t status = be16toh(_status);
 168         switch((status & UMAD_STATUS_CLASS_MASK) >> 8) {
 169                 case UMAD_SA_STATUS_SUCCESS:
 170                         return ("Success");
 171                 case UMAD_SA_STATUS_NO_RESOURCES:
 172                         return ("No Resources");
 173                 case UMAD_SA_STATUS_REQ_INVALID:
 174                         return ("Request Invalid");
 175                 case UMAD_SA_STATUS_NO_RECORDS:
 176                         return ("No Records");
 177                 case UMAD_SA_STATUS_TOO_MANY_RECORDS:
 178                         return ("Too Many Records");
 179                 case UMAD_SA_STATUS_INVALID_GID:
 180                         return ("Invalid GID");
 181                 case UMAD_SA_STATUS_INSUF_COMPS:
 182                         return ("Insufficient Components");
 183                 case UMAD_SA_STATUS_REQ_DENIED:
 184                         return ("Request Denied");
 185                 case UMAD_SA_STATUS_PRI_SUGGESTED:
 186                         return ("Priority Suggested");
 187         }
 188         return ("Undefined Error");
 189 }
 190
 191 static const char *umad_common_attr_str(__be16 attr_id)
 192 {
 193         switch(be16toh(attr_id)) {
 194                 case UMAD_ATTR_CLASS_PORT_INFO:
 195                         return "Class Port Info";
 196                 case UMAD_ATTR_NOTICE:
 197                         return "Notice";
 198                 case UMAD_ATTR_INFORM_INFO:
 199                         return "Inform Info";
 200                 default:
 201                         return "<unknown>";
 202         }
 203 }
 204
 205 static const char * umad_sm_attr_str(__be16 attr_id)
 206 {
 207         switch(be16toh(attr_id)) {
 208                 case UMAD_SM_ATTR_NODE_DESC:
 209                         return ("NodeDescription");
 210                 case UMAD_SM_ATTR_NODE_INFO:
 211                         return ("NodeInfo");
 212                 case UMAD_SM_ATTR_SWITCH_INFO:
 213                         return ("SwitchInfo");
 214                 case UMAD_SM_ATTR_GUID_INFO:
 215                         return ("GUIDInfo");
 216                 case UMAD_SM_ATTR_PORT_INFO:
 217                         return ("PortInfo");
 218                 case UMAD_SM_ATTR_PKEY_TABLE:
 219                         return ("P_KeyTable");
 220                 case UMAD_SM_ATTR_SLVL_TABLE:
 221                         return ("SLtoVLMappingTable");
 222                 case UMAD_SM_ATTR_VL_ARB_TABLE:
 223                         return ("VLArbitrationTable");
 224                 case UMAD_SM_ATTR_LINEAR_FT:
 225                         return ("LinearForwardingTable");
 226                 case UMAD_SM_ATTR_RANDOM_FT:
 227                         return ("RandomForwardingTable");
 228                 case UMAD_SM_ATTR_MCAST_FT:
 229                         return ("MulticastForwardingTable");
 230                 case UMAD_SM_ATTR_SM_INFO:
 231                         return ("SMInfo");
 232                 case UMAD_SM_ATTR_VENDOR_DIAG:
 233                         return ("VendorDiag");
 234                 case UMAD_SM_ATTR_LED_INFO:
 235                         return ("LedInfo");
 236                 case UMAD_SM_ATTR_LINK_SPD_WIDTH_TABLE:
 237                         return ("LinkSpeedWidthPairsTable");
 238                 case UMAD_SM_ATTR_VENDOR_MADS_TABLE:
 239                         return ("VendorSpecificMadsTable");
 240                 case UMAD_SM_ATTR_HIERARCHY_INFO:
 241                         return ("HierarchyInfo");
 242                 case UMAD_SM_ATTR_CABLE_INFO:
 243                         return ("CableInfo");
 244                 case UMAD_SM_ATTR_PORT_INFO_EXT:
 245                         return ("PortInfoExtended");
 246                 default:
 247                         return (umad_common_attr_str(attr_id));
 248         }
 249 }
 250
 251 static const char * umad_sa_attr_str(__be16 attr_id)
 252 {
 253         switch(be16toh(attr_id)) {
 254                 case UMAD_SA_ATTR_NODE_REC:
 255                         return ("NodeRecord");
 256                 case UMAD_SA_ATTR_PORT_INFO_REC:
 257                         return ("PortInfoRecord");
 258                 case UMAD_SA_ATTR_SLVL_REC:
 259                         return ("SLtoVLMappingTableRecord");
 260                 case UMAD_SA_ATTR_SWITCH_INFO_REC:
 261                         return ("SwitchInfoRecord");
 262                 case UMAD_SA_ATTR_LINEAR_FT_REC:
 263                         return ("LinearForwardingTableRecord");
 264                 case UMAD_SA_ATTR_RANDOM_FT_REC:
 265                         return ("RandomForwardingTableRecord");
 266                 case UMAD_SA_ATTR_MCAST_FT_REC:
 267                         return ("MulticastForwardingTableRecord");
 268                 case UMAD_SA_ATTR_SM_INFO_REC:
 269                         return ("SMInfoRecord");
 270                 case UMAD_SA_ATTR_INFORM_INFO_REC:
 271                         return ("InformInfoRecord");
 272                 case UMAD_SA_ATTR_LINK_REC:
 273                         return ("LinkRecord");
 274                 case UMAD_SA_ATTR_GUID_INFO_REC:
 275                         return ("GuidInfoRecord");
 276                 case UMAD_SA_ATTR_SERVICE_REC:
 277                         return ("ServiceRecord");
 278                 case UMAD_SA_ATTR_PKEY_TABLE_REC:
 279                         return ("P_KeyTableRecord");
 280                 case UMAD_SA_ATTR_PATH_REC:
 281                         return ("PathRecord");
 282                 case UMAD_SA_ATTR_VL_ARB_REC:
 283                         return ("VLArbitrationTableRecord");
 284                 case UMAD_SA_ATTR_MCMEMBER_REC:
 285                         return ("MCMemberRecord");
 286                 case UMAD_SA_ATTR_TRACE_REC:
 287                         return ("TraceRecord");
 288                 case UMAD_SA_ATTR_MULTI_PATH_REC:
 289                         return ("MultiPathRecord");
 290                 case UMAD_SA_ATTR_SERVICE_ASSOC_REC:
 291                         return ("ServiceAssociationRecord");
 292                 case UMAD_SA_ATTR_LINK_SPD_WIDTH_TABLE_REC:
 293                         return ("LinkSpeedWidthPairsTableRecord");
 294                 case UMAD_SA_ATTR_HIERARCHY_INFO_REC:
 295                         return ("HierarchyInfoRecord");
 296                 case UMAD_SA_ATTR_CABLE_INFO_REC:
 297                         return ("CableInfoRecord");
 298                 case UMAD_SA_ATTR_PORT_INFO_EXT_REC:
 299                         return ("PortInfoExtendedRecord");
 300                 default:
 301                         return (umad_common_attr_str(attr_id));
 302         }
 303 }
 304
 305 static const char * umad_cm_attr_str(__be16 attr_id)
 306 {
 307         switch(be16toh(attr_id)) {
 308                 case UMAD_CM_ATTR_REQ:
 309                         return "ConnectRequest";
 310                 case UMAD_CM_ATTR_MRA:
 311                         return "MsgRcptAck";
 312                 case UMAD_CM_ATTR_REJ:
 313                         return "ConnectReject";
 314                 case UMAD_CM_ATTR_REP:
 315                         return "ConnectReply";
 316                 case UMAD_CM_ATTR_RTU:
 317                         return "ReadyToUse";
 318                 case UMAD_CM_ATTR_DREQ:
 319                         return "DisconnectRequest";
 320                 case UMAD_CM_ATTR_DREP:
 321                         return "DisconnectReply";
 322                 case UMAD_CM_ATTR_SIDR_REQ:
 323                         return "ServiceIDResReq";
 324                 case UMAD_CM_ATTR_SIDR_REP:
 325                         return "ServiceIDResReqResp";
 326                 case UMAD_CM_ATTR_LAP:
 327                         return "LoadAlternatePath";
 328                 case UMAD_CM_ATTR_APR:
 329                         return "AlternatePathResponse";
 330                 case UMAD_CM_ATTR_SAP:
 331                         return "SuggestAlternatePath";
 332                 case UMAD_CM_ATTR_SPR:
 333                         return "SuggestPathResponse";
 334                 default:
 335                         return (umad_common_attr_str(attr_id));
 336         }
 337 }
 338
 339 const char * umad_attribute_str(uint8_t mgmt_class, __be16 attr_id)
 340 {
 341         switch (mgmt_class) {
 342                 case UMAD_CLASS_SUBN_LID_ROUTED:
 343                 case UMAD_CLASS_SUBN_DIRECTED_ROUTE:
 344                         return(umad_sm_attr_str(attr_id));
 345                 case UMAD_CLASS_SUBN_ADM:
 346                         return(umad_sa_attr_str(attr_id));
 347                 case UMAD_CLASS_CM:
 348                         return(umad_cm_attr_str(attr_id));
 349         }
 350
 351         return (umad_common_attr_str(attr_id));
 352 }