376 lines · plain
1======2usbmon3======4 5Introduction6============7 8The name "usbmon" in lowercase refers to a facility in kernel which is9used to collect traces of I/O on the USB bus. This function is analogous10to a packet socket used by network monitoring tools such as tcpdump(1)11or Ethereal. Similarly, it is expected that a tool such as usbdump or12USBMon (with uppercase letters) is used to examine raw traces produced13by usbmon.14 15The usbmon reports requests made by peripheral-specific drivers to Host16Controller Drivers (HCD). So, if HCD is buggy, the traces reported by17usbmon may not correspond to bus transactions precisely. This is the same18situation as with tcpdump.19 20Two APIs are currently implemented: "text" and "binary". The binary API21is available through a character device in /dev namespace and is an ABI.22The text API is deprecated since 2.6.35, but available for convenience.23 24How to use usbmon to collect raw text traces25============================================26 27Unlike the packet socket, usbmon has an interface which provides traces28in a text format. This is used for two purposes. First, it serves as a29common trace exchange format for tools while more sophisticated formats30are finalized. Second, humans can read it in case tools are not available.31 32To collect a raw text trace, execute following steps.33 341. Prepare35----------36 37Mount debugfs (it has to be enabled in your kernel configuration), and38load the usbmon module (if built as module). The second step is skipped39if usbmon is built into the kernel::40 41 # mount -t debugfs none_debugs /sys/kernel/debug42 # modprobe usbmon43 #44 45Verify that bus sockets are present::46 47 # ls /sys/kernel/debug/usb/usbmon48 0s 0u 1s 1t 1u 2s 2t 2u 3s 3t 3u 4s 4t 4u49 #50 51Now you can choose to either use the socket '0u' (to capture packets on all52buses), and skip to step #3, or find the bus used by your device with step #2.53This allows to filter away annoying devices that talk continuously.54 552. Find which bus connects to the desired device56------------------------------------------------57 58Run "cat /sys/kernel/debug/usb/devices", and find the T-line which corresponds59to the device. Usually you do it by looking for the vendor string. If you have60many similar devices, unplug one and compare the two61/sys/kernel/debug/usb/devices outputs. The T-line will have a bus number.62 63Example::64 65 T: Bus=03 Lev=01 Prnt=01 Port=00 Cnt=01 Dev#= 2 Spd=12 MxCh= 066 D: Ver= 1.10 Cls=00(>ifc ) Sub=00 Prot=00 MxPS= 8 #Cfgs= 167 P: Vendor=0557 ProdID=2004 Rev= 1.0068 S: Manufacturer=ATEN69 S: Product=UC100KM V2.0070 71"Bus=03" means it's bus 3. Alternatively, you can look at the output from72"lsusb" and get the bus number from the appropriate line. Example:73 74Bus 003 Device 002: ID 0557:2004 ATEN UC100KM V2.0075 763. Start 'cat'77--------------78 79::80 81 # cat /sys/kernel/debug/usb/usbmon/3u > /tmp/1.mon.out82 83to listen on a single bus, otherwise, to listen on all buses, type::84 85 # cat /sys/kernel/debug/usb/usbmon/0u > /tmp/1.mon.out86 87This process will read until it is killed. Naturally, the output can be88redirected to a desirable location. This is preferred, because it is going89to be quite long.90 914. Perform the desired operation on the USB bus92-----------------------------------------------93 94This is where you do something that creates the traffic: plug in a flash key,95copy files, control a webcam, etc.96 975. Kill cat98-----------99 100Usually it's done with a keyboard interrupt (Control-C).101 102At this point the output file (/tmp/1.mon.out in this example) can be saved,103sent by e-mail, or inspected with a text editor. In the last case make sure104that the file size is not excessive for your favourite editor.105 106Raw text data format107====================108 109Two formats are supported currently: the original, or '1t' format, and110the '1u' format. The '1t' format is deprecated in kernel 2.6.21. The '1u'111format adds a few fields, such as ISO frame descriptors, interval, etc.112It produces slightly longer lines, but otherwise is a perfect superset113of '1t' format.114 115If it is desired to recognize one from the other in a program, look at the116"address" word (see below), where '1u' format adds a bus number. If 2 colons117are present, it's the '1t' format, otherwise '1u'.118 119Any text format data consists of a stream of events, such as URB submission,120URB callback, submission error. Every event is a text line, which consists121of whitespace separated words. The number or position of words may depend122on the event type, but there is a set of words, common for all types.123 124Here is the list of words, from left to right:125 126- URB Tag. This is used to identify URBs, and is normally an in-kernel address127 of the URB structure in hexadecimal, but can be a sequence number or any128 other unique string, within reason.129 130- Timestamp in microseconds, a decimal number. The timestamp's resolution131 depends on available clock, and so it can be much worse than a microsecond132 (if the implementation uses jiffies, for example).133 134- Event Type. This type refers to the format of the event, not URB type.135 Available types are: S - submission, C - callback, E - submission error.136 137- "Address" word (formerly a "pipe"). It consists of four fields, separated by138 colons: URB type and direction, Bus number, Device address, Endpoint number.139 Type and direction are encoded with two bytes in the following manner:140 141 == == =============================142 Ci Co Control input and output143 Zi Zo Isochronous input and output144 Ii Io Interrupt input and output145 Bi Bo Bulk input and output146 == == =============================147 148 Bus number, Device address, and Endpoint are decimal numbers, but they may149 have leading zeros, for the sake of human readers.150 151- URB Status word. This is either a letter, or several numbers separated152 by colons: URB status, interval, start frame, and error count. Unlike the153 "address" word, all fields save the status are optional. Interval is printed154 only for interrupt and isochronous URBs. Start frame is printed only for155 isochronous URBs. Error count is printed only for isochronous callback156 events.157 158 The status field is a decimal number, sometimes negative, which represents159 a "status" field of the URB. This field makes no sense for submissions, but160 is present anyway to help scripts with parsing. When an error occurs, the161 field contains the error code.162 163 In case of a submission of a Control packet, this field contains a Setup Tag164 instead of an group of numbers. It is easy to tell whether the Setup Tag is165 present because it is never a number. Thus if scripts find a set of numbers166 in this word, they proceed to read Data Length (except for isochronous URBs).167 If they find something else, like a letter, they read the setup packet before168 reading the Data Length or isochronous descriptors.169 170- Setup packet, if present, consists of 5 words: one of each for bmRequestType,171 bRequest, wValue, wIndex, wLength, as specified by the USB Specification 2.0.172 These words are safe to decode if Setup Tag was 's'. Otherwise, the setup173 packet was present, but not captured, and the fields contain filler.174 175- Number of isochronous frame descriptors and descriptors themselves.176 If an Isochronous transfer event has a set of descriptors, a total number177 of them in an URB is printed first, then a word per descriptor, up to a178 total of 5. The word consists of 3 colon-separated decimal numbers for179 status, offset, and length respectively. For submissions, initial length180 is reported. For callbacks, actual length is reported.181 182- Data Length. For submissions, this is the requested length. For callbacks,183 this is the actual length.184 185- Data tag. The usbmon may not always capture data, even if length is nonzero.186 The data words are present only if this tag is '='.187 188- Data words follow, in big endian hexadecimal format. Notice that they are189 not machine words, but really just a byte stream split into words to make190 it easier to read. Thus, the last word may contain from one to four bytes.191 The length of collected data is limited and can be less than the data length192 reported in the Data Length word. In the case of an Isochronous input (Zi)193 completion where the received data is sparse in the buffer, the length of194 the collected data can be greater than the Data Length value (because Data195 Length counts only the bytes that were received whereas the Data words196 contain the entire transfer buffer).197 198Examples:199 200An input control transfer to get a port status::201 202 d5ea89a0 3575914555 S Ci:1:001:0 s a3 00 0000 0003 0004 4 <203 d5ea89a0 3575914560 C Ci:1:001:0 0 4 = 01050000204 205An output bulk transfer to send a SCSI command 0x28 (READ_10) in a 31-byte206Bulk wrapper to a storage device at address 5::207 208 dd65f0e8 4128379752 S Bo:1:005:2 -115 31 = 55534243 ad000000 00800000 80010a28 20000000 20000040 00000000 000000209 dd65f0e8 4128379808 C Bo:1:005:2 0 31 >210 211Raw binary format and API212=========================213 214The overall architecture of the API is about the same as the one above,215only the events are delivered in binary format. Each event is sent in216the following structure (its name is made up, so that we can refer to it)::217 218 struct usbmon_packet {219 u64 id; /* 0: URB ID - from submission to callback */220 unsigned char type; /* 8: Same as text; extensible. */221 unsigned char xfer_type; /* ISO (0), Intr, Control, Bulk (3) */222 unsigned char epnum; /* Endpoint number and transfer direction */223 unsigned char devnum; /* Device address */224 u16 busnum; /* 12: Bus number */225 char flag_setup; /* 14: Same as text */226 char flag_data; /* 15: Same as text; Binary zero is OK. */227 s64 ts_sec; /* 16: gettimeofday */228 s32 ts_usec; /* 24: gettimeofday */229 int status; /* 28: */230 unsigned int length; /* 32: Length of data (submitted or actual) */231 unsigned int len_cap; /* 36: Delivered length */232 union { /* 40: */233 unsigned char setup[SETUP_LEN]; /* Only for Control S-type */234 struct iso_rec { /* Only for ISO */235 int error_count;236 int numdesc;237 } iso;238 } s;239 int interval; /* 48: Only for Interrupt and ISO */240 int start_frame; /* 52: For ISO */241 unsigned int xfer_flags; /* 56: copy of URB's transfer_flags */242 unsigned int ndesc; /* 60: Actual number of ISO descriptors */243 }; /* 64 total length */244 245These events can be received from a character device by reading with read(2),246with an ioctl(2), or by accessing the buffer with mmap. However, read(2)247only returns first 48 bytes for compatibility reasons.248 249The character device is usually called /dev/usbmonN, where N is the USB bus250number. Number zero (/dev/usbmon0) is special and means "all buses".251Note that specific naming policy is set by your Linux distribution.252 253If you create /dev/usbmon0 by hand, make sure that it is owned by root254and has mode 0600. Otherwise, unprivileged users will be able to snoop255keyboard traffic.256 257The following ioctl calls are available, with MON_IOC_MAGIC 0x92:258 259 MON_IOCQ_URB_LEN, defined as _IO(MON_IOC_MAGIC, 1)260 261This call returns the length of data in the next event. Note that majority of262events contain no data, so if this call returns zero, it does not mean that263no events are available.264 265 MON_IOCG_STATS, defined as _IOR(MON_IOC_MAGIC, 3, struct mon_bin_stats)266 267The argument is a pointer to the following structure::268 269 struct mon_bin_stats {270 u32 queued;271 u32 dropped;272 };273 274The member "queued" refers to the number of events currently queued in the275buffer (and not to the number of events processed since the last reset).276 277The member "dropped" is the number of events lost since the last call278to MON_IOCG_STATS.279 280 MON_IOCT_RING_SIZE, defined as _IO(MON_IOC_MAGIC, 4)281 282This call sets the buffer size. The argument is the size in bytes.283The size may be rounded down to the next chunk (or page). If the requested284size is out of [unspecified] bounds for this kernel, the call fails with285-EINVAL.286 287 MON_IOCQ_RING_SIZE, defined as _IO(MON_IOC_MAGIC, 5)288 289This call returns the current size of the buffer in bytes.290 291 MON_IOCX_GET, defined as _IOW(MON_IOC_MAGIC, 6, struct mon_get_arg)292 MON_IOCX_GETX, defined as _IOW(MON_IOC_MAGIC, 10, struct mon_get_arg)293 294These calls wait for events to arrive if none were in the kernel buffer,295then return the first event. The argument is a pointer to the following296structure::297 298 struct mon_get_arg {299 struct usbmon_packet *hdr;300 void *data;301 size_t alloc; /* Length of data (can be zero) */302 };303 304Before the call, hdr, data, and alloc should be filled. Upon return, the area305pointed by hdr contains the next event structure, and the data buffer contains306the data, if any. The event is removed from the kernel buffer.307 308The MON_IOCX_GET copies 48 bytes to hdr area, MON_IOCX_GETX copies 64 bytes.309 310 MON_IOCX_MFETCH, defined as _IOWR(MON_IOC_MAGIC, 7, struct mon_mfetch_arg)311 312This ioctl is primarily used when the application accesses the buffer313with mmap(2). Its argument is a pointer to the following structure::314 315 struct mon_mfetch_arg {316 uint32_t *offvec; /* Vector of events fetched */317 uint32_t nfetch; /* Number of events to fetch (out: fetched) */318 uint32_t nflush; /* Number of events to flush */319 };320 321The ioctl operates in 3 stages.322 323First, it removes and discards up to nflush events from the kernel buffer.324The actual number of events discarded is returned in nflush.325 326Second, it waits for an event to be present in the buffer, unless the pseudo-327device is open with O_NONBLOCK.328 329Third, it extracts up to nfetch offsets into the mmap buffer, and stores330them into the offvec. The actual number of event offsets is stored into331the nfetch.332 333 MON_IOCH_MFLUSH, defined as _IO(MON_IOC_MAGIC, 8)334 335This call removes a number of events from the kernel buffer. Its argument336is the number of events to remove. If the buffer contains fewer events337than requested, all events present are removed, and no error is reported.338This works when no events are available too.339 340 FIONBIO341 342The ioctl FIONBIO may be implemented in the future, if there's a need.343 344In addition to ioctl(2) and read(2), the special file of binary API can345be polled with select(2) and poll(2). But lseek(2) does not work.346 347* Memory-mapped access of the kernel buffer for the binary API348 349The basic idea is simple:350 351To prepare, map the buffer by getting the current size, then using mmap(2).352Then, execute a loop similar to the one written in pseudo-code below::353 354 struct mon_mfetch_arg fetch;355 struct usbmon_packet *hdr;356 int nflush = 0;357 for (;;) {358 fetch.offvec = vec; // Has N 32-bit words359 fetch.nfetch = N; // Or less than N360 fetch.nflush = nflush;361 ioctl(fd, MON_IOCX_MFETCH, &fetch); // Process errors, too362 nflush = fetch.nfetch; // This many packets to flush when done363 for (i = 0; i < nflush; i++) {364 hdr = (struct ubsmon_packet *) &mmap_area[vec[i]];365 if (hdr->type == '@') // Filler packet366 continue;367 caddr_t data = &mmap_area[vec[i]] + 64;368 process_packet(hdr, data);369 }370 }371 372Thus, the main idea is to execute only one ioctl per N events.373 374Although the buffer is circular, the returned headers and data do not cross375the end of the buffer, so the above pseudo-code does not need any gathering.376