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/vfs.h>
  10 #include <sys/mman.h>
  11 #include <unistd.h>
  12 #include <fcntl.h>
  13 #include <errno.h>
  14 #include <sched.h>
  15 #include <linux/unistd.h>
  16 #include <linux/raw.h>
  17 #include <linux/major.h>
  18
  19 #include "binject.h"
  20 #include "../file.h"
  21
  22 #define FIO_HAVE_CPU_AFFINITY
  23 #define FIO_HAVE_DISK_UTIL
  24 #define FIO_HAVE_SGIO
  25 #define FIO_HAVE_IOPRIO
  26 #define FIO_HAVE_IOSCHED_SWITCH
  27 #define FIO_HAVE_ODIRECT
  28 #define FIO_HAVE_HUGETLB
  29 #define FIO_HAVE_RAWBIND
  30 #define FIO_HAVE_BLKTRACE
  31 #define FIO_HAVE_PSHARED_MUTEX
  32 #define FIO_HAVE_CL_SIZE
  33 #define FIO_HAVE_CGROUPS
  34 #define FIO_HAVE_FS_STAT
  35 #define FIO_HAVE_TRIM
  36 #define FIO_HAVE_BINJECT
  37 #define FIO_HAVE_GETTID
  38 #define FIO_USE_GENERIC_INIT_RANDOM_STATE
  39
  40 #ifdef MAP_HUGETLB
  41 #define FIO_HAVE_MMAP_HUGE
  42 #endif
  43
  44 #define OS_MAP_ANON             MAP_ANONYMOUS
  45
  46 typedef cpu_set_t os_cpu_mask_t;
  47
  48 typedef struct drand48_data os_random_state_t;
  49
  50 #ifdef CONFIG_3ARG_AFFINITY
  51 #define fio_setaffinity(pid, cpumask)           \
  52         sched_setaffinity((pid), sizeof(cpumask), &(cpumask))
  53 #define fio_getaffinity(pid, ptr)       \
  54         sched_getaffinity((pid), sizeof(cpu_set_t), (ptr))
  55 #elif defined(CONFIG_2ARG_AFFINITY)
  56 #define fio_setaffinity(pid, cpumask)   \
  57         sched_setaffinity((pid), &(cpumask))
  58 #define fio_getaffinity(pid, ptr)       \
  59         sched_getaffinity((pid), (ptr))
  60 #endif
  61
  62 #define fio_cpu_clear(mask, cpu)        (void) CPU_CLR((cpu), (mask))
  63 #define fio_cpu_set(mask, cpu)          (void) CPU_SET((cpu), (mask))
  64
  65 static inline int fio_cpuset_init(os_cpu_mask_t *mask)
  66 {
  67         CPU_ZERO(mask);
  68         return 0;
  69 }
  70
  71 static inline int fio_cpuset_exit(os_cpu_mask_t *mask)
  72 {
  73         return 0;
  74 }
  75
  76 #define FIO_MAX_CPUS                    CPU_SETSIZE
  77
  78 enum {
  79         IOPRIO_CLASS_NONE,
  80         IOPRIO_CLASS_RT,
  81         IOPRIO_CLASS_BE,
  82         IOPRIO_CLASS_IDLE,
  83 };
  84
  85 enum {
  86         IOPRIO_WHO_PROCESS = 1,
  87         IOPRIO_WHO_PGRP,
  88         IOPRIO_WHO_USER,
  89 };
  90
  91 #define IOPRIO_BITS             16
  92 #define IOPRIO_CLASS_SHIFT      13
  93
  94 static inline int ioprio_set(int which, int who, int ioprio_class, int ioprio)
  95 {
  96         /*
  97          * If no class is set, assume BE
  98          */
  99         if (!ioprio_class)
 100                 ioprio_class = IOPRIO_CLASS_BE;
 101
 102         ioprio |= ioprio_class << IOPRIO_CLASS_SHIFT;
 103         return syscall(__NR_ioprio_set, which, who, ioprio);
 104 }
 105
 106 static inline int gettid(void)
 107 {
 108         return syscall(__NR_gettid);
 109 }
 110
 111 #define SPLICE_DEF_SIZE (64*1024)
 112
 113 #ifndef BLKGETSIZE64
 114 #define BLKGETSIZE64    _IOR(0x12,114,size_t)
 115 #endif
 116
 117 #ifndef BLKFLSBUF
 118 #define BLKFLSBUF       _IO(0x12,97)
 119 #endif
 120
 121 #ifndef BLKDISCARD
 122 #define BLKDISCARD      _IO(0x12,119)
 123 #endif
 124
 125 static inline int blockdev_invalidate_cache(struct fio_file *f)
 126 {
 127         return ioctl(f->fd, BLKFLSBUF);
 128 }
 129
 130 static inline int blockdev_size(struct fio_file *f, unsigned long long *bytes)
 131 {
 132         if (!ioctl(f->fd, BLKGETSIZE64, bytes))
 133                 return 0;
 134
 135         return errno;
 136 }
 137
 138 static inline unsigned long long os_phys_mem(void)
 139 {
 140         long pagesize, pages;
 141
 142         pagesize = sysconf(_SC_PAGESIZE);
 143         pages = sysconf(_SC_PHYS_PAGES);
 144         if (pages == -1 || pagesize == -1)
 145                 return 0;
 146
 147         return (unsigned long long) pages * (unsigned long long) pagesize;
 148 }
 149
 150 static inline void os_random_seed(unsigned long seed, os_random_state_t *rs)
 151 {
 152         srand48_r(seed, rs);
 153 }
 154
 155 static inline long os_random_long(os_random_state_t *rs)
 156 {
 157         long val;
 158
 159         lrand48_r(rs, &val);
 160         return val;
 161 }
 162
 163 static inline int fio_lookup_raw(dev_t dev, int *majdev, int *mindev)
 164 {
 165         struct raw_config_request rq;
 166         int fd;
 167
 168         if (major(dev) != RAW_MAJOR)
 169                 return 1;
 170
 171         /*
 172          * we should be able to find /dev/rawctl or /dev/raw/rawctl
 173          */
 174         fd = open("/dev/rawctl", O_RDONLY);
 175         if (fd < 0) {
 176                 fd = open("/dev/raw/rawctl", O_RDONLY);
 177                 if (fd < 0)
 178                         return 1;
 179         }
 180
 181         rq.raw_minor = minor(dev);
 182         if (ioctl(fd, RAW_GETBIND, &rq) < 0) {
 183                 close(fd);
 184                 return 1;
 185         }
 186
 187         close(fd);
 188         *majdev = rq.block_major;
 189         *mindev = rq.block_minor;
 190         return 0;
 191 }
 192
 193 #ifdef O_NOATIME
 194 #define FIO_O_NOATIME   O_NOATIME
 195 #else
 196 #define FIO_O_NOATIME   0
 197 #endif
 198
 199 #ifdef O_ATOMIC
 200 #define OS_O_ATOMIC     O_ATOMIC
 201 #else
 202 #define OS_O_ATOMIC     040000000
 203 #endif
 204
 205 #ifdef MADV_REMOVE
 206 #define FIO_MADV_FREE   MADV_REMOVE
 207 #endif
 208
 209 #define fio_swap16(x)   __bswap_16(x)
 210 #define fio_swap32(x)   __bswap_32(x)
 211 #define fio_swap64(x)   __bswap_64(x)
 212
 213 #define CACHE_LINE_FILE \
 214         "/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size"
 215
 216 static inline int arch_cache_line_size(void)
 217 {
 218         char size[32];
 219         int fd, ret;
 220
 221         fd = open(CACHE_LINE_FILE, O_RDONLY);
 222         if (fd < 0)
 223                 return -1;
 224
 225         ret = read(fd, size, sizeof(size));
 226
 227         close(fd);
 228
 229         if (ret <= 0)
 230                 return -1;
 231         else
 232                 return atoi(size);
 233 }
 234
 235 static inline unsigned long long get_fs_size(const char *path)
 236 {
 237         unsigned long long ret;
 238         struct statfs s;
 239
 240         if (statfs(path, &s) < 0)
 241                 return -1ULL;
 242
 243         ret = s.f_bsize;
 244         ret *= (unsigned long long) s.f_bfree;
 245         return ret;
 246 }
 247
 248 static inline int os_trim(int fd, unsigned long long start,
 249                           unsigned long long len)
 250 {
 251         uint64_t range[2];
 252
 253         range[0] = start;
 254         range[1] = len;
 255
 256         if (!ioctl(fd, BLKDISCARD, range))
 257                 return 0;
 258
 259         return errno;
 260 }
 261
 262 #ifdef CONFIG_SCHED_IDLE
 263 static inline int fio_set_sched_idle(void)
 264 {
 265         struct sched_param p = { .sched_priority = 0, };
 266         return sched_setscheduler(gettid(), SCHED_IDLE, &p);
 267 }
 268 #endif
 269
 270 #endif