git.sesse.net Git - bcachefs-tools-debian/blob - libbcachefs/fifo.h

   1 #ifndef _BCACHE_FIFO_H
   2 #define _BCACHE_FIFO_H
   3
   4 #define DECLARE_FIFO(type, name)                                        \
   5         struct {                                                        \
   6                 size_t front, back, size, mask;                         \
   7                 type *data;                                             \
   8         } name
   9
  10 #define init_fifo(fifo, _size, _gfp)                                    \
  11 ({                                                                      \
  12         bool _ret = true;                                               \
  13         gfp_t gfp_flags = (_gfp);                                       \
  14                                                                         \
  15         if (gfp_flags & GFP_KERNEL)                                     \
  16                 gfp_flags |= __GFP_NOWARN;                              \
  17                                                                         \
  18         (fifo)->size    = (_size);                                      \
  19         (fifo)->front   = (fifo)->back = 0;                             \
  20         (fifo)->data    = NULL;                                         \
  21                                                                         \
  22         if ((fifo)->size) {                                             \
  23                 size_t _allocated_size, _bytes;                         \
  24                                                                         \
  25                 _allocated_size = roundup_pow_of_two((fifo)->size);     \
  26                 _bytes = _allocated_size * sizeof(*(fifo)->data);       \
  27                                                                         \
  28                 (fifo)->mask = _allocated_size - 1;                     \
  29                                                                         \
  30                 if (_bytes < KMALLOC_MAX_SIZE)                          \
  31                         (fifo)->data = kmalloc(_bytes, gfp_flags);      \
  32                 if ((!(fifo)->data) && (gfp_flags & GFP_KERNEL))        \
  33                         (fifo)->data = vmalloc(_bytes);                 \
  34                 if ((!(fifo)->data))                                    \
  35                         _ret = false;                                   \
  36         }                                                               \
  37         _ret;                                                           \
  38 })
  39
  40 #define free_fifo(fifo)                                                 \
  41 do {                                                                    \
  42         kvfree((fifo)->data);                                           \
  43         (fifo)->data = NULL;                                            \
  44 } while (0)
  45
  46 #define fifo_swap(l, r)                                                 \
  47 do {                                                                    \
  48         swap((l)->front, (r)->front);                                   \
  49         swap((l)->back, (r)->back);                                     \
  50         swap((l)->size, (r)->size);                                     \
  51         swap((l)->mask, (r)->mask);                                     \
  52         swap((l)->data, (r)->data);                                     \
  53 } while (0)
  54
  55 #define fifo_move(dest, src)                                            \
  56 do {                                                                    \
  57         typeof(*((dest)->data)) _t;                                     \
  58         while (!fifo_full(dest) &&                                      \
  59                fifo_pop(src, _t))                                       \
  60                 fifo_push(dest, _t);                                    \
  61 } while (0)
  62
  63 #define fifo_used(fifo)         (((fifo)->back - (fifo)->front))
  64 #define fifo_free(fifo)         ((fifo)->size - fifo_used(fifo))
  65
  66 #define fifo_empty(fifo)        ((fifo)->front == (fifo)->back)
  67 #define fifo_full(fifo)         (fifo_used(fifo) == (fifo)->size)
  68
  69 #define fifo_peek_front(fifo)   ((fifo)->data[(fifo)->front & (fifo)->mask])
  70 #define fifo_peek_back(fifo)    ((fifo)->data[((fifo)->back - 1) & (fifo)->mask])
  71
  72 #define fifo_entry_idx(fifo, p) (((p) - &fifo_peek_front(fifo)) & (fifo)->mask)
  73
  74 #define fifo_push_back(fifo, i)                                         \
  75 ({                                                                      \
  76         bool _r = !fifo_full((fifo));                                   \
  77         if (_r)                                                         \
  78                 (fifo)->data[(fifo)->back++ & (fifo)->mask] = (i);      \
  79         _r;                                                             \
  80 })
  81
  82 #define fifo_pop_front(fifo, i)                                         \
  83 ({                                                                      \
  84         bool _r = !fifo_empty((fifo));                                  \
  85         if (_r)                                                         \
  86                 (i) = (fifo)->data[(fifo)->front++ & (fifo)->mask];     \
  87         _r;                                                             \
  88 })
  89
  90 #define fifo_push_front(fifo, i)                                        \
  91 ({                                                                      \
  92         bool _r = !fifo_full((fifo));                                   \
  93         if (_r)                                                         \
  94                 (fifo)->data[--(fifo)->front & (fifo)->mask] = (i);     \
  95         _r;                                                             \
  96 })
  97
  98 #define fifo_pop_back(fifo, i)                                          \
  99 ({                                                                      \
 100         bool _r = !fifo_empty((fifo));                                  \
 101         if (_r)                                                         \
 102                 (i) = (fifo)->data[--(fifo)->back & (fifo)->mask]       \
 103         _r;                                                             \
 104 })
 105
 106 #define fifo_push(fifo, i)      fifo_push_back(fifo, (i))
 107 #define fifo_pop(fifo, i)       fifo_pop_front(fifo, (i))
 108 #define fifo_peek(fifo)         fifo_peek_front(fifo)
 109
 110 #define fifo_for_each_entry(_entry, _fifo, _iter)                       \
 111         for (_iter = (_fifo)->front;                                    \
 112              ((_iter != (_fifo)->back) &&                               \
 113               (_entry = (_fifo)->data[(_iter) & (_fifo)->mask], true)); \
 114              _iter++)
 115
 116 #define fifo_for_each_entry_ptr(_ptr, _fifo, _iter)                     \
 117         for (_iter = (_fifo)->front;                                    \
 118              ((_iter != (_fifo)->back) &&                               \
 119               (_ptr = &(_fifo)->data[(_iter) & (_fifo)->mask], true));  \
 120              _iter++)
 121
 122 #endif /* _BCACHE_FIFO_H */
 123