mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-30 23:54:04 +08:00
6fa79bcaec
Behavior of null pointer dereference is undefined in the C language. Portably implement the desired behavior. Reported-by: Yang Yeping <yangyeping_666@hotmail.com> Signed-off-by: Stefan Richter <stefanr@s5r6.in-berlin.de>
1036 lines
25 KiB
C
1036 lines
25 KiB
C
/*
|
|
* nosy-dump - Interface to snoop mode driver for TI PCILynx 1394 controllers
|
|
* Copyright (C) 2002-2006 Kristian Høgsberg
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <byteswap.h>
|
|
#include <endian.h>
|
|
#include <fcntl.h>
|
|
#include <linux/firewire-constants.h>
|
|
#include <poll.h>
|
|
#include <popt.h>
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
|
|
#include "list.h"
|
|
#include "nosy-dump.h"
|
|
#include "nosy-user.h"
|
|
|
|
enum {
|
|
PACKET_FIELD_DETAIL = 0x01,
|
|
PACKET_FIELD_DATA_LENGTH = 0x02,
|
|
/* Marks the fields we print in transaction view. */
|
|
PACKET_FIELD_TRANSACTION = 0x04,
|
|
};
|
|
|
|
static void print_packet(uint32_t *data, size_t length);
|
|
static void decode_link_packet(struct link_packet *packet, size_t length,
|
|
int include_flags, int exclude_flags);
|
|
static int run = 1;
|
|
sig_t sys_sigint_handler;
|
|
|
|
static char *option_nosy_device = "/dev/nosy";
|
|
static char *option_view = "packet";
|
|
static char *option_output;
|
|
static char *option_input;
|
|
static int option_hex;
|
|
static int option_iso;
|
|
static int option_cycle_start;
|
|
static int option_version;
|
|
static int option_verbose;
|
|
|
|
enum {
|
|
VIEW_TRANSACTION,
|
|
VIEW_PACKET,
|
|
VIEW_STATS,
|
|
};
|
|
|
|
static const struct poptOption options[] = {
|
|
{
|
|
.longName = "device",
|
|
.shortName = 'd',
|
|
.argInfo = POPT_ARG_STRING,
|
|
.arg = &option_nosy_device,
|
|
.descrip = "Path to nosy device.",
|
|
.argDescrip = "DEVICE"
|
|
},
|
|
{
|
|
.longName = "view",
|
|
.argInfo = POPT_ARG_STRING,
|
|
.arg = &option_view,
|
|
.descrip = "Specify view of bus traffic: packet, transaction or stats.",
|
|
.argDescrip = "VIEW"
|
|
},
|
|
{
|
|
.longName = "hex",
|
|
.shortName = 'x',
|
|
.argInfo = POPT_ARG_NONE,
|
|
.arg = &option_hex,
|
|
.descrip = "Print each packet in hex.",
|
|
},
|
|
{
|
|
.longName = "iso",
|
|
.argInfo = POPT_ARG_NONE,
|
|
.arg = &option_iso,
|
|
.descrip = "Print iso packets.",
|
|
},
|
|
{
|
|
.longName = "cycle-start",
|
|
.argInfo = POPT_ARG_NONE,
|
|
.arg = &option_cycle_start,
|
|
.descrip = "Print cycle start packets.",
|
|
},
|
|
{
|
|
.longName = "verbose",
|
|
.shortName = 'v',
|
|
.argInfo = POPT_ARG_NONE,
|
|
.arg = &option_verbose,
|
|
.descrip = "Verbose packet view.",
|
|
},
|
|
{
|
|
.longName = "output",
|
|
.shortName = 'o',
|
|
.argInfo = POPT_ARG_STRING,
|
|
.arg = &option_output,
|
|
.descrip = "Log to output file.",
|
|
.argDescrip = "FILENAME"
|
|
},
|
|
{
|
|
.longName = "input",
|
|
.shortName = 'i',
|
|
.argInfo = POPT_ARG_STRING,
|
|
.arg = &option_input,
|
|
.descrip = "Decode log from file.",
|
|
.argDescrip = "FILENAME"
|
|
},
|
|
{
|
|
.longName = "version",
|
|
.argInfo = POPT_ARG_NONE,
|
|
.arg = &option_version,
|
|
.descrip = "Specify print version info.",
|
|
},
|
|
POPT_AUTOHELP
|
|
POPT_TABLEEND
|
|
};
|
|
|
|
/* Allow all ^C except the first to interrupt the program in the usual way. */
|
|
static void
|
|
sigint_handler(int signal_num)
|
|
{
|
|
if (run == 1) {
|
|
run = 0;
|
|
signal(SIGINT, SIG_DFL);
|
|
}
|
|
}
|
|
|
|
static struct subaction *
|
|
subaction_create(uint32_t *data, size_t length)
|
|
{
|
|
struct subaction *sa;
|
|
|
|
/* we put the ack in the subaction struct for easy access. */
|
|
sa = malloc(sizeof *sa - sizeof sa->packet + length);
|
|
if (!sa)
|
|
exit(EXIT_FAILURE);
|
|
sa->ack = data[length / 4 - 1];
|
|
sa->length = length;
|
|
memcpy(&sa->packet, data, length);
|
|
|
|
return sa;
|
|
}
|
|
|
|
static void
|
|
subaction_destroy(struct subaction *sa)
|
|
{
|
|
free(sa);
|
|
}
|
|
|
|
static struct list pending_transaction_list = {
|
|
&pending_transaction_list, &pending_transaction_list
|
|
};
|
|
|
|
static struct link_transaction *
|
|
link_transaction_lookup(int request_node, int response_node, int tlabel)
|
|
{
|
|
struct link_transaction *t;
|
|
|
|
list_for_each_entry(t, &pending_transaction_list, link) {
|
|
if (t->request_node == request_node &&
|
|
t->response_node == response_node &&
|
|
t->tlabel == tlabel)
|
|
return t;
|
|
}
|
|
|
|
t = malloc(sizeof *t);
|
|
if (!t)
|
|
exit(EXIT_FAILURE);
|
|
t->request_node = request_node;
|
|
t->response_node = response_node;
|
|
t->tlabel = tlabel;
|
|
list_init(&t->request_list);
|
|
list_init(&t->response_list);
|
|
|
|
list_append(&pending_transaction_list, &t->link);
|
|
|
|
return t;
|
|
}
|
|
|
|
static void
|
|
link_transaction_destroy(struct link_transaction *t)
|
|
{
|
|
struct subaction *sa;
|
|
|
|
while (!list_empty(&t->request_list)) {
|
|
sa = list_head(&t->request_list, struct subaction, link);
|
|
list_remove(&sa->link);
|
|
subaction_destroy(sa);
|
|
}
|
|
while (!list_empty(&t->response_list)) {
|
|
sa = list_head(&t->response_list, struct subaction, link);
|
|
list_remove(&sa->link);
|
|
subaction_destroy(sa);
|
|
}
|
|
free(t);
|
|
}
|
|
|
|
struct protocol_decoder {
|
|
const char *name;
|
|
int (*decode)(struct link_transaction *t);
|
|
};
|
|
|
|
static const struct protocol_decoder protocol_decoders[] = {
|
|
{ "FCP", decode_fcp }
|
|
};
|
|
|
|
static void
|
|
handle_transaction(struct link_transaction *t)
|
|
{
|
|
struct subaction *sa;
|
|
int i;
|
|
|
|
if (!t->request) {
|
|
printf("BUG in handle_transaction\n");
|
|
return;
|
|
}
|
|
|
|
for (i = 0; i < array_length(protocol_decoders); i++)
|
|
if (protocol_decoders[i].decode(t))
|
|
break;
|
|
|
|
/* HACK: decode only fcp right now. */
|
|
return;
|
|
|
|
decode_link_packet(&t->request->packet, t->request->length,
|
|
PACKET_FIELD_TRANSACTION, 0);
|
|
if (t->response)
|
|
decode_link_packet(&t->response->packet, t->request->length,
|
|
PACKET_FIELD_TRANSACTION, 0);
|
|
else
|
|
printf("[no response]");
|
|
|
|
if (option_verbose) {
|
|
list_for_each_entry(sa, &t->request_list, link)
|
|
print_packet((uint32_t *) &sa->packet, sa->length);
|
|
list_for_each_entry(sa, &t->response_list, link)
|
|
print_packet((uint32_t *) &sa->packet, sa->length);
|
|
}
|
|
printf("\r\n");
|
|
|
|
link_transaction_destroy(t);
|
|
}
|
|
|
|
static void
|
|
clear_pending_transaction_list(void)
|
|
{
|
|
struct link_transaction *t;
|
|
|
|
while (!list_empty(&pending_transaction_list)) {
|
|
t = list_head(&pending_transaction_list,
|
|
struct link_transaction, link);
|
|
list_remove(&t->link);
|
|
link_transaction_destroy(t);
|
|
/* print unfinished transactions */
|
|
}
|
|
}
|
|
|
|
static const char * const tcode_names[] = {
|
|
[0x0] = "write_quadlet_request", [0x6] = "read_quadlet_response",
|
|
[0x1] = "write_block_request", [0x7] = "read_block_response",
|
|
[0x2] = "write_response", [0x8] = "cycle_start",
|
|
[0x3] = "reserved", [0x9] = "lock_request",
|
|
[0x4] = "read_quadlet_request", [0xa] = "iso_data",
|
|
[0x5] = "read_block_request", [0xb] = "lock_response",
|
|
};
|
|
|
|
static const char * const ack_names[] = {
|
|
[0x0] = "no ack", [0x8] = "reserved (0x08)",
|
|
[0x1] = "ack_complete", [0x9] = "reserved (0x09)",
|
|
[0x2] = "ack_pending", [0xa] = "reserved (0x0a)",
|
|
[0x3] = "reserved (0x03)", [0xb] = "reserved (0x0b)",
|
|
[0x4] = "ack_busy_x", [0xc] = "reserved (0x0c)",
|
|
[0x5] = "ack_busy_a", [0xd] = "ack_data_error",
|
|
[0x6] = "ack_busy_b", [0xe] = "ack_type_error",
|
|
[0x7] = "reserved (0x07)", [0xf] = "reserved (0x0f)",
|
|
};
|
|
|
|
static const char * const rcode_names[] = {
|
|
[0x0] = "complete", [0x4] = "conflict_error",
|
|
[0x1] = "reserved (0x01)", [0x5] = "data_error",
|
|
[0x2] = "reserved (0x02)", [0x6] = "type_error",
|
|
[0x3] = "reserved (0x03)", [0x7] = "address_error",
|
|
};
|
|
|
|
static const char * const retry_names[] = {
|
|
[0x0] = "retry_1",
|
|
[0x1] = "retry_x",
|
|
[0x2] = "retry_a",
|
|
[0x3] = "retry_b",
|
|
};
|
|
|
|
enum {
|
|
PACKET_RESERVED,
|
|
PACKET_REQUEST,
|
|
PACKET_RESPONSE,
|
|
PACKET_OTHER,
|
|
};
|
|
|
|
struct packet_info {
|
|
const char *name;
|
|
int type;
|
|
int response_tcode;
|
|
const struct packet_field *fields;
|
|
int field_count;
|
|
};
|
|
|
|
struct packet_field {
|
|
const char *name; /* Short name for field. */
|
|
int offset; /* Location of field, specified in bits; */
|
|
/* negative means from end of packet. */
|
|
int width; /* Width of field, 0 means use data_length. */
|
|
int flags; /* Show options. */
|
|
const char * const *value_names;
|
|
};
|
|
|
|
#define COMMON_REQUEST_FIELDS \
|
|
{ "dest", 0, 16, PACKET_FIELD_TRANSACTION }, \
|
|
{ "tl", 16, 6 }, \
|
|
{ "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \
|
|
{ "tcode", 24, 4, PACKET_FIELD_TRANSACTION, tcode_names }, \
|
|
{ "pri", 28, 4, PACKET_FIELD_DETAIL }, \
|
|
{ "src", 32, 16, PACKET_FIELD_TRANSACTION }, \
|
|
{ "offs", 48, 48, PACKET_FIELD_TRANSACTION }
|
|
|
|
#define COMMON_RESPONSE_FIELDS \
|
|
{ "dest", 0, 16 }, \
|
|
{ "tl", 16, 6 }, \
|
|
{ "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \
|
|
{ "tcode", 24, 4, 0, tcode_names }, \
|
|
{ "pri", 28, 4, PACKET_FIELD_DETAIL }, \
|
|
{ "src", 32, 16 }, \
|
|
{ "rcode", 48, 4, PACKET_FIELD_TRANSACTION, rcode_names }
|
|
|
|
static const struct packet_field read_quadlet_request_fields[] = {
|
|
COMMON_REQUEST_FIELDS,
|
|
{ "crc", 96, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", 156, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field read_quadlet_response_fields[] = {
|
|
COMMON_RESPONSE_FIELDS,
|
|
{ "data", 96, 32, PACKET_FIELD_TRANSACTION },
|
|
{ "crc", 128, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", 188, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field read_block_request_fields[] = {
|
|
COMMON_REQUEST_FIELDS,
|
|
{ "data_length", 96, 16, PACKET_FIELD_TRANSACTION },
|
|
{ "extended_tcode", 112, 16 },
|
|
{ "crc", 128, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", 188, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field block_response_fields[] = {
|
|
COMMON_RESPONSE_FIELDS,
|
|
{ "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH },
|
|
{ "extended_tcode", 112, 16 },
|
|
{ "crc", 128, 32, PACKET_FIELD_DETAIL },
|
|
{ "data", 160, 0, PACKET_FIELD_TRANSACTION },
|
|
{ "crc", -64, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", -4, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field write_quadlet_request_fields[] = {
|
|
COMMON_REQUEST_FIELDS,
|
|
{ "data", 96, 32, PACKET_FIELD_TRANSACTION },
|
|
{ "ack", -4, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field block_request_fields[] = {
|
|
COMMON_REQUEST_FIELDS,
|
|
{ "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH | PACKET_FIELD_TRANSACTION },
|
|
{ "extended_tcode", 112, 16, PACKET_FIELD_TRANSACTION },
|
|
{ "crc", 128, 32, PACKET_FIELD_DETAIL },
|
|
{ "data", 160, 0, PACKET_FIELD_TRANSACTION },
|
|
{ "crc", -64, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", -4, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field write_response_fields[] = {
|
|
COMMON_RESPONSE_FIELDS,
|
|
{ "reserved", 64, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", -4, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_field iso_data_fields[] = {
|
|
{ "data_length", 0, 16, PACKET_FIELD_DATA_LENGTH },
|
|
{ "tag", 16, 2 },
|
|
{ "channel", 18, 6 },
|
|
{ "tcode", 24, 4, 0, tcode_names },
|
|
{ "sy", 28, 4 },
|
|
{ "crc", 32, 32, PACKET_FIELD_DETAIL },
|
|
{ "data", 64, 0 },
|
|
{ "crc", -64, 32, PACKET_FIELD_DETAIL },
|
|
{ "ack", -4, 4, 0, ack_names },
|
|
};
|
|
|
|
static const struct packet_info packet_info[] = {
|
|
{
|
|
.name = "write_quadlet_request",
|
|
.type = PACKET_REQUEST,
|
|
.response_tcode = TCODE_WRITE_RESPONSE,
|
|
.fields = write_quadlet_request_fields,
|
|
.field_count = array_length(write_quadlet_request_fields)
|
|
},
|
|
{
|
|
.name = "write_block_request",
|
|
.type = PACKET_REQUEST,
|
|
.response_tcode = TCODE_WRITE_RESPONSE,
|
|
.fields = block_request_fields,
|
|
.field_count = array_length(block_request_fields)
|
|
},
|
|
{
|
|
.name = "write_response",
|
|
.type = PACKET_RESPONSE,
|
|
.fields = write_response_fields,
|
|
.field_count = array_length(write_response_fields)
|
|
},
|
|
{
|
|
.name = "reserved",
|
|
.type = PACKET_RESERVED,
|
|
},
|
|
{
|
|
.name = "read_quadlet_request",
|
|
.type = PACKET_REQUEST,
|
|
.response_tcode = TCODE_READ_QUADLET_RESPONSE,
|
|
.fields = read_quadlet_request_fields,
|
|
.field_count = array_length(read_quadlet_request_fields)
|
|
},
|
|
{
|
|
.name = "read_block_request",
|
|
.type = PACKET_REQUEST,
|
|
.response_tcode = TCODE_READ_BLOCK_RESPONSE,
|
|
.fields = read_block_request_fields,
|
|
.field_count = array_length(read_block_request_fields)
|
|
},
|
|
{
|
|
.name = "read_quadlet_response",
|
|
.type = PACKET_RESPONSE,
|
|
.fields = read_quadlet_response_fields,
|
|
.field_count = array_length(read_quadlet_response_fields)
|
|
},
|
|
{
|
|
.name = "read_block_response",
|
|
.type = PACKET_RESPONSE,
|
|
.fields = block_response_fields,
|
|
.field_count = array_length(block_response_fields)
|
|
},
|
|
{
|
|
.name = "cycle_start",
|
|
.type = PACKET_OTHER,
|
|
.fields = write_quadlet_request_fields,
|
|
.field_count = array_length(write_quadlet_request_fields)
|
|
},
|
|
{
|
|
.name = "lock_request",
|
|
.type = PACKET_REQUEST,
|
|
.fields = block_request_fields,
|
|
.field_count = array_length(block_request_fields)
|
|
},
|
|
{
|
|
.name = "iso_data",
|
|
.type = PACKET_OTHER,
|
|
.fields = iso_data_fields,
|
|
.field_count = array_length(iso_data_fields)
|
|
},
|
|
{
|
|
.name = "lock_response",
|
|
.type = PACKET_RESPONSE,
|
|
.fields = block_response_fields,
|
|
.field_count = array_length(block_response_fields)
|
|
},
|
|
};
|
|
|
|
static int
|
|
handle_request_packet(uint32_t *data, size_t length)
|
|
{
|
|
struct link_packet *p = (struct link_packet *) data;
|
|
struct subaction *sa, *prev;
|
|
struct link_transaction *t;
|
|
|
|
t = link_transaction_lookup(p->common.source, p->common.destination,
|
|
p->common.tlabel);
|
|
sa = subaction_create(data, length);
|
|
t->request = sa;
|
|
|
|
if (!list_empty(&t->request_list)) {
|
|
prev = list_tail(&t->request_list,
|
|
struct subaction, link);
|
|
|
|
if (!ACK_BUSY(prev->ack)) {
|
|
/*
|
|
* error, we should only see ack_busy_* before the
|
|
* ack_pending/ack_complete -- this is an ack_pending
|
|
* instead (ack_complete would have finished the
|
|
* transaction).
|
|
*/
|
|
}
|
|
|
|
if (prev->packet.common.tcode != sa->packet.common.tcode ||
|
|
prev->packet.common.tlabel != sa->packet.common.tlabel) {
|
|
/* memcmp() ? */
|
|
/* error, these should match for retries. */
|
|
}
|
|
}
|
|
|
|
list_append(&t->request_list, &sa->link);
|
|
|
|
switch (sa->ack) {
|
|
case ACK_COMPLETE:
|
|
if (p->common.tcode != TCODE_WRITE_QUADLET_REQUEST &&
|
|
p->common.tcode != TCODE_WRITE_BLOCK_REQUEST)
|
|
/* error, unified transactions only allowed for write */;
|
|
list_remove(&t->link);
|
|
handle_transaction(t);
|
|
break;
|
|
|
|
case ACK_NO_ACK:
|
|
case ACK_DATA_ERROR:
|
|
case ACK_TYPE_ERROR:
|
|
list_remove(&t->link);
|
|
handle_transaction(t);
|
|
break;
|
|
|
|
case ACK_PENDING:
|
|
/* request subaction phase over, wait for response. */
|
|
break;
|
|
|
|
case ACK_BUSY_X:
|
|
case ACK_BUSY_A:
|
|
case ACK_BUSY_B:
|
|
/* ok, wait for retry. */
|
|
/* check that retry protocol is respected. */
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
handle_response_packet(uint32_t *data, size_t length)
|
|
{
|
|
struct link_packet *p = (struct link_packet *) data;
|
|
struct subaction *sa, *prev;
|
|
struct link_transaction *t;
|
|
|
|
t = link_transaction_lookup(p->common.destination, p->common.source,
|
|
p->common.tlabel);
|
|
if (list_empty(&t->request_list)) {
|
|
/* unsolicited response */
|
|
}
|
|
|
|
sa = subaction_create(data, length);
|
|
t->response = sa;
|
|
|
|
if (!list_empty(&t->response_list)) {
|
|
prev = list_tail(&t->response_list, struct subaction, link);
|
|
|
|
if (!ACK_BUSY(prev->ack)) {
|
|
/*
|
|
* error, we should only see ack_busy_* before the
|
|
* ack_pending/ack_complete
|
|
*/
|
|
}
|
|
|
|
if (prev->packet.common.tcode != sa->packet.common.tcode ||
|
|
prev->packet.common.tlabel != sa->packet.common.tlabel) {
|
|
/* use memcmp() instead? */
|
|
/* error, these should match for retries. */
|
|
}
|
|
} else {
|
|
prev = list_tail(&t->request_list, struct subaction, link);
|
|
if (prev->ack != ACK_PENDING) {
|
|
/*
|
|
* error, should not get response unless last request got
|
|
* ack_pending.
|
|
*/
|
|
}
|
|
|
|
if (packet_info[prev->packet.common.tcode].response_tcode !=
|
|
sa->packet.common.tcode) {
|
|
/* error, tcode mismatch */
|
|
}
|
|
}
|
|
|
|
list_append(&t->response_list, &sa->link);
|
|
|
|
switch (sa->ack) {
|
|
case ACK_COMPLETE:
|
|
case ACK_NO_ACK:
|
|
case ACK_DATA_ERROR:
|
|
case ACK_TYPE_ERROR:
|
|
list_remove(&t->link);
|
|
handle_transaction(t);
|
|
/* transaction complete, remove t from pending list. */
|
|
break;
|
|
|
|
case ACK_PENDING:
|
|
/* error for responses. */
|
|
break;
|
|
|
|
case ACK_BUSY_X:
|
|
case ACK_BUSY_A:
|
|
case ACK_BUSY_B:
|
|
/* no problem, wait for next retry */
|
|
break;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
handle_packet(uint32_t *data, size_t length)
|
|
{
|
|
if (length == 0) {
|
|
printf("bus reset\r\n");
|
|
clear_pending_transaction_list();
|
|
} else if (length > sizeof(struct phy_packet)) {
|
|
struct link_packet *p = (struct link_packet *) data;
|
|
|
|
switch (packet_info[p->common.tcode].type) {
|
|
case PACKET_REQUEST:
|
|
return handle_request_packet(data, length);
|
|
|
|
case PACKET_RESPONSE:
|
|
return handle_response_packet(data, length);
|
|
|
|
case PACKET_OTHER:
|
|
case PACKET_RESERVED:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static unsigned int
|
|
get_bits(struct link_packet *packet, int offset, int width)
|
|
{
|
|
uint32_t *data = (uint32_t *) packet;
|
|
uint32_t index, shift, mask;
|
|
|
|
index = offset / 32 + 1;
|
|
shift = 32 - (offset & 31) - width;
|
|
mask = width == 32 ? ~0 : (1 << width) - 1;
|
|
|
|
return (data[index] >> shift) & mask;
|
|
}
|
|
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
#define byte_index(i) ((i) ^ 3)
|
|
#elif __BYTE_ORDER == __BIG_ENDIAN
|
|
#define byte_index(i) (i)
|
|
#else
|
|
#error unsupported byte order.
|
|
#endif
|
|
|
|
static void
|
|
dump_data(unsigned char *data, int length)
|
|
{
|
|
int i, print_length;
|
|
|
|
if (length > 128)
|
|
print_length = 128;
|
|
else
|
|
print_length = length;
|
|
|
|
for (i = 0; i < print_length; i++)
|
|
printf("%s%02hhx",
|
|
(i % 4 == 0 && i != 0) ? " " : "",
|
|
data[byte_index(i)]);
|
|
|
|
if (print_length < length)
|
|
printf(" (%d more bytes)", length - print_length);
|
|
}
|
|
|
|
static void
|
|
decode_link_packet(struct link_packet *packet, size_t length,
|
|
int include_flags, int exclude_flags)
|
|
{
|
|
const struct packet_info *pi;
|
|
int data_length = 0;
|
|
int i;
|
|
|
|
pi = &packet_info[packet->common.tcode];
|
|
|
|
for (i = 0; i < pi->field_count; i++) {
|
|
const struct packet_field *f = &pi->fields[i];
|
|
int offset;
|
|
|
|
if (f->flags & exclude_flags)
|
|
continue;
|
|
if (include_flags && !(f->flags & include_flags))
|
|
continue;
|
|
|
|
if (f->offset < 0)
|
|
offset = length * 8 + f->offset - 32;
|
|
else
|
|
offset = f->offset;
|
|
|
|
if (f->value_names != NULL) {
|
|
uint32_t bits;
|
|
|
|
bits = get_bits(packet, offset, f->width);
|
|
printf("%s", f->value_names[bits]);
|
|
} else if (f->width == 0) {
|
|
printf("%s=[", f->name);
|
|
dump_data((unsigned char *) packet + (offset / 8 + 4), data_length);
|
|
printf("]");
|
|
} else {
|
|
unsigned long long bits;
|
|
int high_width, low_width;
|
|
|
|
if ((offset & ~31) != ((offset + f->width - 1) & ~31)) {
|
|
/* Bit field spans quadlet boundary. */
|
|
high_width = ((offset + 31) & ~31) - offset;
|
|
low_width = f->width - high_width;
|
|
|
|
bits = get_bits(packet, offset, high_width);
|
|
bits = (bits << low_width) |
|
|
get_bits(packet, offset + high_width, low_width);
|
|
} else {
|
|
bits = get_bits(packet, offset, f->width);
|
|
}
|
|
|
|
printf("%s=0x%0*llx", f->name, (f->width + 3) / 4, bits);
|
|
|
|
if (f->flags & PACKET_FIELD_DATA_LENGTH)
|
|
data_length = bits;
|
|
}
|
|
|
|
if (i < pi->field_count - 1)
|
|
printf(", ");
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_packet(uint32_t *data, size_t length)
|
|
{
|
|
int i;
|
|
|
|
printf("%6u ", data[0]);
|
|
|
|
if (length == 4) {
|
|
printf("bus reset");
|
|
} else if (length < sizeof(struct phy_packet)) {
|
|
printf("short packet: ");
|
|
for (i = 1; i < length / 4; i++)
|
|
printf("%s%08x", i == 0 ? "[" : " ", data[i]);
|
|
printf("]");
|
|
|
|
} else if (length == sizeof(struct phy_packet) && data[1] == ~data[2]) {
|
|
struct phy_packet *pp = (struct phy_packet *) data;
|
|
|
|
/* phy packet are 3 quadlets: the 1 quadlet payload,
|
|
* the bitwise inverse of the payload and the snoop
|
|
* mode ack */
|
|
|
|
switch (pp->common.identifier) {
|
|
case PHY_PACKET_CONFIGURATION:
|
|
if (!pp->phy_config.set_root && !pp->phy_config.set_gap_count) {
|
|
printf("ext phy config: phy_id=%02x", pp->phy_config.root_id);
|
|
} else {
|
|
printf("phy config:");
|
|
if (pp->phy_config.set_root)
|
|
printf(" set_root_id=%02x", pp->phy_config.root_id);
|
|
if (pp->phy_config.set_gap_count)
|
|
printf(" set_gap_count=%d", pp->phy_config.gap_count);
|
|
}
|
|
break;
|
|
|
|
case PHY_PACKET_LINK_ON:
|
|
printf("link-on packet, phy_id=%02x", pp->link_on.phy_id);
|
|
break;
|
|
|
|
case PHY_PACKET_SELF_ID:
|
|
if (pp->self_id.extended) {
|
|
printf("extended self id: phy_id=%02x, seq=%d",
|
|
pp->ext_self_id.phy_id, pp->ext_self_id.sequence);
|
|
} else {
|
|
static const char * const speed_names[] = {
|
|
"S100", "S200", "S400", "BETA"
|
|
};
|
|
printf("self id: phy_id=%02x, link %s, gap_count=%d, speed=%s%s%s",
|
|
pp->self_id.phy_id,
|
|
(pp->self_id.link_active ? "active" : "not active"),
|
|
pp->self_id.gap_count,
|
|
speed_names[pp->self_id.phy_speed],
|
|
(pp->self_id.contender ? ", irm contender" : ""),
|
|
(pp->self_id.initiated_reset ? ", initiator" : ""));
|
|
}
|
|
break;
|
|
default:
|
|
printf("unknown phy packet: ");
|
|
for (i = 1; i < length / 4; i++)
|
|
printf("%s%08x", i == 0 ? "[" : " ", data[i]);
|
|
printf("]");
|
|
break;
|
|
}
|
|
} else {
|
|
struct link_packet *packet = (struct link_packet *) data;
|
|
|
|
decode_link_packet(packet, length, 0,
|
|
option_verbose ? 0 : PACKET_FIELD_DETAIL);
|
|
}
|
|
|
|
if (option_hex) {
|
|
printf(" [");
|
|
dump_data((unsigned char *) data + 4, length - 4);
|
|
printf("]");
|
|
}
|
|
|
|
printf("\r\n");
|
|
}
|
|
|
|
#define HIDE_CURSOR "\033[?25l"
|
|
#define SHOW_CURSOR "\033[?25h"
|
|
#define CLEAR "\033[H\033[2J"
|
|
|
|
static void
|
|
print_stats(uint32_t *data, size_t length)
|
|
{
|
|
static int bus_reset_count, short_packet_count, phy_packet_count;
|
|
static int tcode_count[16];
|
|
static struct timeval last_update;
|
|
struct timeval now;
|
|
int i;
|
|
|
|
if (length == 0)
|
|
bus_reset_count++;
|
|
else if (length < sizeof(struct phy_packet))
|
|
short_packet_count++;
|
|
else if (length == sizeof(struct phy_packet) && data[1] == ~data[2])
|
|
phy_packet_count++;
|
|
else {
|
|
struct link_packet *packet = (struct link_packet *) data;
|
|
tcode_count[packet->common.tcode]++;
|
|
}
|
|
|
|
gettimeofday(&now, NULL);
|
|
if (now.tv_sec <= last_update.tv_sec &&
|
|
now.tv_usec < last_update.tv_usec + 500000)
|
|
return;
|
|
|
|
last_update = now;
|
|
printf(CLEAR HIDE_CURSOR
|
|
" bus resets : %8d\n"
|
|
" short packets : %8d\n"
|
|
" phy packets : %8d\n",
|
|
bus_reset_count, short_packet_count, phy_packet_count);
|
|
|
|
for (i = 0; i < array_length(packet_info); i++)
|
|
if (packet_info[i].type != PACKET_RESERVED)
|
|
printf(" %-24s: %8d\n", packet_info[i].name, tcode_count[i]);
|
|
printf(SHOW_CURSOR "\n");
|
|
}
|
|
|
|
static struct termios saved_attributes;
|
|
|
|
static void
|
|
reset_input_mode(void)
|
|
{
|
|
tcsetattr(STDIN_FILENO, TCSANOW, &saved_attributes);
|
|
}
|
|
|
|
static void
|
|
set_input_mode(void)
|
|
{
|
|
struct termios tattr;
|
|
|
|
/* Make sure stdin is a terminal. */
|
|
if (!isatty(STDIN_FILENO)) {
|
|
fprintf(stderr, "Not a terminal.\n");
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
/* Save the terminal attributes so we can restore them later. */
|
|
tcgetattr(STDIN_FILENO, &saved_attributes);
|
|
atexit(reset_input_mode);
|
|
|
|
/* Set the funny terminal modes. */
|
|
tcgetattr(STDIN_FILENO, &tattr);
|
|
tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
|
|
tattr.c_cc[VMIN] = 1;
|
|
tattr.c_cc[VTIME] = 0;
|
|
tcsetattr(STDIN_FILENO, TCSAFLUSH, &tattr);
|
|
}
|
|
|
|
int main(int argc, const char *argv[])
|
|
{
|
|
uint32_t buf[128 * 1024];
|
|
uint32_t filter;
|
|
int length, retval, view;
|
|
int fd = -1;
|
|
FILE *output = NULL, *input = NULL;
|
|
poptContext con;
|
|
char c;
|
|
struct pollfd pollfds[2];
|
|
|
|
sys_sigint_handler = signal(SIGINT, sigint_handler);
|
|
|
|
con = poptGetContext(NULL, argc, argv, options, 0);
|
|
retval = poptGetNextOpt(con);
|
|
if (retval < -1) {
|
|
poptPrintUsage(con, stdout, 0);
|
|
return -1;
|
|
}
|
|
|
|
if (option_version) {
|
|
printf("dump tool for nosy sniffer, version %s\n", VERSION);
|
|
return 0;
|
|
}
|
|
|
|
if (__BYTE_ORDER != __LITTLE_ENDIAN)
|
|
fprintf(stderr, "warning: nosy has only been tested on little "
|
|
"endian machines\n");
|
|
|
|
if (option_input != NULL) {
|
|
input = fopen(option_input, "r");
|
|
if (input == NULL) {
|
|
fprintf(stderr, "Could not open %s, %m\n", option_input);
|
|
return -1;
|
|
}
|
|
} else {
|
|
fd = open(option_nosy_device, O_RDWR);
|
|
if (fd < 0) {
|
|
fprintf(stderr, "Could not open %s, %m\n", option_nosy_device);
|
|
return -1;
|
|
}
|
|
set_input_mode();
|
|
}
|
|
|
|
if (strcmp(option_view, "transaction") == 0)
|
|
view = VIEW_TRANSACTION;
|
|
else if (strcmp(option_view, "stats") == 0)
|
|
view = VIEW_STATS;
|
|
else
|
|
view = VIEW_PACKET;
|
|
|
|
if (option_output) {
|
|
output = fopen(option_output, "w");
|
|
if (output == NULL) {
|
|
fprintf(stderr, "Could not open %s, %m\n", option_output);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
|
|
|
|
filter = ~0;
|
|
if (!option_iso)
|
|
filter &= ~(1 << TCODE_STREAM_DATA);
|
|
if (!option_cycle_start)
|
|
filter &= ~(1 << TCODE_CYCLE_START);
|
|
if (view == VIEW_STATS)
|
|
filter = ~(1 << TCODE_CYCLE_START);
|
|
|
|
ioctl(fd, NOSY_IOC_FILTER, filter);
|
|
|
|
ioctl(fd, NOSY_IOC_START);
|
|
|
|
pollfds[0].fd = fd;
|
|
pollfds[0].events = POLLIN;
|
|
pollfds[1].fd = STDIN_FILENO;
|
|
pollfds[1].events = POLLIN;
|
|
|
|
while (run) {
|
|
if (input != NULL) {
|
|
if (fread(&length, sizeof length, 1, input) != 1)
|
|
return 0;
|
|
fread(buf, 1, length, input);
|
|
} else {
|
|
poll(pollfds, 2, -1);
|
|
if (pollfds[1].revents) {
|
|
read(STDIN_FILENO, &c, sizeof c);
|
|
switch (c) {
|
|
case 'q':
|
|
if (output != NULL)
|
|
fclose(output);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
if (pollfds[0].revents)
|
|
length = read(fd, buf, sizeof buf);
|
|
else
|
|
continue;
|
|
}
|
|
|
|
if (output != NULL) {
|
|
fwrite(&length, sizeof length, 1, output);
|
|
fwrite(buf, 1, length, output);
|
|
}
|
|
|
|
switch (view) {
|
|
case VIEW_TRANSACTION:
|
|
handle_packet(buf, length);
|
|
break;
|
|
case VIEW_PACKET:
|
|
print_packet(buf, length);
|
|
break;
|
|
case VIEW_STATS:
|
|
print_stats(buf, length);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (output != NULL)
|
|
fclose(output);
|
|
|
|
close(fd);
|
|
|
|
poptFreeContext(con);
|
|
|
|
return 0;
|
|
}
|