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 static const char *qemu_version = QEMU_VERSION;
  52
  53 int socket_set_cork(int fd, int v)
  54 {
  55 #if defined(SOL_TCP) && defined(TCP_CORK)
  56     return setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
  57 #else
  58     return 0;
  59 #endif
  60 }
  61
  62 int qemu_madvise(void *addr, size_t len, int advice)
  63 {
  64     if (advice == QEMU_MADV_INVALID) {
  65         errno = EINVAL;
  66         return -1;
  67     }
  68 #if defined(CONFIG_MADVISE)
  69     return madvise(addr, len, advice);
  70 #elif defined(CONFIG_POSIX_MADVISE)
  71     return posix_madvise(addr, len, advice);
  72 #else
  73     errno = EINVAL;
  74     return -1;
  75 #endif
  76 }
  77
  78
  79 /*
  80  * Opens a file with FD_CLOEXEC set
  81  */
  82 int qemu_open(const char *name, int flags, ...)
  83 {
  84     int ret;
  85     int mode = 0;
  86
  87     if (flags & O_CREAT) {
  88         va_list ap;
  89
  90         va_start(ap, flags);
  91         mode = va_arg(ap, int);
  92         va_end(ap);
  93     }
  94
  95 #ifdef O_CLOEXEC
  96     ret = open(name, flags | O_CLOEXEC, mode);
  97 #else
  98     ret = open(name, flags, mode);
  99     if (ret >= 0) {
 100         qemu_set_cloexec(ret);
 101     }
 102 #endif
 103
 104     return ret;
 105 }
 106
 107 /*
 108  * A variant of write(2) which handles partial write.
 109  *
 110  * Return the number of bytes transferred.
 111  * Set errno if fewer than `count' bytes are written.
 112  *
 113  * This function don't work with non-blocking fd's.
 114  * Any of the possibilities with non-bloking fd's is bad:
 115  *   - return a short write (then name is wrong)
 116  *   - busy wait adding (errno == EAGAIN) to the loop
 117  */
 118 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
 119 {
 120     ssize_t ret = 0;
 121     ssize_t total = 0;
 122
 123     while (count) {
 124         ret = write(fd, buf, count);
 125         if (ret < 0) {
 126             if (errno == EINTR)
 127                 continue;
 128             break;
 129         }
 130
 131         count -= ret;
 132         buf += ret;
 133         total += ret;
 134     }
 135
 136     return total;
 137 }
 138
 139 /*
 140  * Opens a socket with FD_CLOEXEC set
 141  */
 142 int qemu_socket(int domain, int type, int protocol)
 143 {
 144     int ret;
 145
 146 #ifdef SOCK_CLOEXEC
 147     ret = socket(domain, type | SOCK_CLOEXEC, protocol);
 148     if (ret != -1 || errno != EINVAL) {
 149         return ret;
 150     }
 151 #endif
 152     ret = socket(domain, type, protocol);
 153     if (ret >= 0) {
 154         qemu_set_cloexec(ret);
 155     }
 156
 157     return ret;
 158 }
 159
 160 /*
 161  * Accept a connection and set FD_CLOEXEC
 162  */
 163 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
 164 {
 165     int ret;
 166
 167 #ifdef CONFIG_ACCEPT4
 168     ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
 169     if (ret != -1 || errno != ENOSYS) {
 170         return ret;
 171     }
 172 #endif
 173     ret = accept(s, addr, addrlen);
 174     if (ret >= 0) {
 175         qemu_set_cloexec(ret);
 176     }
 177
 178     return ret;
 179 }
 180
 181 /*
 182  * A variant of send(2) which handles partial write.
 183  *
 184  * Return the number of bytes transferred, which is only
 185  * smaller than `count' if there is an error.
 186  *
 187  * This function won't work with non-blocking fd's.
 188  * Any of the possibilities with non-bloking fd's is bad:
 189  *   - return a short write (then name is wrong)
 190  *   - busy wait adding (errno == EAGAIN) to the loop
 191  */
 192 ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
 193 {
 194     ssize_t ret = 0;
 195     ssize_t total = 0;
 196
 197     while (count) {
 198         ret = send(fd, buf, count, flags);
 199         if (ret < 0) {
 200             if (errno == EINTR) {
 201                 continue;
 202             }
 203             break;
 204         }
 205
 206         count -= ret;
 207         buf += ret;
 208         total += ret;
 209     }
 210
 211     return total;
 212 }
 213
 214 /*
 215  * A variant of recv(2) which handles partial write.
 216  *
 217  * Return the number of bytes transferred, which is only
 218  * smaller than `count' if there is an error.
 219  *
 220  * This function won't work with non-blocking fd's.
 221  * Any of the possibilities with non-bloking fd's is bad:
 222  *   - return a short write (then name is wrong)
 223  *   - busy wait adding (errno == EAGAIN) to the loop
 224  */
 225 ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
 226 {
 227     ssize_t ret = 0;
 228     ssize_t total = 0;
 229
 230     while (count) {
 231         ret = qemu_recv(fd, buf, count, flags);
 232         if (ret <= 0) {
 233             if (ret < 0 && errno == EINTR) {
 234                 continue;
 235             }
 236             break;
 237         }
 238
 239         count -= ret;
 240         buf += ret;
 241         total += ret;
 242     }
 243
 244     return total;
 245 }
 246
 247 void qemu_set_version(const char *version)
 248 {
 249     qemu_version = version;
 250 }
 251
 252 const char *qemu_get_version(void)
 253 {
 254     return qemu_version;
 255 }