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