syndbg.c (11910B)
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/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 28 typedef 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 /* returns NULL unless there is exactly one HV Synth debug device */ 45 static HvSynDbg *hv_syndbg_find(void) 46 { 47 /* Returns NULL unless there is exactly one hvsd device */ 48 return HVSYNDBG(object_resolve_path_type("", TYPE_HV_SYNDBG, NULL)); 49 } 50 51 static 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 70 static 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 99 static 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; 134 cleanup: 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 146 static 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 /* Setup the eth */ 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 /* Setup the ip */ 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; /* IPDEFTTL */ 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 186 static 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 /* TODO: Handle options and timeout */ 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 242 cleanup_out_data: 243 cpu_physical_memory_unmap(out_data, out_len, 1, out_len); 244 return ret; 245 } 246 247 static 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 288 static 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 303 static 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 /* Parse and host_ip */ 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 354 static 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 364 static const VMStateDescription vmstate_hv_syndbg = { 365 .name = TYPE_HV_SYNDBG, 366 .unmigratable = 1, 367 }; 368 369 static 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 376 static 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 389 static 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 396 static void hv_syndbg_register_types(void) 397 { 398 type_register_static(&hv_syndbg_type_info); 399 } 400 401 type_init(hv_syndbg_register_types)