1 /* 2 * Copyright (c) 2004-2009 Voltaire Inc. All rights reserved. 3 * Copyright (c) 2011 Mellanox Technologies LTD. All rights reserved. 4 * Copyright (c) 2011 Lawrence Livermore National Lab. 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 #if HAVE_CONFIG_H 37 # include <config.h> 38 #endif /* HAVE_CONFIG_H */ 39 40 #include <stdio.h> 41 #include <stdlib.h> 42 #include <unistd.h> 43 #include <string.h> 44 #include <getopt.h> 45 #include <errno.h> 46 #include <netinet/in.h> 47 #include <limits.h> 48 #include <ctype.h> 49 50 #define __STDC_FORMAT_MACROS 51 #include <inttypes.h> 52 53 #include <infiniband/mad.h> 54 55 #include "ibdiag_common.h" 56 57 struct ibmad_port *srcport; 58 59 static ibmad_gid_t dgid; 60 static int with_grh; 61 62 static op_fn_t congestion_key_info; 63 static op_fn_t switch_congestion_setting; 64 static op_fn_t switch_port_congestion_setting; 65 static op_fn_t ca_congestion_setting; 66 static op_fn_t congestion_control_table; 67 68 static const match_rec_t match_tbl[] = { 69 {"CongestionKeyInfo", "CK", congestion_key_info, 0, 70 "<cckey> <cckeyprotectbit> <cckeyleaseperiod> <cckeyviolations>"}, 71 {"SwitchCongestionSetting", "SS", switch_congestion_setting, 0, 72 "<controlmap> <victimmask> <creditmask> <threshold> <packetsize> " 73 "<csthreshold> <csreturndelay> <markingrate>"}, 74 {"SwitchPortCongestionSetting", "SP", switch_port_congestion_setting, 1, 75 "<valid> <control_type> <threshold> <packet_size> <cong_parm_marking_rate>"}, 76 {"CACongestionSetting", "CS", ca_congestion_setting, 0, 77 "<port_control> <control_map> <ccti_timer> <ccti_increase> " 78 "<trigger_threshold> <ccti_min>"}, 79 {"CongestionControlTable", "CT", congestion_control_table, 0, 80 "<cctilimit> <index> <cctentry> <cctentry> ..."}, 81 {0} 82 }; 83 84 uint64_t cckey = 0; 85 86 /*******************************************/ 87 static char *parselonglongint(char *arg, uint64_t *val) 88 { 89 char *endptr = NULL; 90 91 errno = 0; 92 *val = strtoull(arg, &endptr, 0); 93 if ((endptr && *endptr != '\0') 94 || errno != 0) { 95 if (errno == ERANGE) 96 return "value out of range"; 97 return "invalid integer input"; 98 } 99 100 return NULL; 101 } 102 103 static char *parseint(char *arg, uint32_t *val, int hexonly) 104 { 105 char *endptr = NULL; 106 107 errno = 0; 108 *val = strtoul(arg, &endptr, hexonly ? 16 : 0); 109 if ((endptr && *endptr != '\0') 110 || errno != 0) { 111 if (errno == ERANGE) 112 return "value out of range"; 113 return "invalid integer input"; 114 } 115 116 return NULL; 117 } 118 119 static char *congestion_key_info(ib_portid_t * dest, char **argv, int argc) 120 { 121 uint8_t rcv[IB_CC_DATA_SZ] = { 0 }; 122 uint8_t payload[IB_CC_DATA_SZ] = { 0 }; 123 uint64_t cc_key; 124 uint32_t cc_keyprotectbit; 125 uint32_t cc_keyleaseperiod; 126 uint32_t cc_keyviolations; 127 char *errstr; 128 129 if (argc != 4) 130 return "invalid number of parameters for CongestionKeyInfo"; 131 132 if ((errstr = parselonglongint(argv[0], &cc_key))) 133 return errstr; 134 if ((errstr = parseint(argv[1], &cc_keyprotectbit, 0))) 135 return errstr; 136 if ((errstr = parseint(argv[2], &cc_keyleaseperiod, 0))) 137 return errstr; 138 if ((errstr = parseint(argv[3], &cc_keyviolations, 0))) 139 return errstr; 140 141 if (cc_keyprotectbit != 0 && cc_keyprotectbit != 1) 142 return "invalid cc_keyprotectbit value"; 143 144 if (cc_keyleaseperiod > USHRT_MAX) 145 return "invalid cc_keyleaseperiod value"; 146 147 if (cc_keyviolations > USHRT_MAX) 148 return "invalid cc_keyviolations value"; 149 150 mad_set_field64(payload, 151 0, 152 IB_CC_CONGESTION_KEY_INFO_CC_KEY_F, 153 cc_key); 154 155 mad_encode_field(payload, 156 IB_CC_CONGESTION_KEY_INFO_CC_KEY_PROTECT_BIT_F, 157 &cc_keyprotectbit); 158 159 mad_encode_field(payload, 160 IB_CC_CONGESTION_KEY_INFO_CC_KEY_LEASE_PERIOD_F, 161 &cc_keyleaseperiod); 162 163 /* spec says "setting the counter to a value other than zero results 164 * in the counter being left unchanged. So if user wants no change, 165 * they gotta input non-zero 166 */ 167 mad_encode_field(payload, 168 IB_CC_CONGESTION_KEY_INFO_CC_KEY_VIOLATIONS_F, 169 &cc_keyviolations); 170 171 if (!cc_config_status_via(payload, rcv, dest, IB_CC_ATTR_CONGESTION_KEY_INFO, 172 0, 0, NULL, srcport, cckey)) 173 return "congestion key info config failed"; 174 175 return NULL; 176 } 177 178 179 /* parse like it's a hypothetical 256 bit hex code */ 180 static char *parse256(char *arg, uint8_t *buf) 181 { 182 int numdigits = 0; 183 int startindex; 184 char *ptr; 185 int i; 186 187 if (!strncmp(arg, "0x", 2) || !strncmp(arg, "0X", 2)) 188 arg += 2; 189 190 for (ptr = arg; *ptr; ptr++) { 191 if (!isxdigit(*ptr)) 192 return "invalid hex digit read"; 193 numdigits++; 194 } 195 196 if (numdigits > 64) 197 return "hex code too long"; 198 199 /* we need to imagine that this is like a 256-bit int stored 200 * in big endian. So we need to find the first index 201 * point where the user's input would start in our array. 202 */ 203 startindex = 32 - ((numdigits - 1) / 2) - 1; 204 205 for (i = startindex; i <= 31; i++) { 206 char tmp[3] = { 0 }; 207 uint32_t tmpint; 208 char *errstr; 209 210 /* I can't help but think there is a strtoX that 211 * will do this for me, but I can't find it. 212 */ 213 if (i == startindex && numdigits % 2) { 214 memcpy(tmp, arg, 1); 215 arg++; 216 } 217 else { 218 memcpy(tmp, arg, 2); 219 arg += 2; 220 } 221 222 if ((errstr = parseint(tmp, &tmpint, 1))) 223 return errstr; 224 buf[i] = tmpint; 225 } 226 227 return NULL; 228 } 229 230 static char *parsecct(char *arg, uint32_t *shift, uint32_t *multiplier) 231 { 232 char buf[1024] = { 0 }; 233 char *errstr; 234 char *ptr; 235 236 strcpy(buf, arg); 237 238 if (!(ptr = strchr(buf, ':'))) 239 return "ccts are formatted shift:multiplier"; 240 241 *ptr = '\0'; 242 ptr++; 243 244 if ((errstr = parseint(buf, shift, 0))) 245 return errstr; 246 247 if ((errstr = parseint(ptr, multiplier, 0))) 248 return errstr; 249 250 return NULL; 251 } 252 253 static char *switch_congestion_setting(ib_portid_t * dest, char **argv, int argc) 254 { 255 uint8_t rcv[IB_CC_DATA_SZ] = { 0 }; 256 uint8_t payload[IB_CC_DATA_SZ] = { 0 }; 257 uint32_t control_map; 258 uint8_t victim_mask[32] = { 0 }; 259 uint8_t credit_mask[32] = { 0 }; 260 uint32_t threshold; 261 uint32_t packet_size; 262 uint32_t cs_threshold; 263 uint32_t cs_returndelay_s; 264 uint32_t cs_returndelay_m; 265 uint32_t cs_returndelay; 266 uint32_t marking_rate; 267 char *errstr; 268 269 if (argc != 8) 270 return "invalid number of parameters for SwitchCongestionSetting"; 271 272 if ((errstr = parseint(argv[0], &control_map, 0))) 273 return errstr; 274 275 if ((errstr = parse256(argv[1], victim_mask))) 276 return errstr; 277 278 if ((errstr = parse256(argv[2], credit_mask))) 279 return errstr; 280 281 if ((errstr = parseint(argv[3], &threshold, 0))) 282 return errstr; 283 284 if ((errstr = parseint(argv[4], &packet_size, 0))) 285 return errstr; 286 287 if ((errstr = parseint(argv[5], &cs_threshold, 0))) 288 return errstr; 289 290 if ((errstr = parsecct(argv[6], &cs_returndelay_s, &cs_returndelay_m))) 291 return errstr; 292 293 cs_returndelay = cs_returndelay_m; 294 cs_returndelay |= (cs_returndelay_s << 14); 295 296 if ((errstr = parseint(argv[7], &marking_rate, 0))) 297 return errstr; 298 299 mad_encode_field(payload, 300 IB_CC_SWITCH_CONGESTION_SETTING_CONTROL_MAP_F, 301 &control_map); 302 303 mad_set_array(payload, 304 0, 305 IB_CC_SWITCH_CONGESTION_SETTING_VICTIM_MASK_F, 306 victim_mask); 307 308 mad_set_array(payload, 309 0, 310 IB_CC_SWITCH_CONGESTION_SETTING_CREDIT_MASK_F, 311 credit_mask); 312 313 mad_encode_field(payload, 314 IB_CC_SWITCH_CONGESTION_SETTING_THRESHOLD_F, 315 &threshold); 316 317 mad_encode_field(payload, 318 IB_CC_SWITCH_CONGESTION_SETTING_PACKET_SIZE_F, 319 &packet_size); 320 321 mad_encode_field(payload, 322 IB_CC_SWITCH_CONGESTION_SETTING_CS_THRESHOLD_F, 323 &cs_threshold); 324 325 mad_encode_field(payload, 326 IB_CC_SWITCH_CONGESTION_SETTING_CS_RETURN_DELAY_F, 327 &cs_returndelay); 328 329 mad_encode_field(payload, 330 IB_CC_SWITCH_CONGESTION_SETTING_MARKING_RATE_F, 331 &marking_rate); 332 333 if (!cc_config_status_via(payload, rcv, dest, IB_CC_ATTR_SWITCH_CONGESTION_SETTING, 334 0, 0, NULL, srcport, cckey)) 335 return "switch congestion setting config failed"; 336 337 return NULL; 338 } 339 340 static char *switch_port_congestion_setting(ib_portid_t * dest, char **argv, int argc) 341 { 342 uint8_t rcv[IB_CC_DATA_SZ] = { 0 }; 343 uint8_t payload[IB_CC_DATA_SZ] = { 0 }; 344 uint8_t data[IB_CC_DATA_SZ] = { 0 }; 345 uint32_t portnum; 346 uint32_t valid; 347 uint32_t control_type; 348 uint32_t threshold; 349 uint32_t packet_size; 350 uint32_t cong_parm_marking_rate; 351 uint32_t type; 352 uint32_t numports; 353 uint8_t *ptr; 354 char *errstr; 355 356 if (argc != 6) 357 return "invalid number of parameters for SwitchPortCongestion"; 358 359 if ((errstr = parseint(argv[0], &portnum, 0))) 360 return errstr; 361 362 if ((errstr = parseint(argv[1], &valid, 0))) 363 return errstr; 364 365 if ((errstr = parseint(argv[2], &control_type, 0))) 366 return errstr; 367 368 if ((errstr = parseint(argv[3], &threshold, 0))) 369 return errstr; 370 371 if ((errstr = parseint(argv[4], &packet_size, 0))) 372 return errstr; 373 374 if ((errstr = parseint(argv[5], &cong_parm_marking_rate, 0))) 375 return errstr; 376 377 /* Figure out number of ports first */ 378 if (!smp_query_via(data, dest, IB_ATTR_NODE_INFO, 0, 0, srcport)) 379 return "node info config failed"; 380 381 mad_decode_field((uint8_t *)data, IB_NODE_TYPE_F, &type); 382 mad_decode_field((uint8_t *)data, IB_NODE_NPORTS_F, &numports); 383 384 if (type != IB_NODE_SWITCH) 385 return "destination not a switch"; 386 387 if (portnum > numports) 388 return "invalid port number specified"; 389 390 /* We are modifying only 1 port, so get the current config */ 391 if (!cc_query_status_via(payload, dest, IB_CC_ATTR_SWITCH_PORT_CONGESTION_SETTING, 392 portnum / 32, 0, NULL, srcport, cckey)) 393 return "switch port congestion setting query failed"; 394 395 ptr = payload + (((portnum % 32) * 4)); 396 397 mad_encode_field(ptr, 398 IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_VALID_F, 399 &valid); 400 401 mad_encode_field(ptr, 402 IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_CONTROL_TYPE_F, 403 &control_type); 404 405 mad_encode_field(ptr, 406 IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_THRESHOLD_F, 407 &threshold); 408 409 mad_encode_field(ptr, 410 IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_PACKET_SIZE_F, 411 &packet_size); 412 413 mad_encode_field(ptr, 414 IB_CC_SWITCH_PORT_CONGESTION_SETTING_ELEMENT_CONG_PARM_MARKING_RATE_F, 415 &cong_parm_marking_rate); 416 417 if (!cc_config_status_via(payload, rcv, dest, IB_CC_ATTR_SWITCH_PORT_CONGESTION_SETTING, 418 portnum / 32, 0, NULL, srcport, cckey)) 419 return "switch port congestion setting config failed"; 420 421 return NULL; 422 } 423 424 static char *ca_congestion_setting(ib_portid_t * dest, char **argv, int argc) 425 { 426 uint8_t rcv[IB_CC_DATA_SZ] = { 0 }; 427 uint8_t payload[IB_CC_DATA_SZ] = { 0 }; 428 uint32_t port_control; 429 uint32_t control_map; 430 uint32_t ccti_timer; 431 uint32_t ccti_increase; 432 uint32_t trigger_threshold; 433 uint32_t ccti_min; 434 char *errstr; 435 int i; 436 437 if (argc != 6) 438 return "invalid number of parameters for CACongestionSetting"; 439 440 if ((errstr = parseint(argv[0], &port_control, 0))) 441 return errstr; 442 443 if ((errstr = parseint(argv[1], &control_map, 0))) 444 return errstr; 445 446 if ((errstr = parseint(argv[2], &ccti_timer, 0))) 447 return errstr; 448 449 if ((errstr = parseint(argv[3], &ccti_increase, 0))) 450 return errstr; 451 452 if ((errstr = parseint(argv[4], &trigger_threshold, 0))) 453 return errstr; 454 455 if ((errstr = parseint(argv[5], &ccti_min, 0))) 456 return errstr; 457 458 mad_encode_field(payload, 459 IB_CC_CA_CONGESTION_SETTING_PORT_CONTROL_F, 460 &port_control); 461 462 mad_encode_field(payload, 463 IB_CC_CA_CONGESTION_SETTING_CONTROL_MAP_F, 464 &control_map); 465 466 for (i = 0; i < 16; i++) { 467 uint8_t *ptr; 468 469 if (!(control_map & (0x1 << i))) 470 continue; 471 472 ptr = payload + 2 + 2 + i * 8; 473 474 mad_encode_field(ptr, 475 IB_CC_CA_CONGESTION_ENTRY_CCTI_TIMER_F, 476 &ccti_timer); 477 478 mad_encode_field(ptr, 479 IB_CC_CA_CONGESTION_ENTRY_CCTI_INCREASE_F, 480 &ccti_increase); 481 482 mad_encode_field(ptr, 483 IB_CC_CA_CONGESTION_ENTRY_TRIGGER_THRESHOLD_F, 484 &trigger_threshold); 485 486 mad_encode_field(ptr, 487 IB_CC_CA_CONGESTION_ENTRY_CCTI_MIN_F, 488 &ccti_min); 489 } 490 491 if (!cc_config_status_via(payload, rcv, dest, IB_CC_ATTR_CA_CONGESTION_SETTING, 492 0, 0, NULL, srcport, cckey)) 493 return "ca congestion setting config failed"; 494 495 return NULL; 496 } 497 498 static char *congestion_control_table(ib_portid_t * dest, char **argv, int argc) 499 { 500 uint8_t rcv[IB_CC_DATA_SZ] = { 0 }; 501 uint8_t payload[IB_CC_DATA_SZ] = { 0 }; 502 uint32_t ccti_limit; 503 uint32_t index; 504 uint32_t cctshifts[64]; 505 uint32_t cctmults[64]; 506 char *errstr; 507 int i; 508 509 if (argc < 2 || argc > 66) 510 return "invalid number of parameters for CongestionControlTable"; 511 512 if ((errstr = parseint(argv[0], &ccti_limit, 0))) 513 return errstr; 514 515 if ((errstr = parseint(argv[1], &index, 0))) 516 return errstr; 517 518 if (ccti_limit && (ccti_limit + 1) != (index * 64 + (argc - 2))) 519 return "invalid number of cct entries input given ccti_limit and index"; 520 521 for (i = 0; i < (argc - 2); i++) { 522 if ((errstr = parsecct(argv[i + 2], &cctshifts[i], &cctmults[i]))) 523 return errstr; 524 } 525 526 mad_encode_field(payload, 527 IB_CC_CONGESTION_CONTROL_TABLE_CCTI_LIMIT_F, 528 &ccti_limit); 529 530 for (i = 0; i < (argc - 2); i++) { 531 mad_encode_field(payload + 4 + i * 2, 532 IB_CC_CONGESTION_CONTROL_TABLE_ENTRY_CCT_SHIFT_F, 533 &cctshifts[i]); 534 535 mad_encode_field(payload + 4 + i * 2, 536 IB_CC_CONGESTION_CONTROL_TABLE_ENTRY_CCT_MULTIPLIER_F, 537 &cctmults[i]); 538 } 539 540 if (!cc_config_status_via(payload, rcv, dest, IB_CC_ATTR_CONGESTION_CONTROL_TABLE, 541 index, 0, NULL, srcport, cckey)) 542 return "congestion control table config failed"; 543 544 return NULL; 545 } 546 547 static int process_opt(void *context, int ch, char *optarg) 548 { 549 switch (ch) { 550 case 'c': 551 cckey = (uint64_t) strtoull(optarg, 0, 0); 552 break; 553 case 25: 554 if (!inet_pton(AF_INET6, optarg, &dgid)) { 555 fprintf(stderr, "dgid format is wrong!\n"); 556 ibdiag_show_usage(); 557 return 1; 558 } 559 with_grh = 1; 560 break; 561 default: 562 return -1; 563 } 564 return 0; 565 } 566 567 int main(int argc, char **argv) 568 { 569 char usage_args[1024]; 570 int mgmt_classes[3] = { IB_SMI_CLASS, IB_SA_CLASS, IB_CC_CLASS }; 571 ib_portid_t portid = { 0 }; 572 char *err; 573 op_fn_t *fn; 574 const match_rec_t *r; 575 int n; 576 577 const struct ibdiag_opt opts[] = { 578 {"cckey", 'c', 1, "<key>", "CC key"}, 579 {"dgid", 25, 1, NULL, "remote gid (IPv6 format)"}, 580 {0} 581 }; 582 const char *usage_examples[] = { 583 "SwitchCongestionSetting 2 0x1F 0x1FFFFFFFFF 0x0 0xF 8 0 0:0 1\t# Configure Switch Congestion Settings", 584 "CACongestionSetting 1 0 0x3 150 1 0 0\t\t# Configure CA Congestion Settings to SL 0 and SL 1", 585 "CACongestionSetting 1 0 0x4 200 1 0 0\t\t# Configure CA Congestion Settings to SL 2", 586 "CongestionControlTable 1 63 0 0:0 0:1 ...\t# Configure first block of Congestion Control Table", 587 "CongestionControlTable 1 127 0 0:64 0:65 ...\t# Configure second block of Congestion Control Table", 588 NULL 589 }; 590 591 n = sprintf(usage_args, "[-c key] <op> <lid|guid>\n" 592 "\nWARNING -- You should understand what you are " 593 "doing before using this tool. Misuse of this " 594 "tool could result in a broken fabric.\n" 595 "\nSupported ops (and aliases, case insensitive):\n"); 596 for (r = match_tbl; r->name; r++) { 597 n += snprintf(usage_args + n, sizeof(usage_args) - n, 598 " %s (%s) <lid|guid>%s%s%s\n", r->name, 599 r->alias ? r->alias : "", 600 r->opt_portnum ? " <portnum>" : "", 601 r->ops_extra ? " " : "", 602 r->ops_extra ? r->ops_extra : ""); 603 if (n >= sizeof(usage_args)) 604 exit(-1); 605 } 606 607 ibdiag_process_opts(argc, argv, NULL, "DK", opts, process_opt, 608 usage_args, usage_examples); 609 610 argc -= optind; 611 argv += optind; 612 613 if (argc < 2) 614 ibdiag_show_usage(); 615 616 if (!(fn = match_op(match_tbl, argv[0]))) 617 IBEXIT("operation '%s' not supported", argv[0]); 618 619 srcport = mad_rpc_open_port(ibd_ca, ibd_ca_port, mgmt_classes, 3); 620 if (!srcport) 621 IBEXIT("Failed to open '%s' port '%d'", ibd_ca, ibd_ca_port); 622 623 smp_mkey_set(srcport, ibd_mkey); 624 625 if (with_grh && ibd_dest_type != IB_DEST_LID) 626 IBEXIT("When using GRH, LID should be provided"); 627 if (resolve_portid_str(ibd_ca, ibd_ca_port, &portid, argv[1], 628 ibd_dest_type, ibd_sm_id, srcport) < 0) 629 IBEXIT("can't resolve destination %s", argv[1]); 630 if (with_grh) { 631 portid.grh_present = 1; 632 memcpy(&portid.gid, &dgid, sizeof(portid.gid)); 633 } 634 if ((err = fn(&portid, argv + 2, argc - 2))) 635 IBEXIT("operation %s: %s", argv[0], err); 636 637 mad_rpc_close_port(srcport); 638 exit(0); 639 } 640