1 /* 2 * nosy-dump - Interface to snoop mode driver for TI PCILynx 1394 controllers 3 * Copyright (C) 2002-2006 Kristian Høgsberg 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software Foundation, 17 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 18 */ 19 20 #include <byteswap.h> 21 #include <endian.h> 22 #include <fcntl.h> 23 #include <linux/firewire-constants.h> 24 #include <poll.h> 25 #include <popt.h> 26 #include <signal.h> 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <string.h> 30 #include <sys/ioctl.h> 31 #include <sys/time.h> 32 #include <termios.h> 33 #include <unistd.h> 34 35 #include "list.h" 36 #include "nosy-dump.h" 37 #include "nosy-user.h" 38 39 enum { 40 PACKET_FIELD_DETAIL = 0x01, 41 PACKET_FIELD_DATA_LENGTH = 0x02, 42 /* Marks the fields we print in transaction view. */ 43 PACKET_FIELD_TRANSACTION = 0x04, 44 }; 45 46 static void print_packet(uint32_t *data, size_t length); 47 static void decode_link_packet(struct link_packet *packet, size_t length, 48 int include_flags, int exclude_flags); 49 static int run = 1; 50 sig_t sys_sigint_handler; 51 52 static char *option_nosy_device = "/dev/nosy"; 53 static char *option_view = "packet"; 54 static char *option_output; 55 static char *option_input; 56 static int option_hex; 57 static int option_iso; 58 static int option_cycle_start; 59 static int option_version; 60 static int option_verbose; 61 62 enum { 63 VIEW_TRANSACTION, 64 VIEW_PACKET, 65 VIEW_STATS, 66 }; 67 68 static const struct poptOption options[] = { 69 { 70 .longName = "device", 71 .shortName = 'd', 72 .argInfo = POPT_ARG_STRING, 73 .arg = &option_nosy_device, 74 .descrip = "Path to nosy device.", 75 .argDescrip = "DEVICE" 76 }, 77 { 78 .longName = "view", 79 .argInfo = POPT_ARG_STRING, 80 .arg = &option_view, 81 .descrip = "Specify view of bus traffic: packet, transaction or stats.", 82 .argDescrip = "VIEW" 83 }, 84 { 85 .longName = "hex", 86 .shortName = 'x', 87 .argInfo = POPT_ARG_NONE, 88 .arg = &option_hex, 89 .descrip = "Print each packet in hex.", 90 }, 91 { 92 .longName = "iso", 93 .argInfo = POPT_ARG_NONE, 94 .arg = &option_iso, 95 .descrip = "Print iso packets.", 96 }, 97 { 98 .longName = "cycle-start", 99 .argInfo = POPT_ARG_NONE, 100 .arg = &option_cycle_start, 101 .descrip = "Print cycle start packets.", 102 }, 103 { 104 .longName = "verbose", 105 .shortName = 'v', 106 .argInfo = POPT_ARG_NONE, 107 .arg = &option_verbose, 108 .descrip = "Verbose packet view.", 109 }, 110 { 111 .longName = "output", 112 .shortName = 'o', 113 .argInfo = POPT_ARG_STRING, 114 .arg = &option_output, 115 .descrip = "Log to output file.", 116 .argDescrip = "FILENAME" 117 }, 118 { 119 .longName = "input", 120 .shortName = 'i', 121 .argInfo = POPT_ARG_STRING, 122 .arg = &option_input, 123 .descrip = "Decode log from file.", 124 .argDescrip = "FILENAME" 125 }, 126 { 127 .longName = "version", 128 .argInfo = POPT_ARG_NONE, 129 .arg = &option_version, 130 .descrip = "Specify print version info.", 131 }, 132 POPT_AUTOHELP 133 POPT_TABLEEND 134 }; 135 136 /* Allow all ^C except the first to interrupt the program in the usual way. */ 137 static void 138 sigint_handler(int signal_num) 139 { 140 if (run == 1) { 141 run = 0; 142 signal(SIGINT, SIG_DFL); 143 } 144 } 145 146 static struct subaction * 147 subaction_create(uint32_t *data, size_t length) 148 { 149 struct subaction *sa; 150 151 /* we put the ack in the subaction struct for easy access. */ 152 sa = malloc(sizeof *sa - sizeof sa->packet + length); 153 if (!sa) 154 exit(EXIT_FAILURE); 155 sa->ack = data[length / 4 - 1]; 156 sa->length = length; 157 memcpy(&sa->packet, data, length); 158 159 return sa; 160 } 161 162 static void 163 subaction_destroy(struct subaction *sa) 164 { 165 free(sa); 166 } 167 168 static struct list pending_transaction_list = { 169 &pending_transaction_list, &pending_transaction_list 170 }; 171 172 static struct link_transaction * 173 link_transaction_lookup(int request_node, int response_node, int tlabel) 174 { 175 struct link_transaction *t; 176 177 list_for_each_entry(t, &pending_transaction_list, link) { 178 if (t->request_node == request_node && 179 t->response_node == response_node && 180 t->tlabel == tlabel) 181 return t; 182 } 183 184 t = malloc(sizeof *t); 185 if (!t) 186 exit(EXIT_FAILURE); 187 t->request_node = request_node; 188 t->response_node = response_node; 189 t->tlabel = tlabel; 190 list_init(&t->request_list); 191 list_init(&t->response_list); 192 193 list_append(&pending_transaction_list, &t->link); 194 195 return t; 196 } 197 198 static void 199 link_transaction_destroy(struct link_transaction *t) 200 { 201 struct subaction *sa; 202 203 while (!list_empty(&t->request_list)) { 204 sa = list_head(&t->request_list, struct subaction, link); 205 list_remove(&sa->link); 206 subaction_destroy(sa); 207 } 208 while (!list_empty(&t->response_list)) { 209 sa = list_head(&t->response_list, struct subaction, link); 210 list_remove(&sa->link); 211 subaction_destroy(sa); 212 } 213 free(t); 214 } 215 216 struct protocol_decoder { 217 const char *name; 218 int (*decode)(struct link_transaction *t); 219 }; 220 221 static const struct protocol_decoder protocol_decoders[] = { 222 { "FCP", decode_fcp } 223 }; 224 225 static void 226 handle_transaction(struct link_transaction *t) 227 { 228 struct subaction *sa; 229 int i; 230 231 if (!t->request) { 232 printf("BUG in handle_transaction\n"); 233 return; 234 } 235 236 for (i = 0; i < array_length(protocol_decoders); i++) 237 if (protocol_decoders[i].decode(t)) 238 break; 239 240 /* HACK: decode only fcp right now. */ 241 return; 242 243 decode_link_packet(&t->request->packet, t->request->length, 244 PACKET_FIELD_TRANSACTION, 0); 245 if (t->response) 246 decode_link_packet(&t->response->packet, t->request->length, 247 PACKET_FIELD_TRANSACTION, 0); 248 else 249 printf("[no response]"); 250 251 if (option_verbose) { 252 list_for_each_entry(sa, &t->request_list, link) 253 print_packet((uint32_t *) &sa->packet, sa->length); 254 list_for_each_entry(sa, &t->response_list, link) 255 print_packet((uint32_t *) &sa->packet, sa->length); 256 } 257 printf("\r\n"); 258 259 link_transaction_destroy(t); 260 } 261 262 static void 263 clear_pending_transaction_list(void) 264 { 265 struct link_transaction *t; 266 267 while (!list_empty(&pending_transaction_list)) { 268 t = list_head(&pending_transaction_list, 269 struct link_transaction, link); 270 list_remove(&t->link); 271 link_transaction_destroy(t); 272 /* print unfinished transactions */ 273 } 274 } 275 276 static const char * const tcode_names[] = { 277 [0x0] = "write_quadlet_request", [0x6] = "read_quadlet_response", 278 [0x1] = "write_block_request", [0x7] = "read_block_response", 279 [0x2] = "write_response", [0x8] = "cycle_start", 280 [0x3] = "reserved", [0x9] = "lock_request", 281 [0x4] = "read_quadlet_request", [0xa] = "iso_data", 282 [0x5] = "read_block_request", [0xb] = "lock_response", 283 }; 284 285 static const char * const ack_names[] = { 286 [0x0] = "no ack", [0x8] = "reserved (0x08)", 287 [0x1] = "ack_complete", [0x9] = "reserved (0x09)", 288 [0x2] = "ack_pending", [0xa] = "reserved (0x0a)", 289 [0x3] = "reserved (0x03)", [0xb] = "reserved (0x0b)", 290 [0x4] = "ack_busy_x", [0xc] = "reserved (0x0c)", 291 [0x5] = "ack_busy_a", [0xd] = "ack_data_error", 292 [0x6] = "ack_busy_b", [0xe] = "ack_type_error", 293 [0x7] = "reserved (0x07)", [0xf] = "reserved (0x0f)", 294 }; 295 296 static const char * const rcode_names[] = { 297 [0x0] = "complete", [0x4] = "conflict_error", 298 [0x1] = "reserved (0x01)", [0x5] = "data_error", 299 [0x2] = "reserved (0x02)", [0x6] = "type_error", 300 [0x3] = "reserved (0x03)", [0x7] = "address_error", 301 }; 302 303 static const char * const retry_names[] = { 304 [0x0] = "retry_1", 305 [0x1] = "retry_x", 306 [0x2] = "retry_a", 307 [0x3] = "retry_b", 308 }; 309 310 enum { 311 PACKET_RESERVED, 312 PACKET_REQUEST, 313 PACKET_RESPONSE, 314 PACKET_OTHER, 315 }; 316 317 struct packet_info { 318 const char *name; 319 int type; 320 int response_tcode; 321 const struct packet_field *fields; 322 int field_count; 323 }; 324 325 struct packet_field { 326 const char *name; /* Short name for field. */ 327 int offset; /* Location of field, specified in bits; */ 328 /* negative means from end of packet. */ 329 int width; /* Width of field, 0 means use data_length. */ 330 int flags; /* Show options. */ 331 const char * const *value_names; 332 }; 333 334 #define COMMON_REQUEST_FIELDS \ 335 { "dest", 0, 16, PACKET_FIELD_TRANSACTION }, \ 336 { "tl", 16, 6 }, \ 337 { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \ 338 { "tcode", 24, 4, PACKET_FIELD_TRANSACTION, tcode_names }, \ 339 { "pri", 28, 4, PACKET_FIELD_DETAIL }, \ 340 { "src", 32, 16, PACKET_FIELD_TRANSACTION }, \ 341 { "offs", 48, 48, PACKET_FIELD_TRANSACTION } 342 343 #define COMMON_RESPONSE_FIELDS \ 344 { "dest", 0, 16 }, \ 345 { "tl", 16, 6 }, \ 346 { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \ 347 { "tcode", 24, 4, 0, tcode_names }, \ 348 { "pri", 28, 4, PACKET_FIELD_DETAIL }, \ 349 { "src", 32, 16 }, \ 350 { "rcode", 48, 4, PACKET_FIELD_TRANSACTION, rcode_names } 351 352 static const struct packet_field read_quadlet_request_fields[] = { 353 COMMON_REQUEST_FIELDS, 354 { "crc", 96, 32, PACKET_FIELD_DETAIL }, 355 { "ack", 156, 4, 0, ack_names }, 356 }; 357 358 static const struct packet_field read_quadlet_response_fields[] = { 359 COMMON_RESPONSE_FIELDS, 360 { "data", 96, 32, PACKET_FIELD_TRANSACTION }, 361 { "crc", 128, 32, PACKET_FIELD_DETAIL }, 362 { "ack", 188, 4, 0, ack_names }, 363 }; 364 365 static const struct packet_field read_block_request_fields[] = { 366 COMMON_REQUEST_FIELDS, 367 { "data_length", 96, 16, PACKET_FIELD_TRANSACTION }, 368 { "extended_tcode", 112, 16 }, 369 { "crc", 128, 32, PACKET_FIELD_DETAIL }, 370 { "ack", 188, 4, 0, ack_names }, 371 }; 372 373 static const struct packet_field block_response_fields[] = { 374 COMMON_RESPONSE_FIELDS, 375 { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH }, 376 { "extended_tcode", 112, 16 }, 377 { "crc", 128, 32, PACKET_FIELD_DETAIL }, 378 { "data", 160, 0, PACKET_FIELD_TRANSACTION }, 379 { "crc", -64, 32, PACKET_FIELD_DETAIL }, 380 { "ack", -4, 4, 0, ack_names }, 381 }; 382 383 static const struct packet_field write_quadlet_request_fields[] = { 384 COMMON_REQUEST_FIELDS, 385 { "data", 96, 32, PACKET_FIELD_TRANSACTION }, 386 { "ack", -4, 4, 0, ack_names }, 387 }; 388 389 static const struct packet_field block_request_fields[] = { 390 COMMON_REQUEST_FIELDS, 391 { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH | PACKET_FIELD_TRANSACTION }, 392 { "extended_tcode", 112, 16, PACKET_FIELD_TRANSACTION }, 393 { "crc", 128, 32, PACKET_FIELD_DETAIL }, 394 { "data", 160, 0, PACKET_FIELD_TRANSACTION }, 395 { "crc", -64, 32, PACKET_FIELD_DETAIL }, 396 { "ack", -4, 4, 0, ack_names }, 397 }; 398 399 static const struct packet_field write_response_fields[] = { 400 COMMON_RESPONSE_FIELDS, 401 { "reserved", 64, 32, PACKET_FIELD_DETAIL }, 402 { "ack", -4, 4, 0, ack_names }, 403 }; 404 405 static const struct packet_field iso_data_fields[] = { 406 { "data_length", 0, 16, PACKET_FIELD_DATA_LENGTH }, 407 { "tag", 16, 2 }, 408 { "channel", 18, 6 }, 409 { "tcode", 24, 4, 0, tcode_names }, 410 { "sy", 28, 4 }, 411 { "crc", 32, 32, PACKET_FIELD_DETAIL }, 412 { "data", 64, 0 }, 413 { "crc", -64, 32, PACKET_FIELD_DETAIL }, 414 { "ack", -4, 4, 0, ack_names }, 415 }; 416 417 static const struct packet_info packet_info[] = { 418 { 419 .name = "write_quadlet_request", 420 .type = PACKET_REQUEST, 421 .response_tcode = TCODE_WRITE_RESPONSE, 422 .fields = write_quadlet_request_fields, 423 .field_count = array_length(write_quadlet_request_fields) 424 }, 425 { 426 .name = "write_block_request", 427 .type = PACKET_REQUEST, 428 .response_tcode = TCODE_WRITE_RESPONSE, 429 .fields = block_request_fields, 430 .field_count = array_length(block_request_fields) 431 }, 432 { 433 .name = "write_response", 434 .type = PACKET_RESPONSE, 435 .fields = write_response_fields, 436 .field_count = array_length(write_response_fields) 437 }, 438 { 439 .name = "reserved", 440 .type = PACKET_RESERVED, 441 }, 442 { 443 .name = "read_quadlet_request", 444 .type = PACKET_REQUEST, 445 .response_tcode = TCODE_READ_QUADLET_RESPONSE, 446 .fields = read_quadlet_request_fields, 447 .field_count = array_length(read_quadlet_request_fields) 448 }, 449 { 450 .name = "read_block_request", 451 .type = PACKET_REQUEST, 452 .response_tcode = TCODE_READ_BLOCK_RESPONSE, 453 .fields = read_block_request_fields, 454 .field_count = array_length(read_block_request_fields) 455 }, 456 { 457 .name = "read_quadlet_response", 458 .type = PACKET_RESPONSE, 459 .fields = read_quadlet_response_fields, 460 .field_count = array_length(read_quadlet_response_fields) 461 }, 462 { 463 .name = "read_block_response", 464 .type = PACKET_RESPONSE, 465 .fields = block_response_fields, 466 .field_count = array_length(block_response_fields) 467 }, 468 { 469 .name = "cycle_start", 470 .type = PACKET_OTHER, 471 .fields = write_quadlet_request_fields, 472 .field_count = array_length(write_quadlet_request_fields) 473 }, 474 { 475 .name = "lock_request", 476 .type = PACKET_REQUEST, 477 .fields = block_request_fields, 478 .field_count = array_length(block_request_fields) 479 }, 480 { 481 .name = "iso_data", 482 .type = PACKET_OTHER, 483 .fields = iso_data_fields, 484 .field_count = array_length(iso_data_fields) 485 }, 486 { 487 .name = "lock_response", 488 .type = PACKET_RESPONSE, 489 .fields = block_response_fields, 490 .field_count = array_length(block_response_fields) 491 }, 492 }; 493 494 static int 495 handle_request_packet(uint32_t *data, size_t length) 496 { 497 struct link_packet *p = (struct link_packet *) data; 498 struct subaction *sa, *prev; 499 struct link_transaction *t; 500 501 t = link_transaction_lookup(p->common.source, p->common.destination, 502 p->common.tlabel); 503 sa = subaction_create(data, length); 504 t->request = sa; 505 506 if (!list_empty(&t->request_list)) { 507 prev = list_tail(&t->request_list, 508 struct subaction, link); 509 510 if (!ACK_BUSY(prev->ack)) { 511 /* 512 * error, we should only see ack_busy_* before the 513 * ack_pending/ack_complete -- this is an ack_pending 514 * instead (ack_complete would have finished the 515 * transaction). 516 */ 517 } 518 519 if (prev->packet.common.tcode != sa->packet.common.tcode || 520 prev->packet.common.tlabel != sa->packet.common.tlabel) { 521 /* memcmp() ? */ 522 /* error, these should match for retries. */ 523 } 524 } 525 526 list_append(&t->request_list, &sa->link); 527 528 switch (sa->ack) { 529 case ACK_COMPLETE: 530 if (p->common.tcode != TCODE_WRITE_QUADLET_REQUEST && 531 p->common.tcode != TCODE_WRITE_BLOCK_REQUEST) 532 /* error, unified transactions only allowed for write */; 533 list_remove(&t->link); 534 handle_transaction(t); 535 break; 536 537 case ACK_NO_ACK: 538 case ACK_DATA_ERROR: 539 case ACK_TYPE_ERROR: 540 list_remove(&t->link); 541 handle_transaction(t); 542 break; 543 544 case ACK_PENDING: 545 /* request subaction phase over, wait for response. */ 546 break; 547 548 case ACK_BUSY_X: 549 case ACK_BUSY_A: 550 case ACK_BUSY_B: 551 /* ok, wait for retry. */ 552 /* check that retry protocol is respected. */ 553 break; 554 } 555 556 return 1; 557 } 558 559 static int 560 handle_response_packet(uint32_t *data, size_t length) 561 { 562 struct link_packet *p = (struct link_packet *) data; 563 struct subaction *sa, *prev; 564 struct link_transaction *t; 565 566 t = link_transaction_lookup(p->common.destination, p->common.source, 567 p->common.tlabel); 568 if (list_empty(&t->request_list)) { 569 /* unsolicited response */ 570 } 571 572 sa = subaction_create(data, length); 573 t->response = sa; 574 575 if (!list_empty(&t->response_list)) { 576 prev = list_tail(&t->response_list, struct subaction, link); 577 578 if (!ACK_BUSY(prev->ack)) { 579 /* 580 * error, we should only see ack_busy_* before the 581 * ack_pending/ack_complete 582 */ 583 } 584 585 if (prev->packet.common.tcode != sa->packet.common.tcode || 586 prev->packet.common.tlabel != sa->packet.common.tlabel) { 587 /* use memcmp() instead? */ 588 /* error, these should match for retries. */ 589 } 590 } else { 591 prev = list_tail(&t->request_list, struct subaction, link); 592 if (prev->ack != ACK_PENDING) { 593 /* 594 * error, should not get response unless last request got 595 * ack_pending. 596 */ 597 } 598 599 if (packet_info[prev->packet.common.tcode].response_tcode != 600 sa->packet.common.tcode) { 601 /* error, tcode mismatch */ 602 } 603 } 604 605 list_append(&t->response_list, &sa->link); 606 607 switch (sa->ack) { 608 case ACK_COMPLETE: 609 case ACK_NO_ACK: 610 case ACK_DATA_ERROR: 611 case ACK_TYPE_ERROR: 612 list_remove(&t->link); 613 handle_transaction(t); 614 /* transaction complete, remove t from pending list. */ 615 break; 616 617 case ACK_PENDING: 618 /* error for responses. */ 619 break; 620 621 case ACK_BUSY_X: 622 case ACK_BUSY_A: 623 case ACK_BUSY_B: 624 /* no problem, wait for next retry */ 625 break; 626 } 627 628 return 1; 629 } 630 631 static int 632 handle_packet(uint32_t *data, size_t length) 633 { 634 if (length == 0) { 635 printf("bus reset\r\n"); 636 clear_pending_transaction_list(); 637 } else if (length > sizeof(struct phy_packet)) { 638 struct link_packet *p = (struct link_packet *) data; 639 640 switch (packet_info[p->common.tcode].type) { 641 case PACKET_REQUEST: 642 return handle_request_packet(data, length); 643 644 case PACKET_RESPONSE: 645 return handle_response_packet(data, length); 646 647 case PACKET_OTHER: 648 case PACKET_RESERVED: 649 return 0; 650 } 651 } 652 653 return 1; 654 } 655 656 static unsigned int 657 get_bits(struct link_packet *packet, int offset, int width) 658 { 659 uint32_t *data = (uint32_t *) packet; 660 uint32_t index, shift, mask; 661 662 index = offset / 32 + 1; 663 shift = 32 - (offset & 31) - width; 664 mask = width == 32 ? ~0 : (1 << width) - 1; 665 666 return (data[index] >> shift) & mask; 667 } 668 669 #if __BYTE_ORDER == __LITTLE_ENDIAN 670 #define byte_index(i) ((i) ^ 3) 671 #elif __BYTE_ORDER == __BIG_ENDIAN 672 #define byte_index(i) (i) 673 #else 674 #error unsupported byte order. 675 #endif 676 677 static void 678 dump_data(unsigned char *data, int length) 679 { 680 int i, print_length; 681 682 if (length > 128) 683 print_length = 128; 684 else 685 print_length = length; 686 687 for (i = 0; i < print_length; i++) 688 printf("%s%02hhx", 689 (i % 4 == 0 && i != 0) ? " " : "", 690 data[byte_index(i)]); 691 692 if (print_length < length) 693 printf(" (%d more bytes)", length - print_length); 694 } 695 696 static void 697 decode_link_packet(struct link_packet *packet, size_t length, 698 int include_flags, int exclude_flags) 699 { 700 const struct packet_info *pi; 701 int data_length = 0; 702 int i; 703 704 pi = &packet_info[packet->common.tcode]; 705 706 for (i = 0; i < pi->field_count; i++) { 707 const struct packet_field *f = &pi->fields[i]; 708 int offset; 709 710 if (f->flags & exclude_flags) 711 continue; 712 if (include_flags && !(f->flags & include_flags)) 713 continue; 714 715 if (f->offset < 0) 716 offset = length * 8 + f->offset - 32; 717 else 718 offset = f->offset; 719 720 if (f->value_names != NULL) { 721 uint32_t bits; 722 723 bits = get_bits(packet, offset, f->width); 724 printf("%s", f->value_names[bits]); 725 } else if (f->width == 0) { 726 printf("%s=[", f->name); 727 dump_data((unsigned char *) packet + (offset / 8 + 4), data_length); 728 printf("]"); 729 } else { 730 unsigned long long bits; 731 int high_width, low_width; 732 733 if ((offset & ~31) != ((offset + f->width - 1) & ~31)) { 734 /* Bit field spans quadlet boundary. */ 735 high_width = ((offset + 31) & ~31) - offset; 736 low_width = f->width - high_width; 737 738 bits = get_bits(packet, offset, high_width); 739 bits = (bits << low_width) | 740 get_bits(packet, offset + high_width, low_width); 741 } else { 742 bits = get_bits(packet, offset, f->width); 743 } 744 745 printf("%s=0x%0*llx", f->name, (f->width + 3) / 4, bits); 746 747 if (f->flags & PACKET_FIELD_DATA_LENGTH) 748 data_length = bits; 749 } 750 751 if (i < pi->field_count - 1) 752 printf(", "); 753 } 754 } 755 756 static void 757 print_packet(uint32_t *data, size_t length) 758 { 759 int i; 760 761 printf("%6u ", data[0]); 762 763 if (length == 4) { 764 printf("bus reset"); 765 } else if (length < sizeof(struct phy_packet)) { 766 printf("short packet: "); 767 for (i = 1; i < length / 4; i++) 768 printf("%s%08x", i == 0 ? "[" : " ", data[i]); 769 printf("]"); 770 771 } else if (length == sizeof(struct phy_packet) && data[1] == ~data[2]) { 772 struct phy_packet *pp = (struct phy_packet *) data; 773 774 /* phy packet are 3 quadlets: the 1 quadlet payload, 775 * the bitwise inverse of the payload and the snoop 776 * mode ack */ 777 778 switch (pp->common.identifier) { 779 case PHY_PACKET_CONFIGURATION: 780 if (!pp->phy_config.set_root && !pp->phy_config.set_gap_count) { 781 printf("ext phy config: phy_id=%02x", pp->phy_config.root_id); 782 } else { 783 printf("phy config:"); 784 if (pp->phy_config.set_root) 785 printf(" set_root_id=%02x", pp->phy_config.root_id); 786 if (pp->phy_config.set_gap_count) 787 printf(" set_gap_count=%d", pp->phy_config.gap_count); 788 } 789 break; 790 791 case PHY_PACKET_LINK_ON: 792 printf("link-on packet, phy_id=%02x", pp->link_on.phy_id); 793 break; 794 795 case PHY_PACKET_SELF_ID: 796 if (pp->self_id.extended) { 797 printf("extended self id: phy_id=%02x, seq=%d", 798 pp->ext_self_id.phy_id, pp->ext_self_id.sequence); 799 } else { 800 static const char * const speed_names[] = { 801 "S100", "S200", "S400", "BETA" 802 }; 803 printf("self id: phy_id=%02x, link %s, gap_count=%d, speed=%s%s%s", 804 pp->self_id.phy_id, 805 (pp->self_id.link_active ? "active" : "not active"), 806 pp->self_id.gap_count, 807 speed_names[pp->self_id.phy_speed], 808 (pp->self_id.contender ? ", irm contender" : ""), 809 (pp->self_id.initiated_reset ? ", initiator" : "")); 810 } 811 break; 812 default: 813 printf("unknown phy packet: "); 814 for (i = 1; i < length / 4; i++) 815 printf("%s%08x", i == 0 ? "[" : " ", data[i]); 816 printf("]"); 817 break; 818 } 819 } else { 820 struct link_packet *packet = (struct link_packet *) data; 821 822 decode_link_packet(packet, length, 0, 823 option_verbose ? 0 : PACKET_FIELD_DETAIL); 824 } 825 826 if (option_hex) { 827 printf(" ["); 828 dump_data((unsigned char *) data + 4, length - 4); 829 printf("]"); 830 } 831 832 printf("\r\n"); 833 } 834 835 #define HIDE_CURSOR "\033[?25l" 836 #define SHOW_CURSOR "\033[?25h" 837 #define CLEAR "\033[H\033[2J" 838 839 static void 840 print_stats(uint32_t *data, size_t length) 841 { 842 static int bus_reset_count, short_packet_count, phy_packet_count; 843 static int tcode_count[16]; 844 static struct timeval last_update; 845 struct timeval now; 846 int i; 847 848 if (length == 0) 849 bus_reset_count++; 850 else if (length < sizeof(struct phy_packet)) 851 short_packet_count++; 852 else if (length == sizeof(struct phy_packet) && data[1] == ~data[2]) 853 phy_packet_count++; 854 else { 855 struct link_packet *packet = (struct link_packet *) data; 856 tcode_count[packet->common.tcode]++; 857 } 858 859 gettimeofday(&now, NULL); 860 if (now.tv_sec <= last_update.tv_sec && 861 now.tv_usec < last_update.tv_usec + 500000) 862 return; 863 864 last_update = now; 865 printf(CLEAR HIDE_CURSOR 866 " bus resets : %8d\n" 867 " short packets : %8d\n" 868 " phy packets : %8d\n", 869 bus_reset_count, short_packet_count, phy_packet_count); 870 871 for (i = 0; i < array_length(packet_info); i++) 872 if (packet_info[i].type != PACKET_RESERVED) 873 printf(" %-24s: %8d\n", packet_info[i].name, tcode_count[i]); 874 printf(SHOW_CURSOR "\n"); 875 } 876 877 static struct termios saved_attributes; 878 879 static void 880 reset_input_mode(void) 881 { 882 tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes); 883 } 884 885 static void 886 set_input_mode(void) 887 { 888 struct termios tattr; 889 890 /* Make sure stdin is a terminal. */ 891 if (!isatty(STDIN_FILENO)) { 892 fprintf(stderr, "Not a terminal.\n"); 893 exit(EXIT_FAILURE); 894 } 895 896 /* Save the terminal attributes so we can restore them later. */ 897 tcgetattr(STDIN_FILENO, &saved_attributes); 898 atexit(reset_input_mode); 899 900 /* Set the funny terminal modes. */ 901 tcgetattr(STDIN_FILENO, &tattr); 902 tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */ 903 tattr.c_cc[VMIN] = 1; 904 tattr.c_cc[VTIME] = 0; 905 tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr); 906 } 907 908 int main(int argc, const char *argv[]) 909 { 910 uint32_t buf[128 * 1024]; 911 uint32_t filter; 912 int length, retval, view; 913 int fd = -1; 914 FILE *output = NULL, *input = NULL; 915 poptContext con; 916 char c; 917 struct pollfd pollfds[2]; 918 919 sys_sigint_handler = signal(SIGINT, sigint_handler); 920 921 con = poptGetContext(NULL, argc, argv, options, 0); 922 retval = poptGetNextOpt(con); 923 if (retval < -1) { 924 poptPrintUsage(con, stdout, 0); 925 return -1; 926 } 927 928 if (option_version) { 929 printf("dump tool for nosy sniffer, version %s\n", VERSION); 930 return 0; 931 } 932 933 if (__BYTE_ORDER != __LITTLE_ENDIAN) 934 fprintf(stderr, "warning: nosy has only been tested on little " 935 "endian machines\n"); 936 937 if (option_input != NULL) { 938 input = fopen(option_input, "r"); 939 if (input == NULL) { 940 fprintf(stderr, "Could not open %s, %m\n", option_input); 941 return -1; 942 } 943 } else { 944 fd = open(option_nosy_device, O_RDWR); 945 if (fd < 0) { 946 fprintf(stderr, "Could not open %s, %m\n", option_nosy_device); 947 return -1; 948 } 949 set_input_mode(); 950 } 951 952 if (strcmp(option_view, "transaction") == 0) 953 view = VIEW_TRANSACTION; 954 else if (strcmp(option_view, "stats") == 0) 955 view = VIEW_STATS; 956 else 957 view = VIEW_PACKET; 958 959 if (option_output) { 960 output = fopen(option_output, "w"); 961 if (output == NULL) { 962 fprintf(stderr, "Could not open %s, %m\n", option_output); 963 return -1; 964 } 965 } 966 967 setvbuf(stdout, NULL, _IOLBF, BUFSIZ); 968 969 filter = ~0; 970 if (!option_iso) 971 filter &= ~(1 << TCODE_STREAM_DATA); 972 if (!option_cycle_start) 973 filter &= ~(1 << TCODE_CYCLE_START); 974 if (view == VIEW_STATS) 975 filter = ~(1 << TCODE_CYCLE_START); 976 977 ioctl(fd, NOSY_IOC_FILTER, filter); 978 979 ioctl(fd, NOSY_IOC_START); 980 981 pollfds[0].fd = fd; 982 pollfds[0].events = POLLIN; 983 pollfds[1].fd = STDIN_FILENO; 984 pollfds[1].events = POLLIN; 985 986 while (run) { 987 if (input != NULL) { 988 if (fread(&length, sizeof length, 1, input) != 1) 989 return 0; 990 fread(buf, 1, length, input); 991 } else { 992 poll(pollfds, 2, -1); 993 if (pollfds[1].revents) { 994 read(STDIN_FILENO, &c, sizeof c); 995 switch (c) { 996 case 'q': 997 if (output != NULL) 998 fclose(output); 999 return 0; 1000 } 1001 } 1002 1003 if (pollfds[0].revents) 1004 length = read(fd, buf, sizeof buf); 1005 else 1006 continue; 1007 } 1008 1009 if (output != NULL) { 1010 fwrite(&length, sizeof length, 1, output); 1011 fwrite(buf, 1, length, output); 1012 } 1013 1014 switch (view) { 1015 case VIEW_TRANSACTION: 1016 handle_packet(buf, length); 1017 break; 1018 case VIEW_PACKET: 1019 print_packet(buf, length); 1020 break; 1021 case VIEW_STATS: 1022 print_stats(buf, length); 1023 break; 1024 } 1025 } 1026 1027 if (output != NULL) 1028 fclose(output); 1029 1030 close(fd); 1031 1032 poptFreeContext(con); 1033 1034 return 0; 1035 } 1036