xref: /qemu/util/oslib-posix.c (revision 75fb3d28) 
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