Merge tag 'pull-hex-20221003' of https://github.com/quic/qemu into staging
[qemu.git] / hw / usb / pcap.c
1 /*
2 * usb packet capture
3 *
4 * Copyright (c) 2021 Gerd Hoffmann <kraxel@redhat.com>
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 */
9
10 #include "qemu/osdep.h"
11 #include "hw/usb.h"
12
13 #define PCAP_MAGIC 0xa1b2c3d4
14 #define PCAP_MAJOR 2
15 #define PCAP_MINOR 4
16
17 /* https://wiki.wireshark.org/Development/LibpcapFileFormat */
18
19 struct pcap_hdr {
20 uint32_t magic_number; /* magic number */
21 uint16_t version_major; /* major version number */
22 uint16_t version_minor; /* minor version number */
23 int32_t thiszone; /* GMT to local correction */
24 uint32_t sigfigs; /* accuracy of timestamps */
25 uint32_t snaplen; /* max length of captured packets, in octets */
26 uint32_t network; /* data link type */
27 };
28
29 struct pcaprec_hdr {
30 uint32_t ts_sec; /* timestamp seconds */
31 uint32_t ts_usec; /* timestamp microseconds */
32 uint32_t incl_len; /* number of octets of packet saved in file */
33 uint32_t orig_len; /* actual length of packet */
34 };
35
36 /* https://www.tcpdump.org/linktypes.html */
37 /* linux: Documentation/usb/usbmon.rst */
38 /* linux: drivers/usb/mon/mon_bin.c */
39
40 #define LINKTYPE_USB_LINUX 189 /* first 48 bytes only */
41 #define LINKTYPE_USB_LINUX_MMAPPED 220 /* full 64 byte header */
42
43 struct usbmon_packet {
44 uint64_t id; /* 0: URB ID - from submission to callback */
45 unsigned char type; /* 8: Same as text; extensible. */
46 unsigned char xfer_type; /* ISO (0), Intr, Control, Bulk (3) */
47 unsigned char epnum; /* Endpoint number and transfer direction */
48 unsigned char devnum; /* Device address */
49 uint16_t busnum; /* 12: Bus number */
50 char flag_setup; /* 14: Same as text */
51 char flag_data; /* 15: Same as text; Binary zero is OK. */
52 int64_t ts_sec; /* 16: gettimeofday */
53 int32_t ts_usec; /* 24: gettimeofday */
54 int32_t status; /* 28: */
55 unsigned int length; /* 32: Length of data (submitted or actual) */
56 unsigned int len_cap; /* 36: Delivered length */
57 union { /* 40: */
58 unsigned char setup[8]; /* Only for Control S-type */
59 struct iso_rec { /* Only for ISO */
60 int32_t error_count;
61 int32_t numdesc;
62 } iso;
63 } s;
64 int32_t interval; /* 48: Only for Interrupt and ISO */
65 int32_t start_frame; /* 52: For ISO */
66 uint32_t xfer_flags; /* 56: copy of URB's transfer_flags */
67 uint32_t ndesc; /* 60: Actual number of ISO descriptors */
68 }; /* 64 total length */
69
70 /* ------------------------------------------------------------------------ */
71
72 #define CTRL_LEN 4096
73 #define DATA_LEN 256
74
75 static int usbmon_status(USBPacket *p)
76 {
77 switch (p->status) {
78 case USB_RET_SUCCESS:
79 return 0;
80 case USB_RET_NODEV:
81 return -19; /* -ENODEV */
82 default:
83 return -121; /* -EREMOTEIO */
84 }
85 }
86
87 static unsigned int usbmon_epnum(USBPacket *p)
88 {
89 unsigned epnum = 0;
90
91 epnum |= p->ep->nr;
92 epnum |= (p->pid == USB_TOKEN_IN) ? 0x80 : 0;
93 return epnum;
94 }
95
96 static unsigned char usbmon_xfer_type[] = {
97 [USB_ENDPOINT_XFER_CONTROL] = 2,
98 [USB_ENDPOINT_XFER_ISOC] = 0,
99 [USB_ENDPOINT_XFER_BULK] = 3,
100 [USB_ENDPOINT_XFER_INT] = 1,
101 };
102
103 static void do_usb_pcap_header(FILE *fp, struct usbmon_packet *packet)
104 {
105 struct pcaprec_hdr header;
106 struct timeval tv;
107
108 gettimeofday(&tv, NULL);
109 packet->ts_sec = tv.tv_sec;
110 packet->ts_usec = tv.tv_usec;
111
112 header.ts_sec = packet->ts_sec;
113 header.ts_usec = packet->ts_usec;
114 header.incl_len = packet->len_cap;
115 header.orig_len = packet->length + sizeof(*packet);
116 fwrite(&header, sizeof(header), 1, fp);
117 fwrite(packet, sizeof(*packet), 1, fp);
118 }
119
120 static void do_usb_pcap_ctrl(FILE *fp, USBPacket *p, bool setup)
121 {
122 USBDevice *dev = p->ep->dev;
123 bool in = dev->setup_buf[0] & USB_DIR_IN;
124 struct usbmon_packet packet = {
125 .id = 0,
126 .type = setup ? 'S' : 'C',
127 .xfer_type = usbmon_xfer_type[USB_ENDPOINT_XFER_CONTROL],
128 .epnum = in ? 0x80 : 0,
129 .devnum = dev->addr,
130 .flag_setup = setup ? 0 : '-',
131 .flag_data = '=',
132 .length = dev->setup_len,
133 };
134 int data_len = dev->setup_len;
135
136 if (data_len > CTRL_LEN) {
137 data_len = CTRL_LEN;
138 }
139 if (setup) {
140 memcpy(packet.s.setup, dev->setup_buf, 8);
141 } else {
142 packet.status = usbmon_status(p);
143 }
144
145 if (in && setup) {
146 packet.flag_data = '<';
147 packet.length = 0;
148 data_len = 0;
149 }
150 if (!in && !setup) {
151 packet.flag_data = '>';
152 packet.length = 0;
153 data_len = 0;
154 }
155
156 packet.len_cap = data_len + sizeof(packet);
157 do_usb_pcap_header(fp, &packet);
158 if (data_len) {
159 fwrite(dev->data_buf, data_len, 1, fp);
160 }
161
162 fflush(fp);
163 }
164
165 static void do_usb_pcap_data(FILE *fp, USBPacket *p, bool setup)
166 {
167 struct usbmon_packet packet = {
168 .id = p->id,
169 .type = setup ? 'S' : 'C',
170 .xfer_type = usbmon_xfer_type[p->ep->type],
171 .epnum = usbmon_epnum(p),
172 .devnum = p->ep->dev->addr,
173 .flag_setup = '-',
174 .flag_data = '=',
175 .length = p->iov.size,
176 };
177 int data_len = p->iov.size;
178
179 if (p->ep->nr == 0) {
180 /* ignore control pipe packets */
181 return;
182 }
183
184 if (data_len > DATA_LEN) {
185 data_len = DATA_LEN;
186 }
187 if (!setup) {
188 packet.status = usbmon_status(p);
189 if (packet.length > p->actual_length) {
190 packet.length = p->actual_length;
191 }
192 if (data_len > p->actual_length) {
193 data_len = p->actual_length;
194 }
195 }
196
197 if (p->pid == USB_TOKEN_IN && setup) {
198 packet.flag_data = '<';
199 packet.length = 0;
200 data_len = 0;
201 }
202 if (p->pid == USB_TOKEN_OUT && !setup) {
203 packet.flag_data = '>';
204 packet.length = 0;
205 data_len = 0;
206 }
207
208 packet.len_cap = data_len + sizeof(packet);
209 do_usb_pcap_header(fp, &packet);
210 if (data_len) {
211 void *buf = g_malloc(data_len);
212 iov_to_buf(p->iov.iov, p->iov.niov, 0, buf, data_len);
213 fwrite(buf, data_len, 1, fp);
214 g_free(buf);
215 }
216
217 fflush(fp);
218 }
219
220 void usb_pcap_init(FILE *fp)
221 {
222 struct pcap_hdr header = {
223 .magic_number = PCAP_MAGIC,
224 .version_major = 2,
225 .version_minor = 4,
226 .snaplen = MAX(CTRL_LEN, DATA_LEN) + sizeof(struct usbmon_packet),
227 .network = LINKTYPE_USB_LINUX_MMAPPED,
228 };
229
230 fwrite(&header, sizeof(header), 1, fp);
231 }
232
233 void usb_pcap_ctrl(USBPacket *p, bool setup)
234 {
235 FILE *fp = p->ep->dev->pcap;
236
237 if (!fp) {
238 return;
239 }
240
241 do_usb_pcap_ctrl(fp, p, setup);
242 }
243
244 void usb_pcap_data(USBPacket *p, bool setup)
245 {
246 FILE *fp = p->ep->dev->pcap;
247
248 if (!fp) {
249 return;
250 }
251
252 do_usb_pcap_data(fp, p, setup);
253 }