lib/pattern: fix formatting
[fio.git] / os / os-linux.h
1 #ifndef FIO_OS_LINUX_H
2 #define FIO_OS_LINUX_H
3
4 #ifdef __ANDROID__
5 #define FIO_OS  os_android
6 #else
7 #define FIO_OS  os_linux
8 #endif
9
10 #include <sys/ioctl.h>
11 #include <sys/uio.h>
12 #include <sys/syscall.h>
13 #include <sys/sysmacros.h>
14 #include <sys/vfs.h>
15 #include <sys/mman.h>
16 #include <unistd.h>
17 #include <fcntl.h>
18 #include <errno.h>
19 #include <sched.h>
20 #include <linux/unistd.h>
21 #include <linux/major.h>
22 #include <linux/fs.h>
23 #include <scsi/sg.h>
24 #include <asm/byteorder.h>
25 #ifdef __ANDROID__
26 #include "os-ashmem.h"
27 #define FIO_NO_HAVE_SHM_H
28 #endif
29
30 #ifdef ARCH_HAVE_CRC_CRYPTO
31 #include <sys/auxv.h>
32 #ifndef HWCAP_PMULL
33 #define HWCAP_PMULL             (1 << 4)
34 #endif /* HWCAP_PMULL */
35 #ifndef HWCAP_CRC32
36 #define HWCAP_CRC32             (1 << 7)
37 #endif /* HWCAP_CRC32 */
38 #endif /* ARCH_HAVE_CRC_CRYPTO */
39
40 #include "./os-linux-syscall.h"
41 #include "../file.h"
42
43 #ifndef __has_builtin         // Optional of course.
44   #define __has_builtin(x) 0  // Compatibility with non-clang compilers.
45 #endif
46
47 #define FIO_HAVE_CPU_AFFINITY
48 #define FIO_HAVE_DISK_UTIL
49 #define FIO_HAVE_SGIO
50 #define FIO_HAVE_IOPRIO
51 #define FIO_HAVE_IOPRIO_CLASS
52 #define FIO_HAVE_IOSCHED_SWITCH
53 #define FIO_HAVE_ODIRECT
54 #define FIO_HAVE_HUGETLB
55 #define FIO_HAVE_BLKTRACE
56 #define FIO_HAVE_CL_SIZE
57 #define FIO_HAVE_CGROUPS
58 #define FIO_HAVE_FS_STAT
59 #define FIO_HAVE_TRIM
60 #define FIO_HAVE_GETTID
61 #define FIO_USE_GENERIC_INIT_RANDOM_STATE
62 #define FIO_HAVE_BYTEORDER_FUNCS
63 #define FIO_HAVE_PWRITEV2
64 #define FIO_HAVE_SHM_ATTACH_REMOVED
65
66 #ifdef MAP_HUGETLB
67 #define FIO_HAVE_MMAP_HUGE
68 #endif
69
70 #define OS_MAP_ANON             MAP_ANONYMOUS
71
72 #define FIO_EXT_ENG_DIR "/usr/local/lib/fio"
73
74 typedef cpu_set_t os_cpu_mask_t;
75
76 #ifdef CONFIG_3ARG_AFFINITY
77 #define fio_setaffinity(pid, cpumask)           \
78         sched_setaffinity((pid), sizeof(cpumask), &(cpumask))
79 #define fio_getaffinity(pid, ptr)       \
80         sched_getaffinity((pid), sizeof(cpu_set_t), (ptr))
81 #elif defined(CONFIG_2ARG_AFFINITY)
82 #define fio_setaffinity(pid, cpumask)   \
83         sched_setaffinity((pid), &(cpumask))
84 #define fio_getaffinity(pid, ptr)       \
85         sched_getaffinity((pid), (ptr))
86 #endif
87
88 #ifdef CONFIG_PTHREAD_GETAFFINITY
89 #define FIO_HAVE_GET_THREAD_AFFINITY
90 #define fio_get_thread_affinity(mask)   \
91         pthread_getaffinity_np(pthread_self(), sizeof(mask), &(mask))
92 #endif
93
94 #define fio_cpu_clear(mask, cpu)        CPU_CLR((cpu), (mask))
95 #define fio_cpu_set(mask, cpu)          CPU_SET((cpu), (mask))
96 #define fio_cpu_isset(mask, cpu)        (CPU_ISSET((cpu), (mask)) != 0)
97 #define fio_cpu_count(mask)             CPU_COUNT((mask))
98
99 static inline int fio_cpuset_init(os_cpu_mask_t *mask)
100 {
101         CPU_ZERO(mask);
102         return 0;
103 }
104
105 static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
106 {
107         return 0;
108 }
109
110 #define FIO_MAX_CPUS                    CPU_SETSIZE
111
112 enum {
113         IOPRIO_CLASS_NONE,
114         IOPRIO_CLASS_RT,
115         IOPRIO_CLASS_BE,
116         IOPRIO_CLASS_IDLE,
117 };
118
119 enum {
120         IOPRIO_WHO_PROCESS = 1,
121         IOPRIO_WHO_PGRP,
122         IOPRIO_WHO_USER,
123 };
124
125 #define IOPRIO_BITS             16
126 #define IOPRIO_CLASS_SHIFT      13
127
128 #define IOPRIO_MIN_PRIO         0       /* highest priority */
129 #define IOPRIO_MAX_PRIO         7       /* lowest priority */
130
131 #define IOPRIO_MIN_PRIO_CLASS   0
132 #define IOPRIO_MAX_PRIO_CLASS   3
133
134 static inline int ioprio_value(int ioprio_class, int ioprio)
135 {
136         /*
137          * If no class is set, assume BE
138          */
139         if (!ioprio_class)
140                 ioprio_class = IOPRIO_CLASS_BE;
141
142         return (ioprio_class << IOPRIO_CLASS_SHIFT) | ioprio;
143 }
144
145 static inline bool ioprio_value_is_class_rt(unsigned int priority)
146 {
147         return (priority >> IOPRIO_CLASS_SHIFT) == IOPRIO_CLASS_RT;
148 }
149
150 static inline int ioprio_set(int which, int who, int ioprio_class, int ioprio)
151 {
152         return syscall(__NR_ioprio_set, which, who,
153                        ioprio_value(ioprio_class, ioprio));
154 }
155
156 #ifndef CONFIG_HAVE_GETTID
157 static inline int gettid(void)
158 {
159         return syscall(__NR_gettid);
160 }
161 #endif
162
163 #define SPLICE_DEF_SIZE (64*1024)
164
165 #ifndef BLKGETSIZE64
166 #define BLKGETSIZE64    _IOR(0x12,114,size_t)
167 #endif
168
169 #ifndef BLKFLSBUF
170 #define BLKFLSBUF       _IO(0x12,97)
171 #endif
172
173 #ifndef BLKDISCARD
174 #define BLKDISCARD      _IO(0x12,119)
175 #endif
176
177 static inline int blockdev_invalidate_cache(struct fio_file *f)
178 {
179         return ioctl(f->fd, BLKFLSBUF);
180 }
181
182 static inline int blockdev_size(struct fio_file *f, unsigned long long *bytes)
183 {
184         if (!ioctl(f->fd, BLKGETSIZE64, bytes))
185                 return 0;
186
187         return errno;
188 }
189
190 static inline unsigned long long os_phys_mem(void)
191 {
192         long pagesize, pages;
193
194         pagesize = sysconf(_SC_PAGESIZE);
195         pages = sysconf(_SC_PHYS_PAGES);
196         if (pages == -1 || pagesize == -1)
197                 return 0;
198
199         return (unsigned long long) pages * (unsigned long long) pagesize;
200 }
201
202 #ifdef O_NOATIME
203 #define FIO_O_NOATIME   O_NOATIME
204 #else
205 #define FIO_O_NOATIME   0
206 #endif
207
208 #ifdef O_ATOMIC
209 #define OS_O_ATOMIC     O_ATOMIC
210 #else
211 #define OS_O_ATOMIC     040000000
212 #endif
213
214 #ifdef MADV_REMOVE
215 #define FIO_MADV_FREE   MADV_REMOVE
216 #endif
217
218 /* Check for GCC or Clang byte swap intrinsics */
219 #if (__has_builtin(__builtin_bswap16) && __has_builtin(__builtin_bswap32) \
220      && __has_builtin(__builtin_bswap64)) || (__GNUC__ > 4 \
221      || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)) /* fio_swapN */
222 #define fio_swap16(x)   __builtin_bswap16(x)
223 #define fio_swap32(x)   __builtin_bswap32(x)
224 #define fio_swap64(x)   __builtin_bswap64(x)
225 #else
226 #include <byteswap.h>
227 #define fio_swap16(x)   bswap_16(x)
228 #define fio_swap32(x)   bswap_32(x)
229 #define fio_swap64(x)   bswap_64(x)
230 #endif /* fio_swapN */
231
232 #define CACHE_LINE_FILE \
233         "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size"
234
235 static inline int arch_cache_line_size(void)
236 {
237         char size[32];
238         int fd, ret;
239
240         fd = open(CACHE_LINE_FILE, O_RDONLY);
241         if (fd < 0)
242                 return -1;
243
244         ret = read(fd, size, sizeof(size));
245
246         close(fd);
247
248         if (ret <= 0)
249                 return -1;
250         else
251                 return atoi(size);
252 }
253
254 static inline unsigned long long get_fs_free_size(const char *path)
255 {
256         unsigned long long ret;
257         struct statfs s;
258
259         if (statfs(path, &s) < 0)
260                 return -1ULL;
261
262         ret = s.f_bsize;
263         ret *= (unsigned long long) s.f_bfree;
264         return ret;
265 }
266
267 static inline int os_trim(struct fio_file *f, unsigned long long start,
268                           unsigned long long len)
269 {
270         uint64_t range[2];
271
272         range[0] = start;
273         range[1] = len;
274
275         if (!ioctl(f->fd, BLKDISCARD, range))
276                 return 0;
277
278         return errno;
279 }
280
281 #ifdef CONFIG_SCHED_IDLE
282 static inline int fio_set_sched_idle(void)
283 {
284         struct sched_param p = { .sched_priority = 0, };
285         return sched_setscheduler(gettid(), SCHED_IDLE, &p);
286 }
287 #endif
288
289 #ifndef F_GET_RW_HINT
290 #ifndef F_LINUX_SPECIFIC_BASE
291 #define F_LINUX_SPECIFIC_BASE   1024
292 #endif
293 #define F_GET_RW_HINT           (F_LINUX_SPECIFIC_BASE + 11)
294 #define F_SET_RW_HINT           (F_LINUX_SPECIFIC_BASE + 12)
295 #define F_GET_FILE_RW_HINT      (F_LINUX_SPECIFIC_BASE + 13)
296 #define F_SET_FILE_RW_HINT      (F_LINUX_SPECIFIC_BASE + 14)
297 #endif
298
299 #ifndef RWH_WRITE_LIFE_NONE
300 #define RWH_WRITE_LIFE_NOT_SET  0
301 #define RWH_WRITE_LIFE_NONE     1
302 #define RWH_WRITE_LIFE_SHORT    2
303 #define RWH_WRITE_LIFE_MEDIUM   3
304 #define RWH_WRITE_LIFE_LONG     4
305 #define RWH_WRITE_LIFE_EXTREME  5
306 #endif
307
308 #define FIO_HAVE_WRITE_HINT
309
310 #ifndef RWF_HIPRI
311 #define RWF_HIPRI       0x00000001
312 #endif
313 #ifndef RWF_DSYNC
314 #define RWF_DSYNC       0x00000002
315 #endif
316 #ifndef RWF_SYNC
317 #define RWF_SYNC        0x00000004
318 #endif
319 #ifndef RWF_NOWAIT
320 #define RWF_NOWAIT      0x00000008
321 #endif
322
323 #ifndef RWF_UNCACHED
324 #define RWF_UNCACHED    0x00000040
325 #endif
326
327 #ifndef RWF_WRITE_LIFE_SHIFT
328 #define RWF_WRITE_LIFE_SHIFT            4
329 #define RWF_WRITE_LIFE_SHORT            (1 << RWF_WRITE_LIFE_SHIFT)
330 #define RWF_WRITE_LIFE_MEDIUM           (2 << RWF_WRITE_LIFE_SHIFT)
331 #define RWF_WRITE_LIFE_LONG             (3 << RWF_WRITE_LIFE_SHIFT)
332 #define RWF_WRITE_LIFE_EXTREME          (4 << RWF_WRITE_LIFE_SHIFT)
333 #endif
334
335 #ifndef CONFIG_PWRITEV2
336 #ifdef __NR_preadv2
337 static inline void make_pos_h_l(unsigned long *pos_h, unsigned long *pos_l,
338                                 off_t offset)
339 {
340 #if BITS_PER_LONG == 64
341         *pos_l = offset;
342         *pos_h = 0;
343 #else
344         *pos_l = offset & 0xffffffff;
345         *pos_h = ((uint64_t) offset) >> 32;
346 #endif
347 }
348 static inline ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt,
349                               off_t offset, unsigned int flags)
350 {
351         unsigned long pos_l, pos_h;
352
353         make_pos_h_l(&pos_h, &pos_l, offset);
354         return syscall(__NR_preadv2, fd, iov, iovcnt, pos_l, pos_h, flags);
355 }
356 static inline ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt,
357                                off_t offset, unsigned int flags)
358 {
359         unsigned long pos_l, pos_h;
360
361         make_pos_h_l(&pos_h, &pos_l, offset);
362         return syscall(__NR_pwritev2, fd, iov, iovcnt, pos_l, pos_h, flags);
363 }
364 #else
365 static inline ssize_t preadv2(int fd, const struct iovec *iov, int iovcnt,
366                               off_t offset, unsigned int flags)
367 {
368         errno = ENOSYS;
369         return -1;
370 }
371 static inline ssize_t pwritev2(int fd, const struct iovec *iov, int iovcnt,
372                                off_t offset, unsigned int flags)
373 {
374         errno = ENOSYS;
375         return -1;
376 }
377 #endif /* __NR_preadv2 */
378 #endif /* CONFIG_PWRITEV2 */
379
380 static inline int shm_attach_to_open_removed(void)
381 {
382         return 1;
383 }
384
385 #ifdef CONFIG_LINUX_FALLOCATE
386 #define FIO_HAVE_NATIVE_FALLOCATE
387 static inline bool fio_fallocate(struct fio_file *f, uint64_t offset,
388                                  uint64_t len)
389 {
390         int ret;
391         ret = fallocate(f->fd, 0, offset, len);
392         if (ret == 0)
393                 return true;
394
395         /* Work around buggy old glibc versions... */
396         if (ret > 0)
397                 errno = ret;
398
399         return false;
400 }
401 #endif
402
403 #define FIO_HAVE_CPU_HAS
404 static inline bool os_cpu_has(cpu_features feature)
405 {
406         bool have_feature;
407         unsigned long fio_unused hwcap;
408
409         switch (feature) {
410 #ifdef ARCH_HAVE_CRC_CRYPTO
411         case CPU_ARM64_CRC32C:
412                 hwcap = getauxval(AT_HWCAP);
413                 have_feature = (hwcap & (HWCAP_PMULL | HWCAP_CRC32)) ==
414                                (HWCAP_PMULL | HWCAP_CRC32);
415                 break;
416 #endif
417         default:
418                 have_feature = false;
419         }
420
421         return have_feature;
422 }
423
424 #endif