eepro100: Keep includes sorted
[qemu.git] / osdep.c
blob5bf3c00fd115cd683f665bb1af670c59fab7b8b6
1 /*
2 * QEMU low level functions
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <unistd.h>
30 #include <fcntl.h>
32 /* Needed early for CONFIG_BSD etc. */
33 #include "config-host.h"
35 #ifdef CONFIG_SOLARIS
36 #include <sys/types.h>
37 #include <sys/statvfs.h>
38 #endif
40 #ifdef CONFIG_EVENTFD
41 #include <sys/eventfd.h>
42 #endif
44 #ifdef _WIN32
45 #include <windows.h>
46 #elif defined(CONFIG_BSD)
47 #include <stdlib.h>
48 #else
49 #include <malloc.h>
50 #endif
52 #include "qemu-common.h"
53 #include "sysemu.h"
54 #include "qemu_socket.h"
56 #if !defined(_POSIX_C_SOURCE) || defined(_WIN32) || defined(__sun__)
57 static void *oom_check(void *ptr)
59 if (ptr == NULL) {
60 #if defined(_WIN32)
61 fprintf(stderr, "Failed to allocate memory: %lu\n", GetLastError());
62 #else
63 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
64 #endif
65 abort();
67 return ptr;
69 #endif
71 #if defined(_WIN32)
72 void *qemu_memalign(size_t alignment, size_t size)
74 if (!size) {
75 abort();
77 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
80 void *qemu_vmalloc(size_t size)
82 /* FIXME: this is not exactly optimal solution since VirtualAlloc
83 has 64Kb granularity, but at least it guarantees us that the
84 memory is page aligned. */
85 if (!size) {
86 abort();
88 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
91 void qemu_vfree(void *ptr)
93 VirtualFree(ptr, 0, MEM_RELEASE);
96 #else
98 void *qemu_memalign(size_t alignment, size_t size)
100 #if defined(_POSIX_C_SOURCE) && !defined(__sun__)
101 int ret;
102 void *ptr;
103 ret = posix_memalign(&ptr, alignment, size);
104 if (ret != 0) {
105 fprintf(stderr, "Failed to allocate %zu B: %s\n",
106 size, strerror(ret));
107 abort();
109 return ptr;
110 #elif defined(CONFIG_BSD)
111 return oom_check(valloc(size));
112 #else
113 return oom_check(memalign(alignment, size));
114 #endif
117 /* alloc shared memory pages */
118 void *qemu_vmalloc(size_t size)
120 return qemu_memalign(getpagesize(), size);
123 void qemu_vfree(void *ptr)
125 free(ptr);
128 #endif
130 int qemu_create_pidfile(const char *filename)
132 char buffer[128];
133 int len;
134 #ifndef _WIN32
135 int fd;
137 fd = qemu_open(filename, O_RDWR | O_CREAT, 0600);
138 if (fd == -1)
139 return -1;
141 if (lockf(fd, F_TLOCK, 0) == -1)
142 return -1;
144 len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
145 if (write(fd, buffer, len) != len)
146 return -1;
147 #else
148 HANDLE file;
149 OVERLAPPED overlap;
150 BOOL ret;
151 memset(&overlap, 0, sizeof(overlap));
153 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
154 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
156 if (file == INVALID_HANDLE_VALUE)
157 return -1;
159 len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
160 ret = WriteFileEx(file, (LPCVOID)buffer, (DWORD)len,
161 &overlap, NULL);
162 if (ret == 0)
163 return -1;
164 #endif
165 return 0;
168 #ifdef _WIN32
170 /* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
171 #define _W32_FT_OFFSET (116444736000000000ULL)
173 int qemu_gettimeofday(qemu_timeval *tp)
175 union {
176 unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */
177 FILETIME ft;
178 } _now;
180 if(tp)
182 GetSystemTimeAsFileTime (&_now.ft);
183 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL );
184 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL);
186 /* Always return 0 as per Open Group Base Specifications Issue 6.
187 Do not set errno on error. */
188 return 0;
190 #endif /* _WIN32 */
193 #ifdef _WIN32
194 void socket_set_nonblock(int fd)
196 unsigned long opt = 1;
197 ioctlsocket(fd, FIONBIO, &opt);
200 int inet_aton(const char *cp, struct in_addr *ia)
202 uint32_t addr = inet_addr(cp);
203 if (addr == 0xffffffff)
204 return 0;
205 ia->s_addr = addr;
206 return 1;
209 void qemu_set_cloexec(int fd)
213 #else
215 void socket_set_nonblock(int fd)
217 int f;
218 f = fcntl(fd, F_GETFL);
219 fcntl(fd, F_SETFL, f | O_NONBLOCK);
222 void qemu_set_cloexec(int fd)
224 int f;
225 f = fcntl(fd, F_GETFD);
226 fcntl(fd, F_SETFD, f | FD_CLOEXEC);
229 #endif
232 * Opens a file with FD_CLOEXEC set
234 int qemu_open(const char *name, int flags, ...)
236 int ret;
237 int mode = 0;
239 if (flags & O_CREAT) {
240 va_list ap;
242 va_start(ap, flags);
243 mode = va_arg(ap, int);
244 va_end(ap);
247 #ifdef O_CLOEXEC
248 ret = open(name, flags | O_CLOEXEC, mode);
249 #else
250 ret = open(name, flags, mode);
251 if (ret >= 0) {
252 qemu_set_cloexec(ret);
254 #endif
256 return ret;
260 * A variant of write(2) which handles partial write.
262 * Return the number of bytes transferred.
263 * Set errno if fewer than `count' bytes are written.
265 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
267 ssize_t ret = 0;
268 ssize_t total = 0;
270 while (count) {
271 ret = write(fd, buf, count);
272 if (ret < 0) {
273 if (errno == EINTR)
274 continue;
275 break;
278 count -= ret;
279 buf += ret;
280 total += ret;
283 return total;
286 #ifndef _WIN32
288 * Creates an eventfd that looks like a pipe and has EFD_CLOEXEC set.
290 int qemu_eventfd(int fds[2])
292 #ifdef CONFIG_EVENTFD
293 int ret;
295 ret = eventfd(0, 0);
296 if (ret >= 0) {
297 fds[0] = ret;
298 qemu_set_cloexec(ret);
299 if ((fds[1] = dup(ret)) == -1) {
300 close(ret);
301 return -1;
303 qemu_set_cloexec(fds[1]);
304 return 0;
307 if (errno != ENOSYS) {
308 return -1;
310 #endif
312 return qemu_pipe(fds);
316 * Creates a pipe with FD_CLOEXEC set on both file descriptors
318 int qemu_pipe(int pipefd[2])
320 int ret;
322 #ifdef CONFIG_PIPE2
323 ret = pipe2(pipefd, O_CLOEXEC);
324 if (ret != -1 || errno != ENOSYS) {
325 return ret;
327 #endif
328 ret = pipe(pipefd);
329 if (ret == 0) {
330 qemu_set_cloexec(pipefd[0]);
331 qemu_set_cloexec(pipefd[1]);
334 return ret;
336 #endif
339 * Opens a socket with FD_CLOEXEC set
341 int qemu_socket(int domain, int type, int protocol)
343 int ret;
345 #ifdef SOCK_CLOEXEC
346 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
347 if (ret != -1 || errno != EINVAL) {
348 return ret;
350 #endif
351 ret = socket(domain, type, protocol);
352 if (ret >= 0) {
353 qemu_set_cloexec(ret);
356 return ret;
360 * Accept a connection and set FD_CLOEXEC
362 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
364 int ret;
366 #ifdef CONFIG_ACCEPT4
367 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
368 if (ret != -1 || errno != ENOSYS) {
369 return ret;
371 #endif
372 ret = accept(s, addr, addrlen);
373 if (ret >= 0) {
374 qemu_set_cloexec(ret);
377 return ret;