1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2012 Milan Jurik. All rights reserved. 24 */ 25 26 /* 27 * This is the user interface module for the pcitool. It checks commandline 28 * arguments and options and stores them in a pcitool_uiargs_t structure passed 29 * back to the rest of the program for processing. 30 * 31 * Please see pcitool_usage.c for a complete commandline description. 32 */ 33 34 #include <stdio.h> 35 #include <stdlib.h> 36 #include <unistd.h> 37 #include <sys/inttypes.h> 38 #include <sys/types.h> 39 #include <sys/param.h> 40 #include <strings.h> 41 #include <errno.h> 42 #include <sys/pci.h> 43 44 #include <sys/pci_tools.h> 45 46 #include "pcitool_ui.h" 47 48 /* 49 * Uncomment the following for useful debugging / development options for this 50 * module only. 51 */ 52 53 /* #define DEBUG 1 */ 54 /* #define STANDALONE 1 */ 55 56 #define DEVNAME_START_PCI "/pci" 57 #define DEVNAME_START_NIU "/niu" 58 59 /* Default read/write size when -s not specified. */ 60 #define DEFAULT_SIZE 4 61 62 /* For get_value64 */ 63 #define HEX_ONLY B_TRUE 64 #define BASE_BY_PREFIX B_FALSE 65 66 #define BITS_PER_BYTE 8 67 68 /* 69 * This defines which main options can be specified by the user. 70 * Options with colons after them require arguments. 71 */ 72 static char *opt_string = ":n:d:i:m:p:rw:o:s:e:b:vaqlcxgy"; 73 74 /* This defines options used singly and only by themselves (no nexus). */ 75 static char *no_dev_opt_string = "ahpqv"; 76 77 static void print_bad_option(char *argv[], int optopt, char *optarg); 78 static boolean_t get_confirmation(void); 79 static int get_value64(char *value_str, uint64_t *value, boolean_t hex_only); 80 static int parse_nexus_opts(char *input, uint64_t *flags_arg, uint8_t *bank_arg, 81 uint64_t *base_addr_arg); 82 static int extract_bdf_arg(char *cvalue, char *fld, uint64_t fld_flag, 83 uint64_t *all_flags, uint8_t *ivalue); 84 static int extract_bdf(char *value, char **bvalue_p, char **dvalue_p, 85 char **fvalue_p); 86 static int parse_device_opts(char *input, uint64_t *flags_arg, 87 uint8_t *bus_arg, uint8_t *device_arg, uint8_t *func_arg, 88 uint8_t *bank_arg); 89 static int parse_ino_opts(char *input, uint64_t *flags_arg, 90 uint32_t *cpu_arg, uint8_t *ino_arg); 91 static int parse_msi_opts(char *input, uint64_t *flags_arg, uint16_t *msi_arg); 92 static int parse_intr_set_opts(char *input, uint64_t *flags_arg, 93 uint32_t *cpu_arg); 94 static int parse_probeone_opts(char *input, uint64_t *flags_arg, 95 uint8_t *bus_arg, uint8_t *device_arg, uint8_t *func_arg); 96 97 #ifdef DEBUG 98 void dump_struct(pcitool_uiargs_t *dump_this); 99 #endif 100 101 /* Exported functions. */ 102 103 /* 104 * Main commandline argument parsing routine. 105 * 106 * Takes argc and argv straight from the commandline. 107 * Returns a pcitool_uiargs_t with flags of options specified, and values 108 * associated with them. 109 */ 110 int 111 get_commandline_args(int argc, char *argv[], pcitool_uiargs_t *parsed_args) 112 { 113 int c; /* Current option being processed. */ 114 boolean_t error = B_FALSE; 115 boolean_t confirm = B_FALSE; 116 uint64_t recv64; 117 118 /* Needed for getopt(3C) */ 119 extern char *optarg; /* Current commandline string. */ 120 extern int optind; /* Index of current commandline string. */ 121 extern int optopt; /* Option (char) which is missing an operand. */ 122 extern int opterr; /* Set to 0 to disable getopt err reporting. */ 123 124 opterr = 0; 125 126 bzero(parsed_args, sizeof (pcitool_uiargs_t)); 127 128 /* No args. probe mode accounting for bus ranges, nonverbose. */ 129 if (argc == 1) { 130 usage(argv[0]); 131 parsed_args->flags = 0; 132 return (SUCCESS); 133 } 134 135 /* 1st arg is not a device name. */ 136 if ((strstr(argv[1], DEVNAME_START_PCI) != argv[1]) && 137 (strstr(argv[1], DEVNAME_START_NIU) != argv[1])) { 138 139 /* Default is to probe all trees accounting for bus ranges. */ 140 parsed_args->flags = PROBEALL_FLAG | PROBERNG_FLAG; 141 142 /* Loop thru the options until complete or an error is found. */ 143 while (((c = getopt(argc, argv, no_dev_opt_string)) != -1) && 144 (error == B_FALSE)) { 145 146 switch (c) { 147 148 /* Help requested. */ 149 case 'h': 150 usage(argv[0]); 151 parsed_args->flags = 0; 152 return (SUCCESS); 153 154 case 'p': 155 /* Take default probe mode */ 156 break; 157 158 case 'a': 159 /* 160 * Enable display of ALL bus numbers. 161 * 162 * This takes precidence over PROBERNG as -a 163 * is explicitly specified. 164 */ 165 parsed_args->flags &= ~PROBERNG_FLAG; 166 break; 167 168 case 'q': 169 parsed_args->flags |= QUIET_FLAG; 170 break; 171 172 /* Verbose mode for full probe. */ 173 case 'v': 174 parsed_args->flags |= VERBOSE_FLAG; 175 break; 176 177 default: 178 error = B_TRUE; 179 break; 180 } 181 } 182 183 /* Check for values straggling at the end of the command. */ 184 if (optind != argc) { 185 (void) fprintf(stderr, "%s: Unrecognized parameter " 186 "at the end of the command.\n", argv[0]); 187 error = B_TRUE; 188 } 189 190 if (error) { 191 print_bad_option(argv, optopt, optarg); 192 return (FAILURE); 193 } 194 195 return (SUCCESS); 196 } 197 198 /* Device node specified on commandline. */ 199 200 /* Skip argv[1] before continuing below. */ 201 optind++; 202 203 /* Loop through the options until complete or an error is found. */ 204 while (((c = getopt(argc, argv, opt_string)) != -1) && 205 (error == B_FALSE)) { 206 207 switch (c) { 208 209 /* Nexus */ 210 case 'n': 211 if (parsed_args->flags & (LEAF_FLAG | 212 NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) { 213 (void) fprintf(stderr, "%s: -n set with " 214 "-d, -p or -i or is set twice\n", argv[0]); 215 error = B_TRUE; 216 break; 217 } 218 parsed_args->flags |= NEXUS_FLAG; 219 if (parse_nexus_opts(optarg, &parsed_args->flags, 220 &parsed_args->bank, &parsed_args->base_address) != 221 SUCCESS) { 222 (void) fprintf(stderr, 223 "%s: Error parsing -n options\n", argv[0]); 224 error = B_TRUE; 225 break; 226 } 227 break; 228 229 /* Device (leaf node) */ 230 case 'd': 231 if (parsed_args->flags & (LEAF_FLAG | 232 NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) { 233 (void) fprintf(stderr, "%s: -d set with " 234 "-n, -p or -i or is set twice\n", argv[0]); 235 error = B_TRUE; 236 break; 237 } 238 parsed_args->flags |= LEAF_FLAG; 239 if (parse_device_opts(optarg, &parsed_args->flags, 240 &parsed_args->bus, &parsed_args->device, 241 &parsed_args->function, 242 &parsed_args->bank) != SUCCESS) { 243 (void) fprintf(stderr, 244 "%s: Error parsing -d options\n", argv[0]); 245 error = B_TRUE; 246 break; 247 } 248 break; 249 250 /* Interrupt */ 251 case 'i': 252 if (parsed_args->flags & (LEAF_FLAG | 253 NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) { 254 (void) fprintf(stderr, "%s: -i set with -m, " 255 "-n, -d or -p or is set twice\n", argv[0]); 256 error = B_TRUE; 257 break; 258 } 259 parsed_args->flags |= INTR_FLAG; 260 261 /* parse input to get ino value. */ 262 if (parse_ino_opts(optarg, &parsed_args->flags, 263 &parsed_args->old_cpu, 264 &parsed_args->intr_ino) != SUCCESS) { 265 (void) fprintf(stderr, 266 "%s: Error parsing interrupt options\n", 267 argv[0]); 268 error = B_TRUE; 269 } 270 break; 271 /* Interrupt */ 272 case 'm': 273 if (parsed_args->flags & (LEAF_FLAG | 274 NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) { 275 (void) fprintf(stderr, "%s: -m set with -i, " 276 "-n, -d or -p or is set twice\n", argv[0]); 277 error = B_TRUE; 278 break; 279 } 280 parsed_args->flags |= INTR_FLAG; 281 282 /* parse input to get msi value. */ 283 if (parse_msi_opts(optarg, &parsed_args->flags, 284 &parsed_args->intr_msi) != SUCCESS) { 285 (void) fprintf(stderr, 286 "%s: Error parsing interrupt options\n", 287 argv[0]); 288 error = B_TRUE; 289 } 290 break; 291 /* Probe */ 292 case 'p': 293 if (parsed_args->flags & (LEAF_FLAG | 294 NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS)) { 295 (void) fprintf(stderr, "%s: -p set with " 296 "-n, -d or -i or is set twice\n", argv[0]); 297 error = B_TRUE; 298 break; 299 } 300 301 /* Process -p with no dedicated options to it. */ 302 if (optarg[0] == '-') { 303 optind--; 304 305 /* Probe given tree observing ranges */ 306 parsed_args->flags |= 307 (PROBETREE_FLAG | PROBERNG_FLAG); 308 continue; 309 } 310 311 /* parse input to get ino value. */ 312 if (parse_probeone_opts(optarg, &parsed_args->flags, 313 &parsed_args->bus, &parsed_args->device, 314 &parsed_args->function) != SUCCESS) { 315 (void) fprintf(stderr, 316 "%s: Error parsing probe options\n", 317 argv[0]); 318 error = B_TRUE; 319 } else { 320 /* 321 * parse_probeone_opts found options to 322 * set up bdf. 323 */ 324 parsed_args->flags |= PROBEDEV_FLAG; 325 } 326 break; 327 328 /* Probe all busses */ 329 case 'a': 330 /* Must follow -p, and -p must have no bdf. */ 331 if (!(parsed_args->flags & PROBETREE_FLAG)) { 332 error = B_TRUE; 333 break; 334 } 335 336 parsed_args->flags &= ~PROBERNG_FLAG; 337 break; 338 339 /* Read */ 340 case 'r': 341 if (!(parsed_args->flags & 342 (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG))) { 343 error = B_TRUE; 344 break; 345 } 346 347 /* 348 * Allow read and write to be set together for now, 349 * since this means write then read back for device and 350 * nexus accesses. Check for this and disallow with 351 * interrupt command later. 352 */ 353 parsed_args->flags |= READ_FLAG; 354 break; 355 356 /* Write */ 357 case 'w': 358 if (!(parsed_args->flags & 359 (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG))) { 360 error = B_TRUE; 361 break; 362 } 363 if (parsed_args->flags & WRITE_FLAG) { 364 (void) fprintf(stderr, "%s: -w set twice\n", 365 argv[0]); 366 error = B_TRUE; 367 break; 368 } 369 370 /* 371 * For device and nexus, get a single register value 372 * to write. 373 */ 374 if (parsed_args->flags & (NEXUS_FLAG | LEAF_FLAG)) { 375 parsed_args->flags |= WRITE_FLAG; 376 if (get_value64(optarg, 377 &parsed_args->write_value, HEX_ONLY) != 378 SUCCESS) { 379 (void) fprintf(stderr, 380 "%s: Error reading value to " 381 "write.\n", argv[0]); 382 error = B_TRUE; 383 break; 384 } 385 386 /* For interrupt, parse input to get cpu value. */ 387 } else if (parsed_args->flags & INTR_FLAG) { 388 parsed_args->flags |= WRITE_FLAG; 389 if (parse_intr_set_opts(optarg, 390 &parsed_args->flags, 391 &parsed_args->intr_cpu) != SUCCESS) { 392 (void) fprintf(stderr, "%s: Error " 393 "parsing interrupt options.\n", 394 argv[0]); 395 error = B_TRUE; 396 break; 397 } 398 399 } else { 400 error = B_TRUE; 401 break; 402 } 403 break; 404 405 /* Offset */ 406 case 'o': 407 if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) { 408 error = B_TRUE; 409 break; 410 } 411 if (parsed_args->flags & OFFSET_FLAG) { 412 (void) fprintf(stderr, "%s: -o set twice\n", 413 argv[0]); 414 error = B_TRUE; 415 break; 416 } 417 parsed_args->flags |= OFFSET_FLAG; 418 if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) { 419 (void) fprintf(stderr, 420 "%s: Error in offset argument\n", argv[0]); 421 error = B_TRUE; 422 break; 423 } 424 parsed_args->offset = (uint32_t)recv64; 425 if (parsed_args->offset != recv64) { 426 (void) fprintf(stderr, "%s: Offset argument " 427 "too large for 32 bits\n", argv[0]); 428 error = B_TRUE; 429 break; 430 } 431 break; 432 433 /* Size */ 434 case 's': 435 if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) { 436 error = B_TRUE; 437 break; 438 } 439 if (parsed_args->flags & SIZE_FLAG) { 440 (void) fprintf(stderr, "%s: -s set twice\n", 441 argv[0]); 442 error = B_TRUE; 443 break; 444 } 445 parsed_args->flags |= SIZE_FLAG; 446 if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) { 447 (void) fprintf(stderr, 448 "%s: Error in size argument\n", argv[0]); 449 error = B_TRUE; 450 break; 451 } 452 switch (recv64) { 453 case 1: 454 case 2: 455 case 4: 456 case 8: 457 break; 458 default: 459 error = B_TRUE; 460 (void) fprintf(stderr, 461 "%s: Error in size argument\n", argv[0]); 462 break; 463 } 464 parsed_args->size |= (uint8_t)recv64; 465 break; 466 467 /* Endian. */ 468 case 'e': 469 if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) { 470 error = B_TRUE; 471 break; 472 } 473 if (parsed_args->flags & ENDIAN_FLAG) { 474 (void) fprintf(stderr, "%s: -e set twice\n", 475 argv[0]); 476 error = B_TRUE; 477 break; 478 } 479 parsed_args->flags |= ENDIAN_FLAG; 480 481 /* Only a single character allowed. */ 482 if (optarg[1] != '\0') { 483 (void) fprintf(stderr, 484 "%s: Error in endian argument\n", argv[0]); 485 error = B_TRUE; 486 break; 487 } 488 489 switch (optarg[0]) { 490 case 'b': 491 parsed_args->big_endian = B_TRUE; 492 break; 493 case 'l': 494 break; 495 default: 496 (void) fprintf(stderr, 497 "%s: Error in endian argument\n", argv[0]); 498 error = B_TRUE; 499 break; 500 } 501 break; 502 503 /* (Byte)dump */ 504 case 'b': 505 if (!(parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG))) { 506 error = B_TRUE; 507 break; 508 } 509 if (parsed_args->flags & BYTEDUMP_FLAG) { 510 (void) fprintf(stderr, "%s: -b set twice\n", 511 argv[0]); 512 error = B_TRUE; 513 break; 514 } 515 parsed_args->flags |= BYTEDUMP_FLAG; 516 if (get_value64(optarg, &recv64, HEX_ONLY) != SUCCESS) { 517 (void) fprintf(stderr, "%s: Error in " 518 "bytedump argument\n", argv[0]); 519 error = B_TRUE; 520 break; 521 } 522 parsed_args->bytedump_amt = (uint32_t)recv64; 523 if (parsed_args->bytedump_amt != recv64) { 524 (void) fprintf(stderr, "%s: Bytedump amount " 525 "too large for 32 bits\n", argv[0]); 526 error = B_TRUE; 527 break; 528 } 529 break; 530 531 /* Verbose. */ 532 case 'v': 533 parsed_args->flags |= VERBOSE_FLAG; 534 break; 535 536 /* 537 * Quiet - no errors reported as messages. 538 * (Status still returned by program, however.) 539 */ 540 case 'q': 541 parsed_args->flags |= QUIET_FLAG; 542 break; 543 544 /* Loop. */ 545 case 'l': 546 parsed_args->flags |= LOOP_FLAG; 547 break; 548 549 /* 550 * Dump characters with bytedump (-b). 551 * Show controller info with -i. 552 */ 553 case 'c': 554 if (parsed_args->flags & BYTEDUMP_FLAG) { 555 parsed_args->flags |= CHARDUMP_FLAG; 556 557 } else if (parsed_args->flags & INTR_FLAG) { 558 parsed_args->flags |= SHOWCTLR_FLAG; 559 560 } else { 561 error = B_TRUE; 562 } 563 break; 564 565 /* Continue on errors with bytedump (-b). */ 566 case 'x': 567 if (!(parsed_args->flags & BYTEDUMP_FLAG)) { 568 error = B_TRUE; 569 break; 570 } 571 parsed_args->flags |= ERRCONT_FLAG; 572 break; 573 574 case 'g': 575 if (!(parsed_args->flags & INTR_FLAG)) { 576 error = B_TRUE; 577 break; 578 } 579 parsed_args->flags |= SETGRP_FLAG; 580 break; 581 582 /* Take -y as confirmation and don't ask (where applicable). */ 583 case 'y': 584 confirm = B_TRUE; 585 break; 586 587 /* Option without operand. */ 588 case ':': 589 switch (optopt) { 590 case 'p': 591 /* Allow -p without bdf spec. */ 592 parsed_args->flags |= 593 (PROBETREE_FLAG | PROBERNG_FLAG); 594 break; 595 default: 596 error = B_TRUE; 597 break; 598 } 599 break; 600 601 /* Unrecognized option. */ 602 case '?': 603 error = B_TRUE; 604 break; 605 } 606 } 607 608 /* 609 * Commandline has been parsed. Check for errors which can be checked 610 * only after commandline parsing is complete. 611 */ 612 613 if (!error) { 614 615 /* Check for values straggling at the end of the command. */ 616 if (optind != argc) { 617 (void) fprintf(stderr, "%s: Unrecognized parameter " 618 "at the end of the command.\n", argv[0]); 619 print_bad_option(argv, optopt, optarg); 620 return (FAILURE); 621 } 622 623 /* No args other than nexus. Default to probing that nexus */ 624 if (!(parsed_args->flags & 625 (LEAF_FLAG | NEXUS_FLAG | INTR_FLAG | PROBE_FLAGS))) { 626 usage(argv[0]); 627 parsed_args->flags = 0; 628 return (SUCCESS); 629 } 630 631 /* 632 * Don't allow any options other than all-bus, verbose or 633 * quiet with probe command. Set default probe flags if nexus 634 * or leaf options are not specified. 635 */ 636 if (parsed_args->flags & (PROBETREE_FLAG | PROBEALL_FLAG)) { 637 if (parsed_args->flags & 638 ~(PROBE_FLAGS | QUIET_FLAG | VERBOSE_FLAG)) 639 error = B_TRUE; 640 } 641 642 /* 643 * Allow only read, write, quiet and verbose flags for 644 * interrupt command. Note that INO_SPEC_FLAG and CPU_SPEC_FLAG 645 * get set for interrupt command. 646 */ 647 if (parsed_args->flags & INTR_FLAG) { 648 if (parsed_args->flags & 649 ~(INTR_FLAG | VERBOSE_FLAG | QUIET_FLAG | 650 READ_FLAG | WRITE_FLAG | SHOWCTLR_FLAG | 651 SETGRP_FLAG | INO_ALL_FLAG | INO_SPEC_FLAG | 652 MSI_ALL_FLAG | MSI_SPEC_FLAG | CPU_SPEC_FLAG)) { 653 (void) fprintf(stderr, "%s: -v, -q, -r, -w, -c " 654 "-g are only options allowed with " 655 "interrupt command.\n", argv[0]); 656 error = B_TRUE; 657 } 658 659 /* Need cpu and ino values for interrupt set command. */ 660 if ((parsed_args->flags & WRITE_FLAG) && 661 !(parsed_args->flags & CPU_SPEC_FLAG) && 662 !((parsed_args->flags & INO_SPEC_FLAG) || 663 (parsed_args->flags & MSI_SPEC_FLAG))) { 664 (void) fprintf(stderr, 665 "%s: Both cpu and ino/msi must be " 666 "specified explicitly for interrupt " 667 "set command.\n", argv[0]); 668 error = B_TRUE; 669 } 670 671 /* Intr write and show ctlr flags are incompatible. */ 672 if ((parsed_args->flags & 673 (WRITE_FLAG + SHOWCTLR_FLAG)) == 674 (WRITE_FLAG + SHOWCTLR_FLAG)) { 675 (void) fprintf(stderr, 676 "%s: -w and -c are incompatible for " 677 "interrupt command.\n", argv[0]); 678 error = B_TRUE; 679 } 680 681 /* Intr setgrp flag valid only for intr writes. */ 682 if ((parsed_args->flags & (WRITE_FLAG + SETGRP_FLAG)) == 683 SETGRP_FLAG) { 684 (void) fprintf(stderr, 685 "%s: -g is incompatible with -r " 686 "for interrupt command.\n", argv[0]); 687 error = B_TRUE; 688 } 689 690 /* 691 * Disallow read & write together in interrupt command. 692 */ 693 if ((parsed_args->flags & (WRITE_FLAG | READ_FLAG)) == 694 (WRITE_FLAG | READ_FLAG)) { 695 (void) fprintf(stderr, "%s: Only one of -r and " 696 "-w can be specified in " 697 "interrupt command.\n", argv[0]); 698 error = B_TRUE; 699 } 700 } 701 702 /* Bytedump incompatible with some other options. */ 703 if ((parsed_args->flags & BYTEDUMP_FLAG) && 704 (parsed_args->flags & 705 (WRITE_FLAG | PROBE_FLAGS | INTR_FLAG))) { 706 (void) fprintf(stderr, 707 "%s: -b is incompatible with " 708 "another specified option.\n", argv[0]); 709 error = B_TRUE; 710 } 711 712 if (parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG)) { 713 714 if (!(parsed_args->flags & SIZE_FLAG)) { 715 parsed_args->size = DEFAULT_SIZE; 716 } 717 if ((parsed_args->flags & WRITE_FLAG) && 718 parsed_args->size < sizeof (uint64_t) && 719 (parsed_args->write_value >> 720 (parsed_args->size * BITS_PER_BYTE))) { 721 (void) fprintf(stderr, 722 "%s: Data to write is larger than " 723 "specified size.\n", argv[0]); 724 error = B_TRUE; 725 } 726 727 } else { /* Looping is compatible only with register cmds. */ 728 729 if (parsed_args->flags & LOOP_FLAG) { 730 (void) fprintf(stderr, "%s: -l is incompatible " 731 "with given command.\n", argv[0]); 732 error = B_TRUE; 733 } 734 } 735 736 /* Call out an erroneous -y and then ignore it. */ 737 if ((confirm) && (!(parsed_args->flags & BASE_SPEC_FLAG))) { 738 (void) fprintf(stderr, 739 "%s: -y is incompatible with given command." 740 " Ignoring.\n", argv[0]); 741 } 742 } 743 744 /* Now fill in the defaults and other holes. */ 745 if (!(error)) { 746 if (!(parsed_args->flags & (READ_FLAG | WRITE_FLAG))) { 747 parsed_args->flags |= READ_FLAG; 748 } 749 750 if (parsed_args->flags & (LEAF_FLAG | NEXUS_FLAG)) { 751 if (!(parsed_args->flags & ENDIAN_FLAG)) { 752 parsed_args->big_endian = B_FALSE; 753 } 754 } 755 756 if (parsed_args->flags & BASE_SPEC_FLAG) { 757 if (!confirm) { 758 confirm = get_confirmation(); 759 } 760 if (!confirm) { 761 parsed_args->flags &= ~ALL_COMMANDS; 762 } 763 } 764 765 /* 766 * As far as other defaults are concerned: 767 * Other fields: bus, device, function, offset, default to 768 * zero. 769 */ 770 771 } else { /* An error occurred. */ 772 773 print_bad_option(argv, optopt, optarg); 774 } 775 return (error); 776 } 777 778 779 /* Module-private functions. */ 780 781 static void 782 print_bad_option(char *argv[], int optopt, char *optarg) 783 { 784 /* Illegal option operand */ 785 if (optarg != NULL) { 786 (void) fprintf(stderr, 787 "%s: illegal operand %s specified for option %c\n", 788 argv[0], optarg, optopt); 789 790 /* Illegal option */ 791 } else if (optopt != 0) { 792 (void) fprintf(stderr, 793 "%s: option %c is illegal or is missing an operand\n", 794 argv[0], optopt); 795 796 /* getopt wasn't even called. Bad device spec. */ 797 } else { 798 (void) fprintf(stderr, 799 "%s: device spec must start with %s or %s...\n", argv[0], 800 DEVNAME_START_PCI, DEVNAME_START_NIU); 801 } 802 803 (void) fprintf(stderr, 804 "%s: Type \"%s -h\" to get help on running this program.\n", 805 argv[0], argv[0]); 806 } 807 808 /* 809 * Warn the user and ask for confirmation. 810 */ 811 static boolean_t 812 get_confirmation() 813 { 814 int i, b; 815 816 (void) printf("WARNING: This cmd with a bad addr can panic " 817 "the system. Continue [y/n] (n)? "); 818 for (i = 0; ; i++) { 819 b = getchar(); 820 switch (b) { 821 case ' ': 822 case '\t': 823 break; 824 case 'y': 825 case 'Y': 826 return (B_TRUE); 827 default: 828 return (B_FALSE); 829 } 830 } 831 } 832 833 834 /* 835 * Given a digit string, return a 64 bit value. 836 * 837 * If the hex_only arg is true, interpret all strings as hex. 838 * Otherwise, interpret as strtoull(3C) does with base=0. 839 */ 840 static int 841 get_value64(char *value_str, uint64_t *value, boolean_t hex_only) 842 { 843 844 /* This is overkill for now, as everything is in hex. */ 845 static char dec_digits[] = "0123456789"; 846 static char hex_digits[] = "01234567890abcdefABCDEF"; 847 static char oct_digits[] = "01234567"; 848 849 char *digit_string; 850 char *string_to_check; 851 852 if ((value_str == NULL) || (strlen(value_str) == 0)) { 853 (void) fprintf(stderr, "Missing value argument.\n"); 854 return (FAILURE); 855 } 856 857 if (!hex_only && (value_str[0] != '0')) { 858 digit_string = dec_digits; 859 string_to_check = value_str; 860 } else if ((value_str[1] == 'X') || (value_str[1] == 'x')) { 861 digit_string = hex_digits; 862 string_to_check = &value_str[2]; /* Ignore 0x of hex */ 863 } else if (hex_only) { 864 digit_string = hex_digits; 865 string_to_check = value_str; /* Hex number, no 0x prefix */ 866 } else { 867 digit_string = oct_digits; 868 string_to_check = value_str; 869 } 870 871 /* 872 * Verify value is all proper digits. 873 * 874 * For some reason, strtoull doesn't return an error when it cannot 875 * interpret the value. This is why we do the checking ourselves. 876 */ 877 if (strspn(string_to_check, digit_string) != strlen(string_to_check)) { 878 (void) fprintf(stderr, 879 "Value must contain only valid digits.\n"); 880 return (FAILURE); 881 } 882 883 *value = strtoull(value_str, NULL, (hex_only ? 16 : 0)); 884 885 return (SUCCESS); 886 } 887 888 889 /* 890 * Parse nexus options. This includes: 891 * bank=number 892 * 893 * input is what the user specified for the options on the commandline, 894 * flags_arg is modified with the option set, and bank_arg returns the value 895 * specified for bank. 896 */ 897 static int 898 parse_nexus_opts(char *input, uint64_t *flags_arg, uint8_t *bank_arg, 899 uint64_t *base_addr_arg) 900 { 901 enum nexus_opts_index { 902 bank = 0, 903 base 904 }; 905 906 static char *nexus_opts[] = { 907 "bank", 908 "base", 909 NULL 910 }; 911 912 char *value; 913 uint64_t recv64; 914 915 int rval = SUCCESS; 916 917 if (input == NULL) { 918 (void) fprintf(stderr, "Missing argument.\n"); 919 return (FAILURE); 920 } 921 922 while ((*input != '\0') && (rval == SUCCESS)) { 923 switch (getsubopt(&input, nexus_opts, &value)) { 924 case bank: 925 if (*flags_arg & BANK_SPEC_FLAG) { 926 (void) fprintf(stderr, "The bank or bar arg is " 927 "specified more than once.\n"); 928 rval = FAILURE; 929 break; 930 } 931 if (*flags_arg & BASE_SPEC_FLAG) { 932 (void) fprintf(stderr, "Bank and base address " 933 "cannot both be specified.\n"); 934 rval = FAILURE; 935 break; 936 } 937 if (value == NULL) { 938 (void) fprintf(stderr, "Missing bank value.\n"); 939 rval = FAILURE; 940 break; 941 } 942 if ((rval = get_value64(value, &recv64, HEX_ONLY)) != 943 SUCCESS) { 944 break; 945 } 946 *bank_arg = (uint8_t)recv64; 947 if (*bank_arg != recv64) { 948 (void) fprintf(stderr, 949 "Bank argument must fit into 8 bits.\n"); 950 rval = FAILURE; 951 break; 952 } 953 *flags_arg |= BANK_SPEC_FLAG; 954 break; 955 956 case base: 957 if (*flags_arg & BASE_SPEC_FLAG) { 958 (void) fprintf(stderr, "The base address " 959 "is specified more than once.\n"); 960 rval = FAILURE; 961 break; 962 } 963 if (*flags_arg & BANK_SPEC_FLAG) { 964 (void) fprintf(stderr, "Bank and base address " 965 "cannot both be specified.\n"); 966 rval = FAILURE; 967 break; 968 } 969 if (value == NULL) { 970 (void) fprintf(stderr, 971 "Missing base addr value.\n"); 972 rval = FAILURE; 973 break; 974 } 975 if ((rval = get_value64(value, base_addr_arg, 976 HEX_ONLY)) != SUCCESS) { 977 break; 978 } 979 *flags_arg |= BASE_SPEC_FLAG; 980 break; 981 982 default: 983 (void) fprintf(stderr, "Unrecognized option for -n\n"); 984 rval = FAILURE; 985 break; 986 } 987 } 988 989 return (rval); 990 } 991 992 993 static int 994 extract_bdf_arg(char *cvalue, char *fld, uint64_t fld_flag, uint64_t *all_flags, 995 uint8_t *ivalue) 996 { 997 uint64_t recv64; 998 999 if (*all_flags & fld_flag) { 1000 (void) fprintf(stderr, 1001 "The %s is specified more than once.\n", fld); 1002 return (FAILURE); 1003 } 1004 if (get_value64(cvalue, &recv64, HEX_ONLY) != SUCCESS) 1005 return (FAILURE); 1006 1007 *ivalue = (uint8_t)recv64; 1008 if (recv64 != *ivalue) { 1009 (void) fprintf(stderr, 1010 "This program limits the %s argument to 8 bits.\n", fld); 1011 (void) fprintf(stderr, "The actual maximum may be " 1012 "smaller but cannot be enforced by this program.\n"); 1013 return (FAILURE); 1014 } 1015 1016 *all_flags |= fld_flag; 1017 return (SUCCESS); 1018 } 1019 1020 1021 static int extract_bdf(char *value, char **bvalue_p, char **dvalue_p, 1022 char **fvalue_p) 1023 { 1024 char *strtok_state; 1025 char *dummy; 1026 static char *separator = "."; 1027 1028 *bvalue_p = strtok_r(value, separator, &strtok_state); 1029 *dvalue_p = strtok_r(NULL, separator, &strtok_state); 1030 *fvalue_p = strtok_r(NULL, separator, &strtok_state); 1031 dummy = strtok_r(NULL, separator, &strtok_state); 1032 1033 /* Return failure only if too many values specified. */ 1034 return ((dummy) ? FAILURE : SUCCESS); 1035 } 1036 1037 /* 1038 * Parse device options. This includes: 1039 * bus=number 1040 * dev=number 1041 * func=number 1042 * bank=number 1043 * config 1044 * bar0 1045 * bar1 1046 * bar2 1047 * bar3 1048 * bar4 1049 * bar5 1050 * rom 1051 * 1052 * input is what the user specified for the options on the commandline, 1053 * flags_arg is modified with the options set, and the rest of the args return 1054 * their respective values. 1055 */ 1056 static int 1057 parse_device_opts( 1058 char *input, uint64_t *flags_arg, uint8_t *bus_arg, uint8_t *device_arg, 1059 uint8_t *func_arg, uint8_t *bank_arg) 1060 { 1061 /* Needed by getsubopt(3C) */ 1062 enum bdf_opts_index { 1063 bus = 0, 1064 dev = 1, 1065 func = 2, 1066 bdf = 3, 1067 bank = 4, 1068 config = 5, 1069 bar0 = 6, 1070 bar1 = 7, 1071 bar2 = 8, 1072 bar3 = 9, 1073 bar4 = 10, 1074 bar5 = 11, 1075 rom = 12 1076 }; 1077 1078 /* Needed by getsubopt(3C) */ 1079 static char *bdf_opts[] = { 1080 "bus", 1081 "dev", 1082 "func", 1083 "bdf", 1084 "bank", 1085 "config", 1086 "bar0", 1087 "bar1", 1088 "bar2", 1089 "bar3", 1090 "bar4", 1091 "bar5", 1092 "rom", 1093 NULL }; 1094 1095 char *value; /* Current suboption being processed. */ 1096 uint64_t recv64; /* Temporary value. */ 1097 1098 /* This error message is used in many places. */ 1099 static char bank_err[] = 1100 {"The bank or bar arg is specified more than once.\n"}; 1101 1102 int rval = SUCCESS; 1103 1104 while ((*input != '\0') && (rval == SUCCESS)) { 1105 switch (getsubopt(&input, bdf_opts, &value)) { 1106 1107 /* bus=number */ 1108 case bdf: { 1109 char *bvalue, *dvalue, *fvalue; 1110 1111 if ((rval = extract_bdf(value, &bvalue, &dvalue, 1112 &fvalue)) != SUCCESS) { 1113 break; 1114 } 1115 1116 if (!bvalue | !dvalue | !fvalue) { 1117 break; 1118 } 1119 1120 if ((rval = extract_bdf_arg(bvalue, "bus", 1121 BUS_SPEC_FLAG, flags_arg, bus_arg)) != SUCCESS) { 1122 break; 1123 } 1124 if ((rval = extract_bdf_arg(dvalue, "dev", 1125 DEV_SPEC_FLAG, flags_arg, device_arg)) != SUCCESS) { 1126 break; 1127 } 1128 rval = extract_bdf_arg(fvalue, "func", 1129 FUNC_SPEC_FLAG, flags_arg, func_arg); 1130 break; 1131 } 1132 1133 case bus: 1134 rval = extract_bdf_arg(value, "bus", BUS_SPEC_FLAG, 1135 flags_arg, bus_arg); 1136 break; 1137 1138 /* dev=number */ 1139 case dev: 1140 rval = extract_bdf_arg(value, "dev", DEV_SPEC_FLAG, 1141 flags_arg, device_arg); 1142 break; 1143 1144 /* func=number */ 1145 case func: 1146 rval = extract_bdf_arg(value, "func", FUNC_SPEC_FLAG, 1147 flags_arg, func_arg); 1148 break; 1149 1150 /* bank=number */ 1151 case bank: 1152 if (*flags_arg & BANK_SPEC_FLAG) { 1153 (void) fprintf(stderr, bank_err); 1154 rval = FAILURE; 1155 break; 1156 } 1157 if ((rval = get_value64(value, &recv64, HEX_ONLY)) != 1158 SUCCESS) { 1159 break; 1160 } 1161 *bank_arg = (uint8_t)recv64; 1162 if (rval || (*bank_arg != recv64)) { 1163 (void) fprintf(stderr, "Bank argument must" 1164 " fit into 8 bits.\n"); 1165 rval = FAILURE; 1166 break; 1167 } 1168 *flags_arg |= BANK_SPEC_FLAG; 1169 break; 1170 1171 /* config */ 1172 case config: 1173 if (*flags_arg & BANK_SPEC_FLAG) { 1174 (void) fprintf(stderr, bank_err); 1175 rval = FAILURE; 1176 break; 1177 } 1178 *bank_arg = PCITOOL_CONFIG; 1179 *flags_arg |= BANK_SPEC_FLAG; 1180 break; 1181 1182 /* bar0 */ 1183 case bar0: 1184 if (*flags_arg & BANK_SPEC_FLAG) { 1185 (void) fprintf(stderr, bank_err); 1186 rval = FAILURE; 1187 break; 1188 } 1189 *bank_arg = PCITOOL_BAR0; 1190 *flags_arg |= BANK_SPEC_FLAG; 1191 break; 1192 1193 /* bar1 */ 1194 case bar1: 1195 if (*flags_arg & BANK_SPEC_FLAG) { 1196 (void) fprintf(stderr, bank_err); 1197 rval = FAILURE; 1198 break; 1199 } 1200 *bank_arg = PCITOOL_BAR1; 1201 *flags_arg |= BANK_SPEC_FLAG; 1202 break; 1203 1204 /* bar2 */ 1205 case bar2: 1206 if (*flags_arg & BANK_SPEC_FLAG) { 1207 (void) fprintf(stderr, bank_err); 1208 rval = FAILURE; 1209 break; 1210 } 1211 *bank_arg = PCITOOL_BAR2; 1212 *flags_arg |= BANK_SPEC_FLAG; 1213 break; 1214 1215 /* bar3 */ 1216 case bar3: 1217 if (*flags_arg & BANK_SPEC_FLAG) { 1218 (void) fprintf(stderr, bank_err); 1219 rval = FAILURE; 1220 break; 1221 } 1222 *bank_arg = PCITOOL_BAR3; 1223 *flags_arg |= BANK_SPEC_FLAG; 1224 break; 1225 1226 /* bar4 */ 1227 case bar4: 1228 if (*flags_arg & BANK_SPEC_FLAG) { 1229 (void) fprintf(stderr, bank_err); 1230 rval = FAILURE; 1231 break; 1232 } 1233 *bank_arg = PCITOOL_BAR4; 1234 *flags_arg |= BANK_SPEC_FLAG; 1235 break; 1236 1237 /* bar5 */ 1238 case bar5: 1239 if (*flags_arg & BANK_SPEC_FLAG) { 1240 (void) fprintf(stderr, bank_err); 1241 rval = FAILURE; 1242 break; 1243 } 1244 *bank_arg = PCITOOL_BAR5; 1245 *flags_arg |= BANK_SPEC_FLAG; 1246 break; 1247 1248 /* rom */ 1249 case rom: 1250 if (*flags_arg & BANK_SPEC_FLAG) { 1251 (void) fprintf(stderr, bank_err); 1252 rval = FAILURE; 1253 break; 1254 } 1255 *bank_arg = PCITOOL_ROM; 1256 *flags_arg |= BANK_SPEC_FLAG; 1257 break; 1258 1259 default: 1260 (void) fprintf(stderr, "Unrecognized option for -d\n"); 1261 rval = FAILURE; 1262 break; 1263 } 1264 } 1265 1266 /* Bus, dev and func must all be specified. */ 1267 if ((*flags_arg & (BUS_SPEC_FLAG | DEV_SPEC_FLAG | FUNC_SPEC_FLAG)) != 1268 (BUS_SPEC_FLAG | DEV_SPEC_FLAG | FUNC_SPEC_FLAG)) { 1269 rval = FAILURE; 1270 1271 /* No bank specified in any way. Default to config space */ 1272 } else if ((*flags_arg & BANK_SPEC_FLAG) == 0) { 1273 *flags_arg |= BANK_SPEC_FLAG; 1274 *bank_arg = PCITOOL_CONFIG; 1275 } 1276 1277 return (rval); 1278 } 1279 1280 1281 /* 1282 * Parse INO options. This includes: 1283 * ino# | all 1284 * 1285 * input is the string of options to parse. flags_arg returns modified with 1286 * specified options set. Other args return their respective values. 1287 */ 1288 static int 1289 parse_ino_opts(char *input, uint64_t *flags_arg, uint32_t *cpu_arg, 1290 uint8_t *ino_arg) 1291 { 1292 uint64_t value; 1293 char *charvalue; 1294 int rval = SUCCESS; 1295 1296 if (strcmp(input, "all") == 0) { 1297 *flags_arg |= INO_ALL_FLAG; 1298 #ifdef __x86 1299 } else if (strstr(input, ",") == NULL) { 1300 (void) fprintf(stderr, 1301 "Interrupt format should be <cpu#,ino#>.\n"); 1302 rval = FAILURE; 1303 #else 1304 } else if (strstr(input, ",") == NULL) { 1305 if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) 1306 *ino_arg = (uint8_t)value; 1307 1308 if (*ino_arg != value) { 1309 (void) fprintf(stderr, 1310 "ino argument must fit into 8 bits.\n"); 1311 rval = FAILURE; 1312 } else { 1313 *flags_arg |= INO_SPEC_FLAG; 1314 } 1315 #endif 1316 } else if (charvalue = strtok(input, ",")) { 1317 if ((rval = 1318 get_value64(charvalue, &value, HEX_ONLY)) == SUCCESS) { 1319 *cpu_arg = (int)value; 1320 } 1321 1322 input = strtok(NULL, ","); 1323 if (input == NULL) { 1324 (void) fprintf(stderr, "ino argument is need.\n"); 1325 return (FAILURE); 1326 } 1327 1328 if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) 1329 *ino_arg = (uint8_t)value; 1330 1331 if (*ino_arg != value) { 1332 (void) fprintf(stderr, 1333 "ino argument must fit into 8 bits.\n"); 1334 rval = FAILURE; 1335 } else { 1336 *flags_arg |= INO_SPEC_FLAG; 1337 } 1338 } else { 1339 (void) fprintf(stderr, 1340 "Unrecognized option for -i\n"); 1341 rval = FAILURE; 1342 } 1343 1344 return (rval); 1345 } 1346 1347 1348 /* 1349 * Parse MSI options. This includes: 1350 * msi# | all 1351 * 1352 * input is the string of options to parse. flags_arg returns modified with 1353 * specified options set. Other args return their respective values. 1354 */ 1355 static int 1356 parse_msi_opts(char *input, uint64_t *flags_arg, uint16_t *msi_arg) 1357 { 1358 uint64_t value; 1359 int rval = SUCCESS; 1360 1361 if (strcmp(input, "all") == 0) { 1362 *flags_arg |= MSI_ALL_FLAG; 1363 } else if (strstr(input, ",") == NULL) { 1364 if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) 1365 *msi_arg = (uint16_t)value; 1366 1367 if (*msi_arg != value) { 1368 (void) fprintf(stderr, 1369 "msi argument must fit into 16 bits.\n"); 1370 rval = FAILURE; 1371 } else { 1372 *flags_arg |= MSI_SPEC_FLAG; 1373 } 1374 } else if (strtok(input, ",")) { 1375 input = strtok(NULL, ","); 1376 if (input == NULL) { 1377 (void) fprintf(stderr, "msi argument is need.\n"); 1378 return (FAILURE); 1379 } 1380 1381 if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) 1382 *msi_arg = (uint16_t)value; 1383 1384 if (*msi_arg != value) { 1385 (void) fprintf(stderr, 1386 "msi argument must fit into 16 bits.\n"); 1387 rval = FAILURE; 1388 } else { 1389 *flags_arg |= MSI_SPEC_FLAG; 1390 } 1391 } else { 1392 (void) fprintf(stderr, 1393 "Unrecognized option for -m\n"); 1394 rval = FAILURE; 1395 } 1396 1397 return (rval); 1398 } 1399 1400 1401 /* 1402 * Parse interrupt set options. This includes: 1403 * cpu=number 1404 * 1405 * input is the string of options to parse. flags_arg returns modified with 1406 * specified options set. Other args return their respective values. 1407 */ 1408 static int 1409 parse_intr_set_opts(char *input, uint64_t *flags_arg, uint32_t *cpu_arg) 1410 { 1411 uint64_t value; 1412 int rval = SUCCESS; 1413 1414 if ((rval = get_value64(input, &value, HEX_ONLY)) == SUCCESS) { 1415 1416 if ((long)value > sysconf(_SC_CPUID_MAX)) { 1417 (void) fprintf(stderr, "Cpu argument " 1418 "exceeds maximum for this system type.\n"); 1419 rval = FAILURE; 1420 } else { 1421 *cpu_arg = (uint32_t)value; 1422 *flags_arg |= CPU_SPEC_FLAG; 1423 } 1424 } else { 1425 (void) fprintf(stderr, 1426 "Unrecognized option for -i -m -w\n"); 1427 rval = FAILURE; 1428 } 1429 1430 return (rval); 1431 } 1432 1433 1434 static int 1435 parse_probeone_opts( 1436 char *input, uint64_t *flags_arg, uint8_t *bus_arg, uint8_t *device_arg, 1437 uint8_t *func_arg) 1438 { 1439 enum p1_bdf_opts_index { 1440 bus = 0, 1441 dev = 1, 1442 func = 2, 1443 bdf = 3 1444 }; 1445 1446 /* Needed by getsubopt(3C) */ 1447 static char *p1_bdf_opts[] = { 1448 "bus", 1449 "dev", 1450 "func", 1451 "bdf", 1452 NULL }; 1453 1454 char *value; /* Current suboption being processed. */ 1455 1456 int rval = SUCCESS; 1457 1458 while ((*input != '\0') && (rval == SUCCESS)) { 1459 switch (getsubopt(&input, p1_bdf_opts, &value)) { 1460 1461 /* bus=number */ 1462 case bdf: { 1463 char *bvalue, *dvalue, *fvalue; 1464 1465 if ((rval = extract_bdf(value, &bvalue, &dvalue, 1466 &fvalue)) != SUCCESS) { 1467 break; 1468 } 1469 if (bvalue) 1470 if ((rval = extract_bdf_arg(bvalue, "bus", 1471 BUS_SPEC_FLAG, flags_arg, bus_arg)) != 1472 SUCCESS) { 1473 break; 1474 } 1475 if (dvalue) 1476 if ((rval = extract_bdf_arg(dvalue, "dev", 1477 DEV_SPEC_FLAG, flags_arg, device_arg)) != 1478 SUCCESS) { 1479 break; 1480 } 1481 if (fvalue) 1482 rval = extract_bdf_arg(fvalue, "func", 1483 FUNC_SPEC_FLAG, flags_arg, func_arg); 1484 break; 1485 } 1486 1487 case bus: 1488 rval = extract_bdf_arg(value, "bus", BUS_SPEC_FLAG, 1489 flags_arg, bus_arg); 1490 break; 1491 1492 /* dev=number */ 1493 case dev: 1494 rval = extract_bdf_arg(value, "dev", DEV_SPEC_FLAG, 1495 flags_arg, device_arg); 1496 break; 1497 1498 /* func=number */ 1499 case func: 1500 rval = extract_bdf_arg(value, "func", FUNC_SPEC_FLAG, 1501 flags_arg, func_arg); 1502 break; 1503 1504 default: 1505 (void) fprintf(stderr, "Unrecognized option for -p\n"); 1506 rval = FAILURE; 1507 break; 1508 } 1509 } 1510 1511 return (rval); 1512 } 1513 1514 1515 #ifdef DEBUG 1516 1517 static void 1518 dump_struct(pcitool_uiargs_t *dumpthis) 1519 { 1520 (void) printf("flags:0x%x\n", dumpthis->flags); 1521 (void) printf("bus:%d (0x%x)\n", 1522 dumpthis->bus, dumpthis->bus); 1523 (void) printf("device:%d (0x%x)\n", dumpthis->device, 1524 dumpthis->device); 1525 (void) printf("function:%d (0x%x)\n", dumpthis->function, 1526 dumpthis->function); 1527 (void) printf("write_value:%" PRIu64 " (0x%" PRIx64 ")\n", 1528 dumpthis->write_value, dumpthis->write_value); 1529 (void) printf("bank:%d (0x%x)\n", 1530 dumpthis->bank, dumpthis->bank); 1531 (void) printf("offset:%d (0x%x)\n", dumpthis->offset, dumpthis->offset); 1532 (void) printf("size:%d, endian:%s\n", dumpthis->size, 1533 dumpthis->big_endian ? "BIG" : "little"); 1534 (void) printf("ino:%d, cpu:%d\n", 1535 dumpthis->intr_ino, dumpthis->intr_cpu); 1536 } 1537 1538 #ifdef STANDALONE 1539 1540 /* Test program for this module. Useful when implementing new options. */ 1541 int 1542 main(int argc, char *argv[]) 1543 { 1544 int status; 1545 pcitool_uiargs_t parsed_args; 1546 1547 status = get_commandline_args(argc, argv, &parsed_args); 1548 if (status) { 1549 (void) printf("Error getting command.\n"); 1550 } 1551 dump_struct(&parsed_args); 1552 1553 return (SUCCESS); 1554 } 1555 1556 #endif /* STANDALONE */ 1557 #endif /* DEBUG */ 1558