contrib/ofed/libibmad/dump.c

   1 /*
   2  * Copyright (c) 2004-2009 Voltaire Inc.  All rights reserved.
   3  * Copyright (c) 2007 Xsigo Systems Inc.  All rights reserved.
   4  * Copyright (c) 2009-2011 Mellanox Technologies LTD.  All rights reserved.
   5  * Copyright (c) 2009 HNR Consulting.  All rights reserved.
   6  *
   7  * This software is available to you under a choice of one of two
   8  * licenses.  You may choose to be licensed under the terms of the GNU
   9  * General Public License (GPL) Version 2, available from the file
  10  * COPYING in the main directory of this source tree, or the
  11  * OpenIB.org BSD license below:
  12  *
  13  *     Redistribution and use in source and binary forms, with or
  14  *     without modification, are permitted provided that the following
  15  *     conditions are met:
  16  *
  17  *      - Redistributions of source code must retain the above
  18  *        copyright notice, this list of conditions and the following
  19  *        disclaimer.
  20  *
  21  *      - Redistributions in binary form must reproduce the above
  22  *        copyright notice, this list of conditions and the following
  23  *        disclaimer in the documentation and/or other materials
  24  *        provided with the distribution.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33  * SOFTWARE.
  34  *
  35  */
  36
  37 #if HAVE_CONFIG_H
  38 #  include <config.h>
  39 #endif                          /* HAVE_CONFIG_H */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include <infiniband/mad.h>
  46
  47 void mad_dump_int(char *buf, int bufsz, void *val, int valsz)
  48 {
  49         switch (valsz) {
  50         case 1:
  51                 snprintf(buf, bufsz, "%d", *(uint32_t *) val & 0xff);
  52                 break;
  53         case 2:
  54                 snprintf(buf, bufsz, "%d", *(uint32_t *) val & 0xffff);
  55                 break;
  56         case 3:
  57         case 4:
  58                 snprintf(buf, bufsz, "%d", *(uint32_t *) val);
  59                 break;
  60         case 5:
  61         case 6:
  62         case 7:
  63         case 8:
  64                 snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *) val);
  65                 break;
  66         default:
  67                 IBWARN("bad int sz %d", valsz);
  68                 buf[0] = 0;
  69         }
  70 }
  71
  72 void mad_dump_uint(char *buf, int bufsz, void *val, int valsz)
  73 {
  74         switch (valsz) {
  75         case 1:
  76                 snprintf(buf, bufsz, "%u", *(uint32_t *) val & 0xff);
  77                 break;
  78         case 2:
  79                 snprintf(buf, bufsz, "%u", *(uint32_t *) val & 0xffff);
  80                 break;
  81         case 3:
  82         case 4:
  83                 snprintf(buf, bufsz, "%u", *(uint32_t *) val);
  84                 break;
  85         case 5:
  86         case 6:
  87         case 7:
  88         case 8:
  89                 snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *) val);
  90                 break;
  91         default:
  92                 IBWARN("bad int sz %u", valsz);
  93                 buf[0] = 0;
  94         }
  95 }
  96
  97 void mad_dump_hex(char *buf, int bufsz, void *val, int valsz)
  98 {
  99         switch (valsz) {
 100         case 1:
 101                 snprintf(buf, bufsz, "0x%02x", *(uint32_t *) val & 0xff);
 102                 break;
 103         case 2:
 104                 snprintf(buf, bufsz, "0x%04x", *(uint32_t *) val & 0xffff);
 105                 break;
 106         case 3:
 107                 snprintf(buf, bufsz, "0x%06x", *(uint32_t *) val & 0xffffff);
 108                 break;
 109         case 4:
 110                 snprintf(buf, bufsz, "0x%08x", *(uint32_t *) val);
 111                 break;
 112         case 5:
 113                 snprintf(buf, bufsz, "0x%010" PRIx64,
 114                          *(uint64_t *) val & (uint64_t) 0xffffffffffULL);
 115                 break;
 116         case 6:
 117                 snprintf(buf, bufsz, "0x%012" PRIx64,
 118                          *(uint64_t *) val & (uint64_t) 0xffffffffffffULL);
 119                 break;
 120         case 7:
 121                 snprintf(buf, bufsz, "0x%014" PRIx64,
 122                          *(uint64_t *) val & (uint64_t) 0xffffffffffffffULL);
 123                 break;
 124         case 8:
 125                 snprintf(buf, bufsz, "0x%016" PRIx64, *(uint64_t *) val);
 126                 break;
 127         default:
 128                 IBWARN("bad int sz %d", valsz);
 129                 buf[0] = 0;
 130         }
 131 }
 132
 133 void mad_dump_rhex(char *buf, int bufsz, void *val, int valsz)
 134 {
 135         switch (valsz) {
 136         case 1:
 137                 snprintf(buf, bufsz, "%02x", *(uint32_t *) val & 0xff);
 138                 break;
 139         case 2:
 140                 snprintf(buf, bufsz, "%04x", *(uint32_t *) val & 0xffff);
 141                 break;
 142         case 3:
 143                 snprintf(buf, bufsz, "%06x", *(uint32_t *) val & 0xffffff);
 144                 break;
 145         case 4:
 146                 snprintf(buf, bufsz, "%08x", *(uint32_t *) val);
 147                 break;
 148         case 5:
 149                 snprintf(buf, bufsz, "%010" PRIx64,
 150                          *(uint64_t *) val & (uint64_t) 0xffffffffffULL);
 151                 break;
 152         case 6:
 153                 snprintf(buf, bufsz, "%012" PRIx64,
 154                          *(uint64_t *) val & (uint64_t) 0xffffffffffffULL);
 155                 break;
 156         case 7:
 157                 snprintf(buf, bufsz, "%014" PRIx64,
 158                          *(uint64_t *) val & (uint64_t) 0xffffffffffffffULL);
 159                 break;
 160         case 8:
 161                 snprintf(buf, bufsz, "%016" PRIx64, *(uint64_t *) val);
 162                 break;
 163         default:
 164                 IBWARN("bad int sz %d", valsz);
 165                 buf[0] = 0;
 166         }
 167 }
 168
 169 void mad_dump_linkwidth(char *buf, int bufsz, void *val, int valsz)
 170 {
 171         int width = *(int *)val;
 172
 173         switch (width) {
 174         case 1:
 175                 snprintf(buf, bufsz, "1X");
 176                 break;
 177         case 2:
 178                 snprintf(buf, bufsz, "4X");
 179                 break;
 180         case 4:
 181                 snprintf(buf, bufsz, "8X");
 182                 break;
 183         case 8:
 184                 snprintf(buf, bufsz, "12X");
 185                 break;
 186         case 16:
 187                 snprintf(buf, bufsz, "2X");
 188                 break;
 189         default:
 190                 IBWARN("bad width %d", width);
 191                 snprintf(buf, bufsz, "undefined (%d)", width);
 192                 break;
 193         }
 194 }
 195
 196 static void dump_linkwidth(char *buf, int bufsz, int width)
 197 {
 198         int n = 0;
 199
 200         if (width & 0x1)
 201                 n += snprintf(buf + n, bufsz - n, "1X or ");
 202         if (n < bufsz && (width & 0x2))
 203                 n += snprintf(buf + n, bufsz - n, "4X or ");
 204         if (n < bufsz && (width & 0x4))
 205                 n += snprintf(buf + n, bufsz - n, "8X or ");
 206         if (n < bufsz && (width & 0x8))
 207                 n += snprintf(buf + n, bufsz - n, "12X or ");
 208         if (n < bufsz && (width & 0x10))
 209                 n += snprintf(buf + n, bufsz - n, "2X or ");
 210
 211         if (n >= bufsz)
 212                 return;
 213         else if (width == 0 || (width >> 5))
 214                 snprintf(buf + n, bufsz - n, "undefined (%d)", width);
 215         else if (bufsz > 3)
 216                 buf[n - 4] = '\0';
 217 }
 218
 219 void mad_dump_linkwidthsup(char *buf, int bufsz, void *val, int valsz)
 220 {
 221         int width = *(int *)val;
 222
 223         dump_linkwidth(buf, bufsz, width);
 224
 225         switch (width) {
 226         case 1:
 227         case 3:
 228         case 7:
 229         case 11:
 230         case 15:
 231         case 17:
 232         case 19:
 233         case 23:
 234         case 27:
 235         case 31:
 236                 break;
 237
 238         default:
 239                 if (!(width >> 5))
 240                         snprintf(buf + strlen(buf), bufsz - strlen(buf),
 241                                  " (IBA extension)");
 242                 break;
 243         }
 244 }
 245
 246 void mad_dump_linkwidthen(char *buf, int bufsz, void *val, int valsz)
 247 {
 248         int width = *(int *)val;
 249
 250         dump_linkwidth(buf, bufsz, width);
 251 }
 252
 253 void mad_dump_linkspeed(char *buf, int bufsz, void *val, int valsz)
 254 {
 255         int speed = *(int *)val;
 256
 257         switch (speed) {
 258         case 0:
 259                 snprintf(buf, bufsz, "Extended speed");
 260                 break;
 261         case 1:
 262                 snprintf(buf, bufsz, "2.5 Gbps");
 263                 break;
 264         case 2:
 265                 snprintf(buf, bufsz, "5.0 Gbps");
 266                 break;
 267         case 4:
 268                 snprintf(buf, bufsz, "10.0 Gbps");
 269                 break;
 270         default:
 271                 snprintf(buf, bufsz, "undefined (%d)", speed);
 272                 break;
 273         }
 274 }
 275
 276 static void dump_linkspeed(char *buf, int bufsz, int speed)
 277 {
 278         int n = 0;
 279
 280         if (speed & 0x1)
 281                 n += snprintf(buf + n, bufsz - n, "2.5 Gbps or ");
 282         if (n < bufsz && (speed & 0x2))
 283                 n += snprintf(buf + n, bufsz - n, "5.0 Gbps or ");
 284         if (n < bufsz && (speed & 0x4))
 285                 n += snprintf(buf + n, bufsz - n, "10.0 Gbps or ");
 286
 287         if (n >= bufsz)
 288                 return;
 289         else if (speed == 0 || (speed >> 3)) {
 290                 n += snprintf(buf + n, bufsz - n, "undefined (%d)", speed);
 291                 if (n >= bufsz)
 292                         return;
 293         } else if (bufsz > 3) {
 294                 buf[n - 4] = '\0';
 295                 n -= 4;
 296         }
 297
 298         switch (speed) {
 299         case 1:
 300         case 3:
 301         case 5:
 302         case 7:
 303                 break;
 304         default:
 305                 if (!(speed >> 3))
 306                         snprintf(buf + n, bufsz - n, " (IBA extension)");
 307                 break;
 308         }
 309 }
 310
 311 void mad_dump_linkspeedsup(char *buf, int bufsz, void *val, int valsz)
 312 {
 313         int speed = *(int *)val;
 314
 315         dump_linkspeed(buf, bufsz, speed);
 316 }
 317
 318 void mad_dump_linkspeeden(char *buf, int bufsz, void *val, int valsz)
 319 {
 320         int speed = *(int *)val;
 321
 322         dump_linkspeed(buf, bufsz, speed);
 323 }
 324
 325 void mad_dump_linkspeedext(char *buf, int bufsz, void *val, int valsz)
 326 {
 327         int speed = *(int *)val;
 328
 329         switch (speed) {
 330         case 0:
 331                 snprintf(buf, bufsz, "No Extended Speed");
 332                 break;
 333         case 1:
 334                 snprintf(buf, bufsz, "14.0625 Gbps");
 335                 break;
 336         case 2:
 337                 snprintf(buf, bufsz, "25.78125 Gbps");
 338                 break;
 339         default:
 340                 snprintf(buf, bufsz, "undefined (%d)", speed);
 341                 break;
 342         }
 343 }
 344
 345 static void dump_linkspeedext(char *buf, int bufsz, int speed)
 346 {
 347         int n = 0;
 348
 349         if (speed == 0) {
 350                 sprintf(buf, "%d", speed);
 351                 return;
 352         }
 353
 354         if (speed & 0x1)
 355                 n += snprintf(buf + n, bufsz - n, "14.0625 Gbps or ");
 356         if (n < bufsz && speed & 0x2)
 357                 n += snprintf(buf + n, bufsz - n, "25.78125 Gbps or ");
 358         if (n >= bufsz) {
 359                 if (bufsz > 3)
 360                         buf[n - 4] = '\0';
 361                 return;
 362         }
 363
 364         if (speed >> 2) {
 365                 n += snprintf(buf + n, bufsz - n, "undefined (%d)", speed);
 366                 return;
 367         } else if (bufsz > 3)
 368                 buf[n - 4] = '\0';
 369 }
 370
 371 void mad_dump_linkspeedextsup(char *buf, int bufsz, void *val, int valsz)
 372 {
 373         int speed = *(int *)val;
 374
 375         dump_linkspeedext(buf, bufsz, speed);
 376 }
 377
 378 void mad_dump_linkspeedexten(char *buf, int bufsz, void *val, int valsz)
 379 {
 380         int speed = *(int *)val;
 381
 382         if (speed == 30) {
 383                 sprintf(buf, "%s", "Extended link speeds disabled");
 384                 return;
 385         }
 386         dump_linkspeedext(buf, bufsz, speed);
 387 }
 388
 389 void mad_dump_portstate(char *buf, int bufsz, void *val, int valsz)
 390 {
 391         int state = *(int *)val;
 392
 393         switch (state) {
 394         case 0:
 395                 snprintf(buf, bufsz, "NoChange");
 396                 break;
 397         case 1:
 398                 snprintf(buf, bufsz, "Down");
 399                 break;
 400         case 2:
 401                 snprintf(buf, bufsz, "Initialize");
 402                 break;
 403         case 3:
 404                 snprintf(buf, bufsz, "Armed");
 405                 break;
 406         case 4:
 407                 snprintf(buf, bufsz, "Active");
 408                 break;
 409         default:
 410                 snprintf(buf, bufsz, "?(%d)", state);
 411         }
 412 }
 413
 414 void mad_dump_linkdowndefstate(char *buf, int bufsz, void *val, int valsz)
 415 {
 416         int state = *(int *)val;
 417
 418         switch (state) {
 419         case 0:
 420                 snprintf(buf, bufsz, "NoChange");
 421                 break;
 422         case 1:
 423                 snprintf(buf, bufsz, "Sleep");
 424                 break;
 425         case 2:
 426                 snprintf(buf, bufsz, "Polling");
 427                 break;
 428         default:
 429                 snprintf(buf, bufsz, "?(%d)", state);
 430                 break;
 431         }
 432 }
 433
 434 void mad_dump_physportstate(char *buf, int bufsz, void *val, int valsz)
 435 {
 436         int state = *(int *)val;
 437
 438         switch (state) {
 439         case 0:
 440                 snprintf(buf, bufsz, "NoChange");
 441                 break;
 442         case 1:
 443                 snprintf(buf, bufsz, "Sleep");
 444                 break;
 445         case 2:
 446                 snprintf(buf, bufsz, "Polling");
 447                 break;
 448         case 3:
 449                 snprintf(buf, bufsz, "Disabled");
 450                 break;
 451         case 4:
 452                 snprintf(buf, bufsz, "PortConfigurationTraining");
 453                 break;
 454         case 5:
 455                 snprintf(buf, bufsz, "LinkUp");
 456                 break;
 457         case 6:
 458                 snprintf(buf, bufsz, "LinkErrorRecovery");
 459                 break;
 460         case 7:
 461                 snprintf(buf, bufsz, "PhyTest");
 462                 break;
 463         default:
 464                 snprintf(buf, bufsz, "?(%d)", state);
 465         }
 466 }
 467
 468 void mad_dump_mtu(char *buf, int bufsz, void *val, int valsz)
 469 {
 470         int mtu = *(int *)val;
 471
 472         switch (mtu) {
 473         case 1:
 474                 snprintf(buf, bufsz, "256");
 475                 break;
 476         case 2:
 477                 snprintf(buf, bufsz, "512");
 478                 break;
 479         case 3:
 480                 snprintf(buf, bufsz, "1024");
 481                 break;
 482         case 4:
 483                 snprintf(buf, bufsz, "2048");
 484                 break;
 485         case 5:
 486                 snprintf(buf, bufsz, "4096");
 487                 break;
 488         default:
 489                 snprintf(buf, bufsz, "?(%d)", mtu);
 490         }
 491 }
 492
 493 void mad_dump_vlcap(char *buf, int bufsz, void *val, int valsz)
 494 {
 495         int vlcap = *(int *)val;
 496
 497         switch (vlcap) {
 498         case 1:
 499                 snprintf(buf, bufsz, "VL0");
 500                 break;
 501         case 2:
 502                 snprintf(buf, bufsz, "VL0-1");
 503                 break;
 504         case 3:
 505                 snprintf(buf, bufsz, "VL0-3");
 506                 break;
 507         case 4:
 508                 snprintf(buf, bufsz, "VL0-7");
 509                 break;
 510         case 5:
 511                 snprintf(buf, bufsz, "VL0-14");
 512                 break;
 513         default:
 514                 snprintf(buf, bufsz, "?(%d)", vlcap);
 515         }
 516 }
 517
 518 void mad_dump_opervls(char *buf, int bufsz, void *val, int valsz)
 519 {
 520         int opervls = *(int *)val;
 521
 522         switch (opervls) {
 523         case 0:
 524                 snprintf(buf, bufsz, "No change");
 525                 break;
 526         case 1:
 527                 snprintf(buf, bufsz, "VL0");
 528                 break;
 529         case 2:
 530                 snprintf(buf, bufsz, "VL0-1");
 531                 break;
 532         case 3:
 533                 snprintf(buf, bufsz, "VL0-3");
 534                 break;
 535         case 4:
 536                 snprintf(buf, bufsz, "VL0-7");
 537                 break;
 538         case 5:
 539                 snprintf(buf, bufsz, "VL0-14");
 540                 break;
 541         default:
 542                 snprintf(buf, bufsz, "?(%d)", opervls);
 543         }
 544 }
 545
 546 void mad_dump_portcapmask(char *buf, int bufsz, void *val, int valsz)
 547 {
 548         unsigned mask = *(unsigned *)val;
 549         char *s = buf;
 550
 551         s += sprintf(s, "0x%x\n", mask);
 552         if (mask & (1 << 1))
 553                 s += sprintf(s, "\t\t\t\tIsSM\n");
 554         if (mask & (1 << 2))
 555                 s += sprintf(s, "\t\t\t\tIsNoticeSupported\n");
 556         if (mask & (1 << 3))
 557                 s += sprintf(s, "\t\t\t\tIsTrapSupported\n");
 558         if (mask & (1 << 4))
 559                 s += sprintf(s, "\t\t\t\tIsOptionalIPDSupported\n");
 560         if (mask & (1 << 5))
 561                 s += sprintf(s, "\t\t\t\tIsAutomaticMigrationSupported\n");
 562         if (mask & (1 << 6))
 563                 s += sprintf(s, "\t\t\t\tIsSLMappingSupported\n");
 564         if (mask & (1 << 7))
 565                 s += sprintf(s, "\t\t\t\tIsMKeyNVRAM\n");
 566         if (mask & (1 << 8))
 567                 s += sprintf(s, "\t\t\t\tIsPKeyNVRAM\n");
 568         if (mask & (1 << 9))
 569                 s += sprintf(s, "\t\t\t\tIsLedInfoSupported\n");
 570         if (mask & (1 << 10))
 571                 s += sprintf(s, "\t\t\t\tIsSMdisabled\n");
 572         if (mask & (1 << 11))
 573                 s += sprintf(s, "\t\t\t\tIsSystemImageGUIDsupported\n");
 574         if (mask & (1 << 12))
 575                 s += sprintf(s,
 576                              "\t\t\t\tIsPkeySwitchExternalPortTrapSupported\n");
 577         if (mask & (1 << 14))
 578                 s += sprintf(s, "\t\t\t\tIsExtendedSpeedsSupported\n");
 579         if (mask & (1 << 15))
 580                 s += sprintf(s, "\t\t\t\tIsCapabilityMask2Supported\n");
 581         if (mask & (1 << 16))
 582                 s += sprintf(s, "\t\t\t\tIsCommunicatonManagementSupported\n");
 583         if (mask & (1 << 17))
 584                 s += sprintf(s, "\t\t\t\tIsSNMPTunnelingSupported\n");
 585         if (mask & (1 << 18))
 586                 s += sprintf(s, "\t\t\t\tIsReinitSupported\n");
 587         if (mask & (1 << 19))
 588                 s += sprintf(s, "\t\t\t\tIsDeviceManagementSupported\n");
 589         if (mask & (1 << 20))
 590                 s += sprintf(s, "\t\t\t\tIsVendorClassSupported\n");
 591         if (mask & (1 << 21))
 592                 s += sprintf(s, "\t\t\t\tIsDRNoticeSupported\n");
 593         if (mask & (1 << 22))
 594                 s += sprintf(s, "\t\t\t\tIsCapabilityMaskNoticeSupported\n");
 595         if (mask & (1 << 23))
 596                 s += sprintf(s, "\t\t\t\tIsBootManagementSupported\n");
 597         if (mask & (1 << 24))
 598                 s += sprintf(s, "\t\t\t\tIsLinkRoundTripLatencySupported\n");
 599         if (mask & (1 << 25))
 600                 s += sprintf(s, "\t\t\t\tIsClientRegistrationSupported\n");
 601         if (mask & (1 << 26))
 602                 s += sprintf(s, "\t\t\t\tIsOtherLocalChangesNoticeSupported\n");
 603         if (mask & (1 << 27))
 604                 s += sprintf(s,
 605                              "\t\t\t\tIsLinkSpeedWidthPairsTableSupported\n");
 606         if (mask & (1 << 28))
 607                 s += sprintf(s, "\t\t\t\tIsVendorSpecificMadsTableSupported\n");
 608         if (mask & (1 << 29))
 609                 s += sprintf(s, "\t\t\t\tIsMcastPkeyTrapSuppressionSupported\n");
 610         if (mask & (1 << 30))
 611                 s += sprintf(s, "\t\t\t\tIsMulticastFDBTopSupported\n");
 612         if (mask & (1 << 31))
 613                 s += sprintf(s, "\t\t\t\tIsHierarchyInfoSupported\n");
 614
 615         if (s != buf)
 616                 *(--s) = 0;
 617 }
 618
 619 void mad_dump_portcapmask2(char *buf, int bufsz, void *val, int valsz)
 620 {
 621         int mask = *(int *)val;
 622         char *s = buf;
 623
 624         s += sprintf(s, "0x%x\n", mask);
 625         if (mask & (1 << 0))
 626                 s += sprintf(s, "\t\t\t\tIsSetNodeDescriptionSupported\n");
 627         if (mask & (1 << 1))
 628                 s += sprintf(s, "\t\t\t\tIsPortInfoExtendedSupported\n");
 629         if (mask & (1 << 2))
 630                 s += sprintf(s, "\t\t\t\tIsVirtualizationSupported\n");
 631         if (mask & (1 << 3))
 632                 s += sprintf(s, "\t\t\t\tIsSwitchPortStateTableSupported\n");
 633         if (mask & (1 << 4))
 634                 s += sprintf(s, "\t\t\t\tIsLinkWidth2xSupported\n");
 635
 636         if (s != buf)
 637                 *(--s) = 0;
 638 }
 639
 640 void mad_dump_bitfield(char *buf, int bufsz, void *val, int valsz)
 641 {
 642         snprintf(buf, bufsz, "0x%x", *(uint32_t *) val);
 643 }
 644
 645 void mad_dump_array(char *buf, int bufsz, void *val, int valsz)
 646 {
 647         uint8_t *p = val, *e;
 648         char *s = buf;
 649
 650         if (bufsz < valsz * 2)
 651                 valsz = bufsz / 2;
 652
 653         for (p = val, e = p + valsz; p < e; p++, s += 2)
 654                 sprintf(s, "%02x", *p);
 655 }
 656
 657 void mad_dump_string(char *buf, int bufsz, void *val, int valsz)
 658 {
 659         if (bufsz < valsz)
 660                 valsz = bufsz;
 661
 662         snprintf(buf, valsz, "'%s'", (char *)val);
 663 }
 664
 665 void mad_dump_node_type(char *buf, int bufsz, void *val, int valsz)
 666 {
 667         int nodetype = *(int *)val;
 668
 669         switch (nodetype) {
 670         case 1:
 671                 snprintf(buf, bufsz, "Channel Adapter");
 672                 break;
 673         case 2:
 674                 snprintf(buf, bufsz, "Switch");
 675                 break;
 676         case 3:
 677                 snprintf(buf, bufsz, "Router");
 678                 break;
 679         default:
 680                 snprintf(buf, bufsz, "?(%d)?", nodetype);
 681                 break;
 682         }
 683 }
 684
 685 #define IB_MAX_NUM_VLS 16
 686 #define IB_MAX_NUM_VLS_TO_U8 ((IB_MAX_NUM_VLS)/2)
 687
 688 typedef struct _ib_slvl_table {
 689         uint8_t vl_by_sl_num[IB_MAX_NUM_VLS_TO_U8];
 690 } ib_slvl_table_t;
 691
 692 static inline void ib_slvl_get_i(ib_slvl_table_t * tbl, int i, uint8_t * vl)
 693 {
 694         *vl = (tbl->vl_by_sl_num[i >> 1] >> ((!(i & 1)) << 2)) & 0xf;
 695 }
 696
 697 #define IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK 32
 698
 699 typedef struct _ib_vl_arb_table {
 700         struct {
 701                 uint8_t res_vl;
 702                 uint8_t weight;
 703         } vl_entry[IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK];
 704 } ib_vl_arb_table_t;
 705
 706 static inline void ib_vl_arb_get_vl(uint8_t res_vl, uint8_t * const vl)
 707 {
 708         *vl = res_vl & 0x0F;
 709 }
 710
 711 void mad_dump_sltovl(char *buf, int bufsz, void *val, int valsz)
 712 {
 713         ib_slvl_table_t *p_slvl_tbl = val;
 714         uint8_t vl;
 715         int i, n = 0;
 716         n = snprintf(buf, bufsz, "|");
 717         for (i = 0; i < 16; i++) {
 718                 ib_slvl_get_i(p_slvl_tbl, i, &vl);
 719                 n += snprintf(buf + n, bufsz - n, "%2u|", vl);
 720                 if (n >= bufsz)
 721                         break;
 722         }
 723         snprintf(buf + n, bufsz - n, "\n");
 724 }
 725
 726 void mad_dump_vlarbitration(char *buf, int bufsz, void *val, int num)
 727 {
 728         ib_vl_arb_table_t *p_vla_tbl = val;
 729         int i, n;
 730         uint8_t vl;
 731
 732         num /= sizeof(p_vla_tbl->vl_entry[0]);
 733
 734         n = snprintf(buf, bufsz, "\nVL    : |");
 735         if (n >= bufsz)
 736                 return;
 737         for (i = 0; i < num; i++) {
 738                 ib_vl_arb_get_vl(p_vla_tbl->vl_entry[i].res_vl, &vl);
 739                 n += snprintf(buf + n, bufsz - n, "0x%-2X|", vl);
 740                 if (n >= bufsz)
 741                         return;
 742         }
 743
 744         n += snprintf(buf + n, bufsz - n, "\nWEIGHT: |");
 745         if (n >= bufsz)
 746                 return;
 747         for (i = 0; i < num; i++) {
 748                 n += snprintf(buf + n, bufsz - n, "0x%-2X|",
 749                               p_vla_tbl->vl_entry[i].weight);
 750                 if (n >= bufsz)
 751                         return;
 752         }
 753
 754         snprintf(buf + n, bufsz - n, "\n");
 755 }
 756
 757 static int _dump_fields(char *buf, int bufsz, void *data, int start, int end)
 758 {
 759         char val[64];
 760         char *s = buf;
 761         int n, field;
 762
 763         for (field = start; field < end && bufsz > 0; field++) {
 764                 mad_decode_field(data, field, val);
 765                 if (!mad_dump_field(field, s, bufsz-1, val))
 766                         return -1;
 767                 n = strlen(s);
 768                 s += n;
 769                 *s++ = '\n';
 770                 *s = 0;
 771                 n++;
 772                 bufsz -= n;
 773         }
 774
 775         return (int)(s - buf);
 776 }
 777
 778 void mad_dump_fields(char *buf, int bufsz, void *val, int valsz, int start,
 779                      int end)
 780 {
 781         _dump_fields(buf, bufsz, val, start, end);
 782 }
 783
 784 void mad_dump_nodedesc(char *buf, int bufsz, void *val, int valsz)
 785 {
 786         strncpy(buf, val, bufsz);
 787
 788         if (valsz < bufsz)
 789                 buf[valsz] = 0;
 790 }
 791
 792 void mad_dump_nodeinfo(char *buf, int bufsz, void *val, int valsz)
 793 {
 794         _dump_fields(buf, bufsz, val, IB_NODE_FIRST_F, IB_NODE_LAST_F);
 795 }
 796
 797 void mad_dump_portinfo(char *buf, int bufsz, void *val, int valsz)
 798 {
 799         int cnt;
 800
 801         cnt = _dump_fields(buf, bufsz, val, IB_PORT_FIRST_F, IB_PORT_LAST_F);
 802         if (cnt < 0)
 803                 return;
 804
 805         _dump_fields(buf + cnt, bufsz - cnt, val,
 806                      IB_PORT_CAPMASK2_F, IB_PORT_LINK_SPEED_EXT_LAST_F);
 807 }
 808
 809 void mad_dump_portstates(char *buf, int bufsz, void *val, int valsz)
 810 {
 811         _dump_fields(buf, bufsz, val, IB_PORT_STATE_F, IB_PORT_LINK_DOWN_DEF_F);
 812 }
 813
 814 void mad_dump_switchinfo(char *buf, int bufsz, void *val, int valsz)
 815 {
 816         _dump_fields(buf, bufsz, val, IB_SW_FIRST_F, IB_SW_LAST_F);
 817 }
 818
 819 void mad_dump_perfcounters(char *buf, int bufsz, void *val, int valsz)
 820 {
 821         int cnt, cnt2;
 822
 823         cnt = _dump_fields(buf, bufsz, val,
 824                            IB_PC_FIRST_F, IB_PC_VL15_DROPPED_F);
 825         if (cnt < 0)
 826                 return;
 827
 828         cnt2 = _dump_fields(buf + cnt, bufsz - cnt, val,
 829                             IB_PC_QP1_DROP_F, IB_PC_QP1_DROP_F + 1);
 830         if (cnt2 < 0)
 831                 return;
 832
 833         _dump_fields(buf + cnt + cnt2, bufsz - cnt - cnt2, val,
 834                      IB_PC_VL15_DROPPED_F, IB_PC_LAST_F);
 835 }
 836
 837 void mad_dump_perfcounters_ext(char *buf, int bufsz, void *val, int valsz)
 838 {
 839         int cnt;
 840
 841         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_FIRST_F, IB_PC_EXT_LAST_F);
 842         if (cnt < 0)
 843                 return;
 844
 845          _dump_fields(buf + cnt, bufsz - cnt, val,
 846                       IB_PC_EXT_COUNTER_SELECT2_F, IB_PC_EXT_ERR_LAST_F);
 847 }
 848
 849 void mad_dump_perfcounters_xmt_sl(char *buf, int bufsz, void *val, int valsz)
 850 {
 851         int cnt;
 852
 853         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 854                            IB_PC_EXT_XMT_BYTES_F);
 855         if (cnt < 0)
 856                 return;
 857
 858         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_XMT_DATA_SL_FIRST_F,
 859                      IB_PC_XMT_DATA_SL_LAST_F);
 860 }
 861
 862 void mad_dump_perfcounters_rcv_sl(char *buf, int bufsz, void *val, int valsz)
 863 {
 864         int cnt;
 865
 866         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 867                            IB_PC_EXT_XMT_BYTES_F);
 868         if (cnt < 0)
 869                 return;
 870
 871         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_RCV_DATA_SL_FIRST_F,
 872                      IB_PC_RCV_DATA_SL_LAST_F);
 873 }
 874
 875 void mad_dump_perfcounters_xmt_disc(char *buf, int bufsz, void *val, int valsz)
 876 {
 877         int cnt;
 878
 879         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 880                            IB_PC_EXT_XMT_BYTES_F);
 881         if (cnt < 0)
 882                 return;
 883
 884         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_XMT_INACT_DISC_F,
 885                      IB_PC_XMT_DISC_LAST_F);
 886 }
 887
 888 void mad_dump_perfcounters_rcv_err(char *buf, int bufsz, void *val, int valsz)
 889 {
 890         int cnt;
 891
 892         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 893                            IB_PC_EXT_XMT_BYTES_F);
 894         if (cnt < 0)
 895                 return;
 896
 897         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_RCV_LOCAL_PHY_ERR_F,
 898                      IB_PC_RCV_ERR_LAST_F);
 899 }
 900
 901 void mad_dump_portsamples_control(char *buf, int bufsz, void *val, int valsz)
 902 {
 903         _dump_fields(buf, bufsz, val, IB_PSC_OPCODE_F, IB_PSC_LAST_F);
 904 }
 905
 906 void mad_dump_port_ext_speeds_counters_rsfec_active(char *buf, int bufsz,
 907                                                     void *val, int valsz)
 908 {
 909         _dump_fields(buf, bufsz, val, IB_PESC_RSFEC_PORT_SELECT_F,
 910                      IB_PESC_RSFEC_LAST_F);
 911 }
 912
 913 void mad_dump_port_ext_speeds_counters(char *buf, int bufsz, void *val, int valsz)
 914 {
 915         _dump_fields(buf, bufsz, val, IB_PESC_PORT_SELECT_F, IB_PESC_LAST_F);
 916 }
 917
 918 void mad_dump_perfcounters_port_op_rcv_counters(char *buf, int bufsz, void *val, int valsz)
 919 {
 920         int cnt;
 921
 922         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 923                            IB_PC_EXT_XMT_BYTES_F);
 924         if (cnt < 0)
 925                 return;
 926
 927         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_OP_RCV_COUNTERS_FIRST_F,
 928                      IB_PC_PORT_OP_RCV_COUNTERS_LAST_F);
 929 }
 930
 931 void mad_dump_perfcounters_port_flow_ctl_counters(char *buf, int bufsz, void *val, int valsz)
 932 {
 933         int cnt;
 934
 935         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 936                            IB_PC_EXT_XMT_BYTES_F);
 937         if (cnt < 0)
 938                 return;
 939
 940         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_FLOW_CTL_COUNTERS_FIRST_F,
 941                      IB_PC_PORT_FLOW_CTL_COUNTERS_LAST_F);
 942 }
 943
 944 void mad_dump_perfcounters_port_vl_op_packet(char *buf, int bufsz, void *val, int valsz)
 945 {
 946         int cnt;
 947
 948         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 949                            IB_PC_EXT_XMT_BYTES_F);
 950         if (cnt < 0)
 951                 return;
 952
 953         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_VL_OP_PACKETS_FIRST_F,
 954                      IB_PC_PORT_VL_OP_PACKETS_LAST_F);
 955 }
 956
 957 void mad_dump_perfcounters_port_vl_op_data(char *buf, int bufsz, void *val, int valsz)
 958 {
 959         int cnt;
 960
 961         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 962                            IB_PC_EXT_XMT_BYTES_F);
 963         if (cnt < 0)
 964                 return;
 965
 966         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_VL_OP_DATA_FIRST_F,
 967                      IB_PC_PORT_VL_OP_DATA_LAST_F);
 968 }
 969
 970 void mad_dump_perfcounters_port_vl_xmit_flow_ctl_update_errors(char *buf, int bufsz, void *val, int valsz)
 971 {
 972         int cnt;
 973
 974         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 975                            IB_PC_EXT_XMT_BYTES_F);
 976         if (cnt < 0)
 977                 return;
 978
 979         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_VL_XMIT_FLOW_CTL_UPDATE_ERRORS_FIRST_F,
 980                      IB_PC_PORT_VL_XMIT_FLOW_CTL_UPDATE_ERRORS_LAST_F);
 981 }
 982
 983 void mad_dump_perfcounters_port_vl_xmit_wait_counters(char *buf, int bufsz, void *val, int valsz)
 984 {
 985         int cnt;
 986
 987         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
 988                            IB_PC_EXT_XMT_BYTES_F);
 989         if (cnt < 0)
 990                 return;
 991
 992         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_PORT_VL_XMIT_WAIT_COUNTERS_FIRST_F,
 993                      IB_PC_PORT_VL_XMIT_WAIT_COUNTERS_LAST_F);
 994 }
 995
 996 void mad_dump_perfcounters_sw_port_vl_congestion(char *buf, int bufsz, void *val, int valsz)
 997 {
 998         int cnt;
 999
1000         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1001                            IB_PC_EXT_XMT_BYTES_F);
1002         if (cnt < 0)
1003                 return;
1004
1005         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_SW_PORT_VL_CONGESTION_FIRST_F,
1006                      IB_PC_SW_PORT_VL_CONGESTION_LAST_F);
1007 }
1008
1009 void mad_dump_perfcounters_rcv_con_ctrl(char *buf, int bufsz, void *val, int valsz)
1010 {
1011         int cnt;
1012
1013         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1014                            IB_PC_EXT_XMT_BYTES_F);
1015         if (cnt < 0)
1016                 return;
1017
1018         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_RCV_CON_CTRL_FIRST_F,
1019                      IB_PC_RCV_CON_CTRL_LAST_F);
1020 }
1021
1022
1023 void mad_dump_perfcounters_sl_rcv_fecn(char *buf, int bufsz, void *val, int valsz)
1024 {
1025         int cnt;
1026
1027         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1028                            IB_PC_EXT_XMT_BYTES_F);
1029         if (cnt < 0)
1030                 return;
1031
1032         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_SL_RCV_FECN_FIRST_F,
1033                      IB_PC_SL_RCV_FECN_LAST_F);
1034 }
1035
1036 void mad_dump_perfcounters_sl_rcv_becn(char *buf, int bufsz, void *val, int valsz)
1037 {
1038         int cnt;
1039
1040         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1041                            IB_PC_EXT_XMT_BYTES_F);
1042         if (cnt < 0)
1043                 return;
1044
1045         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_SL_RCV_BECN_FIRST_F,
1046                      IB_PC_SL_RCV_BECN_LAST_F);
1047 }
1048
1049 void mad_dump_perfcounters_xmit_con_ctrl(char *buf, int bufsz, void *val, int valsz)
1050 {
1051         int cnt;
1052
1053         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1054                            IB_PC_EXT_XMT_BYTES_F);
1055         if (cnt < 0)
1056                 return;
1057
1058         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_XMIT_CON_CTRL_FIRST_F,
1059                      IB_PC_XMIT_CON_CTRL_LAST_F);
1060 }
1061
1062 void mad_dump_perfcounters_vl_xmit_time_cong(char *buf, int bufsz, void *val, int valsz)
1063 {
1064         int cnt;
1065
1066         cnt = _dump_fields(buf, bufsz, val, IB_PC_EXT_PORT_SELECT_F,
1067                            IB_PC_EXT_XMT_BYTES_F);
1068         if (cnt < 0)
1069                 return;
1070
1071         _dump_fields(buf + cnt, bufsz - cnt, val, IB_PC_VL_XMIT_TIME_CONG_FIRST_F,
1072                      IB_PC_VL_XMIT_TIME_CONG_LAST_F);
1073 }
1074
1075 void mad_dump_mlnx_ext_port_info(char *buf, int bufsz, void *val, int valsz)
1076 {
1077         _dump_fields(buf, bufsz, val, IB_MLNX_EXT_PORT_STATE_CHG_ENABLE_F,
1078                      IB_MLNX_EXT_PORT_LAST_F);
1079 }
1080
1081 void mad_dump_portsamples_result(char *buf, int bufsz, void *val, int valsz)
1082 {
1083         _dump_fields(buf, bufsz, val, IB_PSR_TAG_F, IB_PSR_LAST_F);
1084 }
1085
1086 void mad_dump_cc_congestioninfo(char *buf, int bufsz, void *val, int valsz)
1087 {
1088         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_INFO_FIRST_F,
1089                      IB_CC_CONGESTION_INFO_LAST_F);
1090 }
1091
1092 void mad_dump_cc_congestionkeyinfo(char *buf, int bufsz, void *val, int valsz)
1093 {
1094         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_KEY_INFO_FIRST_F,
1095                      IB_CC_CONGESTION_KEY_INFO_LAST_F);
1096 }
1097
1098 void mad_dump_cc_congestionlog(char *buf, int bufsz, void *val, int valsz)
1099 {
1100         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_LOG_FIRST_F,
1101                      IB_CC_CONGESTION_LOG_LAST_F);
1102 }
1103
1104 void mad_dump_cc_congestionlogswitch(char *buf, int bufsz, void *val, int valsz)
1105 {
1106         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_LOG_SWITCH_FIRST_F,
1107                      IB_CC_CONGESTION_LOG_SWITCH_LAST_F);
1108 }
1109
1110 void mad_dump_cc_congestionlogentryswitch(char *buf, int bufsz, void *val, int valsz)
1111 {
1112         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_LOG_ENTRY_SWITCH_FIRST_F,
1113                      IB_CC_CONGESTION_LOG_ENTRY_SWITCH_LAST_F);
1114 }
1115
1116 void mad_dump_cc_congestionlogca(char *buf, int bufsz, void *val, int valsz)
1117 {
1118         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_LOG_CA_FIRST_F,
1119                      IB_CC_CONGESTION_LOG_CA_LAST_F);
1120 }
1121
1122 void mad_dump_cc_congestionlogentryca(char *buf, int bufsz, void *val, int valsz)
1123 {
1124         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_LOG_ENTRY_CA_FIRST_F,
1125                      IB_CC_CONGESTION_LOG_ENTRY_CA_LAST_F);
1126 }
1127
1128 void mad_dump_cc_switchcongestionsetting(char *buf, int bufsz, void *val, int valsz)
1129 {
1130         _dump_fields(buf, bufsz, val, IB_CC_SWITCH_CONGESTION_SETTING_FIRST_F,
1131                      IB_CC_SWITCH_CONGESTION_SETTING_LAST_F);
1132 }
1133
1134 void mad_dump_cc_switchportcongestionsettingelement(char *buf, int bufsz, void *val, int valsz)
1135 {
1136         _dump_fields(buf, bufsz, val, IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_FIRST_F,
1137                      IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_LAST_F);
1138 }
1139
1140 void mad_dump_cc_cacongestionsetting(char *buf, int bufsz, void *val, int valsz)
1141 {
1142         _dump_fields(buf, bufsz, val, IB_CC_CA_CONGESTION_SETTING_FIRST_F,
1143                      IB_CC_CA_CONGESTION_SETTING_LAST_F);
1144 }
1145
1146 void mad_dump_cc_cacongestionentry(char *buf, int bufsz, void *val, int valsz)
1147 {
1148         _dump_fields(buf, bufsz, val, IB_CC_CA_CONGESTION_ENTRY_FIRST_F,
1149                      IB_CC_CA_CONGESTION_ENTRY_LAST_F);
1150 }
1151
1152 void mad_dump_cc_congestioncontroltable(char *buf, int bufsz, void *val, int valsz)
1153 {
1154         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_CONTROL_TABLE_FIRST_F,
1155                      IB_CC_CONGESTION_CONTROL_TABLE_LAST_F);
1156 }
1157
1158 void mad_dump_cc_congestioncontroltableentry(char *buf, int bufsz, void *val, int valsz)
1159 {
1160         _dump_fields(buf, bufsz, val, IB_CC_CONGESTION_CONTROL_TABLE_ENTRY_FIRST_F,
1161                      IB_CC_CONGESTION_CONTROL_TABLE_ENTRY_LAST_F);
1162 }
1163
1164 void mad_dump_cc_timestamp(char *buf, int bufsz, void *val, int valsz)
1165 {
1166         _dump_fields(buf, bufsz, val, IB_CC_TIMESTAMP_FIRST_F,
1167                      IB_CC_TIMESTAMP_LAST_F);
1168 }
1169
1170 void mad_dump_classportinfo(char *buf, int bufsz, void *val, int valsz)
1171 {
1172         /* no FIRST_F and LAST_F for CPI field enums, must do a hack */
1173         _dump_fields(buf, bufsz, val, IB_CPI_BASEVER_F, IB_CPI_TRAP_QKEY_F + 1);
1174 }
1175
1176 void mad_dump_portmirror_route(char *buf, int bufsz, void *val, int valsz)
1177 {
1178         _dump_fields(buf, bufsz, val, IB_PMR_FIRST_F, IB_PMR_LAST_F);
1179 }
1180
1181 void mad_dump_portmirror_filter(char *buf, int bufsz, void *val, int valsz)
1182 {
1183         _dump_fields(buf, bufsz, val, IB_PMF_FIRST_F, IB_PMF_LAST_F);
1184 }
1185
1186 void mad_dump_portmirror_ports(char *buf, int bufsz, void *val, int valsz)
1187 {
1188         _dump_fields(buf, bufsz, val, IB_PMP_FIRST_F, IB_PMP_LAST_F);
1189 }
1190
1191 void mad_dump_portinfo_ext(char *buf, int bufsz, void *val, int valsz)
1192 {
1193         _dump_fields(buf, bufsz, val, IB_PORT_EXT_CAPMASK_F,
1194                      IB_PORT_EXT_LAST_F);
1195 }
1196
1197 void xdump(FILE * file, char *msg, void *p, int size)
1198 {
1199 #define HEX(x)  ((x) < 10 ? '0' + (x) : 'a' + ((x) -10))
1200         uint8_t *cp = p;
1201         int i;
1202
1203         if (msg)
1204                 fputs(msg, file);
1205
1206         for (i = 0; i < size;) {
1207                 fputc(HEX(*cp >> 4), file);
1208                 fputc(HEX(*cp & 0xf), file);
1209                 if (++i >= size)
1210                         break;
1211                 fputc(HEX(cp[1] >> 4), file);
1212                 fputc(HEX(cp[1] & 0xf), file);
1213                 if ((++i) % 16)
1214                         fputc(' ', file);
1215                 else
1216                         fputc('\n', file);
1217                 cp += 2;
1218         }
1219         if (i % 16)
1220                 fputc('\n', file);
1221 }