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