include/qemu/osdep.h

   1 /*
   2  * OS includes and handling of OS dependencies
   3  *
   4  * This header exists to pull in some common system headers that
   5  * most code in QEMU will want, and to fix up some possible issues with
   6  * it (missing defines, Windows weirdness, and so on).
   7  *
   8  * To avoid getting into possible circular include dependencies, this
   9  * file should not include any other QEMU headers, with the exceptions
  10  * of config-host.h, config-target.h, qemu/compiler.h,
  11  * sysemu/os-posix.h, sysemu/os-win32.h, glib-compat.h and
  12  * qemu/typedefs.h, all of which are doing a similar job to this file
  13  * and are under similar constraints.
  14  *
  15  * This header also contains prototypes for functions defined in
  16  * os-*.c and util/oslib-*.c; those would probably be better split
  17  * out into separate header files.
  18  *
  19  * In an ideal world this header would contain only:
  20  *  (1) things which everybody needs
  21  *  (2) things without which code would work on most platforms but
  22  *      fail to compile or misbehave on a minority of host OSes
  23  *
  24  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  25  * See the COPYING file in the top-level directory.
  26  */
  27 #ifndef QEMU_OSDEP_H
  28 #define QEMU_OSDEP_H
  29
  30 #include "config-host.h"
  31 #ifdef NEED_CPU_H
  32 #include "config-target.h"
  33 #endif
  34 #include "qemu/compiler.h"
  35
  36 /* Older versions of C++ don't get definitions of various macros from
  37  * stdlib.h unless we define these macros before first inclusion of
  38  * that system header.
  39  */
  40 #ifndef __STDC_CONSTANT_MACROS
  41 #define __STDC_CONSTANT_MACROS
  42 #endif
  43 #ifndef __STDC_LIMIT_MACROS
  44 #define __STDC_LIMIT_MACROS
  45 #endif
  46 #ifndef __STDC_FORMAT_MACROS
  47 #define __STDC_FORMAT_MACROS
  48 #endif
  49
  50 /* The following block of code temporarily renames the daemon() function so the
  51  * compiler does not see the warning associated with it in stdlib.h on OSX
  52  */
  53 #ifdef __APPLE__
  54 #define daemon qemu_fake_daemon_function
  55 #include <stdlib.h>
  56 #undef daemon
  57 extern int daemon(int, int);
  58 #endif
  59
  60 #include <stdarg.h>
  61 #include <stddef.h>
  62 #include <stdbool.h>
  63 #include <stdint.h>
  64 #include <sys/types.h>
  65 #include <stdlib.h>
  66 #include <stdio.h>
  67 #include <string.h>
  68 #include <strings.h>
  69 #include <inttypes.h>
  70 #include <limits.h>
  71 /* Put unistd.h before time.h as that triggers localtime_r/gmtime_r
  72  * function availability on recentish Mingw-w64 platforms. */
  73 #include <unistd.h>
  74 #include <time.h>
  75 #include <ctype.h>
  76 #include <errno.h>
  77 #include <fcntl.h>
  78 #include <sys/stat.h>
  79 #include <sys/time.h>
  80 #include <assert.h>
  81 #include <signal.h>
  82
  83 #ifdef __OpenBSD__
  84 #include <sys/signal.h>
  85 #endif
  86
  87 #ifndef _WIN32
  88 #include <sys/wait.h>
  89 #else
  90 #define WIFEXITED(x)   1
  91 #define WEXITSTATUS(x) (x)
  92 #endif
  93
  94 #ifdef _WIN32
  95 #include "sysemu/os-win32.h"
  96 #endif
  97
  98 #ifdef CONFIG_POSIX
  99 #include "sysemu/os-posix.h"
 100 #endif
 101
 102 #include "glib-compat.h"
 103 #include "qemu/typedefs.h"
 104
 105 #ifndef O_LARGEFILE
 106 #define O_LARGEFILE 0
 107 #endif
 108 #ifndef O_BINARY
 109 #define O_BINARY 0
 110 #endif
 111 #ifndef MAP_ANONYMOUS
 112 #define MAP_ANONYMOUS MAP_ANON
 113 #endif
 114 #ifndef ENOMEDIUM
 115 #define ENOMEDIUM ENODEV
 116 #endif
 117 #if !defined(ENOTSUP)
 118 #define ENOTSUP 4096
 119 #endif
 120 #if !defined(ECANCELED)
 121 #define ECANCELED 4097
 122 #endif
 123 #if !defined(EMEDIUMTYPE)
 124 #define EMEDIUMTYPE 4098
 125 #endif
 126 #ifndef TIME_MAX
 127 #define TIME_MAX LONG_MAX
 128 #endif
 129
 130 #ifndef MIN
 131 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 132 #endif
 133 #ifndef MAX
 134 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 135 #endif
 136
 137 /* Minimum function that returns zero only iff both values are zero.
 138  * Intended for use with unsigned values only. */
 139 #ifndef MIN_NON_ZERO
 140 #define MIN_NON_ZERO(a, b) (((a) != 0 && (a) < (b)) ? (a) : (b))
 141 #endif
 142
 143 #ifndef ROUND_UP
 144 #define ROUND_UP(n,d) (((n) + (d) - 1) & -(d))
 145 #endif
 146
 147 #ifndef DIV_ROUND_UP
 148 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 149 #endif
 150
 151 #ifndef ARRAY_SIZE
 152 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 153 #endif
 154
 155 int qemu_daemon(int nochdir, int noclose);
 156 void *qemu_try_memalign(size_t alignment, size_t size);
 157 void *qemu_memalign(size_t alignment, size_t size);
 158 void *qemu_anon_ram_alloc(size_t size, uint64_t *align);
 159 void qemu_vfree(void *ptr);
 160 void qemu_anon_ram_free(void *ptr, size_t size);
 161
 162 #define QEMU_MADV_INVALID -1
 163
 164 #if defined(CONFIG_MADVISE)
 165
 166 #include <sys/mman.h>
 167
 168 #define QEMU_MADV_WILLNEED  MADV_WILLNEED
 169 #define QEMU_MADV_DONTNEED  MADV_DONTNEED
 170 #ifdef MADV_DONTFORK
 171 #define QEMU_MADV_DONTFORK  MADV_DONTFORK
 172 #else
 173 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 174 #endif
 175 #ifdef MADV_MERGEABLE
 176 #define QEMU_MADV_MERGEABLE MADV_MERGEABLE
 177 #else
 178 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 179 #endif
 180 #ifdef MADV_UNMERGEABLE
 181 #define QEMU_MADV_UNMERGEABLE MADV_UNMERGEABLE
 182 #else
 183 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 184 #endif
 185 #ifdef MADV_DODUMP
 186 #define QEMU_MADV_DODUMP MADV_DODUMP
 187 #else
 188 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 189 #endif
 190 #ifdef MADV_DONTDUMP
 191 #define QEMU_MADV_DONTDUMP MADV_DONTDUMP
 192 #else
 193 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 194 #endif
 195 #ifdef MADV_HUGEPAGE
 196 #define QEMU_MADV_HUGEPAGE MADV_HUGEPAGE
 197 #else
 198 #define QEMU_MADV_HUGEPAGE QEMU_MADV_INVALID
 199 #endif
 200 #ifdef MADV_NOHUGEPAGE
 201 #define QEMU_MADV_NOHUGEPAGE MADV_NOHUGEPAGE
 202 #else
 203 #define QEMU_MADV_NOHUGEPAGE QEMU_MADV_INVALID
 204 #endif
 205
 206 #elif defined(CONFIG_POSIX_MADVISE)
 207
 208 #define QEMU_MADV_WILLNEED  POSIX_MADV_WILLNEED
 209 #define QEMU_MADV_DONTNEED  POSIX_MADV_DONTNEED
 210 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 211 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 212 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 213 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 214 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 215 #define QEMU_MADV_HUGEPAGE  QEMU_MADV_INVALID
 216 #define QEMU_MADV_NOHUGEPAGE  QEMU_MADV_INVALID
 217
 218 #else /* no-op */
 219
 220 #define QEMU_MADV_WILLNEED  QEMU_MADV_INVALID
 221 #define QEMU_MADV_DONTNEED  QEMU_MADV_INVALID
 222 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 223 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 224 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 225 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 226 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 227 #define QEMU_MADV_HUGEPAGE  QEMU_MADV_INVALID
 228 #define QEMU_MADV_NOHUGEPAGE  QEMU_MADV_INVALID
 229
 230 #endif
 231
 232 int qemu_madvise(void *addr, size_t len, int advice);
 233
 234 int qemu_open(const char *name, int flags, ...);
 235 int qemu_close(int fd);
 236
 237 #if defined(__HAIKU__) && defined(__i386__)
 238 #define FMT_pid "%ld"
 239 #elif defined(WIN64)
 240 #define FMT_pid "%" PRId64
 241 #else
 242 #define FMT_pid "%d"
 243 #endif
 244
 245 int qemu_create_pidfile(const char *filename);
 246 int qemu_get_thread_id(void);
 247
 248 #ifndef CONFIG_IOVEC
 249 struct iovec {
 250     void *iov_base;
 251     size_t iov_len;
 252 };
 253 /*
 254  * Use the same value as Linux for now.
 255  */
 256 #define IOV_MAX 1024
 257
 258 ssize_t readv(int fd, const struct iovec *iov, int iov_cnt);
 259 ssize_t writev(int fd, const struct iovec *iov, int iov_cnt);
 260 #else
 261 #include <sys/uio.h>
 262 #endif
 263
 264 #ifdef _WIN32
 265 static inline void qemu_timersub(const struct timeval *val1,
 266                                  const struct timeval *val2,
 267                                  struct timeval *res)
 268 {
 269     res->tv_sec = val1->tv_sec - val2->tv_sec;
 270     if (val1->tv_usec < val2->tv_usec) {
 271         res->tv_sec--;
 272         res->tv_usec = val1->tv_usec - val2->tv_usec + 1000 * 1000;
 273     } else {
 274         res->tv_usec = val1->tv_usec - val2->tv_usec;
 275     }
 276 }
 277 #else
 278 #define qemu_timersub timersub
 279 #endif
 280
 281 void qemu_set_cloexec(int fd);
 282
 283 /* QEMU "hardware version" setting. Used to replace code that exposed
 284  * QEMU_VERSION to guests in the past and need to keep compatibilty.
 285  * Do not use qemu_hw_version() in new code.
 286  */
 287 void qemu_set_hw_version(const char *);
 288 const char *qemu_hw_version(void);
 289
 290 void fips_set_state(bool requested);
 291 bool fips_get_state(void);
 292
 293 /* Return a dynamically allocated pathname denoting a file or directory that is
 294  * appropriate for storing local state.
 295  *
 296  * @relative_pathname need not start with a directory separator; one will be
 297  * added automatically.
 298  *
 299  * The caller is responsible for releasing the value returned with g_free()
 300  * after use.
 301  */
 302 char *qemu_get_local_state_pathname(const char *relative_pathname);
 303
 304 /* Find program directory, and save it for later usage with
 305  * qemu_get_exec_dir().
 306  * Try OS specific API first, if not working, parse from argv0. */
 307 void qemu_init_exec_dir(const char *argv0);
 308
 309 /* Get the saved exec dir.
 310  * Caller needs to release the returned string by g_free() */
 311 char *qemu_get_exec_dir(void);
 312
 313 /**
 314  * qemu_getauxval:
 315  * @type: the auxiliary vector key to lookup
 316  *
 317  * Search the auxiliary vector for @type, returning the value
 318  * or 0 if @type is not present.
 319  */
 320 unsigned long qemu_getauxval(unsigned long type);
 321
 322 void qemu_set_tty_echo(int fd, bool echo);
 323
 324 void os_mem_prealloc(int fd, char *area, size_t sz);
 325
 326 int qemu_read_password(char *buf, int buf_size);
 327
 328 /**
 329  * qemu_fork:
 330  *
 331  * A version of fork that avoids signal handler race
 332  * conditions that can lead to child process getting
 333  * signals that are otherwise only expected by the
 334  * parent. It also resets all signal handlers to the
 335  * default settings.
 336  *
 337  * Returns 0 to child process, pid number to parent
 338  * or -1 on failure.
 339  */
 340 pid_t qemu_fork(Error **errp);
 341
 342 #endif