afccb5751f483b0237c3f06a266d2e18fbaee248
[mirror/winof/.git] / ulp / libibmad / src / dump.c
1 /*\r
2  * Copyright (c) 2004-2008 Voltaire Inc.  All rights reserved.\r
3  * Copyright (c) 2007 Xsigo Systems Inc.  All rights reserved.\r
4  *\r
5  * This software is available to you under the OpenFabrics.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AWV\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  */\r
30 \r
31 #if HAVE_CONFIG_H\r
32 #  include <config.h>\r
33 #endif /* HAVE_CONFIG_H */\r
34 \r
35 #include <stdio.h>\r
36 #include <stdlib.h>\r
37 #include <string.h>\r
38 \r
39 #if defined(_WIN32) || defined(_WIN64)\r
40 #include <windows.h>\r
41 #include <winsock2.h>\r
42 #define snprintf _snprintf\r
43 #else\r
44 #include <stdint.h>\r
45 #include <unistd.h>\r
46 #include <inttypes.h>\r
47 #include <netinet/in.h>\r
48 #endif\r
49 \r
50 #include <mad.h>\r
51 #include <complib/cl_types.h>\r
52 \r
53 MAD_EXPORT void\r
54 xdump(FILE *file, char *msg, void *p, int size)\r
55 {\r
56 #define HEX(x)  ((x) < 10 ? '0' + (x) : 'a' + ((x) -10))\r
57         uint8_t *cp = p;\r
58         int i;\r
59 \r
60         if (msg)\r
61                 fputs(msg, file);\r
62 \r
63         for (i = 0; i < size;) {\r
64                 fputc(HEX(*cp >> 4), file);\r
65                 fputc(HEX(*cp & 0xf), file);\r
66                 if (++i >= size)\r
67                         break;\r
68                 fputc(HEX(cp[1] >> 4), file);\r
69                 fputc(HEX(cp[1] & 0xf), file);\r
70                 if ((++i) % 16)\r
71                         fputc(' ', file);\r
72                 else\r
73                         fputc('\n', file);\r
74                 cp += 2;\r
75         }\r
76         if (i % 16) {\r
77                 fputc('\n', file);\r
78         }\r
79 }\r
80 \r
81 MAD_EXPORT void\r
82 mad_dump_int(char *buf, int bufsz, void *val, int valsz)\r
83 {\r
84         switch (valsz) {\r
85         case 1:\r
86                 snprintf(buf, bufsz, "%d", *(uint8_t *)val);\r
87                 break;\r
88         case 2:\r
89                 snprintf(buf, bufsz, "%d", *(uint16_t *)val);\r
90                 break;\r
91         case 3:\r
92         case 4:\r
93                 snprintf(buf, bufsz, "%d", *(uint32_t *)val);\r
94                 break;\r
95         case 5:\r
96         case 6:\r
97         case 7:\r
98         case 8:\r
99                 snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *)val);\r
100                 break;\r
101         default:\r
102                 IBWARN("bad int sz %d", valsz);\r
103                 buf[0] = 0;\r
104         }\r
105 }\r
106 \r
107 MAD_EXPORT void\r
108 mad_dump_uint(char *buf, int bufsz, void *val, int valsz)\r
109 {\r
110         switch (valsz) {\r
111         case 1:\r
112                 snprintf(buf, bufsz, "%u", *(uint8_t *)val);\r
113                 break;\r
114         case 2:\r
115                 snprintf(buf, bufsz, "%u", *(uint16_t *)val);\r
116                 break;\r
117         case 3:\r
118         case 4:\r
119                 snprintf(buf, bufsz, "%u", *(uint32_t *)val);\r
120                 break;\r
121         case 5:\r
122         case 6:\r
123         case 7:\r
124         case 8:\r
125                 snprintf(buf, bufsz, "%" PRIu64, *(uint64_t *)val);\r
126                 break;\r
127         default:\r
128                 IBWARN("bad int sz %u", valsz);\r
129                 buf[0] = 0;\r
130         }\r
131 }\r
132 \r
133 MAD_EXPORT void\r
134 mad_dump_hex(char *buf, int bufsz, void *val, int valsz)\r
135 {\r
136         switch (valsz) {\r
137         case 1:\r
138                 snprintf(buf, bufsz, "0x%02x", *(uint8_t *)val);\r
139                 break;\r
140         case 2:\r
141                 snprintf(buf, bufsz, "0x%04x", *(uint16_t *)val);\r
142                 break;\r
143         case 3:\r
144                 snprintf(buf, bufsz, "0x%06x", *(uint32_t *)val & 0xffffff);\r
145                 break;\r
146         case 4:\r
147                 snprintf(buf, bufsz, "0x%08x", *(uint32_t *)val);\r
148                 break;\r
149         case 5:\r
150                 snprintf(buf, bufsz, "0x%010" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffULL);\r
151                 break;\r
152         case 6:\r
153                 snprintf(buf, bufsz, "0x%012" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffULL);\r
154                 break;\r
155         case 7:\r
156                 snprintf(buf, bufsz, "0x%014" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffffULL);\r
157                 break;\r
158         case 8:\r
159                 snprintf(buf, bufsz, "0x%016" PRIx64, *(uint64_t *)val);\r
160                 break;\r
161         default:\r
162                 IBWARN("bad int sz %d", valsz);\r
163                 buf[0] = 0;\r
164         }\r
165 }\r
166 \r
167 MAD_EXPORT void\r
168 mad_dump_rhex(char *buf, int bufsz, void *val, int valsz)\r
169 {\r
170         switch (valsz) {\r
171         case 1:\r
172                 snprintf(buf, bufsz, "%02x", *(uint8_t *)val);\r
173                 break;\r
174         case 2:\r
175                 snprintf(buf, bufsz, "%04x", *(uint16_t *)val);\r
176                 break;\r
177         case 3:\r
178                 snprintf(buf, bufsz, "%06x", *(uint32_t *)val & 0xffffff);\r
179                 break;\r
180         case 4:\r
181                 snprintf(buf, bufsz, "%08x", *(uint32_t *)val);\r
182                 break;\r
183         case 5:\r
184                 snprintf(buf, bufsz, "%010" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffULL);\r
185                 break;\r
186         case 6:\r
187                 snprintf(buf, bufsz, "%012" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffULL);\r
188                 break;\r
189         case 7:\r
190                 snprintf(buf, bufsz, "%014" PRIx64, *(uint64_t *)val & (uint64_t) 0xffffffffffffffULL);\r
191                 break;\r
192         case 8:\r
193                 snprintf(buf, bufsz, "%016" PRIx64, *(uint64_t *)val);\r
194                 break;\r
195         default:\r
196                 IBWARN("bad int sz %d", valsz);\r
197                 buf[0] = 0;\r
198         }\r
199 }\r
200 \r
201 MAD_EXPORT void\r
202 mad_dump_linkwidth(char *buf, int bufsz, void *val, int valsz)\r
203 {\r
204         int width = *(int *)val;\r
205 \r
206         switch (width) {\r
207         case 1:\r
208                 snprintf(buf, bufsz, "1X");\r
209                 break;\r
210         case 2:\r
211                 snprintf(buf, bufsz, "4X");\r
212                 break;\r
213         case 4:\r
214                 snprintf(buf, bufsz, "8X");\r
215                 break;\r
216         case 8:\r
217                 snprintf(buf, bufsz, "12X");\r
218                 break;\r
219         default:\r
220                 IBWARN("bad width %d", width);\r
221                 buf[0] = 0;\r
222         }\r
223 }\r
224 \r
225 static void\r
226 dump_linkwidth(char *buf, int bufsz, int width)\r
227 {\r
228         int n = 0;\r
229 \r
230         if (width & 0x1)\r
231                 n += snprintf(buf + n, bufsz - n, "1X or ");\r
232         if (n < bufsz && (width & 0x2))\r
233                 n += snprintf(buf + n, bufsz - n, "4X or ");\r
234         if (n < bufsz && (width & 0x4))\r
235                 n += snprintf(buf + n, bufsz - n, "8X or ");\r
236         if (n < bufsz && (width & 0x8))\r
237                 n += snprintf(buf + n, bufsz - n, "12X or ");\r
238 \r
239         if (n >= bufsz)\r
240                 return;\r
241         else if (width == 0 || (width >> 4))\r
242                 snprintf(buf + n, bufsz - n, "undefined (%d)", width);\r
243         else if (bufsz > 3)\r
244                 buf[n-4] = '\0';\r
245 }\r
246 \r
247 MAD_EXPORT void\r
248 mad_dump_linkwidthsup(char *buf, int bufsz, void *val, int valsz)\r
249 {\r
250         int width = *(int *)val;\r
251 \r
252         dump_linkwidth(buf, bufsz, width);\r
253 \r
254         switch(width) {\r
255         case 1:\r
256         case 3:\r
257         case 7:\r
258         case 11:\r
259         case 15:\r
260                 break;\r
261 \r
262         default:\r
263                 if (!(width >> 4))\r
264                         snprintf(buf + strlen(buf), bufsz - strlen(buf),\r
265                                  " (IBA extension)");\r
266                 break;\r
267         }\r
268 }\r
269 \r
270 MAD_EXPORT void\r
271 mad_dump_linkwidthen(char *buf, int bufsz, void *val, int valsz)\r
272 {\r
273         int width = *(int *)val;\r
274 \r
275         dump_linkwidth(buf, bufsz, width);\r
276 }\r
277 \r
278 MAD_EXPORT void\r
279 mad_dump_linkspeed(char *buf, int bufsz, void *val, int valsz)\r
280 {\r
281         int speed = *(int *)val;\r
282 \r
283         switch (speed) {\r
284         case 1:\r
285                 snprintf(buf, bufsz, "2.5 Gbps");\r
286                 break;\r
287         case 2:\r
288                 snprintf(buf, bufsz, "5.0 Gbps");\r
289                 break;\r
290         case 4:\r
291                 snprintf(buf, bufsz, "10.0 Gbps");\r
292                 break;\r
293         default:\r
294                 snprintf(buf, bufsz, "undefined (%d)", speed);\r
295                 break;\r
296         }\r
297 }\r
298 \r
299 static void\r
300 dump_linkspeed(char *buf, int bufsz, int speed)\r
301 {\r
302         int n = 0;\r
303 \r
304         if (speed & 0x1)\r
305                 n += snprintf(buf + n, bufsz - n, "2.5 Gbps or ");\r
306         if (n < bufsz && (speed & 0x2))\r
307                 n += snprintf(buf + n, bufsz - n, "5.0 Gbps or ");\r
308         if (n < bufsz && (speed & 0x4))\r
309                 n += snprintf(buf + n, bufsz - n, "10.0 Gbps or ");\r
310 \r
311         if (n >= bufsz)\r
312                 return;\r
313         else if (speed == 0 || (speed >> 3)) {\r
314                 n += snprintf(buf + n, bufsz - n, "undefined (%d)", speed);\r
315                 if (n >= bufsz)\r
316                         return;\r
317         } else if (bufsz > 3) {\r
318                 buf[n-4] = '\0';\r
319                 n -= 4;\r
320         }\r
321 \r
322         switch (speed) {\r
323         case 1:\r
324         case 3:\r
325         case 5:\r
326         case 7:\r
327                 break;\r
328         default:\r
329                 if (!(speed >> 3))\r
330                         snprintf(buf + n, bufsz - n, " (IBA extension)");\r
331                 break;\r
332         }\r
333 }\r
334 \r
335 MAD_EXPORT void\r
336 mad_dump_linkspeedsup(char *buf, int bufsz, void *val, int valsz)\r
337 {\r
338         int speed = *(int *)val;\r
339 \r
340         dump_linkspeed(buf, bufsz, speed);\r
341 }\r
342 \r
343 MAD_EXPORT void\r
344 mad_dump_linkspeeden(char *buf, int bufsz, void *val, int valsz)\r
345 {\r
346         int speed = *(int *)val;\r
347 \r
348         dump_linkspeed(buf, bufsz, speed);\r
349 }\r
350 \r
351 MAD_EXPORT void\r
352 mad_dump_portstate(char *buf, int bufsz, void *val, int valsz)\r
353 {\r
354         int state = *(int *)val;\r
355 \r
356         switch (state) {\r
357         case 0:\r
358                 snprintf(buf, bufsz, "NoChange");\r
359                 break;\r
360         case 1:\r
361                 snprintf(buf, bufsz, "Down");\r
362                 break;\r
363         case 2:\r
364                 snprintf(buf, bufsz, "Initialize");\r
365                 break;\r
366         case 3:\r
367                 snprintf(buf, bufsz, "Armed");\r
368                 break;\r
369         case 4:\r
370                 snprintf(buf, bufsz, "Active");\r
371                 break;\r
372         default:\r
373                 snprintf(buf, bufsz, "?(%d)", state);\r
374         }\r
375 }\r
376 \r
377 MAD_EXPORT void\r
378 mad_dump_linkdowndefstate(char *buf, int bufsz, void *val, int valsz)\r
379 {\r
380         int state = *(int *)val;\r
381 \r
382         switch(state) {\r
383         case 0:\r
384                 snprintf(buf, bufsz, "NoChange");\r
385                 break;\r
386         case 1:\r
387                 snprintf(buf, bufsz, "Sleep");\r
388                 break;\r
389         case 2:\r
390                 snprintf(buf, bufsz, "Polling");\r
391                 break;\r
392         default:\r
393                 snprintf(buf, bufsz, "?(%d)", state);\r
394                 break;\r
395         }\r
396 }\r
397 \r
398 MAD_EXPORT void\r
399 mad_dump_physportstate(char *buf, int bufsz, void *val, int valsz)\r
400 {\r
401         int state = *(int *)val;\r
402 \r
403         switch (state) {\r
404         case 0:\r
405                 snprintf(buf, bufsz, "NoChange");\r
406                 break;\r
407         case 1:\r
408                 snprintf(buf, bufsz, "Sleep");\r
409                 break;\r
410         case 2:\r
411                 snprintf(buf, bufsz, "Polling");\r
412                 break;\r
413         case 3:\r
414                 snprintf(buf, bufsz, "Disabled");\r
415                 break;\r
416         case 4:\r
417                 snprintf(buf, bufsz, "PortConfigurationTraining");\r
418                 break;\r
419         case 5:\r
420                 snprintf(buf, bufsz, "LinkUp");\r
421                 break;\r
422         case 6:\r
423                 snprintf(buf, bufsz, "LinkErrorRecovery");\r
424                 break;\r
425         case 7:\r
426                 snprintf(buf, bufsz, "PhyTest");\r
427                 break;\r
428         default:\r
429                 snprintf(buf, bufsz, "?(%d)", state);\r
430         }\r
431 }\r
432 \r
433 MAD_EXPORT void\r
434 mad_dump_mtu(char *buf, int bufsz, void *val, int valsz)\r
435 {\r
436         int mtu = *(int *)val;\r
437 \r
438         switch (mtu) {\r
439         case 1:\r
440                 snprintf(buf, bufsz, "256");\r
441                 break;\r
442         case 2:\r
443                 snprintf(buf, bufsz, "512");\r
444                 break;\r
445         case 3:\r
446                 snprintf(buf, bufsz, "1024");\r
447                 break;\r
448         case 4:\r
449                 snprintf(buf, bufsz, "2048");\r
450                 break;\r
451         case 5:\r
452                 snprintf(buf, bufsz, "4096");\r
453                 break;\r
454         default:\r
455                 snprintf(buf, bufsz, "?(%d)", mtu);\r
456                 buf[0] = 0;\r
457         }\r
458 }\r
459 \r
460 MAD_EXPORT void\r
461 mad_dump_vlcap(char *buf, int bufsz, void *val, int valsz)\r
462 {\r
463         int vlcap = *(int *)val;\r
464 \r
465         switch (vlcap) {\r
466         case 1:\r
467                 snprintf(buf, bufsz, "VL0");\r
468                 break;\r
469         case 2:\r
470                 snprintf(buf, bufsz, "VL0-1");\r
471                 break;\r
472         case 3:\r
473                 snprintf(buf, bufsz, "VL0-3");\r
474                 break;\r
475         case 4:\r
476                 snprintf(buf, bufsz, "VL0-7");\r
477                 break;\r
478         case 5:\r
479                 snprintf(buf, bufsz, "VL0-14");\r
480                 break;\r
481         default:\r
482                 snprintf(buf, bufsz, "?(%d)", vlcap);\r
483         }\r
484 }\r
485 \r
486 MAD_EXPORT void\r
487 mad_dump_opervls(char *buf, int bufsz, void *val, int valsz)\r
488 {\r
489         int opervls = *(int *)val;\r
490 \r
491         switch (opervls) {\r
492         case 0:\r
493                 snprintf(buf, bufsz, "No change");\r
494                 break;\r
495         case 1:\r
496                 snprintf(buf, bufsz, "VL0");\r
497                 break;\r
498         case 2:\r
499                 snprintf(buf, bufsz, "VL0-1");\r
500                 break;\r
501         case 3:\r
502                 snprintf(buf, bufsz, "VL0-3");\r
503                 break;\r
504         case 4:\r
505                 snprintf(buf, bufsz, "VL0-7");\r
506                 break;\r
507         case 5:\r
508                 snprintf(buf, bufsz, "VL0-14");\r
509                 break;\r
510         default:\r
511                 snprintf(buf, bufsz, "?(%d)", opervls);\r
512         }\r
513 }\r
514 \r
515 MAD_EXPORT void\r
516 mad_dump_portcapmask(char *buf, int bufsz, void *val, int valsz)\r
517 {\r
518         unsigned mask = *(unsigned *)val;\r
519         char *s = buf;\r
520 \r
521         s += sprintf(s, "0x%x\n", mask);\r
522         if (mask & (1 << 1))\r
523                 s += sprintf(s, "\t\t\t\tIsSM\n");\r
524         if (mask & (1 << 2))\r
525                 s += sprintf(s, "\t\t\t\tIsNoticeSupported\n");\r
526         if (mask & (1 << 3))\r
527                 s += sprintf(s, "\t\t\t\tIsTrapSupported\n");\r
528         if (mask & (1 << 5))\r
529                 s += sprintf(s, "\t\t\t\tIsAutomaticMigrationSupported\n");\r
530         if (mask & (1 << 6))\r
531                 s += sprintf(s, "\t\t\t\tIsSLMappingSupported\n");\r
532         if (mask & (1 << 7))\r
533                 s += sprintf(s, "\t\t\t\tIsMKeyNVRAM\n");\r
534         if (mask & (1 << 8))\r
535                 s += sprintf(s, "\t\t\t\tIsPKeyNVRAM\n");\r
536         if (mask & (1 << 9))\r
537                 s += sprintf(s, "\t\t\t\tIsLedInfoSupported\n");\r
538         if (mask & (1 << 10))\r
539                 s += sprintf(s, "\t\t\t\tIsSMdisabled\n");\r
540         if (mask & (1 << 11))\r
541                 s += sprintf(s, "\t\t\t\tIsSystemImageGUIDsupported\n");\r
542         if (mask & (1 << 12))\r
543                 s += sprintf(s, "\t\t\t\tIsPkeySwitchExternalPortTrapSupported\n");\r
544         if (mask & (1 << 16))\r
545                 s += sprintf(s, "\t\t\t\tIsCommunicatonManagementSupported\n");\r
546         if (mask & (1 << 17))\r
547                 s += sprintf(s, "\t\t\t\tIsSNMPTunnelingSupported\n");\r
548         if (mask & (1 << 18))\r
549                 s += sprintf(s, "\t\t\t\tIsReinitSupported\n");\r
550         if (mask & (1 << 19))\r
551                 s += sprintf(s, "\t\t\t\tIsDeviceManagementSupported\n");\r
552         if (mask & (1 << 20))\r
553                 s += sprintf(s, "\t\t\t\tIsVendorClassSupported\n");\r
554         if (mask & (1 << 21))\r
555                 s += sprintf(s, "\t\t\t\tIsDRNoticeSupported\n");\r
556         if (mask & (1 << 22))\r
557                 s += sprintf(s, "\t\t\t\tIsCapabilityMaskNoticeSupported\n");\r
558         if (mask & (1 << 23))\r
559                 s += sprintf(s, "\t\t\t\tIsBootManagementSupported\n");\r
560         if (mask & (1 << 24))\r
561                 s += sprintf(s, "\t\t\t\tIsLinkRoundTripLatencySupported\n");\r
562         if (mask & (1 << 25))\r
563                 s += sprintf(s, "\t\t\t\tIsClientRegistrationSupported\n");\r
564 \r
565         if (s != buf)\r
566                 *(--s) = 0;\r
567 }\r
568 \r
569 MAD_EXPORT void\r
570 mad_dump_bitfield(char *buf, int bufsz, void *val, int valsz)\r
571 {\r
572         snprintf(buf, bufsz, "0x%x", *(uint32_t *)val);\r
573 }\r
574 \r
575 MAD_EXPORT void\r
576 mad_dump_array(char *buf, int bufsz, void *val, int valsz)\r
577 {\r
578         uint8_t *p = val, *e;\r
579         char *s = buf;\r
580 \r
581         if (bufsz < valsz*2)\r
582                 valsz = bufsz/2;\r
583 \r
584         for (p = val, e = p + valsz; p < e; p++, s += 2)\r
585                 sprintf(s, "%02x", *p);\r
586 }\r
587 \r
588 MAD_EXPORT void\r
589 mad_dump_string(char *buf, int bufsz, void *val, int valsz)\r
590 {\r
591         if (bufsz < valsz)\r
592                 valsz = bufsz;\r
593 \r
594         snprintf(buf, valsz, "'%s'", (char *)val);\r
595 }\r
596 \r
597 MAD_EXPORT void\r
598 mad_dump_node_type(char *buf, int bufsz, void *val, int valsz)\r
599 {\r
600         int nodetype = *(int*)val;\r
601 \r
602         switch (nodetype) {\r
603         case 1:\r
604                 snprintf(buf, bufsz, "Channel Adapter");\r
605                 break;\r
606         case 2:\r
607                 snprintf(buf, bufsz, "Switch");\r
608                 break;\r
609         case 3:\r
610                 snprintf(buf, bufsz, "Router");\r
611                 break;\r
612         default:\r
613                 snprintf(buf, bufsz, "?(%d)?", nodetype);\r
614                 break;\r
615         }\r
616 }\r
617 \r
618 #define IB_MAX_NUM_VLS 16\r
619 #define IB_MAX_NUM_VLS_TO_U8 ((IB_MAX_NUM_VLS)/2)\r
620 \r
621 typedef struct _ib_slvl_table {\r
622         uint8_t vl_by_sl_num[IB_MAX_NUM_VLS_TO_U8];\r
623 } ib_slvl_table_t;\r
624 \r
625 static inline void\r
626 ib_slvl_get_i(ib_slvl_table_t *tbl, int i, uint8_t *vl)\r
627 {\r
628         *vl = (tbl->vl_by_sl_num[i >> 1] >> ((!(i&1)) << 2)) & 0xf;\r
629 }\r
630 \r
631 #define IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK 32\r
632 \r
633 typedef struct _ib_vl_arb_table {\r
634         struct {\r
635                 uint8_t res_vl;\r
636                 uint8_t weight;\r
637         } vl_entry[IB_NUM_VL_ARB_ELEMENTS_IN_BLOCK];\r
638 } ib_vl_arb_table_t;\r
639 \r
640 static inline void\r
641 ib_vl_arb_get_vl(uint8_t res_vl, uint8_t *const vl )\r
642 {\r
643         *vl = res_vl & 0x0F;\r
644 }\r
645 \r
646 MAD_EXPORT void\r
647 mad_dump_sltovl(char *buf, int bufsz, void *val, int valsz)\r
648 {\r
649         ib_slvl_table_t* p_slvl_tbl = val;\r
650         uint8_t vl;\r
651         int i, n = 0;\r
652         n = snprintf(buf, bufsz, "|");\r
653         for (i = 0; i < 16; i++) {\r
654                 ib_slvl_get_i(p_slvl_tbl, i, &vl);\r
655                 n += snprintf(buf + n, bufsz - n, "%2u|", vl);\r
656                 if (n >= bufsz)\r
657                         break;\r
658         }\r
659         snprintf(buf + n, bufsz - n, "\n");\r
660 }\r
661 \r
662 MAD_EXPORT void\r
663 mad_dump_vlarbitration(char *buf, int bufsz, void *val, int num)\r
664 {\r
665         ib_vl_arb_table_t* p_vla_tbl = val;\r
666         int i, n;\r
667         uint8_t vl;\r
668 \r
669         num /= sizeof(p_vla_tbl->vl_entry[0]);\r
670 \r
671         n = snprintf(buf, bufsz, "\nVL    : |");\r
672         if (n >= bufsz)\r
673                 return;\r
674         for (i = 0; i < num; i++) {\r
675                 ib_vl_arb_get_vl(p_vla_tbl->vl_entry[i].res_vl, &vl);\r
676                 n += snprintf(buf + n, bufsz - n, "0x%-2X|", vl);\r
677                 if (n >= bufsz)\r
678                         return;\r
679         }\r
680 \r
681         n += snprintf(buf + n, bufsz - n, "\nWEIGHT: |");\r
682         if (n >= bufsz)\r
683                 return;\r
684         for (i = 0; i < num; i++) {\r
685                 n += snprintf(buf + n, bufsz - n, "0x%-2X|",\r
686                               p_vla_tbl->vl_entry[i].weight);\r
687                 if (n >= bufsz)\r
688                         return;\r
689         }\r
690 \r
691         snprintf(buf + n, bufsz - n, "\n");\r
692 }\r
693 \r
694 static int\r
695 _dump_fields(char *buf, int bufsz, void *data, int start, int end)\r
696 {\r
697         char val[64];\r
698         char *s = buf;\r
699         int n, field;\r
700 \r
701         for (field = start; field < end && bufsz > 0; field++) {\r
702                 mad_decode_field(data, field, val);\r
703                 if (!mad_dump_field(field, s, bufsz, val))\r
704                         return -1;\r
705                 n = strlen(s);\r
706                 s += n;\r
707                 *s++ = '\n';\r
708                 *s = 0;\r
709                 n++;\r
710                 bufsz -= n;\r
711         }\r
712 \r
713         return (int)(s - buf);\r
714 }\r
715 \r
716 MAD_EXPORT void\r
717 mad_dump_nodedesc(char *buf, int bufsz, void *val, int valsz)\r
718 {\r
719         strncpy(buf, val, bufsz);\r
720 \r
721         if (valsz < bufsz)\r
722                 buf[valsz] = 0;\r
723 }\r
724 \r
725 MAD_EXPORT void\r
726 mad_dump_nodeinfo(char *buf, int bufsz, void *val, int valsz)\r
727 {\r
728         _dump_fields(buf, bufsz, val, IB_NODE_FIRST_F, IB_NODE_LAST_F);\r
729 }\r
730 \r
731 MAD_EXPORT void\r
732 mad_dump_portinfo(char *buf, int bufsz, void *val, int valsz)\r
733 {\r
734         _dump_fields(buf, bufsz, val, IB_PORT_FIRST_F, IB_PORT_LAST_F);\r
735 }\r
736 \r
737 MAD_EXPORT void\r
738 mad_dump_portstates(char *buf, int bufsz, void *val, int valsz)\r
739 {\r
740         _dump_fields(buf, bufsz, val, IB_PORT_STATE_F, IB_PORT_LINK_DOWN_DEF_F);\r
741 }\r
742 \r
743 MAD_EXPORT void\r
744 mad_dump_switchinfo(char *buf, int bufsz, void *val, int valsz)\r
745 {\r
746         _dump_fields(buf, bufsz, val, IB_SW_FIRST_F, IB_SW_LAST_F);\r
747 }\r
748 \r
749 MAD_EXPORT void\r
750 mad_dump_perfcounters(char *buf, int bufsz, void *val, int valsz)\r
751 {\r
752         _dump_fields(buf, bufsz, val, IB_PC_FIRST_F, IB_PC_LAST_F);\r
753 }\r
754 \r
755 MAD_EXPORT void\r
756 mad_dump_perfcounters_ext(char *buf, int bufsz, void *val, int valsz)\r
757 {\r
758         _dump_fields(buf, bufsz, val, IB_PC_EXT_FIRST_F, IB_PC_EXT_LAST_F);\r
759 }\r
760 \r
761 /************************/\r
762 \r
763 char *\r
764 _mad_dump_val(ib_field_t *f, char *buf, int bufsz, void *val)\r
765 {\r
766         f->def_dump_fn(buf, bufsz, val, ALIGN(f->bitlen, 8) / 8);\r
767         buf[bufsz - 1] = 0;\r
768 \r
769         return buf;\r
770 }\r
771 \r
772 char *\r
773 _mad_dump_field(ib_field_t *f, char *name, char *buf, int bufsz, void *val)\r
774 {\r
775         char dots[128];\r
776         int l, n;\r
777 \r
778         if (bufsz <= 32)\r
779                 return 0;               /* buf too small */\r
780 \r
781         if (!name)\r
782                 name = f->name;\r
783 \r
784         l = strlen(name);\r
785         if (l < 32) {\r
786                 memset(dots, '.', 32 - l);\r
787                 dots[32 - l] = 0;\r
788         }\r
789 \r
790         n = snprintf(buf, bufsz, "%s:%s", name, dots);\r
791         _mad_dump_val(f, buf + n, bufsz - n, val);\r
792         buf[bufsz - 1] = 0;\r
793 \r
794         return buf;\r
795 }\r
796 \r
797 int\r
798 _mad_dump(ib_mad_dump_fn *fn, char *name, void *val, int valsz)\r
799 {\r
800         ib_field_t f;\r
801         char buf[512];\r
802 \r
803         memset(&f, 0, sizeof(f));\r
804         f.def_dump_fn = fn; \r
805         f.bitlen = valsz * 8;\r
806 \r
807         return printf("%s\n", _mad_dump_field(&f, name, buf, sizeof buf, val));\r
808 }\r
809 \r
810 int\r
811 _mad_print_field(ib_field_t *f, char *name, void *val, int valsz)\r
812 {\r
813         return _mad_dump(f->def_dump_fn, name ? name : f->name, val, valsz ? valsz : ALIGN(f->bitlen, 8) / 8);\r
814 }\r
815 \r