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 <stdbool.h> 28 #include <string.h> 29 #include <errno.h> 30 #include <unistd.h> 31 #include <fcntl.h> 32 33 /* Needed early for CONFIG_BSD etc. */ 34 #include "config-host.h" 35 36 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE) 37 #include <sys/mman.h> 38 #endif 39 40 #ifdef CONFIG_SOLARIS 41 #include <sys/types.h> 42 #include <sys/statvfs.h> 43 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for 44 discussion about Solaris header problems */ 45 extern int madvise(caddr_t, size_t, int); 46 #endif 47 48 #include "qemu-common.h" 49 #include "qemu/sockets.h" 50 #include "qemu/error-report.h" 51 #include "monitor/monitor.h" 52 53 static bool fips_enabled = false; 54 55 static const char *hw_version = QEMU_VERSION; 56 57 int socket_set_cork(int fd, int v) 58 { 59 #if defined(SOL_TCP) && defined(TCP_CORK) 60 return qemu_setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v)); 61 #else 62 return 0; 63 #endif 64 } 65 66 int socket_set_nodelay(int fd) 67 { 68 int v = 1; 69 return qemu_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &v, sizeof(v)); 70 } 71 72 int qemu_madvise(void *addr, size_t len, int advice) 73 { 74 if (advice == QEMU_MADV_INVALID) { 75 errno = EINVAL; 76 return -1; 77 } 78 #if defined(CONFIG_MADVISE) 79 return madvise(addr, len, advice); 80 #elif defined(CONFIG_POSIX_MADVISE) 81 return posix_madvise(addr, len, advice); 82 #else 83 errno = EINVAL; 84 return -1; 85 #endif 86 } 87 88 #ifndef _WIN32 89 /* 90 * Dups an fd and sets the flags 91 */ 92 static int qemu_dup_flags(int fd, int flags) 93 { 94 int ret; 95 int serrno; 96 int dup_flags; 97 98 #ifdef F_DUPFD_CLOEXEC 99 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0); 100 #else 101 ret = dup(fd); 102 if (ret != -1) { 103 qemu_set_cloexec(ret); 104 } 105 #endif 106 if (ret == -1) { 107 goto fail; 108 } 109 110 dup_flags = fcntl(ret, F_GETFL); 111 if (dup_flags == -1) { 112 goto fail; 113 } 114 115 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) { 116 errno = EINVAL; 117 goto fail; 118 } 119 120 /* Set/unset flags that we can with fcntl */ 121 if (fcntl(ret, F_SETFL, flags) == -1) { 122 goto fail; 123 } 124 125 /* Truncate the file in the cases that open() would truncate it */ 126 if (flags & O_TRUNC || 127 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) { 128 if (ftruncate(ret, 0) == -1) { 129 goto fail; 130 } 131 } 132 133 return ret; 134 135 fail: 136 serrno = errno; 137 if (ret != -1) { 138 close(ret); 139 } 140 errno = serrno; 141 return -1; 142 } 143 144 static int qemu_parse_fdset(const char *param) 145 { 146 return qemu_parse_fd(param); 147 } 148 #endif 149 150 /* 151 * Opens a file with FD_CLOEXEC set 152 */ 153 int qemu_open(const char *name, int flags, ...) 154 { 155 int ret; 156 int mode = 0; 157 158 #ifndef _WIN32 159 const char *fdset_id_str; 160 161 /* Attempt dup of fd from fd set */ 162 if (strstart(name, "/dev/fdset/", &fdset_id_str)) { 163 int64_t fdset_id; 164 int fd, dupfd; 165 166 fdset_id = qemu_parse_fdset(fdset_id_str); 167 if (fdset_id == -1) { 168 errno = EINVAL; 169 return -1; 170 } 171 172 fd = monitor_fdset_get_fd(fdset_id, flags); 173 if (fd == -1) { 174 return -1; 175 } 176 177 dupfd = qemu_dup_flags(fd, flags); 178 if (dupfd == -1) { 179 return -1; 180 } 181 182 ret = monitor_fdset_dup_fd_add(fdset_id, dupfd); 183 if (ret == -1) { 184 close(dupfd); 185 errno = EINVAL; 186 return -1; 187 } 188 189 return dupfd; 190 } 191 #endif 192 193 if (flags & O_CREAT) { 194 va_list ap; 195 196 va_start(ap, flags); 197 mode = va_arg(ap, int); 198 va_end(ap); 199 } 200 201 #ifdef O_CLOEXEC 202 ret = open(name, flags | O_CLOEXEC, mode); 203 #else 204 ret = open(name, flags, mode); 205 if (ret >= 0) { 206 qemu_set_cloexec(ret); 207 } 208 #endif 209 210 #ifdef O_DIRECT 211 if (ret == -1 && errno == EINVAL && (flags & O_DIRECT)) { 212 error_report("file system may not support O_DIRECT"); 213 errno = EINVAL; /* in case it was clobbered */ 214 } 215 #endif /* O_DIRECT */ 216 217 return ret; 218 } 219 220 int qemu_close(int fd) 221 { 222 int64_t fdset_id; 223 224 /* Close fd that was dup'd from an fdset */ 225 fdset_id = monitor_fdset_dup_fd_find(fd); 226 if (fdset_id != -1) { 227 int ret; 228 229 ret = close(fd); 230 if (ret == 0) { 231 monitor_fdset_dup_fd_remove(fd); 232 } 233 234 return ret; 235 } 236 237 return close(fd); 238 } 239 240 /* 241 * A variant of write(2) which handles partial write. 242 * 243 * Return the number of bytes transferred. 244 * Set errno if fewer than `count' bytes are written. 245 * 246 * This function don't work with non-blocking fd's. 247 * Any of the possibilities with non-bloking fd's is bad: 248 * - return a short write (then name is wrong) 249 * - busy wait adding (errno == EAGAIN) to the loop 250 */ 251 ssize_t qemu_write_full(int fd, const void *buf, size_t count) 252 { 253 ssize_t ret = 0; 254 ssize_t total = 0; 255 256 while (count) { 257 ret = write(fd, buf, count); 258 if (ret < 0) { 259 if (errno == EINTR) 260 continue; 261 break; 262 } 263 264 count -= ret; 265 buf += ret; 266 total += ret; 267 } 268 269 return total; 270 } 271 272 /* 273 * Opens a socket with FD_CLOEXEC set 274 */ 275 int qemu_socket(int domain, int type, int protocol) 276 { 277 int ret; 278 279 #ifdef SOCK_CLOEXEC 280 ret = socket(domain, type | SOCK_CLOEXEC, protocol); 281 if (ret != -1 || errno != EINVAL) { 282 return ret; 283 } 284 #endif 285 ret = socket(domain, type, protocol); 286 if (ret >= 0) { 287 qemu_set_cloexec(ret); 288 } 289 290 return ret; 291 } 292 293 /* 294 * Accept a connection and set FD_CLOEXEC 295 */ 296 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen) 297 { 298 int ret; 299 300 #ifdef CONFIG_ACCEPT4 301 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC); 302 if (ret != -1 || errno != ENOSYS) { 303 return ret; 304 } 305 #endif 306 ret = accept(s, addr, addrlen); 307 if (ret >= 0) { 308 qemu_set_cloexec(ret); 309 } 310 311 return ret; 312 } 313 314 void qemu_set_hw_version(const char *version) 315 { 316 hw_version = version; 317 } 318 319 const char *qemu_hw_version(void) 320 { 321 return hw_version; 322 } 323 324 void fips_set_state(bool requested) 325 { 326 #ifdef __linux__ 327 if (requested) { 328 FILE *fds = fopen("/proc/sys/crypto/fips_enabled", "r"); 329 if (fds != NULL) { 330 fips_enabled = (fgetc(fds) == '1'); 331 fclose(fds); 332 } 333 } 334 #else 335 fips_enabled = false; 336 #endif /* __linux__ */ 337 338 #ifdef _FIPS_DEBUG 339 fprintf(stderr, "FIPS mode %s (requested %s)\n", 340 (fips_enabled ? "enabled" : "disabled"), 341 (requested ? "enabled" : "disabled")); 342 #endif 343 } 344 345 bool fips_get_state(void) 346 { 347 return fips_enabled; 348 } 349 350 #ifdef _WIN32 351 static void socket_cleanup(void) 352 { 353 WSACleanup(); 354 } 355 #endif 356 357 int socket_init(void) 358 { 359 #ifdef _WIN32 360 WSADATA Data; 361 int ret, err; 362 363 ret = WSAStartup(MAKEWORD(2, 2), &Data); 364 if (ret != 0) { 365 err = WSAGetLastError(); 366 fprintf(stderr, "WSAStartup: %d\n", err); 367 return -1; 368 } 369 atexit(socket_cleanup); 370 #endif 371 return 0; 372 } 373 374 #if !GLIB_CHECK_VERSION(2, 31, 0) 375 /* Ensure that glib is running in multi-threaded mode 376 * Old versions of glib require explicit initialization. Failure to do 377 * this results in the single-threaded code paths being taken inside 378 * glib. For example, the g_slice allocator will not be thread-safe 379 * and cause crashes. 380 */ 381 static void __attribute__((constructor)) thread_init(void) 382 { 383 if (!g_thread_supported()) { 384 g_thread_init(NULL); 385 } 386 } 387 #endif 388 389 #ifndef CONFIG_IOVEC 390 /* helper function for iov_send_recv() */ 391 static ssize_t 392 readv_writev(int fd, const struct iovec *iov, int iov_cnt, bool do_write) 393 { 394 unsigned i = 0; 395 ssize_t ret = 0; 396 while (i < iov_cnt) { 397 ssize_t r = do_write 398 ? write(fd, iov[i].iov_base, iov[i].iov_len) 399 : read(fd, iov[i].iov_base, iov[i].iov_len); 400 if (r > 0) { 401 ret += r; 402 } else if (!r) { 403 break; 404 } else if (errno == EINTR) { 405 continue; 406 } else { 407 /* else it is some "other" error, 408 * only return if there was no data processed. */ 409 if (ret == 0) { 410 ret = -1; 411 } 412 break; 413 } 414 i++; 415 } 416 return ret; 417 } 418 419 ssize_t 420 readv(int fd, const struct iovec *iov, int iov_cnt) 421 { 422 return readv_writev(fd, iov, iov_cnt, false); 423 } 424 425 ssize_t 426 writev(int fd, const struct iovec *iov, int iov_cnt) 427 { 428 return readv_writev(fd, iov, iov_cnt, true); 429 } 430 #endif 431