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 361