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