2 * nosy-dump - Interface to snoop mode driver for TI PCILynx 1394 controllers
3 * Copyright (C) 2002-2006 Kristian Høgsberg
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.
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.
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.
29 #include <sys/ioctl.h>
35 #include "nosy-dump.h"
36 #include "nosy-user.h"
39 PACKET_FIELD_DETAIL
= 0x01,
40 PACKET_FIELD_DATA_LENGTH
= 0x02,
41 /* Marks the fields we print in transaction view. */
42 PACKET_FIELD_TRANSACTION
= 0x04,
45 static void print_packet(uint32_t *data
, size_t length
);
46 static void decode_link_packet(struct link_packet
*packet
, size_t length
,
47 int include_flags
, int exclude_flags
);
49 sig_t sys_sigint_handler
;
51 static char *option_nosy_device
= "/dev/nosy";
52 static char *option_view
= "packet";
53 static char *option_output
;
54 static char *option_input
;
55 static int option_hex
;
56 static int option_iso
;
57 static int option_cycle_start
;
58 static int option_version
;
59 static int option_verbose
;
67 static const struct poptOption options
[] = {
71 .argInfo
= POPT_ARG_STRING
,
72 .arg
= &option_nosy_device
,
73 .descrip
= "Path to nosy device.",
74 .argDescrip
= "DEVICE"
78 .argInfo
= POPT_ARG_STRING
,
80 .descrip
= "Specify view of bus traffic: packet, transaction or stats.",
86 .argInfo
= POPT_ARG_NONE
,
88 .descrip
= "Print each packet in hex.",
92 .argInfo
= POPT_ARG_NONE
,
94 .descrip
= "Print iso packets.",
97 .longName
= "cycle-start",
98 .argInfo
= POPT_ARG_NONE
,
99 .arg
= &option_cycle_start
,
100 .descrip
= "Print cycle start packets.",
103 .longName
= "verbose",
105 .argInfo
= POPT_ARG_NONE
,
106 .arg
= &option_verbose
,
107 .descrip
= "Verbose packet view.",
110 .longName
= "output",
112 .argInfo
= POPT_ARG_STRING
,
113 .arg
= &option_output
,
114 .descrip
= "Log to output file.",
115 .argDescrip
= "FILENAME"
120 .argInfo
= POPT_ARG_STRING
,
121 .arg
= &option_input
,
122 .descrip
= "Decode log from file.",
123 .argDescrip
= "FILENAME"
126 .longName
= "version",
127 .argInfo
= POPT_ARG_NONE
,
128 .arg
= &option_version
,
129 .descrip
= "Specify print version info.",
135 /* Allow all ^C except the first to interrupt the program in the usual way. */
137 sigint_handler(int signal_num
)
141 signal(SIGINT
, SIG_DFL
);
145 static struct subaction
*
146 subaction_create(uint32_t *data
, size_t length
)
148 struct subaction
*sa
;
150 /* we put the ack in the subaction struct for easy access. */
151 sa
= malloc(sizeof *sa
- sizeof sa
->packet
+ length
);
152 sa
->ack
= data
[length
/ 4 - 1];
154 memcpy(&sa
->packet
, data
, length
);
160 subaction_destroy(struct subaction
*sa
)
165 static struct list pending_transaction_list
= {
166 &pending_transaction_list
, &pending_transaction_list
169 static struct link_transaction
*
170 link_transaction_lookup(int request_node
, int response_node
, int tlabel
)
172 struct link_transaction
*t
;
174 list_for_each_entry(t
, &pending_transaction_list
, link
) {
175 if (t
->request_node
== request_node
&&
176 t
->response_node
== response_node
&&
181 t
= malloc(sizeof *t
);
182 t
->request_node
= request_node
;
183 t
->response_node
= response_node
;
185 list_init(&t
->request_list
);
186 list_init(&t
->response_list
);
188 list_append(&pending_transaction_list
, &t
->link
);
194 link_transaction_destroy(struct link_transaction
*t
)
196 struct subaction
*sa
;
198 while (!list_empty(&t
->request_list
)) {
199 sa
= list_head(&t
->request_list
, struct subaction
, link
);
200 list_remove(&sa
->link
);
201 subaction_destroy(sa
);
203 while (!list_empty(&t
->response_list
)) {
204 sa
= list_head(&t
->response_list
, struct subaction
, link
);
205 list_remove(&sa
->link
);
206 subaction_destroy(sa
);
211 struct protocol_decoder
{
213 int (*decode
)(struct link_transaction
*t
);
216 static const struct protocol_decoder protocol_decoders
[] = {
217 { "FCP", decode_fcp
}
221 handle_transaction(struct link_transaction
*t
)
223 struct subaction
*sa
;
227 printf("BUG in handle_transaction\n");
231 for (i
= 0; i
< array_length(protocol_decoders
); i
++)
232 if (protocol_decoders
[i
].decode(t
))
235 /* HACK: decode only fcp right now. */
238 decode_link_packet(&t
->request
->packet
, t
->request
->length
,
239 PACKET_FIELD_TRANSACTION
, 0);
241 decode_link_packet(&t
->response
->packet
, t
->request
->length
,
242 PACKET_FIELD_TRANSACTION
, 0);
244 printf("[no response]");
246 if (option_verbose
) {
247 list_for_each_entry(sa
, &t
->request_list
, link
)
248 print_packet((uint32_t *) &sa
->packet
, sa
->length
);
249 list_for_each_entry(sa
, &t
->response_list
, link
)
250 print_packet((uint32_t *) &sa
->packet
, sa
->length
);
254 link_transaction_destroy(t
);
258 clear_pending_transaction_list(void)
260 struct link_transaction
*t
;
262 while (!list_empty(&pending_transaction_list
)) {
263 t
= list_head(&pending_transaction_list
,
264 struct link_transaction
, link
);
265 list_remove(&t
->link
);
266 link_transaction_destroy(t
);
267 /* print unfinished transactions */
271 static const char * const tcode_names
[] = {
272 [0x0] = "write_quadlet_request", [0x6] = "read_quadlet_response",
273 [0x1] = "write_block_request", [0x7] = "read_block_response",
274 [0x2] = "write_response", [0x8] = "cycle_start",
275 [0x3] = "reserved", [0x9] = "lock_request",
276 [0x4] = "read_quadlet_request", [0xa] = "iso_data",
277 [0x5] = "read_block_request", [0xb] = "lock_response",
280 static const char * const ack_names
[] = {
281 [0x0] = "no ack", [0x8] = "reserved (0x08)",
282 [0x1] = "ack_complete", [0x9] = "reserved (0x09)",
283 [0x2] = "ack_pending", [0xa] = "reserved (0x0a)",
284 [0x3] = "reserved (0x03)", [0xb] = "reserved (0x0b)",
285 [0x4] = "ack_busy_x", [0xc] = "reserved (0x0c)",
286 [0x5] = "ack_busy_a", [0xd] = "ack_data_error",
287 [0x6] = "ack_busy_b", [0xe] = "ack_type_error",
288 [0x7] = "reserved (0x07)", [0xf] = "reserved (0x0f)",
291 static const char * const rcode_names
[] = {
292 [0x0] = "complete", [0x4] = "conflict_error",
293 [0x1] = "reserved (0x01)", [0x5] = "data_error",
294 [0x2] = "reserved (0x02)", [0x6] = "type_error",
295 [0x3] = "reserved (0x03)", [0x7] = "address_error",
298 static const char * const retry_names
[] = {
316 const struct packet_field
*fields
;
320 struct packet_field
{
321 const char *name
; /* Short name for field. */
322 int offset
; /* Location of field, specified in bits; */
323 /* negative means from end of packet. */
324 int width
; /* Width of field, 0 means use data_length. */
325 int flags
; /* Show options. */
326 const char * const *value_names
;
329 #define COMMON_REQUEST_FIELDS \
330 { "dest", 0, 16, PACKET_FIELD_TRANSACTION }, \
332 { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \
333 { "tcode", 24, 4, PACKET_FIELD_TRANSACTION, tcode_names }, \
334 { "pri", 28, 4, PACKET_FIELD_DETAIL }, \
335 { "src", 32, 16, PACKET_FIELD_TRANSACTION }, \
336 { "offs", 48, 48, PACKET_FIELD_TRANSACTION }
338 #define COMMON_RESPONSE_FIELDS \
341 { "rt", 22, 2, PACKET_FIELD_DETAIL, retry_names }, \
342 { "tcode", 24, 4, 0, tcode_names }, \
343 { "pri", 28, 4, PACKET_FIELD_DETAIL }, \
345 { "rcode", 48, 4, PACKET_FIELD_TRANSACTION, rcode_names }
347 static const struct packet_field read_quadlet_request_fields
[] = {
348 COMMON_REQUEST_FIELDS
,
349 { "crc", 96, 32, PACKET_FIELD_DETAIL
},
350 { "ack", 156, 4, 0, ack_names
},
353 static const struct packet_field read_quadlet_response_fields
[] = {
354 COMMON_RESPONSE_FIELDS
,
355 { "data", 96, 32, PACKET_FIELD_TRANSACTION
},
356 { "crc", 128, 32, PACKET_FIELD_DETAIL
},
357 { "ack", 188, 4, 0, ack_names
},
360 static const struct packet_field read_block_request_fields
[] = {
361 COMMON_REQUEST_FIELDS
,
362 { "data_length", 96, 16, PACKET_FIELD_TRANSACTION
},
363 { "extended_tcode", 112, 16 },
364 { "crc", 128, 32, PACKET_FIELD_DETAIL
},
365 { "ack", 188, 4, 0, ack_names
},
368 static const struct packet_field block_response_fields
[] = {
369 COMMON_RESPONSE_FIELDS
,
370 { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH
},
371 { "extended_tcode", 112, 16 },
372 { "crc", 128, 32, PACKET_FIELD_DETAIL
},
373 { "data", 160, 0, PACKET_FIELD_TRANSACTION
},
374 { "crc", -64, 32, PACKET_FIELD_DETAIL
},
375 { "ack", -4, 4, 0, ack_names
},
378 static const struct packet_field write_quadlet_request_fields
[] = {
379 COMMON_REQUEST_FIELDS
,
380 { "data", 96, 32, PACKET_FIELD_TRANSACTION
},
381 { "ack", -4, 4, 0, ack_names
},
384 static const struct packet_field block_request_fields
[] = {
385 COMMON_REQUEST_FIELDS
,
386 { "data_length", 96, 16, PACKET_FIELD_DATA_LENGTH
| PACKET_FIELD_TRANSACTION
},
387 { "extended_tcode", 112, 16, PACKET_FIELD_TRANSACTION
},
388 { "crc", 128, 32, PACKET_FIELD_DETAIL
},
389 { "data", 160, 0, PACKET_FIELD_TRANSACTION
},
390 { "crc", -64, 32, PACKET_FIELD_DETAIL
},
391 { "ack", -4, 4, 0, ack_names
},
394 static const struct packet_field write_response_fields
[] = {
395 COMMON_RESPONSE_FIELDS
,
396 { "reserved", 64, 32, PACKET_FIELD_DETAIL
},
397 { "ack", -4, 4, 0, ack_names
},
400 static const struct packet_field iso_data_fields
[] = {
401 { "data_length", 0, 16, PACKET_FIELD_DATA_LENGTH
},
403 { "channel", 18, 6 },
404 { "tcode", 24, 4, 0, tcode_names
},
406 { "crc", 32, 32, PACKET_FIELD_DETAIL
},
408 { "crc", -64, 32, PACKET_FIELD_DETAIL
},
409 { "ack", -4, 4, 0, ack_names
},
412 static const struct packet_info packet_info
[] = {
414 .name
= "write_quadlet_request",
415 .type
= PACKET_REQUEST
,
416 .response_tcode
= TCODE_WRITE_RESPONSE
,
417 .fields
= write_quadlet_request_fields
,
418 .field_count
= array_length(write_quadlet_request_fields
)
421 .name
= "write_block_request",
422 .type
= PACKET_REQUEST
,
423 .response_tcode
= TCODE_WRITE_RESPONSE
,
424 .fields
= block_request_fields
,
425 .field_count
= array_length(block_request_fields
)
428 .name
= "write_response",
429 .type
= PACKET_RESPONSE
,
430 .fields
= write_response_fields
,
431 .field_count
= array_length(write_response_fields
)
435 .type
= PACKET_RESERVED
,
438 .name
= "read_quadlet_request",
439 .type
= PACKET_REQUEST
,
440 .response_tcode
= TCODE_READ_QUADLET_RESPONSE
,
441 .fields
= read_quadlet_request_fields
,
442 .field_count
= array_length(read_quadlet_request_fields
)
445 .name
= "read_block_request",
446 .type
= PACKET_REQUEST
,
447 .response_tcode
= TCODE_READ_BLOCK_RESPONSE
,
448 .fields
= read_block_request_fields
,
449 .field_count
= array_length(read_block_request_fields
)
452 .name
= "read_quadlet_response",
453 .type
= PACKET_RESPONSE
,
454 .fields
= read_quadlet_response_fields
,
455 .field_count
= array_length(read_quadlet_response_fields
)
458 .name
= "read_block_response",
459 .type
= PACKET_RESPONSE
,
460 .fields
= block_response_fields
,
461 .field_count
= array_length(block_response_fields
)
464 .name
= "cycle_start",
465 .type
= PACKET_OTHER
,
466 .fields
= write_quadlet_request_fields
,
467 .field_count
= array_length(write_quadlet_request_fields
)
470 .name
= "lock_request",
471 .type
= PACKET_REQUEST
,
472 .fields
= block_request_fields
,
473 .field_count
= array_length(block_request_fields
)
477 .type
= PACKET_OTHER
,
478 .fields
= iso_data_fields
,
479 .field_count
= array_length(iso_data_fields
)
482 .name
= "lock_response",
483 .type
= PACKET_RESPONSE
,
484 .fields
= block_response_fields
,
485 .field_count
= array_length(block_response_fields
)
490 handle_request_packet(uint32_t *data
, size_t length
)
492 struct link_packet
*p
= (struct link_packet
*) data
;
493 struct subaction
*sa
, *prev
;
494 struct link_transaction
*t
;
496 t
= link_transaction_lookup(p
->common
.source
, p
->common
.destination
,
498 sa
= subaction_create(data
, length
);
501 if (!list_empty(&t
->request_list
)) {
502 prev
= list_tail(&t
->request_list
,
503 struct subaction
, link
);
505 if (!ACK_BUSY(prev
->ack
)) {
507 * error, we should only see ack_busy_* before the
508 * ack_pending/ack_complete -- this is an ack_pending
509 * instead (ack_complete would have finished the
514 if (prev
->packet
.common
.tcode
!= sa
->packet
.common
.tcode
||
515 prev
->packet
.common
.tlabel
!= sa
->packet
.common
.tlabel
) {
517 /* error, these should match for retries. */
521 list_append(&t
->request_list
, &sa
->link
);
525 if (p
->common
.tcode
!= TCODE_WRITE_QUADLET
&&
526 p
->common
.tcode
!= TCODE_WRITE_BLOCK
)
527 /* error, unified transactions only allowed for write */;
528 list_remove(&t
->link
);
529 handle_transaction(t
);
535 list_remove(&t
->link
);
536 handle_transaction(t
);
540 /* request subaction phase over, wait for response. */
546 /* ok, wait for retry. */
547 /* check that retry protocol is respected. */
555 handle_response_packet(uint32_t *data
, size_t length
)
557 struct link_packet
*p
= (struct link_packet
*) data
;
558 struct subaction
*sa
, *prev
;
559 struct link_transaction
*t
;
561 t
= link_transaction_lookup(p
->common
.destination
, p
->common
.source
,
563 if (list_empty(&t
->request_list
)) {
564 /* unsolicited response */
567 sa
= subaction_create(data
, length
);
570 if (!list_empty(&t
->response_list
)) {
571 prev
= list_tail(&t
->response_list
, struct subaction
, link
);
573 if (!ACK_BUSY(prev
->ack
)) {
575 * error, we should only see ack_busy_* before the
576 * ack_pending/ack_complete
580 if (prev
->packet
.common
.tcode
!= sa
->packet
.common
.tcode
||
581 prev
->packet
.common
.tlabel
!= sa
->packet
.common
.tlabel
) {
582 /* use memcmp() instead? */
583 /* error, these should match for retries. */
586 prev
= list_tail(&t
->request_list
, struct subaction
, link
);
587 if (prev
->ack
!= ACK_PENDING
) {
589 * error, should not get response unless last request got
594 if (packet_info
[prev
->packet
.common
.tcode
].response_tcode
!=
595 sa
->packet
.common
.tcode
) {
596 /* error, tcode mismatch */
600 list_append(&t
->response_list
, &sa
->link
);
607 list_remove(&t
->link
);
608 handle_transaction(t
);
609 /* transaction complete, remove t from pending list. */
613 /* error for responses. */
619 /* no problem, wait for next retry */
627 handle_packet(uint32_t *data
, size_t length
)
630 printf("bus reset\r\n");
631 clear_pending_transaction_list();
632 } else if (length
> sizeof(struct phy_packet
)) {
633 struct link_packet
*p
= (struct link_packet
*) data
;
635 switch (packet_info
[p
->common
.tcode
].type
) {
637 return handle_request_packet(data
, length
);
639 case PACKET_RESPONSE
:
640 return handle_response_packet(data
, length
);
643 case PACKET_RESERVED
:
652 get_bits(struct link_packet
*packet
, int offset
, int width
)
654 uint32_t *data
= (uint32_t *) packet
;
655 uint32_t index
, shift
, mask
;
657 index
= offset
/ 32 + 1;
658 shift
= 32 - (offset
& 31) - width
;
659 mask
= width
== 32 ? ~0 : (1 << width
) - 1;
661 return (data
[index
] >> shift
) & mask
;
664 #if __BYTE_ORDER == __LITTLE_ENDIAN
665 #define byte_index(i) ((i) ^ 3)
666 #elif __BYTE_ORDER == __BIG_ENDIAN
667 #define byte_index(i) (i)
669 #error unsupported byte order.
673 dump_data(unsigned char *data
, int length
)
680 print_length
= length
;
682 for (i
= 0; i
< print_length
; i
++)
684 (i
% 4 == 0 && i
!= 0) ? " " : "",
685 data
[byte_index(i
)]);
687 if (print_length
< length
)
688 printf(" (%d more bytes)", length
- print_length
);
692 decode_link_packet(struct link_packet
*packet
, size_t length
,
693 int include_flags
, int exclude_flags
)
695 const struct packet_info
*pi
;
699 pi
= &packet_info
[packet
->common
.tcode
];
701 for (i
= 0; i
< pi
->field_count
; i
++) {
702 const struct packet_field
*f
= &pi
->fields
[i
];
705 if (f
->flags
& exclude_flags
)
707 if (include_flags
&& !(f
->flags
& include_flags
))
711 offset
= length
* 8 + f
->offset
- 32;
715 if (f
->value_names
!= NULL
) {
718 bits
= get_bits(packet
, offset
, f
->width
);
719 printf("%s", f
->value_names
[bits
]);
720 } else if (f
->width
== 0) {
721 printf("%s=[", f
->name
);
722 dump_data((unsigned char *) packet
+ (offset
/ 8 + 4), data_length
);
725 unsigned long long bits
;
726 int high_width
, low_width
;
728 if ((offset
& ~31) != ((offset
+ f
->width
- 1) & ~31)) {
729 /* Bit field spans quadlet boundary. */
730 high_width
= ((offset
+ 31) & ~31) - offset
;
731 low_width
= f
->width
- high_width
;
733 bits
= get_bits(packet
, offset
, high_width
);
734 bits
= (bits
<< low_width
) |
735 get_bits(packet
, offset
+ high_width
, low_width
);
737 bits
= get_bits(packet
, offset
, f
->width
);
740 printf("%s=0x%0*llx", f
->name
, (f
->width
+ 3) / 4, bits
);
742 if (f
->flags
& PACKET_FIELD_DATA_LENGTH
)
746 if (i
< pi
->field_count
- 1)
752 print_packet(uint32_t *data
, size_t length
)
756 printf("%6u ", data
[0]);
760 } else if (length
< sizeof(struct phy_packet
)) {
761 printf("short packet: ");
762 for (i
= 1; i
< length
/ 4; i
++)
763 printf("%s%08x", i
== 0 ? "[" : " ", data
[i
]);
766 } else if (length
== sizeof(struct phy_packet
) && data
[1] == ~data
[2]) {
767 struct phy_packet
*pp
= (struct phy_packet
*) data
;
769 /* phy packet are 3 quadlets: the 1 quadlet payload,
770 * the bitwise inverse of the payload and the snoop
773 switch (pp
->common
.identifier
) {
774 case PHY_PACKET_CONFIGURATION
:
775 if (!pp
->phy_config
.set_root
&& !pp
->phy_config
.set_gap_count
) {
776 printf("ext phy config: phy_id=%02x", pp
->phy_config
.root_id
);
778 printf("phy config:");
779 if (pp
->phy_config
.set_root
)
780 printf(" set_root_id=%02x", pp
->phy_config
.root_id
);
781 if (pp
->phy_config
.set_gap_count
)
782 printf(" set_gap_count=%d", pp
->phy_config
.gap_count
);
786 case PHY_PACKET_LINK_ON
:
787 printf("link-on packet, phy_id=%02x", pp
->link_on
.phy_id
);
790 case PHY_PACKET_SELF_ID
:
791 if (pp
->self_id
.extended
) {
792 printf("extended self id: phy_id=%02x, seq=%d",
793 pp
->ext_self_id
.phy_id
, pp
->ext_self_id
.sequence
);
795 static const char * const speed_names
[] = {
796 "S100", "S200", "S400", "BETA"
798 printf("self id: phy_id=%02x, link %s, gap_count=%d, speed=%s%s%s",
800 (pp
->self_id
.link_active
? "active" : "not active"),
801 pp
->self_id
.gap_count
,
802 speed_names
[pp
->self_id
.phy_speed
],
803 (pp
->self_id
.contender
? ", irm contender" : ""),
804 (pp
->self_id
.initiated_reset
? ", initiator" : ""));
808 printf("unknown phy packet: ");
809 for (i
= 1; i
< length
/ 4; i
++)
810 printf("%s%08x", i
== 0 ? "[" : " ", data
[i
]);
815 struct link_packet
*packet
= (struct link_packet
*) data
;
817 decode_link_packet(packet
, length
, 0,
818 option_verbose
? 0 : PACKET_FIELD_DETAIL
);
823 dump_data((unsigned char *) data
+ 4, length
- 4);
830 #define HIDE_CURSOR "\033[?25l"
831 #define SHOW_CURSOR "\033[?25h"
832 #define CLEAR "\033[H\033[2J"
835 print_stats(uint32_t *data
, size_t length
)
837 static int bus_reset_count
, short_packet_count
, phy_packet_count
;
838 static int tcode_count
[16];
839 static struct timeval last_update
;
845 else if (length
< sizeof(struct phy_packet
))
846 short_packet_count
++;
847 else if (length
== sizeof(struct phy_packet
) && data
[1] == ~data
[2])
850 struct link_packet
*packet
= (struct link_packet
*) data
;
851 tcode_count
[packet
->common
.tcode
]++;
854 gettimeofday(&now
, NULL
);
855 if (now
.tv_sec
<= last_update
.tv_sec
&&
856 now
.tv_usec
< last_update
.tv_usec
+ 500000)
860 printf(CLEAR HIDE_CURSOR
861 " bus resets : %8d\n"
862 " short packets : %8d\n"
863 " phy packets : %8d\n",
864 bus_reset_count
, short_packet_count
, phy_packet_count
);
866 for (i
= 0; i
< array_length(packet_info
); i
++)
867 if (packet_info
[i
].type
!= PACKET_RESERVED
)
868 printf(" %-24s: %8d\n", packet_info
[i
].name
, tcode_count
[i
]);
869 printf(SHOW_CURSOR
"\n");
872 static struct termios saved_attributes
;
875 reset_input_mode(void)
877 tcsetattr(STDIN_FILENO
, TCSANOW
, &saved_attributes
);
883 struct termios tattr
;
885 /* Make sure stdin is a terminal. */
886 if (!isatty(STDIN_FILENO
)) {
887 fprintf(stderr
, "Not a terminal.\n");
891 /* Save the terminal attributes so we can restore them later. */
892 tcgetattr(STDIN_FILENO
, &saved_attributes
);
893 atexit(reset_input_mode
);
895 /* Set the funny terminal modes. */
896 tcgetattr(STDIN_FILENO
, &tattr
);
897 tattr
.c_lflag
&= ~(ICANON
|ECHO
); /* Clear ICANON and ECHO. */
898 tattr
.c_cc
[VMIN
] = 1;
899 tattr
.c_cc
[VTIME
] = 0;
900 tcsetattr(STDIN_FILENO
, TCSAFLUSH
, &tattr
);
903 int main(int argc
, const char *argv
[])
906 FILE *output
= NULL
, *input
= NULL
;
911 struct pollfd pollfds
[2];
913 sys_sigint_handler
= signal(SIGINT
, sigint_handler
);
915 con
= poptGetContext(NULL
, argc
, argv
, options
, 0);
916 retval
= poptGetNextOpt(con
);
918 poptPrintUsage(con
, stdout
, 0);
922 if (option_version
) {
923 printf("dump tool for nosy sniffer, version %s\n", VERSION
);
927 if (__BYTE_ORDER
!= __LITTLE_ENDIAN
)
928 fprintf(stderr
, "warning: nosy has only been tested on little "
929 "endian machines\n");
931 if (option_input
!= NULL
) {
932 input
= fopen(option_input
, "r");
934 fprintf(stderr
, "Could not open %s, %m\n", option_input
);
938 fd
= open(option_nosy_device
, O_RDWR
);
940 fprintf(stderr
, "Could not open %s, %m\n", option_nosy_device
);
946 if (strcmp(option_view
, "transaction") == 0)
947 view
= VIEW_TRANSACTION
;
948 else if (strcmp(option_view
, "stats") == 0)
954 output
= fopen(option_output
, "w");
955 if (output
== NULL
) {
956 fprintf(stderr
, "Could not open %s, %m\n", option_output
);
961 setvbuf(stdout
, NULL
, _IOLBF
, BUFSIZ
);
964 uint32_t buf
[128 * 1024];
970 filter
&= ~(1 << TCODE_ISO_DATA
);
971 if (!option_cycle_start
)
972 filter
&= ~(1 << TCODE_CYCLE_START
);
973 if (view
== VIEW_STATS
)
974 filter
= ~(1 << TCODE_CYCLE_START
);
976 ioctl(fd
, NOSY_IOC_FILTER
, filter
);
978 ioctl(fd
, NOSY_IOC_START
);
981 pollfds
[0].events
= POLLIN
;
982 pollfds
[1].fd
= STDIN_FILENO
;
983 pollfds
[1].events
= POLLIN
;
987 if (fread(&length
, sizeof length
, 1, input
) != 1)
989 fread(buf
, 1, length
, input
);
991 poll(pollfds
, 2, -1);
992 if (pollfds
[1].revents
) {
993 read(STDIN_FILENO
, &c
, sizeof c
);
1002 if (pollfds
[0].revents
)
1003 length
= read(fd
, buf
, sizeof buf
);
1008 if (output
!= NULL
) {
1009 fwrite(&length
, sizeof length
, 1, output
);
1010 fwrite(buf
, 1, length
, output
);
1014 case VIEW_TRANSACTION
:
1015 handle_packet(buf
, length
);
1018 print_packet(buf
, length
);
1021 print_stats(buf
, length
);
1026 poptPrintUsage(con
, stdout
, 0);
1034 poptFreeContext(con
);