1 #include <sys/epoll.h> 2 #include <sys/un.h> 3 #include <sys/types.h> 4 #include <sys/socket.h> 5 #include <sys/eventfd.h> 6 #include <dirent.h> 7 8 #include "kvm/kvm-ipc.h" 9 #include "kvm/rwsem.h" 10 #include "kvm/read-write.h" 11 #include "kvm/util.h" 12 #include "kvm/kvm.h" 13 #include "kvm/builtin-debug.h" 14 #include "kvm/strbuf.h" 15 #include "kvm/kvm-cpu.h" 16 #include "kvm/8250-serial.h" 17 18 struct kvm_ipc_head { 19 u32 type; 20 u32 len; 21 }; 22 23 #define KVM_IPC_MAX_MSGS 16 24 25 #define KVM_SOCK_SUFFIX ".sock" 26 #define KVM_SOCK_SUFFIX_LEN ((ssize_t)sizeof(KVM_SOCK_SUFFIX) - 1) 27 28 extern __thread struct kvm_cpu *current_kvm_cpu; 29 static void (*msgs[KVM_IPC_MAX_MSGS])(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg); 30 static DECLARE_RWSEM(msgs_rwlock); 31 static int epoll_fd, server_fd, stop_fd; 32 static pthread_t thread; 33 34 static int kvm__create_socket(struct kvm *kvm) 35 { 36 char full_name[PATH_MAX]; 37 unsigned int s; 38 struct sockaddr_un local; 39 int len, r; 40 41 /* This usually 108 bytes long */ 42 BUILD_BUG_ON(sizeof(local.sun_path) < 32); 43 44 snprintf(full_name, sizeof(full_name), "%s/%s%s", 45 kvm__get_dir(), kvm->cfg.guest_name, KVM_SOCK_SUFFIX); 46 if (access(full_name, F_OK) == 0) { 47 pr_err("Socket file %s already exist", full_name); 48 return -EEXIST; 49 } 50 51 s = socket(AF_UNIX, SOCK_STREAM, 0); 52 if (s < 0) 53 return s; 54 local.sun_family = AF_UNIX; 55 strlcpy(local.sun_path, full_name, sizeof(local.sun_path)); 56 len = strlen(local.sun_path) + sizeof(local.sun_family); 57 r = bind(s, (struct sockaddr *)&local, len); 58 if (r < 0) 59 goto fail; 60 61 r = listen(s, 5); 62 if (r < 0) 63 goto fail; 64 65 return s; 66 67 fail: 68 close(s); 69 return r; 70 } 71 72 void kvm__remove_socket(const char *name) 73 { 74 char full_name[PATH_MAX]; 75 76 snprintf(full_name, sizeof(full_name), "%s/%s%s", 77 kvm__get_dir(), name, KVM_SOCK_SUFFIX); 78 unlink(full_name); 79 } 80 81 int kvm__get_sock_by_instance(const char *name) 82 { 83 int s, len, r; 84 char sock_file[PATH_MAX]; 85 struct sockaddr_un local; 86 87 snprintf(sock_file, sizeof(sock_file), "%s/%s%s", 88 kvm__get_dir(), name, KVM_SOCK_SUFFIX); 89 s = socket(AF_UNIX, SOCK_STREAM, 0); 90 91 local.sun_family = AF_UNIX; 92 strlcpy(local.sun_path, sock_file, sizeof(local.sun_path)); 93 len = strlen(local.sun_path) + sizeof(local.sun_family); 94 95 r = connect(s, &local, len); 96 if (r < 0 && errno == ECONNREFUSED) { 97 /* Tell the user clean ghost socket file */ 98 pr_err("\"%s\" could be a ghost socket file, please remove it", 99 sock_file); 100 return r; 101 } else if (r < 0) { 102 return r; 103 } 104 105 return s; 106 } 107 108 int kvm__enumerate_instances(int (*callback)(const char *name, int fd)) 109 { 110 int sock; 111 DIR *dir; 112 struct dirent entry, *result; 113 int ret = 0; 114 115 dir = opendir(kvm__get_dir()); 116 if (!dir) 117 return -errno; 118 119 for (;;) { 120 readdir_r(dir, &entry, &result); 121 if (result == NULL) 122 break; 123 if (entry.d_type == DT_SOCK) { 124 ssize_t name_len = strlen(entry.d_name); 125 char *p; 126 127 if (name_len <= KVM_SOCK_SUFFIX_LEN) 128 continue; 129 130 p = &entry.d_name[name_len - KVM_SOCK_SUFFIX_LEN]; 131 if (memcmp(KVM_SOCK_SUFFIX, p, KVM_SOCK_SUFFIX_LEN)) 132 continue; 133 134 *p = 0; 135 sock = kvm__get_sock_by_instance(entry.d_name); 136 if (sock < 0) 137 continue; 138 ret = callback(entry.d_name, sock); 139 close(sock); 140 if (ret < 0) 141 break; 142 } 143 } 144 145 closedir(dir); 146 147 return ret; 148 } 149 150 int kvm_ipc__register_handler(u32 type, void (*cb)(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg)) 151 { 152 if (type >= KVM_IPC_MAX_MSGS) 153 return -ENOSPC; 154 155 down_write(&msgs_rwlock); 156 msgs[type] = cb; 157 up_write(&msgs_rwlock); 158 159 return 0; 160 } 161 162 int kvm_ipc__send(int fd, u32 type) 163 { 164 struct kvm_ipc_head head = {.type = type, .len = 0,}; 165 166 if (write_in_full(fd, &head, sizeof(head)) < 0) 167 return -1; 168 169 return 0; 170 } 171 172 int kvm_ipc__send_msg(int fd, u32 type, u32 len, u8 *msg) 173 { 174 struct kvm_ipc_head head = {.type = type, .len = len,}; 175 176 if (write_in_full(fd, &head, sizeof(head)) < 0) 177 return -1; 178 179 if (write_in_full(fd, msg, len) < 0) 180 return -1; 181 182 return 0; 183 } 184 185 static int kvm_ipc__handle(struct kvm *kvm, int fd, u32 type, u32 len, u8 *data) 186 { 187 void (*cb)(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg); 188 189 if (type >= KVM_IPC_MAX_MSGS) 190 return -ENOSPC; 191 192 down_read(&msgs_rwlock); 193 cb = msgs[type]; 194 up_read(&msgs_rwlock); 195 196 if (cb == NULL) { 197 pr_warning("No device handles type %u\n", type); 198 return -ENODEV; 199 } 200 201 cb(kvm, fd, type, len, data); 202 203 return 0; 204 } 205 206 static int kvm_ipc__new_conn(int fd) 207 { 208 int client; 209 struct epoll_event ev; 210 211 client = accept(fd, NULL, NULL); 212 if (client < 0) 213 return -1; 214 215 ev.events = EPOLLIN | EPOLLRDHUP; 216 ev.data.fd = client; 217 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client, &ev) < 0) { 218 close(client); 219 return -1; 220 } 221 222 return client; 223 } 224 225 static void kvm_ipc__close_conn(int fd) 226 { 227 epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL); 228 close(fd); 229 } 230 231 static int kvm_ipc__receive(struct kvm *kvm, int fd) 232 { 233 struct kvm_ipc_head head; 234 u8 *msg = NULL; 235 u32 n; 236 237 n = read(fd, &head, sizeof(head)); 238 if (n != sizeof(head)) 239 goto done; 240 241 msg = malloc(head.len); 242 if (msg == NULL) 243 goto done; 244 245 n = read_in_full(fd, msg, head.len); 246 if (n != head.len) 247 goto done; 248 249 kvm_ipc__handle(kvm, fd, head.type, head.len, msg); 250 251 return 0; 252 253 done: 254 free(msg); 255 return -1; 256 } 257 258 static void *kvm_ipc__thread(void *param) 259 { 260 struct epoll_event event; 261 struct kvm *kvm = param; 262 263 kvm__set_thread_name("kvm-ipc"); 264 265 for (;;) { 266 int nfds; 267 268 nfds = epoll_wait(epoll_fd, &event, 1, -1); 269 if (nfds > 0) { 270 int fd = event.data.fd; 271 272 if (fd == stop_fd && event.events & EPOLLIN) { 273 break; 274 } else if (fd == server_fd) { 275 int client, r; 276 277 client = kvm_ipc__new_conn(fd); 278 /* 279 * Handle multiple IPC cmd at a time 280 */ 281 do { 282 r = kvm_ipc__receive(kvm, client); 283 } while (r == 0); 284 285 } else if (event.events & (EPOLLERR | EPOLLRDHUP | EPOLLHUP)) { 286 kvm_ipc__close_conn(fd); 287 } else { 288 kvm_ipc__receive(kvm, fd); 289 } 290 } 291 } 292 293 return NULL; 294 } 295 296 static void kvm__pid(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 297 { 298 pid_t pid = getpid(); 299 int r = 0; 300 301 if (type == KVM_IPC_PID) 302 r = write(fd, &pid, sizeof(pid)); 303 304 if (r < 0) 305 pr_warning("Failed sending PID"); 306 } 307 308 static void handle_stop(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 309 { 310 if (WARN_ON(type != KVM_IPC_STOP || len)) 311 return; 312 313 kvm_cpu__reboot(kvm); 314 } 315 316 /* Pause/resume the guest using SIGUSR2 */ 317 static int is_paused; 318 319 static void handle_pause(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 320 { 321 if (WARN_ON(len)) 322 return; 323 324 if (type == KVM_IPC_RESUME && is_paused) { 325 kvm->vm_state = KVM_VMSTATE_RUNNING; 326 kvm__continue(kvm); 327 } else if (type == KVM_IPC_PAUSE && !is_paused) { 328 kvm->vm_state = KVM_VMSTATE_PAUSED; 329 ioctl(kvm->vm_fd, KVM_KVMCLOCK_CTRL); 330 kvm__pause(kvm); 331 } else { 332 return; 333 } 334 335 is_paused = !is_paused; 336 } 337 338 static void handle_vmstate(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 339 { 340 int r = 0; 341 342 if (type == KVM_IPC_VMSTATE) 343 r = write(fd, &kvm->vm_state, sizeof(kvm->vm_state)); 344 345 if (r < 0) 346 pr_warning("Failed sending VMSTATE"); 347 } 348 349 /* 350 * Serialize debug printout so that the output of multiple vcpus does not 351 * get mixed up: 352 */ 353 static int printout_done; 354 355 static void handle_sigusr1(int sig) 356 { 357 struct kvm_cpu *cpu = current_kvm_cpu; 358 int fd = kvm_cpu__get_debug_fd(); 359 360 if (!cpu || cpu->needs_nmi) 361 return; 362 363 dprintf(fd, "\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id); 364 kvm_cpu__show_registers(cpu); 365 kvm_cpu__show_code(cpu); 366 kvm_cpu__show_page_tables(cpu); 367 fflush(stdout); 368 printout_done = 1; 369 } 370 371 static void handle_debug(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 372 { 373 int i; 374 struct debug_cmd_params *params; 375 u32 dbg_type; 376 u32 vcpu; 377 378 if (WARN_ON(type != KVM_IPC_DEBUG || len != sizeof(*params))) 379 return; 380 381 params = (void *)msg; 382 dbg_type = params->dbg_type; 383 vcpu = params->cpu; 384 385 if (dbg_type & KVM_DEBUG_CMD_TYPE_SYSRQ) 386 serial8250__inject_sysrq(kvm, params->sysrq); 387 388 if (dbg_type & KVM_DEBUG_CMD_TYPE_NMI) { 389 if ((int)vcpu >= kvm->nrcpus) 390 return; 391 392 kvm->cpus[vcpu]->needs_nmi = 1; 393 pthread_kill(kvm->cpus[vcpu]->thread, SIGUSR1); 394 } 395 396 if (!(dbg_type & KVM_DEBUG_CMD_TYPE_DUMP)) 397 return; 398 399 for (i = 0; i < kvm->nrcpus; i++) { 400 struct kvm_cpu *cpu = kvm->cpus[i]; 401 402 if (!cpu) 403 continue; 404 405 printout_done = 0; 406 407 kvm_cpu__set_debug_fd(fd); 408 pthread_kill(cpu->thread, SIGUSR1); 409 /* 410 * Wait for the vCPU to dump state before signalling 411 * the next thread. Since this is debug code it does 412 * not matter that we are burning CPU time a bit: 413 */ 414 while (!printout_done) 415 sleep(0); 416 } 417 418 close(fd); 419 420 serial8250__inject_sysrq(kvm, 'p'); 421 } 422 423 int kvm_ipc__init(struct kvm *kvm) 424 { 425 int ret; 426 int sock = kvm__create_socket(kvm); 427 struct epoll_event ev = {0}; 428 429 server_fd = sock; 430 431 epoll_fd = epoll_create(KVM_IPC_MAX_MSGS); 432 if (epoll_fd < 0) { 433 ret = epoll_fd; 434 goto err; 435 } 436 437 ev.events = EPOLLIN | EPOLLET; 438 ev.data.fd = sock; 439 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev) < 0) { 440 pr_err("Failed starting IPC thread"); 441 ret = -EFAULT; 442 goto err_epoll; 443 } 444 445 stop_fd = eventfd(0, 0); 446 if (stop_fd < 0) { 447 ret = stop_fd; 448 goto err_epoll; 449 } 450 451 ev.events = EPOLLIN | EPOLLET; 452 ev.data.fd = stop_fd; 453 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, stop_fd, &ev) < 0) { 454 pr_err("Failed adding stop event to epoll"); 455 ret = -EFAULT; 456 goto err_stop; 457 } 458 459 if (pthread_create(&thread, NULL, kvm_ipc__thread, kvm) != 0) { 460 pr_err("Failed starting IPC thread"); 461 ret = -EFAULT; 462 goto err_stop; 463 } 464 465 kvm_ipc__register_handler(KVM_IPC_PID, kvm__pid); 466 kvm_ipc__register_handler(KVM_IPC_DEBUG, handle_debug); 467 kvm_ipc__register_handler(KVM_IPC_PAUSE, handle_pause); 468 kvm_ipc__register_handler(KVM_IPC_RESUME, handle_pause); 469 kvm_ipc__register_handler(KVM_IPC_STOP, handle_stop); 470 kvm_ipc__register_handler(KVM_IPC_VMSTATE, handle_vmstate); 471 signal(SIGUSR1, handle_sigusr1); 472 473 return 0; 474 475 err_stop: 476 close(stop_fd); 477 err_epoll: 478 close(epoll_fd); 479 err: 480 return ret; 481 } 482 base_init(kvm_ipc__init); 483 484 int kvm_ipc__exit(struct kvm *kvm) 485 { 486 u64 val = 1; 487 int ret; 488 489 ret = write(stop_fd, &val, sizeof(val)); 490 if (ret < 0) 491 return ret; 492 493 close(server_fd); 494 close(epoll_fd); 495 496 kvm__remove_socket(kvm->cfg.guest_name); 497 498 return ret; 499 } 500 base_exit(kvm_ipc__exit); 501