qemu/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 /* setjmp must be declared before sysemu/os-win32.h
  82  * because it is redefined there. */
  83 #include <setjmp.h>
  84 #include <signal.h>
  85
  86 #ifdef __OpenBSD__
  87 #include <sys/signal.h>
  88 #endif
  89
  90 #ifndef _WIN32
  91 #include <sys/wait.h>
  92 #else
  93 #define WIFEXITED(x)   1
  94 #define WEXITSTATUS(x) (x)
  95 #endif
  96
  97 #ifdef _WIN32
  98 #include "sysemu/os-win32.h"
  99 #endif
 100
 101 #ifdef CONFIG_POSIX
 102 #include "sysemu/os-posix.h"
 103 #endif
 104
 105 #include "glib-compat.h"
 106 #include "qemu/typedefs.h"
 107
 108 #ifndef O_LARGEFILE
 109 #define O_LARGEFILE 0
 110 #endif
 111 #ifndef O_BINARY
 112 #define O_BINARY 0
 113 #endif
 114 #ifndef MAP_ANONYMOUS
 115 #define MAP_ANONYMOUS MAP_ANON
 116 #endif
 117 #ifndef ENOMEDIUM
 118 #define ENOMEDIUM ENODEV
 119 #endif
 120 #if !defined(ENOTSUP)
 121 #define ENOTSUP 4096
 122 #endif
 123 #if !defined(ECANCELED)
 124 #define ECANCELED 4097
 125 #endif
 126 #if !defined(EMEDIUMTYPE)
 127 #define EMEDIUMTYPE 4098
 128 #endif
 129 #ifndef TIME_MAX
 130 #define TIME_MAX LONG_MAX
 131 #endif
 132
 133 /* HOST_LONG_BITS is the size of a native pointer in bits. */
 134 #if UINTPTR_MAX == UINT32_MAX
 135 # define HOST_LONG_BITS 32
 136 #elif UINTPTR_MAX == UINT64_MAX
 137 # define HOST_LONG_BITS 64
 138 #else
 139 # error Unknown pointer size
 140 #endif
 141
 142 #ifndef MIN
 143 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 144 #endif
 145 #ifndef MAX
 146 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
 147 #endif
 148
 149 /* Minimum function that returns zero only iff both values are zero.
 150  * Intended for use with unsigned values only. */
 151 #ifndef MIN_NON_ZERO
 152 #define MIN_NON_ZERO(a, b) (((a) != 0 && (a) < (b)) ? (a) : (b))
 153 #endif
 154
 155 /* Round number down to multiple */
 156 #define QEMU_ALIGN_DOWN(n, m) ((n) / (m) * (m))
 157
 158 /* Round number up to multiple */
 159 #define QEMU_ALIGN_UP(n, m) QEMU_ALIGN_DOWN((n) + (m) - 1, (m))
 160
 161 #ifndef ROUND_UP
 162 #define ROUND_UP(n,d) (((n) + (d) - 1) & -(d))
 163 #endif
 164
 165 #ifndef DIV_ROUND_UP
 166 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 167 #endif
 168
 169 #ifndef ARRAY_SIZE
 170 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 171 #endif
 172
 173 int qemu_daemon(int nochdir, int noclose);
 174 void *qemu_try_memalign(size_t alignment, size_t size);
 175 void *qemu_memalign(size_t alignment, size_t size);
 176 void *qemu_anon_ram_alloc(size_t size, uint64_t *align);
 177 void qemu_vfree(void *ptr);
 178 void qemu_anon_ram_free(void *ptr, size_t size);
 179
 180 #define QEMU_MADV_INVALID -1
 181
 182 #if defined(CONFIG_MADVISE)
 183
 184 #include <sys/mman.h>
 185
 186 #define QEMU_MADV_WILLNEED  MADV_WILLNEED
 187 #define QEMU_MADV_DONTNEED  MADV_DONTNEED
 188 #ifdef MADV_DONTFORK
 189 #define QEMU_MADV_DONTFORK  MADV_DONTFORK
 190 #else
 191 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 192 #endif
 193 #ifdef MADV_MERGEABLE
 194 #define QEMU_MADV_MERGEABLE MADV_MERGEABLE
 195 #else
 196 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 197 #endif
 198 #ifdef MADV_UNMERGEABLE
 199 #define QEMU_MADV_UNMERGEABLE MADV_UNMERGEABLE
 200 #else
 201 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 202 #endif
 203 #ifdef MADV_DODUMP
 204 #define QEMU_MADV_DODUMP MADV_DODUMP
 205 #else
 206 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 207 #endif
 208 #ifdef MADV_DONTDUMP
 209 #define QEMU_MADV_DONTDUMP MADV_DONTDUMP
 210 #else
 211 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 212 #endif
 213 #ifdef MADV_HUGEPAGE
 214 #define QEMU_MADV_HUGEPAGE MADV_HUGEPAGE
 215 #else
 216 #define QEMU_MADV_HUGEPAGE QEMU_MADV_INVALID
 217 #endif
 218 #ifdef MADV_NOHUGEPAGE
 219 #define QEMU_MADV_NOHUGEPAGE MADV_NOHUGEPAGE
 220 #else
 221 #define QEMU_MADV_NOHUGEPAGE QEMU_MADV_INVALID
 222 #endif
 223
 224 #elif defined(CONFIG_POSIX_MADVISE)
 225
 226 #define QEMU_MADV_WILLNEED  POSIX_MADV_WILLNEED
 227 #define QEMU_MADV_DONTNEED  POSIX_MADV_DONTNEED
 228 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 229 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 230 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 231 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 232 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 233 #define QEMU_MADV_HUGEPAGE  QEMU_MADV_INVALID
 234 #define QEMU_MADV_NOHUGEPAGE  QEMU_MADV_INVALID
 235
 236 #else /* no-op */
 237
 238 #define QEMU_MADV_WILLNEED  QEMU_MADV_INVALID
 239 #define QEMU_MADV_DONTNEED  QEMU_MADV_INVALID
 240 #define QEMU_MADV_DONTFORK  QEMU_MADV_INVALID
 241 #define QEMU_MADV_MERGEABLE QEMU_MADV_INVALID
 242 #define QEMU_MADV_UNMERGEABLE QEMU_MADV_INVALID
 243 #define QEMU_MADV_DODUMP QEMU_MADV_INVALID
 244 #define QEMU_MADV_DONTDUMP QEMU_MADV_INVALID
 245 #define QEMU_MADV_HUGEPAGE  QEMU_MADV_INVALID
 246 #define QEMU_MADV_NOHUGEPAGE  QEMU_MADV_INVALID
 247
 248 #endif
 249
 250 int qemu_madvise(void *addr, size_t len, int advice);
 251
 252 int qemu_open(const char *name, int flags, ...);
 253 int qemu_close(int fd);
 254
 255 #if defined(__HAIKU__) && defined(__i386__)
 256 #define FMT_pid "%ld"
 257 #elif defined(WIN64)
 258 #define FMT_pid "%" PRId64
 259 #else
 260 #define FMT_pid "%d"
 261 #endif
 262
 263 int qemu_create_pidfile(const char *filename);
 264 int qemu_get_thread_id(void);
 265
 266 #ifndef CONFIG_IOVEC
 267 struct iovec {
 268     void *iov_base;
 269     size_t iov_len;
 270 };
 271 /*
 272  * Use the same value as Linux for now.
 273  */
 274 #define IOV_MAX 1024
 275
 276 ssize_t readv(int fd, const struct iovec *iov, int iov_cnt);
 277 ssize_t writev(int fd, const struct iovec *iov, int iov_cnt);
 278 #else
 279 #include <sys/uio.h>
 280 #endif
 281
 282 #ifdef _WIN32
 283 static inline void qemu_timersub(const struct timeval *val1,
 284                                  const struct timeval *val2,
 285                                  struct timeval *res)
 286 {
 287     res->tv_sec = val1->tv_sec - val2->tv_sec;
 288     if (val1->tv_usec < val2->tv_usec) {
 289         res->tv_sec--;
 290         res->tv_usec = val1->tv_usec - val2->tv_usec + 1000 * 1000;
 291     } else {
 292         res->tv_usec = val1->tv_usec - val2->tv_usec;
 293     }
 294 }
 295 #else
 296 #define qemu_timersub timersub
 297 #endif
 298
 299 void qemu_set_cloexec(int fd);
 300
 301 /* QEMU "hardware version" setting. Used to replace code that exposed
 302  * QEMU_VERSION to guests in the past and need to keep compatibilty.
 303  * Do not use qemu_hw_version() in new code.
 304  */
 305 void qemu_set_hw_version(const char *);
 306 const char *qemu_hw_version(void);
 307
 308 void fips_set_state(bool requested);
 309 bool fips_get_state(void);
 310
 311 /* Return a dynamically allocated pathname denoting a file or directory that is
 312  * appropriate for storing local state.
 313  *
 314  * @relative_pathname need not start with a directory separator; one will be
 315  * added automatically.
 316  *
 317  * The caller is responsible for releasing the value returned with g_free()
 318  * after use.
 319  */
 320 char *qemu_get_local_state_pathname(const char *relative_pathname);
 321
 322 /* Find program directory, and save it for later usage with
 323  * qemu_get_exec_dir().
 324  * Try OS specific API first, if not working, parse from argv0. */
 325 void qemu_init_exec_dir(const char *argv0);
 326
 327 /* Get the saved exec dir.
 328  * Caller needs to release the returned string by g_free() */
 329 char *qemu_get_exec_dir(void);
 330
 331 /**
 332  * qemu_getauxval:
 333  * @type: the auxiliary vector key to lookup
 334  *
 335  * Search the auxiliary vector for @type, returning the value
 336  * or 0 if @type is not present.
 337  */
 338 unsigned long qemu_getauxval(unsigned long type);
 339
 340 void qemu_set_tty_echo(int fd, bool echo);
 341
 342 void os_mem_prealloc(int fd, char *area, size_t sz);
 343
 344 int qemu_read_password(char *buf, int buf_size);
 345
 346 /**
 347  * qemu_fork:
 348  *
 349  * A version of fork that avoids signal handler race
 350  * conditions that can lead to child process getting
 351  * signals that are otherwise only expected by the
 352  * parent. It also resets all signal handlers to the
 353  * default settings.
 354  *
 355  * Returns 0 to child process, pid number to parent
 356  * or -1 on failure.
 357  */
 358 pid_t qemu_fork(Error **errp);
 359
 360 #endif