blob: dbf872aea79b999312f9d1d590c92ef0e4fef009 [file] [log] [blame]
bellardea888122004-02-16 22:12:40 +00001/*
2 * QEMU low level functions
ths5fafdf22007-09-16 21:08:06 +00003 *
bellardea888122004-02-16 22:12:40 +00004 * Copyright (c) 2003 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellardea888122004-02-16 22:12:40 +00006 * 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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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.
23 */
24#include <stdlib.h>
25#include <stdio.h>
26#include <stdarg.h>
27#include <string.h>
bellardea888122004-02-16 22:12:40 +000028#include <errno.h>
29#include <unistd.h>
thsaa26bb22007-03-25 21:33:06 +000030#include <fcntl.h>
Paolo Bonzinif582af52010-02-02 20:33:11 +010031
32/* Needed early for CONFIG_BSD etc. */
33#include "config-host.h"
34
Juan Quinteladfe5fff2009-07-27 16:12:40 +020035#ifdef CONFIG_SOLARIS
ths605686c2007-01-17 23:31:19 +000036#include <sys/types.h>
37#include <sys/statvfs.h>
38#endif
bellardea888122004-02-16 22:12:40 +000039
Paolo Bonzinif3dfda62010-02-11 00:23:46 +010040#ifdef CONFIG_EVENTFD
41#include <sys/eventfd.h>
42#endif
43
bellard6e4255f2005-04-17 18:33:47 +000044#ifdef _WIN32
45#include <windows.h>
Juan Quintela71e72a12009-07-27 16:12:56 +020046#elif defined(CONFIG_BSD)
bellard194884d2005-02-21 20:10:36 +000047#include <stdlib.h>
48#else
bellard49b470e2005-02-10 21:59:25 +000049#include <malloc.h>
bellard194884d2005-02-21 20:10:36 +000050#endif
bellard49b470e2005-02-10 21:59:25 +000051
blueswir1511d2b12009-03-07 15:32:56 +000052#include "qemu-common.h"
53#include "sysemu.h"
aliguori03ff3ca2008-09-15 15:51:35 +000054#include "qemu_socket.h"
55
Blue Swirld7414292009-09-12 12:36:04 +000056#if !defined(_POSIX_C_SOURCE) || defined(_WIN32) || defined(__sun__)
malcd644f8b2009-07-08 18:24:05 +040057static void *oom_check(void *ptr)
58{
59 if (ptr == NULL) {
Stefan Weild2d5adc2010-01-21 22:24:58 +010060#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
malcd644f8b2009-07-08 18:24:05 +040065 abort();
66 }
67 return ptr;
68}
69#endif
70
bellard6e4255f2005-04-17 18:33:47 +000071#if defined(_WIN32)
balrog33f00272007-12-24 14:33:24 +000072void *qemu_memalign(size_t alignment, size_t size)
73{
malcd644f8b2009-07-08 18:24:05 +040074 if (!size) {
75 abort();
76 }
77 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
balrog33f00272007-12-24 14:33:24 +000078}
bellard6e4255f2005-04-17 18:33:47 +000079
80void *qemu_vmalloc(size_t size)
81{
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. */
malcd644f8b2009-07-08 18:24:05 +040085 if (!size) {
86 abort();
87 }
88 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
bellard6e4255f2005-04-17 18:33:47 +000089}
90
91void qemu_vfree(void *ptr)
92{
93 VirtualFree(ptr, 0, MEM_RELEASE);
94}
95
pbrook6cb7ee82006-05-22 14:10:48 +000096#else
97
balrog33f00272007-12-24 14:33:24 +000098void *qemu_memalign(size_t alignment, size_t size)
99{
Blue Swirld7414292009-09-12 12:36:04 +0000100#if defined(_POSIX_C_SOURCE) && !defined(__sun__)
balrog33f00272007-12-24 14:33:24 +0000101 int ret;
102 void *ptr;
103 ret = posix_memalign(&ptr, alignment, size);
Stefan Weild2d5adc2010-01-21 22:24:58 +0100104 if (ret != 0) {
105 fprintf(stderr, "Failed to allocate %zu B: %s\n",
106 size, strerror(ret));
malcd644f8b2009-07-08 18:24:05 +0400107 abort();
Stefan Weild2d5adc2010-01-21 22:24:58 +0100108 }
balrog33f00272007-12-24 14:33:24 +0000109 return ptr;
Juan Quintela71e72a12009-07-27 16:12:56 +0200110#elif defined(CONFIG_BSD)
malcd644f8b2009-07-08 18:24:05 +0400111 return oom_check(valloc(size));
balrog33f00272007-12-24 14:33:24 +0000112#else
malcd644f8b2009-07-08 18:24:05 +0400113 return oom_check(memalign(alignment, size));
balrog33f00272007-12-24 14:33:24 +0000114#endif
115}
116
bellard49b470e2005-02-10 21:59:25 +0000117/* alloc shared memory pages */
118void *qemu_vmalloc(size_t size)
119{
malc48253bd2008-11-18 01:42:15 +0000120 return qemu_memalign(getpagesize(), size);
bellard49b470e2005-02-10 21:59:25 +0000121}
122
123void qemu_vfree(void *ptr)
124{
125 free(ptr);
126}
127
128#endif
129
thsaa26bb22007-03-25 21:33:06 +0000130int qemu_create_pidfile(const char *filename)
131{
132 char buffer[128];
133 int len;
134#ifndef _WIN32
135 int fd;
136
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100137 fd = qemu_open(filename, O_RDWR | O_CREAT, 0600);
thsaa26bb22007-03-25 21:33:06 +0000138 if (fd == -1)
139 return -1;
140
141 if (lockf(fd, F_TLOCK, 0) == -1)
142 return -1;
143
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;
thsaa26bb22007-03-25 21:33:06 +0000149 OVERLAPPED overlap;
150 BOOL ret;
Juha Riihimäki099fe232009-12-03 15:56:03 +0200151 memset(&overlap, 0, sizeof(overlap));
thsaa26bb22007-03-25 21:33:06 +0000152
Juha Riihimäki099fe232009-12-03 15:56:03 +0200153 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
thsaa26bb22007-03-25 21:33:06 +0000154 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
155
156 if (file == INVALID_HANDLE_VALUE)
157 return -1;
158
thsaa26bb22007-03-25 21:33:06 +0000159 len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
ths5fafdf22007-09-16 21:08:06 +0000160 ret = WriteFileEx(file, (LPCVOID)buffer, (DWORD)len,
thsaa26bb22007-03-25 21:33:06 +0000161 &overlap, NULL);
162 if (ret == 0)
163 return -1;
164#endif
165 return 0;
166}
pbrook29b3a662007-06-07 23:09:47 +0000167
168#ifdef _WIN32
169
Stefan Weil4972d592010-06-12 16:07:12 +0200170/* mingw32 needs ffs for compilations without optimization. */
171int ffs(int i)
172{
173 /* Use gcc's builtin ffs. */
174 return __builtin_ffs(i);
175}
176
pbrook29b3a662007-06-07 23:09:47 +0000177/* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
178#define _W32_FT_OFFSET (116444736000000000ULL)
179
180int qemu_gettimeofday(qemu_timeval *tp)
181{
182 union {
183 unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */
184 FILETIME ft;
185 } _now;
186
187 if(tp)
188 {
189 GetSystemTimeAsFileTime (&_now.ft);
190 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL );
191 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL);
192 }
193 /* Always return 0 as per Open Group Base Specifications Issue 6.
194 Do not set errno on error. */
195 return 0;
196}
197#endif /* _WIN32 */
aliguori03ff3ca2008-09-15 15:51:35 +0000198
199
200#ifdef _WIN32
201void socket_set_nonblock(int fd)
202{
203 unsigned long opt = 1;
204 ioctlsocket(fd, FIONBIO, &opt);
205}
206
207int inet_aton(const char *cp, struct in_addr *ia)
208{
209 uint32_t addr = inet_addr(cp);
210 if (addr == 0xffffffff)
211 return 0;
212 ia->s_addr = addr;
213 return 1;
214}
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100215
216void qemu_set_cloexec(int fd)
217{
218}
219
aliguori03ff3ca2008-09-15 15:51:35 +0000220#else
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100221
aliguori03ff3ca2008-09-15 15:51:35 +0000222void socket_set_nonblock(int fd)
223{
224 int f;
225 f = fcntl(fd, F_GETFL);
226 fcntl(fd, F_SETFL, f | O_NONBLOCK);
227}
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100228
229void qemu_set_cloexec(int fd)
230{
231 int f;
232 f = fcntl(fd, F_GETFD);
233 fcntl(fd, F_SETFD, f | FD_CLOEXEC);
234}
235
aliguori03ff3ca2008-09-15 15:51:35 +0000236#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100237
238/*
239 * Opens a file with FD_CLOEXEC set
240 */
241int qemu_open(const char *name, int flags, ...)
242{
243 int ret;
244 int mode = 0;
245
246 if (flags & O_CREAT) {
247 va_list ap;
248
249 va_start(ap, flags);
250 mode = va_arg(ap, int);
251 va_end(ap);
252 }
253
254#ifdef O_CLOEXEC
255 ret = open(name, flags | O_CLOEXEC, mode);
256#else
257 ret = open(name, flags, mode);
258 if (ret >= 0) {
259 qemu_set_cloexec(ret);
260 }
261#endif
262
263 return ret;
264}
265
Kirill A. Shutemov7b5f6992010-01-20 00:56:08 +0100266/*
267 * A variant of write(2) which handles partial write.
268 *
269 * Return the number of bytes transferred.
270 * Set errno if fewer than `count' bytes are written.
Juan Quintela1298cb62010-03-04 10:00:39 +0100271 *
272 * This function don't work with non-blocking fd's.
273 * Any of the possibilities with non-bloking fd's is bad:
274 * - return a short write (then name is wrong)
275 * - busy wait adding (errno == EAGAIN) to the loop
Kirill A. Shutemov7b5f6992010-01-20 00:56:08 +0100276 */
277ssize_t qemu_write_full(int fd, const void *buf, size_t count)
278{
279 ssize_t ret = 0;
280 ssize_t total = 0;
281
282 while (count) {
283 ret = write(fd, buf, count);
284 if (ret < 0) {
285 if (errno == EINTR)
286 continue;
287 break;
288 }
289
290 count -= ret;
291 buf += ret;
292 total += ret;
293 }
294
295 return total;
296}
297
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100298#ifndef _WIN32
299/*
Paolo Bonzinif3dfda62010-02-11 00:23:46 +0100300 * Creates an eventfd that looks like a pipe and has EFD_CLOEXEC set.
301 */
302int qemu_eventfd(int fds[2])
303{
Avi Kivity153ceef2010-02-23 10:16:53 +0100304#ifdef CONFIG_EVENTFD
Paolo Bonzinif3dfda62010-02-11 00:23:46 +0100305 int ret;
306
Paolo Bonzinif3dfda62010-02-11 00:23:46 +0100307 ret = eventfd(0, 0);
308 if (ret >= 0) {
309 fds[0] = ret;
310 qemu_set_cloexec(ret);
311 if ((fds[1] = dup(ret)) == -1) {
312 close(ret);
313 return -1;
314 }
315 qemu_set_cloexec(fds[1]);
316 return 0;
317 }
318
319 if (errno != ENOSYS) {
320 return -1;
321 }
322#endif
323
324 return qemu_pipe(fds);
325}
326
327/*
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100328 * Creates a pipe with FD_CLOEXEC set on both file descriptors
329 */
330int qemu_pipe(int pipefd[2])
331{
332 int ret;
333
334#ifdef CONFIG_PIPE2
335 ret = pipe2(pipefd, O_CLOEXEC);
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100336 if (ret != -1 || errno != ENOSYS) {
337 return ret;
338 }
339#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100340 ret = pipe(pipefd);
341 if (ret == 0) {
342 qemu_set_cloexec(pipefd[0]);
343 qemu_set_cloexec(pipefd[1]);
344 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100345
346 return ret;
347}
348#endif
349
350/*
351 * Opens a socket with FD_CLOEXEC set
352 */
353int qemu_socket(int domain, int type, int protocol)
354{
355 int ret;
356
357#ifdef SOCK_CLOEXEC
358 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100359 if (ret != -1 || errno != EINVAL) {
360 return ret;
361 }
362#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100363 ret = socket(domain, type, protocol);
364 if (ret >= 0) {
365 qemu_set_cloexec(ret);
366 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100367
368 return ret;
369}
370
371/*
372 * Accept a connection and set FD_CLOEXEC
373 */
374int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
375{
376 int ret;
377
378#ifdef CONFIG_ACCEPT4
379 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
Kevin Wolf347ed552010-01-13 16:20:56 +0100380 if (ret != -1 || errno != ENOSYS) {
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100381 return ret;
382 }
383#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100384 ret = accept(s, addr, addrlen);
385 if (ret >= 0) {
386 qemu_set_cloexec(ret);
387 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100388
389 return ret;
390}