1 /* 2 * os-posix-lib.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010 Red Hat, Inc. 6 * 7 * QEMU library functions on POSIX which are shared between QEMU and 8 * the QEMU tools. 9 * 10 * Permission is hereby granted, free of charge, to any person obtaining a copy 11 * of this software and associated documentation files (the "Software"), to deal 12 * in the Software without restriction, including without limitation the rights 13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 * copies of the Software, and to permit persons to whom the Software is 15 * furnished to do so, subject to the following conditions: 16 * 17 * The above copyright notice and this permission notice shall be included in 18 * all copies or substantial portions of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 * THE SOFTWARE. 27 */ 28 29 #if defined(__linux__) && (defined(__x86_64__) || defined(__arm__)) 30 /* Use 2 MiB alignment so transparent hugepages can be used by KVM. 31 Valgrind does not support alignments larger than 1 MiB, 32 therefore we need special code which handles running on Valgrind. */ 33 # define QEMU_VMALLOC_ALIGN (512 * 4096) 34 #elif defined(__linux__) && defined(__s390x__) 35 /* Use 1 MiB (segment size) alignment so gmap can be used by KVM. */ 36 # define QEMU_VMALLOC_ALIGN (256 * 4096) 37 #else 38 # define QEMU_VMALLOC_ALIGN getpagesize() 39 #endif 40 41 #include "qemu/osdep.h" 42 #include <termios.h> 43 #include <termios.h> 44 45 #include <glib/gprintf.h> 46 47 #include "sysemu/sysemu.h" 48 #include "trace.h" 49 #include "qemu/sockets.h" 50 #include <sys/mman.h> 51 #include <libgen.h> 52 #include <setjmp.h> 53 #include <sys/signal.h> 54 55 #ifdef CONFIG_LINUX 56 #include <sys/syscall.h> 57 #endif 58 59 #ifdef __FreeBSD__ 60 #include <sys/sysctl.h> 61 #endif 62 63 #include <qemu/mmap-alloc.h> 64 65 int qemu_get_thread_id(void) 66 { 67 #if defined(__linux__) 68 return syscall(SYS_gettid); 69 #else 70 return getpid(); 71 #endif 72 } 73 74 int qemu_daemon(int nochdir, int noclose) 75 { 76 return daemon(nochdir, noclose); 77 } 78 79 void *qemu_oom_check(void *ptr) 80 { 81 if (ptr == NULL) { 82 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno)); 83 abort(); 84 } 85 return ptr; 86 } 87 88 void *qemu_try_memalign(size_t alignment, size_t size) 89 { 90 void *ptr; 91 92 if (alignment < sizeof(void*)) { 93 alignment = sizeof(void*); 94 } 95 96 #if defined(_POSIX_C_SOURCE) && !defined(__sun__) 97 int ret; 98 ret = posix_memalign(&ptr, alignment, size); 99 if (ret != 0) { 100 errno = ret; 101 ptr = NULL; 102 } 103 #elif defined(CONFIG_BSD) 104 ptr = valloc(size); 105 #else 106 ptr = memalign(alignment, size); 107 #endif 108 trace_qemu_memalign(alignment, size, ptr); 109 return ptr; 110 } 111 112 void *qemu_memalign(size_t alignment, size_t size) 113 { 114 return qemu_oom_check(qemu_try_memalign(alignment, size)); 115 } 116 117 /* alloc shared memory pages */ 118 void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment) 119 { 120 size_t align = QEMU_VMALLOC_ALIGN; 121 void *ptr = qemu_ram_mmap(-1, size, align, false); 122 123 if (ptr == MAP_FAILED) { 124 return NULL; 125 } 126 127 if (alignment) { 128 *alignment = align; 129 } 130 131 trace_qemu_anon_ram_alloc(size, ptr); 132 return ptr; 133 } 134 135 void qemu_vfree(void *ptr) 136 { 137 trace_qemu_vfree(ptr); 138 free(ptr); 139 } 140 141 void qemu_anon_ram_free(void *ptr, size_t size) 142 { 143 trace_qemu_anon_ram_free(ptr, size); 144 qemu_ram_munmap(ptr, size); 145 } 146 147 void qemu_set_block(int fd) 148 { 149 int f; 150 f = fcntl(fd, F_GETFL); 151 fcntl(fd, F_SETFL, f & ~O_NONBLOCK); 152 } 153 154 void qemu_set_nonblock(int fd) 155 { 156 int f; 157 f = fcntl(fd, F_GETFL); 158 fcntl(fd, F_SETFL, f | O_NONBLOCK); 159 } 160 161 int socket_set_fast_reuse(int fd) 162 { 163 int val = 1, ret; 164 165 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 166 (const char *)&val, sizeof(val)); 167 168 assert(ret == 0); 169 170 return ret; 171 } 172 173 void qemu_set_cloexec(int fd) 174 { 175 int f; 176 f = fcntl(fd, F_GETFD); 177 fcntl(fd, F_SETFD, f | FD_CLOEXEC); 178 } 179 180 /* 181 * Creates a pipe with FD_CLOEXEC set on both file descriptors 182 */ 183 int qemu_pipe(int pipefd[2]) 184 { 185 int ret; 186 187 #ifdef CONFIG_PIPE2 188 ret = pipe2(pipefd, O_CLOEXEC); 189 if (ret != -1 || errno != ENOSYS) { 190 return ret; 191 } 192 #endif 193 ret = pipe(pipefd); 194 if (ret == 0) { 195 qemu_set_cloexec(pipefd[0]); 196 qemu_set_cloexec(pipefd[1]); 197 } 198 199 return ret; 200 } 201 202 int qemu_utimens(const char *path, const struct timespec *times) 203 { 204 struct timeval tv[2], tv_now; 205 struct stat st; 206 int i; 207 #ifdef CONFIG_UTIMENSAT 208 int ret; 209 210 ret = utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW); 211 if (ret != -1 || errno != ENOSYS) { 212 return ret; 213 } 214 #endif 215 /* Fallback: use utimes() instead of utimensat() */ 216 217 /* happy if special cases */ 218 if (times[0].tv_nsec == UTIME_OMIT && times[1].tv_nsec == UTIME_OMIT) { 219 return 0; 220 } 221 if (times[0].tv_nsec == UTIME_NOW && times[1].tv_nsec == UTIME_NOW) { 222 return utimes(path, NULL); 223 } 224 225 /* prepare for hard cases */ 226 if (times[0].tv_nsec == UTIME_NOW || times[1].tv_nsec == UTIME_NOW) { 227 gettimeofday(&tv_now, NULL); 228 } 229 if (times[0].tv_nsec == UTIME_OMIT || times[1].tv_nsec == UTIME_OMIT) { 230 stat(path, &st); 231 } 232 233 for (i = 0; i < 2; i++) { 234 if (times[i].tv_nsec == UTIME_NOW) { 235 tv[i].tv_sec = tv_now.tv_sec; 236 tv[i].tv_usec = tv_now.tv_usec; 237 } else if (times[i].tv_nsec == UTIME_OMIT) { 238 tv[i].tv_sec = (i == 0) ? st.st_atime : st.st_mtime; 239 tv[i].tv_usec = 0; 240 } else { 241 tv[i].tv_sec = times[i].tv_sec; 242 tv[i].tv_usec = times[i].tv_nsec / 1000; 243 } 244 } 245 246 return utimes(path, &tv[0]); 247 } 248 249 char * 250 qemu_get_local_state_pathname(const char *relative_pathname) 251 { 252 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR, 253 relative_pathname); 254 } 255 256 void qemu_set_tty_echo(int fd, bool echo) 257 { 258 struct termios tty; 259 260 tcgetattr(fd, &tty); 261 262 if (echo) { 263 tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN; 264 } else { 265 tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN); 266 } 267 268 tcsetattr(fd, TCSANOW, &tty); 269 } 270 271 static char exec_dir[PATH_MAX]; 272 273 void qemu_init_exec_dir(const char *argv0) 274 { 275 char *dir; 276 char *p = NULL; 277 char buf[PATH_MAX]; 278 279 assert(!exec_dir[0]); 280 281 #if defined(__linux__) 282 { 283 int len; 284 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); 285 if (len > 0) { 286 buf[len] = 0; 287 p = buf; 288 } 289 } 290 #elif defined(__FreeBSD__) 291 { 292 static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1}; 293 size_t len = sizeof(buf) - 1; 294 295 *buf = '\0'; 296 if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) && 297 *buf) { 298 buf[sizeof(buf) - 1] = '\0'; 299 p = buf; 300 } 301 } 302 #endif 303 /* If we don't have any way of figuring out the actual executable 304 location then try argv[0]. */ 305 if (!p) { 306 if (!argv0) { 307 return; 308 } 309 p = realpath(argv0, buf); 310 if (!p) { 311 return; 312 } 313 } 314 dir = dirname(p); 315 316 pstrcpy(exec_dir, sizeof(exec_dir), dir); 317 } 318 319 char *qemu_get_exec_dir(void) 320 { 321 return g_strdup(exec_dir); 322 } 323 324 static sigjmp_buf sigjump; 325 326 static void sigbus_handler(int signal) 327 { 328 siglongjmp(sigjump, 1); 329 } 330 331 void os_mem_prealloc(int fd, char *area, size_t memory) 332 { 333 int ret; 334 struct sigaction act, oldact; 335 sigset_t set, oldset; 336 337 memset(&act, 0, sizeof(act)); 338 act.sa_handler = &sigbus_handler; 339 act.sa_flags = 0; 340 341 ret = sigaction(SIGBUS, &act, &oldact); 342 if (ret) { 343 perror("os_mem_prealloc: failed to install signal handler"); 344 exit(1); 345 } 346 347 /* unblock SIGBUS */ 348 sigemptyset(&set); 349 sigaddset(&set, SIGBUS); 350 pthread_sigmask(SIG_UNBLOCK, &set, &oldset); 351 352 if (sigsetjmp(sigjump, 1)) { 353 fprintf(stderr, "os_mem_prealloc: Insufficient free host memory " 354 "pages available to allocate guest RAM\n"); 355 exit(1); 356 } else { 357 int i; 358 size_t hpagesize = qemu_fd_getpagesize(fd); 359 size_t numpages = DIV_ROUND_UP(memory, hpagesize); 360 361 /* MAP_POPULATE silently ignores failures */ 362 for (i = 0; i < numpages; i++) { 363 memset(area + (hpagesize * i), 0, 1); 364 } 365 366 ret = sigaction(SIGBUS, &oldact, NULL); 367 if (ret) { 368 perror("os_mem_prealloc: failed to reinstall signal handler"); 369 exit(1); 370 } 371 372 pthread_sigmask(SIG_SETMASK, &oldset, NULL); 373 } 374 } 375 376 377 static struct termios oldtty; 378 379 static void term_exit(void) 380 { 381 tcsetattr(0, TCSANOW, &oldtty); 382 } 383 384 static void term_init(void) 385 { 386 struct termios tty; 387 388 tcgetattr(0, &tty); 389 oldtty = tty; 390 391 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP 392 |INLCR|IGNCR|ICRNL|IXON); 393 tty.c_oflag |= OPOST; 394 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN); 395 tty.c_cflag &= ~(CSIZE|PARENB); 396 tty.c_cflag |= CS8; 397 tty.c_cc[VMIN] = 1; 398 tty.c_cc[VTIME] = 0; 399 400 tcsetattr(0, TCSANOW, &tty); 401 402 atexit(term_exit); 403 } 404 405 int qemu_read_password(char *buf, int buf_size) 406 { 407 uint8_t ch; 408 int i, ret; 409 410 printf("password: "); 411 fflush(stdout); 412 term_init(); 413 i = 0; 414 for (;;) { 415 ret = read(0, &ch, 1); 416 if (ret == -1) { 417 if (errno == EAGAIN || errno == EINTR) { 418 continue; 419 } else { 420 break; 421 } 422 } else if (ret == 0) { 423 ret = -1; 424 break; 425 } else { 426 if (ch == '\r' || 427 ch == '\n') { 428 ret = 0; 429 break; 430 } 431 if (i < (buf_size - 1)) { 432 buf[i++] = ch; 433 } 434 } 435 } 436 term_exit(); 437 buf[i] = '\0'; 438 printf("\n"); 439 return ret; 440 } 441 442 443 pid_t qemu_fork(Error **errp) 444 { 445 sigset_t oldmask, newmask; 446 struct sigaction sig_action; 447 int saved_errno; 448 pid_t pid; 449 450 /* 451 * Need to block signals now, so that child process can safely 452 * kill off caller's signal handlers without a race. 453 */ 454 sigfillset(&newmask); 455 if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) { 456 error_setg_errno(errp, errno, 457 "cannot block signals"); 458 return -1; 459 } 460 461 pid = fork(); 462 saved_errno = errno; 463 464 if (pid < 0) { 465 /* attempt to restore signal mask, but ignore failure, to 466 * avoid obscuring the fork failure */ 467 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL); 468 error_setg_errno(errp, saved_errno, 469 "cannot fork child process"); 470 errno = saved_errno; 471 return -1; 472 } else if (pid) { 473 /* parent process */ 474 475 /* Restore our original signal mask now that the child is 476 * safely running. Only documented failures are EFAULT (not 477 * possible, since we are using just-grabbed mask) or EINVAL 478 * (not possible, since we are using correct arguments). */ 479 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL); 480 } else { 481 /* child process */ 482 size_t i; 483 484 /* Clear out all signal handlers from parent so nothing 485 * unexpected can happen in our child once we unblock 486 * signals */ 487 sig_action.sa_handler = SIG_DFL; 488 sig_action.sa_flags = 0; 489 sigemptyset(&sig_action.sa_mask); 490 491 for (i = 1; i < NSIG; i++) { 492 /* Only possible errors are EFAULT or EINVAL The former 493 * won't happen, the latter we expect, so no need to check 494 * return value */ 495 (void)sigaction(i, &sig_action, NULL); 496 } 497 498 /* Unmask all signals in child, since we've no idea what the 499 * caller's done with their signal mask and don't want to 500 * propagate that to children */ 501 sigemptyset(&newmask); 502 if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) { 503 Error *local_err = NULL; 504 error_setg_errno(&local_err, errno, 505 "cannot unblock signals"); 506 error_report_err(local_err); 507 _exit(1); 508 } 509 } 510 return pid; 511 } 512