]>
Commit | Line | Data |
---|---|---|
c1b0b93b JS |
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 | ||
f97742d0 AR |
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 | ||
2e07b297 | 38 | #if defined(__linux__) && (defined(__x86_64__) || defined(__arm__)) |
c2a8238a SW |
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. */ | |
36b58628 | 42 | # define QEMU_VMALLOC_ALIGN (512 * 4096) |
c2a8238a | 43 | # define CONFIG_VALGRIND |
fdec9918 CB |
44 | #elif defined(__linux__) && defined(__s390x__) |
45 | /* Use 1 MiB (segment size) alignment so gmap can be used by KVM. */ | |
46 | # define QEMU_VMALLOC_ALIGN (256 * 4096) | |
36b58628 AK |
47 | #else |
48 | # define QEMU_VMALLOC_ALIGN getpagesize() | |
49 | #endif | |
50 | ||
c1b0b93b | 51 | #include "config-host.h" |
9c17d615 | 52 | #include "sysemu/sysemu.h" |
c1b0b93b | 53 | #include "trace.h" |
1de7afc9 | 54 | #include "qemu/sockets.h" |
c1b0b93b | 55 | |
c2a8238a SW |
56 | #if defined(CONFIG_VALGRIND) |
57 | static int running_on_valgrind = -1; | |
58 | #else | |
59 | # define running_on_valgrind 0 | |
60 | #endif | |
cbcfa041 PB |
61 | #ifdef CONFIG_LINUX |
62 | #include <sys/syscall.h> | |
63 | #endif | |
cbcfa041 PB |
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 | } | |
f97742d0 AR |
73 | |
74 | int qemu_daemon(int nochdir, int noclose) | |
75 | { | |
76 | return daemon(nochdir, noclose); | |
77 | } | |
78 | ||
b152aa84 | 79 | void *qemu_oom_check(void *ptr) |
c1b0b93b JS |
80 | { |
81 | if (ptr == NULL) { | |
82 | fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno)); | |
83 | abort(); | |
84 | } | |
85 | return ptr; | |
86 | } | |
c1b0b93b JS |
87 | |
88 | void *qemu_memalign(size_t alignment, size_t size) | |
89 | { | |
90 | void *ptr; | |
91 | #if defined(_POSIX_C_SOURCE) && !defined(__sun__) | |
92 | int ret; | |
93 | ret = posix_memalign(&ptr, alignment, size); | |
94 | if (ret != 0) { | |
95 | fprintf(stderr, "Failed to allocate %zu B: %s\n", | |
96 | size, strerror(ret)); | |
97 | abort(); | |
98 | } | |
99 | #elif defined(CONFIG_BSD) | |
b152aa84 | 100 | ptr = qemu_oom_check(valloc(size)); |
c1b0b93b | 101 | #else |
b152aa84 | 102 | ptr = qemu_oom_check(memalign(alignment, size)); |
c1b0b93b JS |
103 | #endif |
104 | trace_qemu_memalign(alignment, size, ptr); | |
105 | return ptr; | |
106 | } | |
107 | ||
108 | /* alloc shared memory pages */ | |
109 | void *qemu_vmalloc(size_t size) | |
110 | { | |
c7f4111a | 111 | void *ptr; |
36b58628 AK |
112 | size_t align = QEMU_VMALLOC_ALIGN; |
113 | ||
c2a8238a SW |
114 | #if defined(CONFIG_VALGRIND) |
115 | if (running_on_valgrind < 0) { | |
116 | /* First call, test whether we are running on Valgrind. | |
117 | This is a substitute for RUNNING_ON_VALGRIND from valgrind.h. */ | |
118 | const char *ld = getenv("LD_PRELOAD"); | |
119 | running_on_valgrind = (ld != NULL && strstr(ld, "vgpreload")); | |
120 | } | |
121 | #endif | |
122 | ||
123 | if (size < align || running_on_valgrind) { | |
36b58628 AK |
124 | align = getpagesize(); |
125 | } | |
126 | ptr = qemu_memalign(align, size); | |
c7f4111a JS |
127 | trace_qemu_vmalloc(size, ptr); |
128 | return ptr; | |
c1b0b93b JS |
129 | } |
130 | ||
131 | void qemu_vfree(void *ptr) | |
132 | { | |
133 | trace_qemu_vfree(ptr); | |
134 | free(ptr); | |
135 | } | |
9549e764 | 136 | |
154b9a0c PB |
137 | void socket_set_block(int fd) |
138 | { | |
139 | int f; | |
140 | f = fcntl(fd, F_GETFL); | |
141 | fcntl(fd, F_SETFL, f & ~O_NONBLOCK); | |
142 | } | |
143 | ||
9549e764 JS |
144 | void socket_set_nonblock(int fd) |
145 | { | |
146 | int f; | |
147 | f = fcntl(fd, F_GETFL); | |
148 | fcntl(fd, F_SETFL, f | O_NONBLOCK); | |
149 | } | |
150 | ||
151 | void qemu_set_cloexec(int fd) | |
152 | { | |
153 | int f; | |
154 | f = fcntl(fd, F_GETFD); | |
155 | fcntl(fd, F_SETFD, f | FD_CLOEXEC); | |
156 | } | |
70e72ce4 JS |
157 | |
158 | /* | |
159 | * Creates a pipe with FD_CLOEXEC set on both file descriptors | |
160 | */ | |
161 | int qemu_pipe(int pipefd[2]) | |
162 | { | |
163 | int ret; | |
164 | ||
165 | #ifdef CONFIG_PIPE2 | |
166 | ret = pipe2(pipefd, O_CLOEXEC); | |
167 | if (ret != -1 || errno != ENOSYS) { | |
168 | return ret; | |
169 | } | |
170 | #endif | |
171 | ret = pipe(pipefd); | |
172 | if (ret == 0) { | |
173 | qemu_set_cloexec(pipefd[0]); | |
174 | qemu_set_cloexec(pipefd[1]); | |
175 | } | |
176 | ||
177 | return ret; | |
178 | } | |
38671423 | 179 | |
ae0f940e | 180 | int qemu_utimens(const char *path, const struct timespec *times) |
38671423 HS |
181 | { |
182 | struct timeval tv[2], tv_now; | |
183 | struct stat st; | |
184 | int i; | |
185 | #ifdef CONFIG_UTIMENSAT | |
186 | int ret; | |
187 | ||
ae0f940e | 188 | ret = utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW); |
38671423 HS |
189 | if (ret != -1 || errno != ENOSYS) { |
190 | return ret; | |
191 | } | |
192 | #endif | |
193 | /* Fallback: use utimes() instead of utimensat() */ | |
194 | ||
195 | /* happy if special cases */ | |
196 | if (times[0].tv_nsec == UTIME_OMIT && times[1].tv_nsec == UTIME_OMIT) { | |
197 | return 0; | |
198 | } | |
199 | if (times[0].tv_nsec == UTIME_NOW && times[1].tv_nsec == UTIME_NOW) { | |
200 | return utimes(path, NULL); | |
201 | } | |
202 | ||
203 | /* prepare for hard cases */ | |
204 | if (times[0].tv_nsec == UTIME_NOW || times[1].tv_nsec == UTIME_NOW) { | |
205 | gettimeofday(&tv_now, NULL); | |
206 | } | |
207 | if (times[0].tv_nsec == UTIME_OMIT || times[1].tv_nsec == UTIME_OMIT) { | |
208 | stat(path, &st); | |
209 | } | |
210 | ||
211 | for (i = 0; i < 2; i++) { | |
212 | if (times[i].tv_nsec == UTIME_NOW) { | |
213 | tv[i].tv_sec = tv_now.tv_sec; | |
214 | tv[i].tv_usec = tv_now.tv_usec; | |
215 | } else if (times[i].tv_nsec == UTIME_OMIT) { | |
216 | tv[i].tv_sec = (i == 0) ? st.st_atime : st.st_mtime; | |
217 | tv[i].tv_usec = 0; | |
218 | } else { | |
219 | tv[i].tv_sec = times[i].tv_sec; | |
220 | tv[i].tv_usec = times[i].tv_nsec / 1000; | |
221 | } | |
222 | } | |
223 | ||
224 | return utimes(path, &tv[0]); | |
225 | } |