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