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