1 /* 2 * os-posix-lib.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010 Red Hat, Inc. 6 * 7 * QEMU library functions on POSIX which are shared between QEMU and 8 * the QEMU tools. 9 * 10 * Permission is hereby granted, free of charge, to any person obtaining a copy 11 * of this software and associated documentation files (the "Software"), to deal 12 * in the Software without restriction, including without limitation the rights 13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 14 * copies of the Software, and to permit persons to whom the Software is 15 * furnished to do so, subject to the following conditions: 16 * 17 * The above copyright notice and this permission notice shall be included in 18 * all copies or substantial portions of the Software. 19 * 20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 26 * THE SOFTWARE. 27 */ 28 29 /* The following block of code temporarily renames the daemon() function so the 30 compiler does not see the warning associated with it in stdlib.h on OSX */ 31 #ifdef __APPLE__ 32 #define daemon qemu_fake_daemon_function 33 #include <stdlib.h> 34 #undef daemon 35 extern int daemon(int, int); 36 #endif 37 38 #if defined(__linux__) && (defined(__x86_64__) || defined(__arm__)) 39 /* Use 2 MiB alignment so transparent hugepages can be used by KVM. 40 Valgrind does not support alignments larger than 1 MiB, 41 therefore we need special code which handles running on Valgrind. */ 42 # define QEMU_VMALLOC_ALIGN (512 * 4096) 43 #elif defined(__linux__) && defined(__s390x__) 44 /* Use 1 MiB (segment size) alignment so gmap can be used by KVM. */ 45 # define QEMU_VMALLOC_ALIGN (256 * 4096) 46 #else 47 # define QEMU_VMALLOC_ALIGN getpagesize() 48 #endif 49 50 #include <glib/gprintf.h> 51 52 #include "config-host.h" 53 #include "sysemu/sysemu.h" 54 #include "trace.h" 55 #include "qemu/sockets.h" 56 #include <sys/mman.h> 57 58 #ifdef CONFIG_LINUX 59 #include <sys/syscall.h> 60 #endif 61 62 int qemu_get_thread_id(void) 63 { 64 #if defined(__linux__) 65 return syscall(SYS_gettid); 66 #else 67 return getpid(); 68 #endif 69 } 70 71 int qemu_daemon(int nochdir, int noclose) 72 { 73 return daemon(nochdir, noclose); 74 } 75 76 void *qemu_oom_check(void *ptr) 77 { 78 if (ptr == NULL) { 79 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno)); 80 abort(); 81 } 82 return ptr; 83 } 84 85 void *qemu_memalign(size_t alignment, size_t size) 86 { 87 void *ptr; 88 #if defined(_POSIX_C_SOURCE) && !defined(__sun__) 89 int ret; 90 ret = posix_memalign(&ptr, alignment, size); 91 if (ret != 0) { 92 fprintf(stderr, "Failed to allocate %zu B: %s\n", 93 size, strerror(ret)); 94 abort(); 95 } 96 #elif defined(CONFIG_BSD) 97 ptr = qemu_oom_check(valloc(size)); 98 #else 99 ptr = qemu_oom_check(memalign(alignment, size)); 100 #endif 101 trace_qemu_memalign(alignment, size, ptr); 102 return ptr; 103 } 104 105 /* alloc shared memory pages */ 106 void *qemu_anon_ram_alloc(size_t size) 107 { 108 size_t align = QEMU_VMALLOC_ALIGN; 109 size_t total = size + align - getpagesize(); 110 void *ptr = mmap(0, total, PROT_READ | PROT_WRITE, 111 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); 112 size_t offset = QEMU_ALIGN_UP((uintptr_t)ptr, align) - (uintptr_t)ptr; 113 114 if (ptr == MAP_FAILED) { 115 return NULL; 116 } 117 118 ptr += offset; 119 total -= offset; 120 121 if (offset > 0) { 122 munmap(ptr - offset, offset); 123 } 124 if (total > size) { 125 munmap(ptr + size, total - size); 126 } 127 128 trace_qemu_anon_ram_alloc(size, ptr); 129 return ptr; 130 } 131 132 void qemu_vfree(void *ptr) 133 { 134 trace_qemu_vfree(ptr); 135 free(ptr); 136 } 137 138 void qemu_anon_ram_free(void *ptr, size_t size) 139 { 140 trace_qemu_anon_ram_free(ptr, size); 141 if (ptr) { 142 munmap(ptr, size); 143 } 144 } 145 146 void qemu_set_block(int fd) 147 { 148 int f; 149 f = fcntl(fd, F_GETFL); 150 fcntl(fd, F_SETFL, f & ~O_NONBLOCK); 151 } 152 153 void qemu_set_nonblock(int fd) 154 { 155 int f; 156 f = fcntl(fd, F_GETFL); 157 fcntl(fd, F_SETFL, f | O_NONBLOCK); 158 } 159 160 void qemu_set_cloexec(int fd) 161 { 162 int f; 163 f = fcntl(fd, F_GETFD); 164 fcntl(fd, F_SETFD, f | FD_CLOEXEC); 165 } 166 167 /* 168 * Creates a pipe with FD_CLOEXEC set on both file descriptors 169 */ 170 int qemu_pipe(int pipefd[2]) 171 { 172 int ret; 173 174 #ifdef CONFIG_PIPE2 175 ret = pipe2(pipefd, O_CLOEXEC); 176 if (ret != -1 || errno != ENOSYS) { 177 return ret; 178 } 179 #endif 180 ret = pipe(pipefd); 181 if (ret == 0) { 182 qemu_set_cloexec(pipefd[0]); 183 qemu_set_cloexec(pipefd[1]); 184 } 185 186 return ret; 187 } 188 189 int qemu_utimens(const char *path, const struct timespec *times) 190 { 191 struct timeval tv[2], tv_now; 192 struct stat st; 193 int i; 194 #ifdef CONFIG_UTIMENSAT 195 int ret; 196 197 ret = utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW); 198 if (ret != -1 || errno != ENOSYS) { 199 return ret; 200 } 201 #endif 202 /* Fallback: use utimes() instead of utimensat() */ 203 204 /* happy if special cases */ 205 if (times[0].tv_nsec == UTIME_OMIT && times[1].tv_nsec == UTIME_OMIT) { 206 return 0; 207 } 208 if (times[0].tv_nsec == UTIME_NOW && times[1].tv_nsec == UTIME_NOW) { 209 return utimes(path, NULL); 210 } 211 212 /* prepare for hard cases */ 213 if (times[0].tv_nsec == UTIME_NOW || times[1].tv_nsec == UTIME_NOW) { 214 gettimeofday(&tv_now, NULL); 215 } 216 if (times[0].tv_nsec == UTIME_OMIT || times[1].tv_nsec == UTIME_OMIT) { 217 stat(path, &st); 218 } 219 220 for (i = 0; i < 2; i++) { 221 if (times[i].tv_nsec == UTIME_NOW) { 222 tv[i].tv_sec = tv_now.tv_sec; 223 tv[i].tv_usec = tv_now.tv_usec; 224 } else if (times[i].tv_nsec == UTIME_OMIT) { 225 tv[i].tv_sec = (i == 0) ? st.st_atime : st.st_mtime; 226 tv[i].tv_usec = 0; 227 } else { 228 tv[i].tv_sec = times[i].tv_sec; 229 tv[i].tv_usec = times[i].tv_nsec / 1000; 230 } 231 } 232 233 return utimes(path, &tv[0]); 234 } 235 236 char * 237 qemu_get_local_state_pathname(const char *relative_pathname) 238 { 239 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR, 240 relative_pathname); 241 } 242