blob: 09fbc992e3f2bc132e39f8eb3731161895f2f776 [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>
Juan Quinteladfe5fff2009-07-27 16:12:40 +020031#ifdef CONFIG_SOLARIS
ths605686c2007-01-17 23:31:19 +000032#include <sys/types.h>
33#include <sys/statvfs.h>
34#endif
bellardea888122004-02-16 22:12:40 +000035
Juan Quintela71e72a12009-07-27 16:12:56 +020036/* Needed early for CONFIG_BSD etc. */
blueswir1d40cdb12009-03-07 16:52:02 +000037#include "config-host.h"
38
bellard6e4255f2005-04-17 18:33:47 +000039#ifdef _WIN32
40#include <windows.h>
Juan Quintela71e72a12009-07-27 16:12:56 +020041#elif defined(CONFIG_BSD)
bellard194884d2005-02-21 20:10:36 +000042#include <stdlib.h>
43#else
bellard49b470e2005-02-10 21:59:25 +000044#include <malloc.h>
bellard194884d2005-02-21 20:10:36 +000045#endif
bellard49b470e2005-02-10 21:59:25 +000046
blueswir1511d2b12009-03-07 15:32:56 +000047#include "qemu-common.h"
48#include "sysemu.h"
aliguori03ff3ca2008-09-15 15:51:35 +000049#include "qemu_socket.h"
50
Blue Swirld7414292009-09-12 12:36:04 +000051#if !defined(_POSIX_C_SOURCE) || defined(_WIN32) || defined(__sun__)
malcd644f8b2009-07-08 18:24:05 +040052static void *oom_check(void *ptr)
53{
54 if (ptr == NULL) {
55 abort();
56 }
57 return ptr;
58}
59#endif
60
bellard6e4255f2005-04-17 18:33:47 +000061#if defined(_WIN32)
balrog33f00272007-12-24 14:33:24 +000062void *qemu_memalign(size_t alignment, size_t size)
63{
malcd644f8b2009-07-08 18:24:05 +040064 if (!size) {
65 abort();
66 }
67 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
balrog33f00272007-12-24 14:33:24 +000068}
bellard6e4255f2005-04-17 18:33:47 +000069
70void *qemu_vmalloc(size_t size)
71{
72 /* FIXME: this is not exactly optimal solution since VirtualAlloc
73 has 64Kb granularity, but at least it guarantees us that the
74 memory is page aligned. */
malcd644f8b2009-07-08 18:24:05 +040075 if (!size) {
76 abort();
77 }
78 return oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE));
bellard6e4255f2005-04-17 18:33:47 +000079}
80
81void qemu_vfree(void *ptr)
82{
83 VirtualFree(ptr, 0, MEM_RELEASE);
84}
85
pbrook6cb7ee82006-05-22 14:10:48 +000086#else
87
balrog33f00272007-12-24 14:33:24 +000088void *qemu_memalign(size_t alignment, size_t size)
89{
Blue Swirld7414292009-09-12 12:36:04 +000090#if defined(_POSIX_C_SOURCE) && !defined(__sun__)
balrog33f00272007-12-24 14:33:24 +000091 int ret;
92 void *ptr;
93 ret = posix_memalign(&ptr, alignment, size);
94 if (ret != 0)
malcd644f8b2009-07-08 18:24:05 +040095 abort();
balrog33f00272007-12-24 14:33:24 +000096 return ptr;
Juan Quintela71e72a12009-07-27 16:12:56 +020097#elif defined(CONFIG_BSD)
malcd644f8b2009-07-08 18:24:05 +040098 return oom_check(valloc(size));
balrog33f00272007-12-24 14:33:24 +000099#else
malcd644f8b2009-07-08 18:24:05 +0400100 return oom_check(memalign(alignment, size));
balrog33f00272007-12-24 14:33:24 +0000101#endif
102}
103
bellard49b470e2005-02-10 21:59:25 +0000104/* alloc shared memory pages */
105void *qemu_vmalloc(size_t size)
106{
malc48253bd2008-11-18 01:42:15 +0000107 return qemu_memalign(getpagesize(), size);
bellard49b470e2005-02-10 21:59:25 +0000108}
109
110void qemu_vfree(void *ptr)
111{
112 free(ptr);
113}
114
115#endif
116
thsaa26bb22007-03-25 21:33:06 +0000117int qemu_create_pidfile(const char *filename)
118{
119 char buffer[128];
120 int len;
121#ifndef _WIN32
122 int fd;
123
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100124 fd = qemu_open(filename, O_RDWR | O_CREAT, 0600);
thsaa26bb22007-03-25 21:33:06 +0000125 if (fd == -1)
126 return -1;
127
128 if (lockf(fd, F_TLOCK, 0) == -1)
129 return -1;
130
131 len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
132 if (write(fd, buffer, len) != len)
133 return -1;
134#else
135 HANDLE file;
thsaa26bb22007-03-25 21:33:06 +0000136 OVERLAPPED overlap;
137 BOOL ret;
Juha Riihimäki099fe232009-12-03 15:56:03 +0200138 memset(&overlap, 0, sizeof(overlap));
thsaa26bb22007-03-25 21:33:06 +0000139
Juha Riihimäki099fe232009-12-03 15:56:03 +0200140 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
thsaa26bb22007-03-25 21:33:06 +0000141 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
142
143 if (file == INVALID_HANDLE_VALUE)
144 return -1;
145
thsaa26bb22007-03-25 21:33:06 +0000146 len = snprintf(buffer, sizeof(buffer), "%ld\n", (long)getpid());
ths5fafdf22007-09-16 21:08:06 +0000147 ret = WriteFileEx(file, (LPCVOID)buffer, (DWORD)len,
thsaa26bb22007-03-25 21:33:06 +0000148 &overlap, NULL);
149 if (ret == 0)
150 return -1;
151#endif
152 return 0;
153}
pbrook29b3a662007-06-07 23:09:47 +0000154
155#ifdef _WIN32
156
157/* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */
158#define _W32_FT_OFFSET (116444736000000000ULL)
159
160int qemu_gettimeofday(qemu_timeval *tp)
161{
162 union {
163 unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */
164 FILETIME ft;
165 } _now;
166
167 if(tp)
168 {
169 GetSystemTimeAsFileTime (&_now.ft);
170 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL );
171 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL);
172 }
173 /* Always return 0 as per Open Group Base Specifications Issue 6.
174 Do not set errno on error. */
175 return 0;
176}
177#endif /* _WIN32 */
aliguori03ff3ca2008-09-15 15:51:35 +0000178
179
180#ifdef _WIN32
181void socket_set_nonblock(int fd)
182{
183 unsigned long opt = 1;
184 ioctlsocket(fd, FIONBIO, &opt);
185}
186
187int inet_aton(const char *cp, struct in_addr *ia)
188{
189 uint32_t addr = inet_addr(cp);
190 if (addr == 0xffffffff)
191 return 0;
192 ia->s_addr = addr;
193 return 1;
194}
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100195
196void qemu_set_cloexec(int fd)
197{
198}
199
aliguori03ff3ca2008-09-15 15:51:35 +0000200#else
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100201
aliguori03ff3ca2008-09-15 15:51:35 +0000202void socket_set_nonblock(int fd)
203{
204 int f;
205 f = fcntl(fd, F_GETFL);
206 fcntl(fd, F_SETFL, f | O_NONBLOCK);
207}
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100208
209void qemu_set_cloexec(int fd)
210{
211 int f;
212 f = fcntl(fd, F_GETFD);
213 fcntl(fd, F_SETFD, f | FD_CLOEXEC);
214}
215
aliguori03ff3ca2008-09-15 15:51:35 +0000216#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100217
218/*
219 * Opens a file with FD_CLOEXEC set
220 */
221int qemu_open(const char *name, int flags, ...)
222{
223 int ret;
224 int mode = 0;
225
226 if (flags & O_CREAT) {
227 va_list ap;
228
229 va_start(ap, flags);
230 mode = va_arg(ap, int);
231 va_end(ap);
232 }
233
234#ifdef O_CLOEXEC
235 ret = open(name, flags | O_CLOEXEC, mode);
236#else
237 ret = open(name, flags, mode);
238 if (ret >= 0) {
239 qemu_set_cloexec(ret);
240 }
241#endif
242
243 return ret;
244}
245
Kirill A. Shutemov7b5f6992010-01-20 00:56:08 +0100246/*
247 * A variant of write(2) which handles partial write.
248 *
249 * Return the number of bytes transferred.
250 * Set errno if fewer than `count' bytes are written.
251 */
252ssize_t qemu_write_full(int fd, const void *buf, size_t count)
253{
254 ssize_t ret = 0;
255 ssize_t total = 0;
256
257 while (count) {
258 ret = write(fd, buf, count);
259 if (ret < 0) {
260 if (errno == EINTR)
261 continue;
262 break;
263 }
264
265 count -= ret;
266 buf += ret;
267 total += ret;
268 }
269
270 return total;
271}
272
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100273#ifndef _WIN32
274/*
275 * Creates a pipe with FD_CLOEXEC set on both file descriptors
276 */
277int qemu_pipe(int pipefd[2])
278{
279 int ret;
280
281#ifdef CONFIG_PIPE2
282 ret = pipe2(pipefd, O_CLOEXEC);
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100283 if (ret != -1 || errno != ENOSYS) {
284 return ret;
285 }
286#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100287 ret = pipe(pipefd);
288 if (ret == 0) {
289 qemu_set_cloexec(pipefd[0]);
290 qemu_set_cloexec(pipefd[1]);
291 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100292
293 return ret;
294}
295#endif
296
297/*
298 * Opens a socket with FD_CLOEXEC set
299 */
300int qemu_socket(int domain, int type, int protocol)
301{
302 int ret;
303
304#ifdef SOCK_CLOEXEC
305 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100306 if (ret != -1 || errno != EINVAL) {
307 return ret;
308 }
309#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100310 ret = socket(domain, type, protocol);
311 if (ret >= 0) {
312 qemu_set_cloexec(ret);
313 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100314
315 return ret;
316}
317
318/*
319 * Accept a connection and set FD_CLOEXEC
320 */
321int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
322{
323 int ret;
324
325#ifdef CONFIG_ACCEPT4
326 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
Kevin Wolf347ed552010-01-13 16:20:56 +0100327 if (ret != -1 || errno != ENOSYS) {
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100328 return ret;
329 }
330#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100331 ret = accept(s, addr, addrlen);
332 if (ret >= 0) {
333 qemu_set_cloexec(ret);
334 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100335
336 return ret;
337}