os/os-linux.h

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