blob: 5b51a0322e5bedadd82e9d0a0f64c004330d8ae9 [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>
Paul Moore0f669982012-08-03 14:39:21 -040027#include <stdbool.h>
bellardea888122004-02-16 22:12:40 +000028#include <string.h>
bellardea888122004-02-16 22:12:40 +000029#include <errno.h>
30#include <unistd.h>
thsaa26bb22007-03-25 21:33:06 +000031#include <fcntl.h>
Paolo Bonzinif582af52010-02-02 20:33:11 +010032
33/* Needed early for CONFIG_BSD etc. */
34#include "config-host.h"
35
Andreas Färbere78815a2010-09-25 11:26:05 +000036#if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
37#include <sys/mman.h>
38#endif
39
Juan Quinteladfe5fff2009-07-27 16:12:40 +020040#ifdef CONFIG_SOLARIS
ths605686c2007-01-17 23:31:19 +000041#include <sys/types.h>
42#include <sys/statvfs.h>
Andreas Färbere78815a2010-09-25 11:26:05 +000043/* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
44 discussion about Solaris header problems */
45extern int madvise(caddr_t, size_t, int);
ths605686c2007-01-17 23:31:19 +000046#endif
bellardea888122004-02-16 22:12:40 +000047
blueswir1511d2b12009-03-07 15:32:56 +000048#include "qemu-common.h"
Stefan Hajnoczicd245a12010-05-22 18:09:25 +010049#include "trace.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010050#include "qemu/sockets.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010051#include "monitor/monitor.h"
aliguori03ff3ca2008-09-15 15:51:35 +000052
Paul Moore0f669982012-08-03 14:39:21 -040053static bool fips_enabled = false;
54
Crístian Viana93bfef42012-05-30 00:35:51 -030055static const char *qemu_version = QEMU_VERSION;
56
Paolo Bonzini128aa582011-09-21 12:36:48 +020057int socket_set_cork(int fd, int v)
58{
59#if defined(SOL_TCP) && defined(TCP_CORK)
60 return setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
61#else
62 return 0;
63#endif
64}
65
Andreas Färbere78815a2010-09-25 11:26:05 +000066int qemu_madvise(void *addr, size_t len, int advice)
67{
68 if (advice == QEMU_MADV_INVALID) {
69 errno = EINVAL;
70 return -1;
71 }
72#if defined(CONFIG_MADVISE)
73 return madvise(addr, len, advice);
74#elif defined(CONFIG_POSIX_MADVISE)
75 return posix_madvise(addr, len, advice);
76#else
77 errno = EINVAL;
78 return -1;
79#endif
80}
81
Corey Bryantadb696f2012-08-14 16:43:47 -040082#ifndef _WIN32
83/*
84 * Dups an fd and sets the flags
85 */
86static int qemu_dup_flags(int fd, int flags)
87{
88 int ret;
89 int serrno;
90 int dup_flags;
Corey Bryantadb696f2012-08-14 16:43:47 -040091
92#ifdef F_DUPFD_CLOEXEC
93 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0);
94#else
95 ret = dup(fd);
96 if (ret != -1) {
97 qemu_set_cloexec(ret);
98 }
99#endif
100 if (ret == -1) {
101 goto fail;
102 }
103
104 dup_flags = fcntl(ret, F_GETFL);
105 if (dup_flags == -1) {
106 goto fail;
107 }
108
109 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) {
110 errno = EINVAL;
111 goto fail;
112 }
113
114 /* Set/unset flags that we can with fcntl */
Corey Bryant3b6eda22012-10-18 16:41:04 -0400115 if (fcntl(ret, F_SETFL, flags) == -1) {
Corey Bryantadb696f2012-08-14 16:43:47 -0400116 goto fail;
117 }
118
119 /* Truncate the file in the cases that open() would truncate it */
120 if (flags & O_TRUNC ||
121 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) {
122 if (ftruncate(ret, 0) == -1) {
123 goto fail;
124 }
125 }
126
127 return ret;
128
129fail:
130 serrno = errno;
131 if (ret != -1) {
132 close(ret);
133 }
134 errno = serrno;
135 return -1;
136}
Paolo Bonzini0100fbb2012-10-29 15:19:18 +0100137
138static int qemu_parse_fdset(const char *param)
139{
140 return qemu_parse_fd(param);
141}
Corey Bryantadb696f2012-08-14 16:43:47 -0400142#endif
aliguori03ff3ca2008-09-15 15:51:35 +0000143
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100144/*
145 * Opens a file with FD_CLOEXEC set
146 */
147int qemu_open(const char *name, int flags, ...)
148{
149 int ret;
150 int mode = 0;
151
Corey Bryantadb696f2012-08-14 16:43:47 -0400152#ifndef _WIN32
153 const char *fdset_id_str;
154
155 /* Attempt dup of fd from fd set */
156 if (strstart(name, "/dev/fdset/", &fdset_id_str)) {
157 int64_t fdset_id;
158 int fd, dupfd;
159
160 fdset_id = qemu_parse_fdset(fdset_id_str);
161 if (fdset_id == -1) {
162 errno = EINVAL;
163 return -1;
164 }
165
166 fd = monitor_fdset_get_fd(fdset_id, flags);
167 if (fd == -1) {
168 return -1;
169 }
170
171 dupfd = qemu_dup_flags(fd, flags);
172 if (dupfd == -1) {
173 return -1;
174 }
175
176 ret = monitor_fdset_dup_fd_add(fdset_id, dupfd);
177 if (ret == -1) {
178 close(dupfd);
179 errno = EINVAL;
180 return -1;
181 }
182
183 return dupfd;
184 }
185#endif
186
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100187 if (flags & O_CREAT) {
188 va_list ap;
189
190 va_start(ap, flags);
191 mode = va_arg(ap, int);
192 va_end(ap);
193 }
194
195#ifdef O_CLOEXEC
196 ret = open(name, flags | O_CLOEXEC, mode);
197#else
198 ret = open(name, flags, mode);
199 if (ret >= 0) {
200 qemu_set_cloexec(ret);
201 }
202#endif
203
204 return ret;
205}
206
Corey Bryant2e1e79d2012-08-14 16:43:46 -0400207int qemu_close(int fd)
208{
Corey Bryantadb696f2012-08-14 16:43:47 -0400209 int64_t fdset_id;
210
211 /* Close fd that was dup'd from an fdset */
212 fdset_id = monitor_fdset_dup_fd_find(fd);
213 if (fdset_id != -1) {
214 int ret;
215
216 ret = close(fd);
217 if (ret == 0) {
218 monitor_fdset_dup_fd_remove(fd);
219 }
220
221 return ret;
222 }
223
Corey Bryant2e1e79d2012-08-14 16:43:46 -0400224 return close(fd);
225}
226
Kirill A. Shutemov7b5f6992010-01-20 00:56:08 +0100227/*
228 * A variant of write(2) which handles partial write.
229 *
230 * Return the number of bytes transferred.
231 * Set errno if fewer than `count' bytes are written.
Juan Quintela1298cb62010-03-04 10:00:39 +0100232 *
233 * This function don't work with non-blocking fd's.
234 * Any of the possibilities with non-bloking fd's is bad:
235 * - return a short write (then name is wrong)
236 * - busy wait adding (errno == EAGAIN) to the loop
Kirill A. Shutemov7b5f6992010-01-20 00:56:08 +0100237 */
238ssize_t qemu_write_full(int fd, const void *buf, size_t count)
239{
240 ssize_t ret = 0;
241 ssize_t total = 0;
242
243 while (count) {
244 ret = write(fd, buf, count);
245 if (ret < 0) {
246 if (errno == EINTR)
247 continue;
248 break;
249 }
250
251 count -= ret;
252 buf += ret;
253 total += ret;
254 }
255
256 return total;
257}
258
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100259/*
260 * Opens a socket with FD_CLOEXEC set
261 */
262int qemu_socket(int domain, int type, int protocol)
263{
264 int ret;
265
266#ifdef SOCK_CLOEXEC
267 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100268 if (ret != -1 || errno != EINVAL) {
269 return ret;
270 }
271#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100272 ret = socket(domain, type, protocol);
273 if (ret >= 0) {
274 qemu_set_cloexec(ret);
275 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100276
277 return ret;
278}
279
280/*
281 * Accept a connection and set FD_CLOEXEC
282 */
283int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
284{
285 int ret;
286
287#ifdef CONFIG_ACCEPT4
288 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
Kevin Wolf347ed552010-01-13 16:20:56 +0100289 if (ret != -1 || errno != ENOSYS) {
Andre Przywara3a03bfa2009-12-18 10:45:07 +0100290 return ret;
291 }
292#endif
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100293 ret = accept(s, addr, addrlen);
294 if (ret >= 0) {
295 qemu_set_cloexec(ret);
296 }
Kevin Wolf40ff6d72009-12-02 12:24:42 +0100297
298 return ret;
299}
Paolo Bonzini993295f2011-09-17 16:27:59 +0200300
301/*
302 * A variant of send(2) which handles partial write.
303 *
304 * Return the number of bytes transferred, which is only
305 * smaller than `count' if there is an error.
306 *
307 * This function won't work with non-blocking fd's.
308 * Any of the possibilities with non-bloking fd's is bad:
309 * - return a short write (then name is wrong)
310 * - busy wait adding (errno == EAGAIN) to the loop
311 */
312ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
313{
314 ssize_t ret = 0;
315 ssize_t total = 0;
316
317 while (count) {
318 ret = send(fd, buf, count, flags);
319 if (ret < 0) {
320 if (errno == EINTR) {
321 continue;
322 }
323 break;
324 }
325
326 count -= ret;
327 buf += ret;
328 total += ret;
329 }
330
331 return total;
332}
333
334/*
335 * A variant of recv(2) which handles partial write.
336 *
337 * Return the number of bytes transferred, which is only
338 * smaller than `count' if there is an error.
339 *
340 * This function won't work with non-blocking fd's.
341 * Any of the possibilities with non-bloking fd's is bad:
342 * - return a short write (then name is wrong)
343 * - busy wait adding (errno == EAGAIN) to the loop
344 */
345ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
346{
347 ssize_t ret = 0;
348 ssize_t total = 0;
349
350 while (count) {
351 ret = qemu_recv(fd, buf, count, flags);
352 if (ret <= 0) {
353 if (ret < 0 && errno == EINTR) {
354 continue;
355 }
356 break;
357 }
358
359 count -= ret;
360 buf += ret;
361 total += ret;
362 }
363
364 return total;
365}
366
Crístian Viana93bfef42012-05-30 00:35:51 -0300367void qemu_set_version(const char *version)
368{
369 qemu_version = version;
370}
371
372const char *qemu_get_version(void)
373{
374 return qemu_version;
375}
Paul Moore0f669982012-08-03 14:39:21 -0400376
377void fips_set_state(bool requested)
378{
379#ifdef __linux__
380 if (requested) {
381 FILE *fds = fopen("/proc/sys/crypto/fips_enabled", "r");
382 if (fds != NULL) {
383 fips_enabled = (fgetc(fds) == '1');
384 fclose(fds);
385 }
386 }
387#else
388 fips_enabled = false;
389#endif /* __linux__ */
390
391#ifdef _FIPS_DEBUG
392 fprintf(stderr, "FIPS mode %s (requested %s)\n",
393 (fips_enabled ? "enabled" : "disabled"),
394 (requested ? "enabled" : "disabled"));
395#endif
396}
397
398bool fips_get_state(void)
399{
400 return fips_enabled;
401}
Paolo Bonzini0100fbb2012-10-29 15:19:18 +0100402