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 for (;;) { 264 int nfds; 265 266 nfds = epoll_wait(epoll_fd, &event, 1, -1); 267 if (nfds > 0) { 268 int fd = event.data.fd; 269 270 if (fd == stop_fd && event.events & EPOLLIN) { 271 break; 272 } else if (fd == server_fd) { 273 int client, r; 274 275 client = kvm_ipc__new_conn(fd); 276 /* 277 * Handle multiple IPC cmd at a time 278 */ 279 do { 280 r = kvm_ipc__receive(kvm, client); 281 } while (r == 0); 282 283 } else if (event.events & (EPOLLERR | EPOLLRDHUP | EPOLLHUP)) { 284 kvm_ipc__close_conn(fd); 285 } else { 286 kvm_ipc__receive(kvm, fd); 287 } 288 } 289 } 290 291 return NULL; 292 } 293 294 static void kvm__pid(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 295 { 296 pid_t pid = getpid(); 297 int r = 0; 298 299 if (type == KVM_IPC_PID) 300 r = write(fd, &pid, sizeof(pid)); 301 302 if (r < 0) 303 pr_warning("Failed sending PID"); 304 } 305 306 static void handle_stop(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 307 { 308 if (WARN_ON(type != KVM_IPC_STOP || len)) 309 return; 310 311 kvm_cpu__reboot(kvm); 312 } 313 314 /* Pause/resume the guest using SIGUSR2 */ 315 static int is_paused; 316 317 static void handle_pause(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 318 { 319 if (WARN_ON(len)) 320 return; 321 322 if (type == KVM_IPC_RESUME && is_paused) { 323 kvm->vm_state = KVM_VMSTATE_RUNNING; 324 kvm__continue(kvm); 325 } else if (type == KVM_IPC_PAUSE && !is_paused) { 326 kvm->vm_state = KVM_VMSTATE_PAUSED; 327 ioctl(kvm->vm_fd, KVM_KVMCLOCK_CTRL); 328 kvm__pause(kvm); 329 } else { 330 return; 331 } 332 333 is_paused = !is_paused; 334 } 335 336 static void handle_vmstate(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 337 { 338 int r = 0; 339 340 if (type == KVM_IPC_VMSTATE) 341 r = write(fd, &kvm->vm_state, sizeof(kvm->vm_state)); 342 343 if (r < 0) 344 pr_warning("Failed sending VMSTATE"); 345 } 346 347 /* 348 * Serialize debug printout so that the output of multiple vcpus does not 349 * get mixed up: 350 */ 351 static int printout_done; 352 353 static void handle_sigusr1(int sig) 354 { 355 struct kvm_cpu *cpu = current_kvm_cpu; 356 int fd = kvm_cpu__get_debug_fd(); 357 358 if (!cpu || cpu->needs_nmi) 359 return; 360 361 dprintf(fd, "\n #\n # vCPU #%ld's dump:\n #\n", cpu->cpu_id); 362 kvm_cpu__show_registers(cpu); 363 kvm_cpu__show_code(cpu); 364 kvm_cpu__show_page_tables(cpu); 365 fflush(stdout); 366 printout_done = 1; 367 } 368 369 static void handle_debug(struct kvm *kvm, int fd, u32 type, u32 len, u8 *msg) 370 { 371 int i; 372 struct debug_cmd_params *params; 373 u32 dbg_type; 374 u32 vcpu; 375 376 if (WARN_ON(type != KVM_IPC_DEBUG || len != sizeof(*params))) 377 return; 378 379 params = (void *)msg; 380 dbg_type = params->dbg_type; 381 vcpu = params->cpu; 382 383 if (dbg_type & KVM_DEBUG_CMD_TYPE_SYSRQ) 384 serial8250__inject_sysrq(kvm, params->sysrq); 385 386 if (dbg_type & KVM_DEBUG_CMD_TYPE_NMI) { 387 if ((int)vcpu >= kvm->nrcpus) 388 return; 389 390 kvm->cpus[vcpu]->needs_nmi = 1; 391 pthread_kill(kvm->cpus[vcpu]->thread, SIGUSR1); 392 } 393 394 if (!(dbg_type & KVM_DEBUG_CMD_TYPE_DUMP)) 395 return; 396 397 for (i = 0; i < kvm->nrcpus; i++) { 398 struct kvm_cpu *cpu = kvm->cpus[i]; 399 400 if (!cpu) 401 continue; 402 403 printout_done = 0; 404 405 kvm_cpu__set_debug_fd(fd); 406 pthread_kill(cpu->thread, SIGUSR1); 407 /* 408 * Wait for the vCPU to dump state before signalling 409 * the next thread. Since this is debug code it does 410 * not matter that we are burning CPU time a bit: 411 */ 412 while (!printout_done) 413 sleep(0); 414 } 415 416 close(fd); 417 418 serial8250__inject_sysrq(kvm, 'p'); 419 } 420 421 int kvm_ipc__init(struct kvm *kvm) 422 { 423 int ret; 424 int sock = kvm__create_socket(kvm); 425 struct epoll_event ev = {0}; 426 427 server_fd = sock; 428 429 epoll_fd = epoll_create(KVM_IPC_MAX_MSGS); 430 if (epoll_fd < 0) { 431 ret = epoll_fd; 432 goto err; 433 } 434 435 ev.events = EPOLLIN | EPOLLET; 436 ev.data.fd = sock; 437 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sock, &ev) < 0) { 438 pr_err("Failed starting IPC thread"); 439 ret = -EFAULT; 440 goto err_epoll; 441 } 442 443 stop_fd = eventfd(0, 0); 444 if (stop_fd < 0) { 445 ret = stop_fd; 446 goto err_epoll; 447 } 448 449 ev.events = EPOLLIN | EPOLLET; 450 ev.data.fd = stop_fd; 451 if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, stop_fd, &ev) < 0) { 452 pr_err("Failed adding stop event to epoll"); 453 ret = -EFAULT; 454 goto err_stop; 455 } 456 457 if (pthread_create(&thread, NULL, kvm_ipc__thread, kvm) != 0) { 458 pr_err("Failed starting IPC thread"); 459 ret = -EFAULT; 460 goto err_stop; 461 } 462 463 kvm_ipc__register_handler(KVM_IPC_PID, kvm__pid); 464 kvm_ipc__register_handler(KVM_IPC_DEBUG, handle_debug); 465 kvm_ipc__register_handler(KVM_IPC_PAUSE, handle_pause); 466 kvm_ipc__register_handler(KVM_IPC_RESUME, handle_pause); 467 kvm_ipc__register_handler(KVM_IPC_STOP, handle_stop); 468 kvm_ipc__register_handler(KVM_IPC_VMSTATE, handle_vmstate); 469 signal(SIGUSR1, handle_sigusr1); 470 471 return 0; 472 473 err_stop: 474 close(stop_fd); 475 err_epoll: 476 close(epoll_fd); 477 err: 478 return ret; 479 } 480 base_init(kvm_ipc__init); 481 482 int kvm_ipc__exit(struct kvm *kvm) 483 { 484 u64 val = 1; 485 int ret; 486 487 ret = write(stop_fd, &val, sizeof(val)); 488 if (ret < 0) 489 return ret; 490 491 close(server_fd); 492 close(epoll_fd); 493 494 kvm__remove_socket(kvm->cfg.guest_name); 495 496 return ret; 497 } 498 base_exit(kvm_ipc__exit); 499