drivers/md/bcache/util.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2
   3 #ifndef _BCACHE_UTIL_H
   4 #define _BCACHE_UTIL_H
   5
   6 #include <linux/blkdev.h>
   7 #include <linux/errno.h>
   8 #include <linux/kernel.h>
   9 #include <linux/sched/clock.h>
  10 #include <linux/llist.h>
  11 #include <linux/ratelimit.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/workqueue.h>
  14 #include <linux/crc64.h>
  15
  16 #include "closure.h"
  17
  18 #define PAGE_SECTORS            (PAGE_SIZE / 512)
  19
  20 struct closure;
  21
  22 #ifdef CONFIG_BCACHE_DEBUG
  23
  24 #define EBUG_ON(cond)                   BUG_ON(cond)
  25 #define atomic_dec_bug(v)       BUG_ON(atomic_dec_return(v) < 0)
  26 #define atomic_inc_bug(v, i)    BUG_ON(atomic_inc_return(v) <= i)
  27
  28 #else /* DEBUG */
  29
  30 #define EBUG_ON(cond)                   do { if (cond); } while (0)
  31 #define atomic_dec_bug(v)       atomic_dec(v)
  32 #define atomic_inc_bug(v, i)    atomic_inc(v)
  33
  34 #endif
  35
  36 #define DECLARE_HEAP(type, name)                                        \
  37         struct {                                                        \
  38                 size_t size, used;                                      \
  39                 type *data;                                             \
  40         } name
  41
  42 #define init_heap(heap, _size, gfp)                                     \
  43 ({                                                                      \
  44         size_t _bytes;                                                  \
  45         (heap)->used = 0;                                               \
  46         (heap)->size = (_size);                                         \
  47         _bytes = (heap)->size * sizeof(*(heap)->data);                  \
  48         (heap)->data = kvmalloc(_bytes, (gfp) & GFP_KERNEL);            \
  49         (heap)->data;                                                   \
  50 })
  51
  52 #define free_heap(heap)                                                 \
  53 do {                                                                    \
  54         kvfree((heap)->data);                                           \
  55         (heap)->data = NULL;                                            \
  56 } while (0)
  57
  58 #define heap_swap(h, i, j)      swap((h)->data[i], (h)->data[j])
  59
  60 #define heap_sift(h, i, cmp)                                            \
  61 do {                                                                    \
  62         size_t _r, _j = i;                                              \
  63                                                                         \
  64         for (; _j * 2 + 1 < (h)->used; _j = _r) {                       \
  65                 _r = _j * 2 + 1;                                        \
  66                 if (_r + 1 < (h)->used &&                               \
  67                     cmp((h)->data[_r], (h)->data[_r + 1]))              \
  68                         _r++;                                           \
  69                                                                         \
  70                 if (cmp((h)->data[_r], (h)->data[_j]))                  \
  71                         break;                                          \
  72                 heap_swap(h, _r, _j);                                   \
  73         }                                                               \
  74 } while (0)
  75
  76 #define heap_sift_down(h, i, cmp)                                       \
  77 do {                                                                    \
  78         while (i) {                                                     \
  79                 size_t p = (i - 1) / 2;                                 \
  80                 if (cmp((h)->data[i], (h)->data[p]))                    \
  81                         break;                                          \
  82                 heap_swap(h, i, p);                                     \
  83                 i = p;                                                  \
  84         }                                                               \
  85 } while (0)
  86
  87 #define heap_add(h, d, cmp)                                             \
  88 ({                                                                      \
  89         bool _r = !heap_full(h);                                        \
  90         if (_r) {                                                       \
  91                 size_t _i = (h)->used++;                                \
  92                 (h)->data[_i] = d;                                      \
  93                                                                         \
  94                 heap_sift_down(h, _i, cmp);                             \
  95                 heap_sift(h, _i, cmp);                                  \
  96         }                                                               \
  97         _r;                                                             \
  98 })
  99
 100 #define heap_pop(h, d, cmp)                                             \
 101 ({                                                                      \
 102         bool _r = (h)->used;                                            \
 103         if (_r) {                                                       \
 104                 (d) = (h)->data[0];                                     \
 105                 (h)->used--;                                            \
 106                 heap_swap(h, 0, (h)->used);                             \
 107                 heap_sift(h, 0, cmp);                                   \
 108         }                                                               \
 109         _r;                                                             \
 110 })
 111
 112 #define heap_peek(h)    ((h)->used ? (h)->data[0] : NULL)
 113
 114 #define heap_full(h)    ((h)->used == (h)->size)
 115
 116 #define DECLARE_FIFO(type, name)                                        \
 117         struct {                                                        \
 118                 size_t front, back, size, mask;                         \
 119                 type *data;                                             \
 120         } name
 121
 122 #define fifo_for_each(c, fifo, iter)                                    \
 123         for (iter = (fifo)->front;                                      \
 124              c = (fifo)->data[iter], iter != (fifo)->back;              \
 125              iter = (iter + 1) & (fifo)->mask)
 126
 127 #define __init_fifo(fifo, gfp)                                          \
 128 ({                                                                      \
 129         size_t _allocated_size, _bytes;                                 \
 130         BUG_ON(!(fifo)->size);                                          \
 131                                                                         \
 132         _allocated_size = roundup_pow_of_two((fifo)->size + 1);         \
 133         _bytes = _allocated_size * sizeof(*(fifo)->data);               \
 134                                                                         \
 135         (fifo)->mask = _allocated_size - 1;                             \
 136         (fifo)->front = (fifo)->back = 0;                               \
 137                                                                         \
 138         (fifo)->data = kvmalloc(_bytes, (gfp) & GFP_KERNEL);            \
 139         (fifo)->data;                                                   \
 140 })
 141
 142 #define init_fifo_exact(fifo, _size, gfp)                               \
 143 ({                                                                      \
 144         (fifo)->size = (_size);                                         \
 145         __init_fifo(fifo, gfp);                                         \
 146 })
 147
 148 #define init_fifo(fifo, _size, gfp)                                     \
 149 ({                                                                      \
 150         (fifo)->size = (_size);                                         \
 151         if ((fifo)->size > 4)                                           \
 152                 (fifo)->size = roundup_pow_of_two((fifo)->size) - 1;    \
 153         __init_fifo(fifo, gfp);                                         \
 154 })
 155
 156 #define free_fifo(fifo)                                                 \
 157 do {                                                                    \
 158         kvfree((fifo)->data);                                           \
 159         (fifo)->data = NULL;                                            \
 160 } while (0)
 161
 162 #define fifo_used(fifo)         (((fifo)->back - (fifo)->front) & (fifo)->mask)
 163 #define fifo_free(fifo)         ((fifo)->size - fifo_used(fifo))
 164
 165 #define fifo_empty(fifo)        (!fifo_used(fifo))
 166 #define fifo_full(fifo)         (!fifo_free(fifo))
 167
 168 #define fifo_front(fifo)        ((fifo)->data[(fifo)->front])
 169 #define fifo_back(fifo)                                                 \
 170         ((fifo)->data[((fifo)->back - 1) & (fifo)->mask])
 171
 172 #define fifo_idx(fifo, p)       (((p) - &fifo_front(fifo)) & (fifo)->mask)
 173
 174 #define fifo_push_back(fifo, i)                                         \
 175 ({                                                                      \
 176         bool _r = !fifo_full((fifo));                                   \
 177         if (_r) {                                                       \
 178                 (fifo)->data[(fifo)->back++] = (i);                     \
 179                 (fifo)->back &= (fifo)->mask;                           \
 180         }                                                               \
 181         _r;                                                             \
 182 })
 183
 184 #define fifo_pop_front(fifo, i)                                         \
 185 ({                                                                      \
 186         bool _r = !fifo_empty((fifo));                                  \
 187         if (_r) {                                                       \
 188                 (i) = (fifo)->data[(fifo)->front++];                    \
 189                 (fifo)->front &= (fifo)->mask;                          \
 190         }                                                               \
 191         _r;                                                             \
 192 })
 193
 194 #define fifo_push_front(fifo, i)                                        \
 195 ({                                                                      \
 196         bool _r = !fifo_full((fifo));                                   \
 197         if (_r) {                                                       \
 198                 --(fifo)->front;                                        \
 199                 (fifo)->front &= (fifo)->mask;                          \
 200                 (fifo)->data[(fifo)->front] = (i);                      \
 201         }                                                               \
 202         _r;                                                             \
 203 })
 204
 205 #define fifo_pop_back(fifo, i)                                          \
 206 ({                                                                      \
 207         bool _r = !fifo_empty((fifo));                                  \
 208         if (_r) {                                                       \
 209                 --(fifo)->back;                                         \
 210                 (fifo)->back &= (fifo)->mask;                           \
 211                 (i) = (fifo)->data[(fifo)->back]                        \
 212         }                                                               \
 213         _r;                                                             \
 214 })
 215
 216 #define fifo_push(fifo, i)      fifo_push_back(fifo, (i))
 217 #define fifo_pop(fifo, i)       fifo_pop_front(fifo, (i))
 218
 219 #define fifo_swap(l, r)                                                 \
 220 do {                                                                    \
 221         swap((l)->front, (r)->front);                                   \
 222         swap((l)->back, (r)->back);                                     \
 223         swap((l)->size, (r)->size);                                     \
 224         swap((l)->mask, (r)->mask);                                     \
 225         swap((l)->data, (r)->data);                                     \
 226 } while (0)
 227
 228 #define fifo_move(dest, src)                                            \
 229 do {                                                                    \
 230         typeof(*((dest)->data)) _t;                                     \
 231         while (!fifo_full(dest) &&                                      \
 232                fifo_pop(src, _t))                                       \
 233                 fifo_push(dest, _t);                                    \
 234 } while (0)
 235
 236 /*
 237  * Simple array based allocator - preallocates a number of elements and you can
 238  * never allocate more than that, also has no locking.
 239  *
 240  * Handy because if you know you only need a fixed number of elements you don't
 241  * have to worry about memory allocation failure, and sometimes a mempool isn't
 242  * what you want.
 243  *
 244  * We treat the free elements as entries in a singly linked list, and the
 245  * freelist as a stack - allocating and freeing push and pop off the freelist.
 246  */
 247
 248 #define DECLARE_ARRAY_ALLOCATOR(type, name, size)                       \
 249         struct {                                                        \
 250                 type    *freelist;                                      \
 251                 type    data[size];                                     \
 252         } name
 253
 254 #define array_alloc(array)                                              \
 255 ({                                                                      \
 256         typeof((array)->freelist) _ret = (array)->freelist;             \
 257                                                                         \
 258         if (_ret)                                                       \
 259                 (array)->freelist = *((typeof((array)->freelist) *) _ret);\
 260                                                                         \
 261         _ret;                                                           \
 262 })
 263
 264 #define array_free(array, ptr)                                          \
 265 do {                                                                    \
 266         typeof((array)->freelist) _ptr = ptr;                           \
 267                                                                         \
 268         *((typeof((array)->freelist) *) _ptr) = (array)->freelist;      \
 269         (array)->freelist = _ptr;                                       \
 270 } while (0)
 271
 272 #define array_allocator_init(array)                                     \
 273 do {                                                                    \
 274         typeof((array)->freelist) _i;                                   \
 275                                                                         \
 276         BUILD_BUG_ON(sizeof((array)->data[0]) < sizeof(void *));        \
 277         (array)->freelist = NULL;                                       \
 278                                                                         \
 279         for (_i = (array)->data;                                        \
 280              _i < (array)->data + ARRAY_SIZE((array)->data);            \
 281              _i++)                                                      \
 282                 array_free(array, _i);                                  \
 283 } while (0)
 284
 285 #define array_freelist_empty(array)     ((array)->freelist == NULL)
 286
 287 #define ANYSINT_MAX(t)                                                  \
 288         ((((t) 1 << (sizeof(t) * 8 - 2)) - (t) 1) * (t) 2 + (t) 1)
 289
 290 int bch_strtoint_h(const char *cp, int *res);
 291 int bch_strtouint_h(const char *cp, unsigned int *res);
 292 int bch_strtoll_h(const char *cp, long long *res);
 293 int bch_strtoull_h(const char *cp, unsigned long long *res);
 294
 295 static inline int bch_strtol_h(const char *cp, long *res)
 296 {
 297 #if BITS_PER_LONG == 32
 298         return bch_strtoint_h(cp, (int *) res);
 299 #else
 300         return bch_strtoll_h(cp, (long long *) res);
 301 #endif
 302 }
 303
 304 static inline int bch_strtoul_h(const char *cp, long *res)
 305 {
 306 #if BITS_PER_LONG == 32
 307         return bch_strtouint_h(cp, (unsigned int *) res);
 308 #else
 309         return bch_strtoull_h(cp, (unsigned long long *) res);
 310 #endif
 311 }
 312
 313 #define strtoi_h(cp, res)                                               \
 314         (__builtin_types_compatible_p(typeof(*res), int)                \
 315         ? bch_strtoint_h(cp, (void *) res)                              \
 316         : __builtin_types_compatible_p(typeof(*res), long)              \
 317         ? bch_strtol_h(cp, (void *) res)                                \
 318         : __builtin_types_compatible_p(typeof(*res), long long)         \
 319         ? bch_strtoll_h(cp, (void *) res)                               \
 320         : __builtin_types_compatible_p(typeof(*res), unsigned int)      \
 321         ? bch_strtouint_h(cp, (void *) res)                             \
 322         : __builtin_types_compatible_p(typeof(*res), unsigned long)     \
 323         ? bch_strtoul_h(cp, (void *) res)                               \
 324         : __builtin_types_compatible_p(typeof(*res), unsigned long long)\
 325         ? bch_strtoull_h(cp, (void *) res) : -EINVAL)
 326
 327 #define strtoul_safe(cp, var)                                           \
 328 ({                                                                      \
 329         unsigned long _v;                                               \
 330         int _r = kstrtoul(cp, 10, &_v);                                 \
 331         if (!_r)                                                        \
 332                 var = _v;                                               \
 333         _r;                                                             \
 334 })
 335
 336 #define strtoul_safe_clamp(cp, var, min, max)                           \
 337 ({                                                                      \
 338         unsigned long _v;                                               \
 339         int _r = kstrtoul(cp, 10, &_v);                                 \
 340         if (!_r)                                                        \
 341                 var = clamp_t(typeof(var), _v, min, max);               \
 342         _r;                                                             \
 343 })
 344
 345 #define snprint(buf, size, var)                                         \
 346         snprintf(buf, size,                                             \
 347                 __builtin_types_compatible_p(typeof(var), int)          \
 348                      ? "%i\n" :                                         \
 349                 __builtin_types_compatible_p(typeof(var), unsigned int) \
 350                      ? "%u\n" :                                         \
 351                 __builtin_types_compatible_p(typeof(var), long)         \
 352                      ? "%li\n" :                                        \
 353                 __builtin_types_compatible_p(typeof(var), unsigned long)\
 354                      ? "%lu\n" :                                        \
 355                 __builtin_types_compatible_p(typeof(var), int64_t)      \
 356                      ? "%lli\n" :                                       \
 357                 __builtin_types_compatible_p(typeof(var), uint64_t)     \
 358                      ? "%llu\n" :                                       \
 359                 __builtin_types_compatible_p(typeof(var), const char *) \
 360                      ? "%s\n" : "%i\n", var)
 361
 362 ssize_t bch_hprint(char *buf, int64_t v);
 363
 364 bool bch_is_zero(const char *p, size_t n);
 365 int bch_parse_uuid(const char *s, char *uuid);
 366
 367 struct time_stats {
 368         spinlock_t      lock;
 369         /*
 370          * all fields are in nanoseconds, averages are ewmas stored left shifted
 371          * by 8
 372          */
 373         uint64_t        max_duration;
 374         uint64_t        average_duration;
 375         uint64_t        average_frequency;
 376         uint64_t        last;
 377 };
 378
 379 void bch_time_stats_update(struct time_stats *stats, uint64_t time);
 380
 381 static inline unsigned int local_clock_us(void)
 382 {
 383         return local_clock() >> 10;
 384 }
 385
 386 #define NSEC_PER_ns                     1L
 387 #define NSEC_PER_us                     NSEC_PER_USEC
 388 #define NSEC_PER_ms                     NSEC_PER_MSEC
 389 #define NSEC_PER_sec                    NSEC_PER_SEC
 390
 391 #define __print_time_stat(stats, name, stat, units)                     \
 392         sysfs_print(name ## _ ## stat ## _ ## units,                    \
 393                     div_u64((stats)->stat >> 8, NSEC_PER_ ## units))
 394
 395 #define sysfs_print_time_stats(stats, name,                             \
 396                                frequency_units,                         \
 397                                duration_units)                          \
 398 do {                                                                    \
 399         __print_time_stat(stats, name,                                  \
 400                           average_frequency,    frequency_units);       \
 401         __print_time_stat(stats, name,                                  \
 402                           average_duration,     duration_units);        \
 403         sysfs_print(name ## _ ##max_duration ## _ ## duration_units,    \
 404                         div_u64((stats)->max_duration,                  \
 405                                 NSEC_PER_ ## duration_units));          \
 406                                                                         \
 407         sysfs_print(name ## _last_ ## frequency_units, (stats)->last    \
 408                     ? div_s64(local_clock() - (stats)->last,            \
 409                               NSEC_PER_ ## frequency_units)             \
 410                     : -1LL);                                            \
 411 } while (0)
 412
 413 #define sysfs_time_stats_attribute(name,                                \
 414                                    frequency_units,                     \
 415                                    duration_units)                      \
 416 read_attribute(name ## _average_frequency_ ## frequency_units);         \
 417 read_attribute(name ## _average_duration_ ## duration_units);           \
 418 read_attribute(name ## _max_duration_ ## duration_units);               \
 419 read_attribute(name ## _last_ ## frequency_units)
 420
 421 #define sysfs_time_stats_attribute_list(name,                           \
 422                                         frequency_units,                \
 423                                         duration_units)                 \
 424 &sysfs_ ## name ## _average_frequency_ ## frequency_units,              \
 425 &sysfs_ ## name ## _average_duration_ ## duration_units,                \
 426 &sysfs_ ## name ## _max_duration_ ## duration_units,                    \
 427 &sysfs_ ## name ## _last_ ## frequency_units,
 428
 429 #define ewma_add(ewma, val, weight, factor)                             \
 430 ({                                                                      \
 431         (ewma) *= (weight) - 1;                                         \
 432         (ewma) += (val) << factor;                                      \
 433         (ewma) /= (weight);                                             \
 434         (ewma) >> factor;                                               \
 435 })
 436
 437 struct bch_ratelimit {
 438         /* Next time we want to do some work, in nanoseconds */
 439         uint64_t                next;
 440
 441         /*
 442          * Rate at which we want to do work, in units per second
 443          * The units here correspond to the units passed to bch_next_delay()
 444          */
 445         atomic_long_t           rate;
 446 };
 447
 448 static inline void bch_ratelimit_reset(struct bch_ratelimit *d)
 449 {
 450         d->next = local_clock();
 451 }
 452
 453 uint64_t bch_next_delay(struct bch_ratelimit *d, uint64_t done);
 454
 455 #define __DIV_SAFE(n, d, zero)                                          \
 456 ({                                                                      \
 457         typeof(n) _n = (n);                                             \
 458         typeof(d) _d = (d);                                             \
 459         _d ? _n / _d : zero;                                            \
 460 })
 461
 462 #define DIV_SAFE(n, d)  __DIV_SAFE(n, d, 0)
 463
 464 #define container_of_or_null(ptr, type, member)                         \
 465 ({                                                                      \
 466         typeof(ptr) _ptr = ptr;                                         \
 467         _ptr ? container_of(_ptr, type, member) : NULL;                 \
 468 })
 469
 470 #define RB_INSERT(root, new, member, cmp)                               \
 471 ({                                                                      \
 472         __label__ dup;                                                  \
 473         struct rb_node **n = &(root)->rb_node, *parent = NULL;          \
 474         typeof(new) this;                                               \
 475         int res, ret = -1;                                              \
 476                                                                         \
 477         while (*n) {                                                    \
 478                 parent = *n;                                            \
 479                 this = container_of(*n, typeof(*(new)), member);        \
 480                 res = cmp(new, this);                                   \
 481                 if (!res)                                               \
 482                         goto dup;                                       \
 483                 n = res < 0                                             \
 484                         ? &(*n)->rb_left                                \
 485                         : &(*n)->rb_right;                              \
 486         }                                                               \
 487                                                                         \
 488         rb_link_node(&(new)->member, parent, n);                        \
 489         rb_insert_color(&(new)->member, root);                          \
 490         ret = 0;                                                        \
 491 dup:                                                                    \
 492         ret;                                                            \
 493 })
 494
 495 #define RB_SEARCH(root, search, member, cmp)                            \
 496 ({                                                                      \
 497         struct rb_node *n = (root)->rb_node;                            \
 498         typeof(&(search)) this, ret = NULL;                             \
 499         int res;                                                        \
 500                                                                         \
 501         while (n) {                                                     \
 502                 this = container_of(n, typeof(search), member);         \
 503                 res = cmp(&(search), this);                             \
 504                 if (!res) {                                             \
 505                         ret = this;                                     \
 506                         break;                                          \
 507                 }                                                       \
 508                 n = res < 0                                             \
 509                         ? n->rb_left                                    \
 510                         : n->rb_right;                                  \
 511         }                                                               \
 512         ret;                                                            \
 513 })
 514
 515 #define RB_GREATER(root, search, member, cmp)                           \
 516 ({                                                                      \
 517         struct rb_node *n = (root)->rb_node;                            \
 518         typeof(&(search)) this, ret = NULL;                             \
 519         int res;                                                        \
 520                                                                         \
 521         while (n) {                                                     \
 522                 this = container_of(n, typeof(search), member);         \
 523                 res = cmp(&(search), this);                             \
 524                 if (res < 0) {                                          \
 525                         ret = this;                                     \
 526                         n = n->rb_left;                                 \
 527                 } else                                                  \
 528                         n = n->rb_right;                                \
 529         }                                                               \
 530         ret;                                                            \
 531 })
 532
 533 #define RB_FIRST(root, type, member)                                    \
 534         container_of_or_null(rb_first(root), type, member)
 535
 536 #define RB_LAST(root, type, member)                                     \
 537         container_of_or_null(rb_last(root), type, member)
 538
 539 #define RB_NEXT(ptr, member)                                            \
 540         container_of_or_null(rb_next(&(ptr)->member), typeof(*ptr), member)
 541
 542 #define RB_PREV(ptr, member)                                            \
 543         container_of_or_null(rb_prev(&(ptr)->member), typeof(*ptr), member)
 544
 545 static inline uint64_t bch_crc64(const void *p, size_t len)
 546 {
 547         uint64_t crc = 0xffffffffffffffffULL;
 548
 549         crc = crc64_be(crc, p, len);
 550         return crc ^ 0xffffffffffffffffULL;
 551 }
 552
 553 static inline uint64_t bch_crc64_update(uint64_t crc,
 554                                         const void *p,
 555                                         size_t len)
 556 {
 557         crc = crc64_be(crc, p, len);
 558         return crc;
 559 }
 560
 561 /* Does linear interpolation between powers of two */
 562 static inline unsigned int fract_exp_two(unsigned int x,
 563                                          unsigned int fract_bits)
 564 {
 565         unsigned int fract = x & ~(~0 << fract_bits);
 566
 567         x >>= fract_bits;
 568         x   = 1 << x;
 569         x  += (x * fract) >> fract_bits;
 570
 571         return x;
 572 }
 573
 574 void bch_bio_map(struct bio *bio, void *base);
 575 int bch_bio_alloc_pages(struct bio *bio, gfp_t gfp_mask);
 576
 577 static inline sector_t bdev_sectors(struct block_device *bdev)
 578 {
 579         return bdev->bd_inode->i_size >> 9;
 580 }
 581 #endif /* _BCACHE_UTIL_H */