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