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 "trace.h" 50 #include "qemu/sockets.h" 51 #include "monitor/monitor.h" 52 53 static bool fips_enabled = false; 54 55 static const char *qemu_version = QEMU_VERSION; 56 57 int 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 66 int 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 82 #ifndef _WIN32 83 /* 84 * Dups an fd and sets the flags 85 */ 86 static int qemu_dup_flags(int fd, int flags) 87 { 88 int ret; 89 int serrno; 90 int dup_flags; 91 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 */ 115 if (fcntl(ret, F_SETFL, flags) == -1) { 116 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 129 fail: 130 serrno = errno; 131 if (ret != -1) { 132 close(ret); 133 } 134 errno = serrno; 135 return -1; 136 } 137 138 static int qemu_parse_fdset(const char *param) 139 { 140 return qemu_parse_fd(param); 141 } 142 #endif 143 144 /* 145 * Opens a file with FD_CLOEXEC set 146 */ 147 int qemu_open(const char *name, int flags, ...) 148 { 149 int ret; 150 int mode = 0; 151 152 #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 187 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 207 int qemu_close(int fd) 208 { 209 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 224 return close(fd); 225 } 226 227 /* 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. 232 * 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 237 */ 238 ssize_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 259 /* 260 * Opens a socket with FD_CLOEXEC set 261 */ 262 int 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); 268 if (ret != -1 || errno != EINVAL) { 269 return ret; 270 } 271 #endif 272 ret = socket(domain, type, protocol); 273 if (ret >= 0) { 274 qemu_set_cloexec(ret); 275 } 276 277 return ret; 278 } 279 280 /* 281 * Accept a connection and set FD_CLOEXEC 282 */ 283 int 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); 289 if (ret != -1 || errno != ENOSYS) { 290 return ret; 291 } 292 #endif 293 ret = accept(s, addr, addrlen); 294 if (ret >= 0) { 295 qemu_set_cloexec(ret); 296 } 297 298 return ret; 299 } 300 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 */ 312 ssize_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 */ 345 ssize_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 367 void qemu_set_version(const char *version) 368 { 369 qemu_version = version; 370 } 371 372 const char *qemu_get_version(void) 373 { 374 return qemu_version; 375 } 376 377 void 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 398 bool fips_get_state(void) 399 { 400 return fips_enabled; 401 } 402 403