util/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 "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