1
2
3
4
5
6
7
8#include "qemu/ctype.h"
9#include "qemu/osdep.h"
10#include "qemu/error-report.h"
11#include "qemu/main-loop.h"
12#include "qemu/sockets.h"
13#include "qapi/error.h"
14#include "migration/vmstate.h"
15#include "hw/qdev-properties.h"
16#include "hw/loader.h"
17#include "cpu.h"
18#include "hw/hyperv/hyperv.h"
19#include "hw/hyperv/vmbus-bridge.h"
20#include "hw/hyperv/hyperv-proto.h"
21#include "net/net.h"
22#include "net/eth.h"
23#include "net/checksum.h"
24#include "trace.h"
25
26#define TYPE_HV_SYNDBG "hv-syndbg"
27
28typedef struct HvSynDbg {
29 DeviceState parent_obj;
30
31 char *host_ip;
32 uint16_t host_port;
33 bool use_hcalls;
34
35 uint32_t target_ip;
36 struct sockaddr_in servaddr;
37 int socket;
38 bool has_data_pending;
39 uint64_t pending_page_gpa;
40} HvSynDbg;
41
42#define HVSYNDBG(obj) OBJECT_CHECK(HvSynDbg, (obj), TYPE_HV_SYNDBG)
43
44
45static HvSynDbg *hv_syndbg_find(void)
46{
47
48 return HVSYNDBG(object_resolve_path_type("", TYPE_HV_SYNDBG, NULL));
49}
50
51static void set_pending_state(HvSynDbg *syndbg, bool has_pending)
52{
53 hwaddr out_len;
54 void *out_data;
55
56 syndbg->has_data_pending = has_pending;
57
58 if (!syndbg->pending_page_gpa) {
59 return;
60 }
61
62 out_len = 1;
63 out_data = cpu_physical_memory_map(syndbg->pending_page_gpa, &out_len, 1);
64 if (out_data) {
65 *(uint8_t *)out_data = !!has_pending;
66 cpu_physical_memory_unmap(out_data, out_len, 1, out_len);
67 }
68}
69
70static bool get_udb_pkt_data(void *p, uint32_t len, uint32_t *data_ofs,
71 uint32_t *src_ip)
72{
73 uint32_t offset, curr_len = len;
74
75 if (curr_len < sizeof(struct eth_header) ||
76 (be16_to_cpu(PKT_GET_ETH_HDR(p)->h_proto) != ETH_P_IP)) {
77 return false;
78 }
79 offset = sizeof(struct eth_header);
80 curr_len -= sizeof(struct eth_header);
81
82 if (curr_len < sizeof(struct ip_header) ||
83 PKT_GET_IP_HDR(p)->ip_p != IP_PROTO_UDP) {
84 return false;
85 }
86 offset += PKT_GET_IP_HDR_LEN(p);
87 curr_len -= PKT_GET_IP_HDR_LEN(p);
88
89 if (curr_len < sizeof(struct udp_header)) {
90 return false;
91 }
92
93 offset += sizeof(struct udp_header);
94 *data_ofs = offset;
95 *src_ip = PKT_GET_IP_HDR(p)->ip_src;
96 return true;
97}
98
99static uint16_t handle_send_msg(HvSynDbg *syndbg, uint64_t ingpa,
100 uint32_t count, bool is_raw,
101 uint32_t *pending_count)
102{
103 uint16_t ret;
104 hwaddr data_len;
105 void *debug_data = NULL;
106 uint32_t udp_data_ofs = 0;
107 const void *pkt_data;
108 int sent_count;
109
110 data_len = count;
111 debug_data = cpu_physical_memory_map(ingpa, &data_len, 0);
112 if (!debug_data || data_len < count) {
113 ret = HV_STATUS_INSUFFICIENT_MEMORY;
114 goto cleanup;
115 }
116
117 if (is_raw &&
118 !get_udb_pkt_data(debug_data, count, &udp_data_ofs,
119 &syndbg->target_ip)) {
120 ret = HV_STATUS_SUCCESS;
121 goto cleanup;
122 }
123
124 pkt_data = (const void *)((uintptr_t)debug_data + udp_data_ofs);
125 sent_count = sendto(syndbg->socket, pkt_data, count - udp_data_ofs,
126 MSG_NOSIGNAL, NULL, 0);
127 if (sent_count == -1) {
128 ret = HV_STATUS_INSUFFICIENT_MEMORY;
129 goto cleanup;
130 }
131
132 *pending_count = count - (sent_count + udp_data_ofs);
133 ret = HV_STATUS_SUCCESS;
134cleanup:
135 if (debug_data) {
136 cpu_physical_memory_unmap(debug_data, count, 0, data_len);
137 }
138
139 return ret;
140}
141
142#define UDP_PKT_HEADER_SIZE \
143 (sizeof(struct eth_header) + sizeof(struct ip_header) +\
144 sizeof(struct udp_header))
145
146static bool create_udp_pkt(HvSynDbg *syndbg, void *pkt, uint32_t pkt_len,
147 void *udp_data, uint32_t udp_data_len)
148{
149 struct udp_header *udp_part;
150
151 if (pkt_len < (UDP_PKT_HEADER_SIZE + udp_data_len)) {
152 return false;
153 }
154
155
156 memset(&PKT_GET_ETH_HDR(pkt)->h_source, 0, ETH_ALEN);
157 memset(&PKT_GET_ETH_HDR(pkt)->h_dest, 0, ETH_ALEN);
158 PKT_GET_ETH_HDR(pkt)->h_proto = cpu_to_be16(ETH_P_IP);
159
160
161 PKT_GET_IP_HDR(pkt)->ip_ver_len =
162 (4 << 4) | (sizeof(struct ip_header) >> 2);
163 PKT_GET_IP_HDR(pkt)->ip_tos = 0;
164 PKT_GET_IP_HDR(pkt)->ip_id = 0;
165 PKT_GET_IP_HDR(pkt)->ip_off = 0;
166 PKT_GET_IP_HDR(pkt)->ip_ttl = 64;
167 PKT_GET_IP_HDR(pkt)->ip_p = IP_PROTO_UDP;
168 PKT_GET_IP_HDR(pkt)->ip_src = syndbg->servaddr.sin_addr.s_addr;
169 PKT_GET_IP_HDR(pkt)->ip_dst = syndbg->target_ip;
170 PKT_GET_IP_HDR(pkt)->ip_len =
171 cpu_to_be16(sizeof(struct ip_header) + sizeof(struct udp_header) +
172 udp_data_len);
173 eth_fix_ip4_checksum(PKT_GET_IP_HDR(pkt), PKT_GET_IP_HDR_LEN(pkt));
174
175 udp_part = (struct udp_header *)((uintptr_t)pkt +
176 sizeof(struct eth_header) +
177 PKT_GET_IP_HDR_LEN(pkt));
178 udp_part->uh_sport = syndbg->servaddr.sin_port;
179 udp_part->uh_dport = syndbg->servaddr.sin_port;
180 udp_part->uh_ulen = cpu_to_be16(sizeof(struct udp_header) + udp_data_len);
181 memcpy(udp_part + 1, udp_data, udp_data_len);
182 net_checksum_calculate(pkt, UDP_PKT_HEADER_SIZE + udp_data_len, CSUM_ALL);
183 return true;
184}
185
186static uint16_t handle_recv_msg(HvSynDbg *syndbg, uint64_t outgpa,
187 uint32_t count, bool is_raw, uint32_t options,
188 uint64_t timeout, uint32_t *retrieved_count)
189{
190 uint16_t ret;
191 uint8_t data_buf[TARGET_PAGE_SIZE - UDP_PKT_HEADER_SIZE];
192 hwaddr out_len;
193 void *out_data;
194 ssize_t recv_byte_count;
195
196
197 (void)options;
198 (void)timeout;
199
200 if (!syndbg->has_data_pending) {
201 recv_byte_count = 0;
202 } else {
203 recv_byte_count = recv(syndbg->socket, data_buf,
204 MIN(sizeof(data_buf), count), MSG_WAITALL);
205 if (recv_byte_count == -1) {
206 return HV_STATUS_INVALID_PARAMETER;
207 }
208 }
209
210 if (!recv_byte_count) {
211 *retrieved_count = 0;
212 return HV_STATUS_NO_DATA;
213 }
214
215 set_pending_state(syndbg, false);
216
217 out_len = recv_byte_count;
218 if (is_raw) {
219 out_len += UDP_PKT_HEADER_SIZE;
220 }
221 out_data = cpu_physical_memory_map(outgpa, &out_len, 1);
222 if (!out_data) {
223 return HV_STATUS_INSUFFICIENT_MEMORY;
224 }
225
226 if (is_raw &&
227 !create_udp_pkt(syndbg, out_data,
228 recv_byte_count + UDP_PKT_HEADER_SIZE,
229 data_buf, recv_byte_count)) {
230 ret = HV_STATUS_INSUFFICIENT_MEMORY;
231 goto cleanup_out_data;
232 } else if (!is_raw) {
233 memcpy(out_data, data_buf, recv_byte_count);
234 }
235
236 *retrieved_count = recv_byte_count;
237 if (is_raw) {
238 *retrieved_count += UDP_PKT_HEADER_SIZE;
239 }
240 ret = HV_STATUS_SUCCESS;
241
242cleanup_out_data:
243 cpu_physical_memory_unmap(out_data, out_len, 1, out_len);
244 return ret;
245}
246
247static uint16_t hv_syndbg_handler(void *context, HvSynDbgMsg *msg)
248{
249 HvSynDbg *syndbg = context;
250 uint16_t ret = HV_STATUS_INVALID_HYPERCALL_CODE;
251
252 switch (msg->type) {
253 case HV_SYNDBG_MSG_CONNECTION_INFO:
254 msg->u.connection_info.host_ip =
255 ntohl(syndbg->servaddr.sin_addr.s_addr);
256 msg->u.connection_info.host_port =
257 ntohs(syndbg->servaddr.sin_port);
258 ret = HV_STATUS_SUCCESS;
259 break;
260 case HV_SYNDBG_MSG_SEND:
261 ret = handle_send_msg(syndbg, msg->u.send.buf_gpa, msg->u.send.count,
262 msg->u.send.is_raw, &msg->u.send.pending_count);
263 break;
264 case HV_SYNDBG_MSG_RECV:
265 ret = handle_recv_msg(syndbg, msg->u.recv.buf_gpa, msg->u.recv.count,
266 msg->u.recv.is_raw, msg->u.recv.options,
267 msg->u.recv.timeout,
268 &msg->u.recv.retrieved_count);
269 break;
270 case HV_SYNDBG_MSG_SET_PENDING_PAGE:
271 syndbg->pending_page_gpa = msg->u.pending_page.buf_gpa;
272 ret = HV_STATUS_SUCCESS;
273 break;
274 case HV_SYNDBG_MSG_QUERY_OPTIONS:
275 msg->u.query_options.options = 0;
276 if (syndbg->use_hcalls) {
277 msg->u.query_options.options = HV_X64_SYNDBG_OPTION_USE_HCALLS;
278 }
279 ret = HV_STATUS_SUCCESS;
280 break;
281 default:
282 break;
283 }
284
285 return ret;
286}
287
288static void hv_syndbg_recv_event(void *opaque)
289{
290 HvSynDbg *syndbg = opaque;
291 struct timeval tv;
292 fd_set rfds;
293
294 tv.tv_sec = 0;
295 tv.tv_usec = 0;
296 FD_ZERO(&rfds);
297 FD_SET(syndbg->socket, &rfds);
298 if (select(syndbg->socket + 1, &rfds, NULL, NULL, &tv) > 0) {
299 set_pending_state(syndbg, true);
300 }
301}
302
303static void hv_syndbg_realize(DeviceState *dev, Error **errp)
304{
305 HvSynDbg *syndbg = HVSYNDBG(dev);
306
307 if (!hv_syndbg_find()) {
308 error_setg(errp, "at most one %s device is permitted", TYPE_HV_SYNDBG);
309 return;
310 }
311
312 if (!vmbus_bridge_find()) {
313 error_setg(errp, "%s device requires vmbus-bridge device",
314 TYPE_HV_SYNDBG);
315 return;
316 }
317
318
319 if (qemu_isdigit(syndbg->host_ip[0])) {
320 syndbg->servaddr.sin_addr.s_addr = inet_addr(syndbg->host_ip);
321 } else {
322 struct hostent *he = gethostbyname(syndbg->host_ip);
323 if (!he) {
324 error_setg(errp, "%s failed to resolve host name %s",
325 TYPE_HV_SYNDBG, syndbg->host_ip);
326 return;
327 }
328 syndbg->servaddr.sin_addr = *(struct in_addr *)he->h_addr;
329 }
330
331 syndbg->socket = socket(AF_INET, SOCK_DGRAM, 0);
332 if (syndbg->socket < 0) {
333 error_setg(errp, "%s failed to create socket", TYPE_HV_SYNDBG);
334 return;
335 }
336
337 qemu_socket_set_nonblock(syndbg->socket);
338
339 syndbg->servaddr.sin_port = htons(syndbg->host_port);
340 syndbg->servaddr.sin_family = AF_INET;
341 if (connect(syndbg->socket, (struct sockaddr *)&syndbg->servaddr,
342 sizeof(syndbg->servaddr)) < 0) {
343 closesocket(syndbg->socket);
344 error_setg(errp, "%s failed to connect to socket", TYPE_HV_SYNDBG);
345 return;
346 }
347
348 syndbg->pending_page_gpa = 0;
349 syndbg->has_data_pending = false;
350 hyperv_set_syndbg_handler(hv_syndbg_handler, syndbg);
351 qemu_set_fd_handler(syndbg->socket, hv_syndbg_recv_event, NULL, syndbg);
352}
353
354static void hv_syndbg_unrealize(DeviceState *dev)
355{
356 HvSynDbg *syndbg = HVSYNDBG(dev);
357
358 if (syndbg->socket > 0) {
359 qemu_set_fd_handler(syndbg->socket, NULL, NULL, NULL);
360 closesocket(syndbg->socket);
361 }
362}
363
364static const VMStateDescription vmstate_hv_syndbg = {
365 .name = TYPE_HV_SYNDBG,
366 .unmigratable = 1,
367};
368
369static Property hv_syndbg_properties[] = {
370 DEFINE_PROP_STRING("host_ip", HvSynDbg, host_ip),
371 DEFINE_PROP_UINT16("host_port", HvSynDbg, host_port, 50000),
372 DEFINE_PROP_BOOL("use_hcalls", HvSynDbg, use_hcalls, false),
373 DEFINE_PROP_END_OF_LIST(),
374};
375
376static void hv_syndbg_class_init(ObjectClass *klass, void *data)
377{
378 DeviceClass *dc = DEVICE_CLASS(klass);
379
380 device_class_set_props(dc, hv_syndbg_properties);
381 dc->fw_name = TYPE_HV_SYNDBG;
382 dc->vmsd = &vmstate_hv_syndbg;
383 dc->realize = hv_syndbg_realize;
384 dc->unrealize = hv_syndbg_unrealize;
385 dc->user_creatable = true;
386 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
387}
388
389static const TypeInfo hv_syndbg_type_info = {
390 .name = TYPE_HV_SYNDBG,
391 .parent = TYPE_DEVICE,
392 .instance_size = sizeof(HvSynDbg),
393 .class_init = hv_syndbg_class_init,
394};
395
396static void hv_syndbg_register_types(void)
397{
398 type_register_static(&hv_syndbg_type_info);
399}
400
401type_init(hv_syndbg_register_types)
402
