usb-bsd: convert to QOM
[qemu.git] / osdep.c
1 /*
2 * QEMU low level functions
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
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:
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>
28 #include <errno.h>
29 #include <unistd.h>
30 #include <fcntl.h>
31
32 /* Needed early for CONFIG_BSD etc. */
33 #include "config-host.h"
34
35 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
36 #include <sys/mman.h>
37 #endif
38
39 #ifdef CONFIG_SOLARIS
40 #include <sys/types.h>
41 #include <sys/statvfs.h>
42 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
43 discussion about Solaris header problems */
44 extern int madvise(caddr_t, size_t, int);
45 #endif
46
47 #include "qemu-common.h"
48 #include "trace.h"
49 #include "qemu_socket.h"
50
51 int socket_set_cork(int fd, int v)
52 {
53 #if defined(SOL_TCP) && defined(TCP_CORK)
54 return setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
55 #else
56 return 0;
57 #endif
58 }
59
60 int qemu_madvise(void *addr, size_t len, int advice)
61 {
62 if (advice == QEMU_MADV_INVALID) {
63 errno = EINVAL;
64 return -1;
65 }
66 #if defined(CONFIG_MADVISE)
67 return madvise(addr, len, advice);
68 #elif defined(CONFIG_POSIX_MADVISE)
69 return posix_madvise(addr, len, advice);
70 #else
71 errno = EINVAL;
72 return -1;
73 #endif
74 }
75
76
77 /*
78 * Opens a file with FD_CLOEXEC set
79 */
80 int qemu_open(const char *name, int flags, ...)
81 {
82 int ret;
83 int mode = 0;
84
85 if (flags & O_CREAT) {
86 va_list ap;
87
88 va_start(ap, flags);
89 mode = va_arg(ap, int);
90 va_end(ap);
91 }
92
93 #ifdef O_CLOEXEC
94 ret = open(name, flags | O_CLOEXEC, mode);
95 #else
96 ret = open(name, flags, mode);
97 if (ret >= 0) {
98 qemu_set_cloexec(ret);
99 }
100 #endif
101
102 return ret;
103 }
104
105 /*
106 * A variant of write(2) which handles partial write.
107 *
108 * Return the number of bytes transferred.
109 * Set errno if fewer than `count' bytes are written.
110 *
111 * This function don't work with non-blocking fd's.
112 * Any of the possibilities with non-bloking fd's is bad:
113 * - return a short write (then name is wrong)
114 * - busy wait adding (errno == EAGAIN) to the loop
115 */
116 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
117 {
118 ssize_t ret = 0;
119 ssize_t total = 0;
120
121 while (count) {
122 ret = write(fd, buf, count);
123 if (ret < 0) {
124 if (errno == EINTR)
125 continue;
126 break;
127 }
128
129 count -= ret;
130 buf += ret;
131 total += ret;
132 }
133
134 return total;
135 }
136
137 /*
138 * Opens a socket with FD_CLOEXEC set
139 */
140 int qemu_socket(int domain, int type, int protocol)
141 {
142 int ret;
143
144 #ifdef SOCK_CLOEXEC
145 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
146 if (ret != -1 || errno != EINVAL) {
147 return ret;
148 }
149 #endif
150 ret = socket(domain, type, protocol);
151 if (ret >= 0) {
152 qemu_set_cloexec(ret);
153 }
154
155 return ret;
156 }
157
158 /*
159 * Accept a connection and set FD_CLOEXEC
160 */
161 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
162 {
163 int ret;
164
165 #ifdef CONFIG_ACCEPT4
166 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
167 if (ret != -1 || errno != ENOSYS) {
168 return ret;
169 }
170 #endif
171 ret = accept(s, addr, addrlen);
172 if (ret >= 0) {
173 qemu_set_cloexec(ret);
174 }
175
176 return ret;
177 }
178
179 /*
180 * A variant of send(2) which handles partial write.
181 *
182 * Return the number of bytes transferred, which is only
183 * smaller than `count' if there is an error.
184 *
185 * This function won't work with non-blocking fd's.
186 * Any of the possibilities with non-bloking fd's is bad:
187 * - return a short write (then name is wrong)
188 * - busy wait adding (errno == EAGAIN) to the loop
189 */
190 ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
191 {
192 ssize_t ret = 0;
193 ssize_t total = 0;
194
195 while (count) {
196 ret = send(fd, buf, count, flags);
197 if (ret < 0) {
198 if (errno == EINTR) {
199 continue;
200 }
201 break;
202 }
203
204 count -= ret;
205 buf += ret;
206 total += ret;
207 }
208
209 return total;
210 }
211
212 /*
213 * A variant of recv(2) which handles partial write.
214 *
215 * Return the number of bytes transferred, which is only
216 * smaller than `count' if there is an error.
217 *
218 * This function won't work with non-blocking fd's.
219 * Any of the possibilities with non-bloking fd's is bad:
220 * - return a short write (then name is wrong)
221 * - busy wait adding (errno == EAGAIN) to the loop
222 */
223 ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
224 {
225 ssize_t ret = 0;
226 ssize_t total = 0;
227
228 while (count) {
229 ret = qemu_recv(fd, buf, count, flags);
230 if (ret <= 0) {
231 if (ret < 0 && errno == EINTR) {
232 continue;
233 }
234 break;
235 }
236
237 count -= ret;
238 buf += ret;
239 total += ret;
240 }
241
242 return total;
243 }
244