linux/tools/firewire/nosy-dump.c
<<
>>
Prefs
   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
  39enum {
  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
  46static void print_packet(uint32_t *data, size_t length);
  47static void decode_link_packet(struct link_packet *packet, size_t length,
  48                               int include_flags, int exclude_flags);
  49static int run = 1;
  50sig_t sys_sigint_handler;
  51
  52static char *option_nosy_device = "/dev/nosy";
  53static char *option_view = "packet";
  54static char *option_output;
  55static char *option_input;
  56static int option_hex;
  57static int option_iso;
  58static int option_cycle_start;
  59static int option_version;
  60static int option_verbose;
  61
  62enum {
  63        VIEW_TRANSACTION,
  64        VIEW_PACKET,
  65        VIEW_STATS,
  66};
  67
  68static 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. */
 137static void
 138sigint_handler(int signal_num)
 139{
 140        if (run == 1) {
 141                run = 0;
 142                signal(SIGINT, SIG_DFL);
 143        }
 144}
 145
 146static struct subaction *
 147subaction_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
 162static void
 163subaction_destroy(struct subaction *sa)
 164{
 165        free(sa);
 166}
 167
 168static struct list pending_transaction_list = {
 169        &pending_transaction_list, &pending_transaction_list
 170};
 171
 172static struct link_transaction *
 173link_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
 198static void
 199link_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
 216struct protocol_decoder {
 217        const char *name;
 218        int (*decode)(struct link_transaction *t);
 219};
 220
 221static const struct protocol_decoder protocol_decoders[] = {
 222        { "FCP", decode_fcp }
 223};
 224
 225static void
 226handle_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
 262static void
 263clear_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
 276static 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
 285static 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
 296static 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
 303static const char * const retry_names[] = {
 304        [0x0] = "retry_1",
 305        [0x1] = "retry_x",
 306        [0x2] = "retry_a",
 307        [0x3] = "retry_b",
 308};
 309
 310enum {
 311        PACKET_RESERVED,
 312        PACKET_REQUEST,
 313        PACKET_RESPONSE,
 314        PACKET_OTHER,
 315};
 316
 317struct 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
 325struct 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
 352static 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
 358static 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
 365static 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
 373static 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
 383static 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
 389static 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
 399static 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
 405static 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
 417static 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
 494static int
 495handle_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
 559static int
 560handle_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
 631static int
 632handle_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
 656static unsigned int
 657get_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
 677static void
 678dump_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
 696static void
 697decode_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
 756static void
 757print_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
 839static void
 840print_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
 877static struct termios saved_attributes;
 878
 879static void
 880reset_input_mode(void)
 881{
 882        tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes);
 883}
 884
 885static void
 886set_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
 908int 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
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.