include/linux/kfifo.h

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2 /*
   3  * A generic kernel FIFO implementation
   4  *
   5  * Copyright (C) 2013 Stefani Seibold <stefani@seibold.net>
   6  */
   7
   8 #ifndef _LINUX_KFIFO_H
   9 #define _LINUX_KFIFO_H
  10
  11 /*
  12  * How to porting drivers to the new generic FIFO API:
  13  *
  14  * - Modify the declaration of the "struct kfifo *" object into a
  15  *   in-place "struct kfifo" object
  16  * - Init the in-place object with kfifo_alloc() or kfifo_init()
  17  *   Note: The address of the in-place "struct kfifo" object must be
  18  *   passed as the first argument to this functions
  19  * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
  20  *   into kfifo_out
  21  * - Replace the use of kfifo_put into kfifo_in_spinlocked and kfifo_get
  22  *   into kfifo_out_spinlocked
  23  *   Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
  24  *   must be passed now to the kfifo_in_spinlocked and kfifo_out_spinlocked
  25  *   as the last parameter
  26  * - The formerly __kfifo_* functions are renamed into kfifo_*
  27  */
  28
  29 /*
  30  * Note about locking: There is no locking required until only one reader
  31  * and one writer is using the fifo and no kfifo_reset() will be called.
  32  * kfifo_reset_out() can be safely used, until it will be only called
  33  * in the reader thread.
  34  * For multiple writer and one reader there is only a need to lock the writer.
  35  * And vice versa for only one writer and multiple reader there is only a need
  36  * to lock the reader.
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/spinlock.h>
  41 #include <linux/stddef.h>
  42 #include <linux/scatterlist.h>
  43
  44 struct __kfifo {
  45         unsigned int    in;
  46         unsigned int    out;
  47         unsigned int    mask;
  48         unsigned int    esize;
  49         void            *data;
  50 };
  51
  52 #define __STRUCT_KFIFO_COMMON(datatype, recsize, ptrtype) \
  53         union { \
  54                 struct __kfifo  kfifo; \
  55                 datatype        *type; \
  56                 const datatype  *const_type; \
  57                 char            (*rectype)[recsize]; \
  58                 ptrtype         *ptr; \
  59                 ptrtype const   *ptr_const; \
  60         }
  61
  62 #define __STRUCT_KFIFO(type, size, recsize, ptrtype) \
  63 { \
  64         __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
  65         type            buf[((size < 2) || (size & (size - 1))) ? -1 : size]; \
  66 }
  67
  68 #define STRUCT_KFIFO(type, size) \
  69         struct __STRUCT_KFIFO(type, size, 0, type)
  70
  71 #define __STRUCT_KFIFO_PTR(type, recsize, ptrtype) \
  72 { \
  73         __STRUCT_KFIFO_COMMON(type, recsize, ptrtype); \
  74         type            buf[0]; \
  75 }
  76
  77 #define STRUCT_KFIFO_PTR(type) \
  78         struct __STRUCT_KFIFO_PTR(type, 0, type)
  79
  80 /*
  81  * define compatibility "struct kfifo" for dynamic allocated fifos
  82  */
  83 struct kfifo __STRUCT_KFIFO_PTR(unsigned char, 0, void);
  84
  85 #define STRUCT_KFIFO_REC_1(size) \
  86         struct __STRUCT_KFIFO(unsigned char, size, 1, void)
  87
  88 #define STRUCT_KFIFO_REC_2(size) \
  89         struct __STRUCT_KFIFO(unsigned char, size, 2, void)
  90
  91 /*
  92  * define kfifo_rec types
  93  */
  94 struct kfifo_rec_ptr_1 __STRUCT_KFIFO_PTR(unsigned char, 1, void);
  95 struct kfifo_rec_ptr_2 __STRUCT_KFIFO_PTR(unsigned char, 2, void);
  96
  97 /*
  98  * helper macro to distinguish between real in place fifo where the fifo
  99  * array is a part of the structure and the fifo type where the array is
 100  * outside of the fifo structure.
 101  */
 102 #define __is_kfifo_ptr(fifo) \
 103         (sizeof(*fifo) == sizeof(STRUCT_KFIFO_PTR(typeof(*(fifo)->type))))
 104
 105 /**
 106  * DECLARE_KFIFO_PTR - macro to declare a fifo pointer object
 107  * @fifo: name of the declared fifo
 108  * @type: type of the fifo elements
 109  */
 110 #define DECLARE_KFIFO_PTR(fifo, type)   STRUCT_KFIFO_PTR(type) fifo
 111
 112 /**
 113  * DECLARE_KFIFO - macro to declare a fifo object
 114  * @fifo: name of the declared fifo
 115  * @type: type of the fifo elements
 116  * @size: the number of elements in the fifo, this must be a power of 2
 117  */
 118 #define DECLARE_KFIFO(fifo, type, size) STRUCT_KFIFO(type, size) fifo
 119
 120 /**
 121  * INIT_KFIFO - Initialize a fifo declared by DECLARE_KFIFO
 122  * @fifo: name of the declared fifo datatype
 123  */
 124 #define INIT_KFIFO(fifo) \
 125 (void)({ \
 126         typeof(&(fifo)) __tmp = &(fifo); \
 127         struct __kfifo *__kfifo = &__tmp->kfifo; \
 128         __kfifo->in = 0; \
 129         __kfifo->out = 0; \
 130         __kfifo->mask = __is_kfifo_ptr(__tmp) ? 0 : ARRAY_SIZE(__tmp->buf) - 1;\
 131         __kfifo->esize = sizeof(*__tmp->buf); \
 132         __kfifo->data = __is_kfifo_ptr(__tmp) ?  NULL : __tmp->buf; \
 133 })
 134
 135 /**
 136  * DEFINE_KFIFO - macro to define and initialize a fifo
 137  * @fifo: name of the declared fifo datatype
 138  * @type: type of the fifo elements
 139  * @size: the number of elements in the fifo, this must be a power of 2
 140  *
 141  * Note: the macro can be used for global and local fifo data type variables.
 142  */
 143 #define DEFINE_KFIFO(fifo, type, size) \
 144         DECLARE_KFIFO(fifo, type, size) = \
 145         (typeof(fifo)) { \
 146                 { \
 147                         { \
 148                         .in     = 0, \
 149                         .out    = 0, \
 150                         .mask   = __is_kfifo_ptr(&(fifo)) ? \
 151                                   0 : \
 152                                   ARRAY_SIZE((fifo).buf) - 1, \
 153                         .esize  = sizeof(*(fifo).buf), \
 154                         .data   = __is_kfifo_ptr(&(fifo)) ? \
 155                                 NULL : \
 156                                 (fifo).buf, \
 157                         } \
 158                 } \
 159         }
 160
 161
 162 static inline unsigned int __must_check
 163 __kfifo_uint_must_check_helper(unsigned int val)
 164 {
 165         return val;
 166 }
 167
 168 static inline int __must_check
 169 __kfifo_int_must_check_helper(int val)
 170 {
 171         return val;
 172 }
 173
 174 /**
 175  * kfifo_initialized - Check if the fifo is initialized
 176  * @fifo: address of the fifo to check
 177  *
 178  * Return %true if fifo is initialized, otherwise %false.
 179  * Assumes the fifo was 0 before.
 180  */
 181 #define kfifo_initialized(fifo) ((fifo)->kfifo.mask)
 182
 183 /**
 184  * kfifo_esize - returns the size of the element managed by the fifo
 185  * @fifo: address of the fifo to be used
 186  */
 187 #define kfifo_esize(fifo)       ((fifo)->kfifo.esize)
 188
 189 /**
 190  * kfifo_recsize - returns the size of the record length field
 191  * @fifo: address of the fifo to be used
 192  */
 193 #define kfifo_recsize(fifo)     (sizeof(*(fifo)->rectype))
 194
 195 /**
 196  * kfifo_size - returns the size of the fifo in elements
 197  * @fifo: address of the fifo to be used
 198  */
 199 #define kfifo_size(fifo)        ((fifo)->kfifo.mask + 1)
 200
 201 /**
 202  * kfifo_reset - removes the entire fifo content
 203  * @fifo: address of the fifo to be used
 204  *
 205  * Note: usage of kfifo_reset() is dangerous. It should be only called when the
 206  * fifo is exclusived locked or when it is secured that no other thread is
 207  * accessing the fifo.
 208  */
 209 #define kfifo_reset(fifo) \
 210 (void)({ \
 211         typeof((fifo) + 1) __tmp = (fifo); \
 212         __tmp->kfifo.in = __tmp->kfifo.out = 0; \
 213 })
 214
 215 /**
 216  * kfifo_reset_out - skip fifo content
 217  * @fifo: address of the fifo to be used
 218  *
 219  * Note: The usage of kfifo_reset_out() is safe until it will be only called
 220  * from the reader thread and there is only one concurrent reader. Otherwise
 221  * it is dangerous and must be handled in the same way as kfifo_reset().
 222  */
 223 #define kfifo_reset_out(fifo)   \
 224 (void)({ \
 225         typeof((fifo) + 1) __tmp = (fifo); \
 226         __tmp->kfifo.out = __tmp->kfifo.in; \
 227 })
 228
 229 /**
 230  * kfifo_len - returns the number of used elements in the fifo
 231  * @fifo: address of the fifo to be used
 232  */
 233 #define kfifo_len(fifo) \
 234 ({ \
 235         typeof((fifo) + 1) __tmpl = (fifo); \
 236         __tmpl->kfifo.in - __tmpl->kfifo.out; \
 237 })
 238
 239 /**
 240  * kfifo_is_empty - returns true if the fifo is empty
 241  * @fifo: address of the fifo to be used
 242  */
 243 #define kfifo_is_empty(fifo) \
 244 ({ \
 245         typeof((fifo) + 1) __tmpq = (fifo); \
 246         __tmpq->kfifo.in == __tmpq->kfifo.out; \
 247 })
 248
 249 /**
 250  * kfifo_is_empty_spinlocked - returns true if the fifo is empty using
 251  * a spinlock for locking
 252  * @fifo: address of the fifo to be used
 253  * @lock: spinlock to be used for locking
 254  */
 255 #define kfifo_is_empty_spinlocked(fifo, lock) \
 256 ({ \
 257         unsigned long __flags; \
 258         bool __ret; \
 259         spin_lock_irqsave(lock, __flags); \
 260         __ret = kfifo_is_empty(fifo); \
 261         spin_unlock_irqrestore(lock, __flags); \
 262         __ret; \
 263 })
 264
 265 /**
 266  * kfifo_is_empty_spinlocked_noirqsave  - returns true if the fifo is empty
 267  * using a spinlock for locking, doesn't disable interrupts
 268  * @fifo: address of the fifo to be used
 269  * @lock: spinlock to be used for locking
 270  */
 271 #define kfifo_is_empty_spinlocked_noirqsave(fifo, lock) \
 272 ({ \
 273         bool __ret; \
 274         spin_lock(lock); \
 275         __ret = kfifo_is_empty(fifo); \
 276         spin_unlock(lock); \
 277         __ret; \
 278 })
 279
 280 /**
 281  * kfifo_is_full - returns true if the fifo is full
 282  * @fifo: address of the fifo to be used
 283  */
 284 #define kfifo_is_full(fifo) \
 285 ({ \
 286         typeof((fifo) + 1) __tmpq = (fifo); \
 287         kfifo_len(__tmpq) > __tmpq->kfifo.mask; \
 288 })
 289
 290 /**
 291  * kfifo_avail - returns the number of unused elements in the fifo
 292  * @fifo: address of the fifo to be used
 293  */
 294 #define kfifo_avail(fifo) \
 295 __kfifo_uint_must_check_helper( \
 296 ({ \
 297         typeof((fifo) + 1) __tmpq = (fifo); \
 298         const size_t __recsize = sizeof(*__tmpq->rectype); \
 299         unsigned int __avail = kfifo_size(__tmpq) - kfifo_len(__tmpq); \
 300         (__recsize) ? ((__avail <= __recsize) ? 0 : \
 301         __kfifo_max_r(__avail - __recsize, __recsize)) : \
 302         __avail; \
 303 }) \
 304 )
 305
 306 /**
 307  * kfifo_skip - skip output data
 308  * @fifo: address of the fifo to be used
 309  */
 310 #define kfifo_skip(fifo) \
 311 (void)({ \
 312         typeof((fifo) + 1) __tmp = (fifo); \
 313         const size_t __recsize = sizeof(*__tmp->rectype); \
 314         struct __kfifo *__kfifo = &__tmp->kfifo; \
 315         if (__recsize) \
 316                 __kfifo_skip_r(__kfifo, __recsize); \
 317         else \
 318                 __kfifo->out++; \
 319 })
 320
 321 /**
 322  * kfifo_peek_len - gets the size of the next fifo record
 323  * @fifo: address of the fifo to be used
 324  *
 325  * This function returns the size of the next fifo record in number of bytes.
 326  */
 327 #define kfifo_peek_len(fifo) \
 328 __kfifo_uint_must_check_helper( \
 329 ({ \
 330         typeof((fifo) + 1) __tmp = (fifo); \
 331         const size_t __recsize = sizeof(*__tmp->rectype); \
 332         struct __kfifo *__kfifo = &__tmp->kfifo; \
 333         (!__recsize) ? kfifo_len(__tmp) * sizeof(*__tmp->type) : \
 334         __kfifo_len_r(__kfifo, __recsize); \
 335 }) \
 336 )
 337
 338 /**
 339  * kfifo_alloc - dynamically allocates a new fifo buffer
 340  * @fifo: pointer to the fifo
 341  * @size: the number of elements in the fifo, this must be a power of 2
 342  * @gfp_mask: get_free_pages mask, passed to kmalloc()
 343  *
 344  * This macro dynamically allocates a new fifo buffer.
 345  *
 346  * The number of elements will be rounded-up to a power of 2.
 347  * The fifo will be release with kfifo_free().
 348  * Return 0 if no error, otherwise an error code.
 349  */
 350 #define kfifo_alloc(fifo, size, gfp_mask) \
 351 __kfifo_int_must_check_helper( \
 352 ({ \
 353         typeof((fifo) + 1) __tmp = (fifo); \
 354         struct __kfifo *__kfifo = &__tmp->kfifo; \
 355         __is_kfifo_ptr(__tmp) ? \
 356         __kfifo_alloc(__kfifo, size, sizeof(*__tmp->type), gfp_mask) : \
 357         -EINVAL; \
 358 }) \
 359 )
 360
 361 /**
 362  * kfifo_free - frees the fifo
 363  * @fifo: the fifo to be freed
 364  */
 365 #define kfifo_free(fifo) \
 366 ({ \
 367         typeof((fifo) + 1) __tmp = (fifo); \
 368         struct __kfifo *__kfifo = &__tmp->kfifo; \
 369         if (__is_kfifo_ptr(__tmp)) \
 370                 __kfifo_free(__kfifo); \
 371 })
 372
 373 /**
 374  * kfifo_init - initialize a fifo using a preallocated buffer
 375  * @fifo: the fifo to assign the buffer
 376  * @buffer: the preallocated buffer to be used
 377  * @size: the size of the internal buffer, this have to be a power of 2
 378  *
 379  * This macro initializes a fifo using a preallocated buffer.
 380  *
 381  * The number of elements will be rounded-up to a power of 2.
 382  * Return 0 if no error, otherwise an error code.
 383  */
 384 #define kfifo_init(fifo, buffer, size) \
 385 ({ \
 386         typeof((fifo) + 1) __tmp = (fifo); \
 387         struct __kfifo *__kfifo = &__tmp->kfifo; \
 388         __is_kfifo_ptr(__tmp) ? \
 389         __kfifo_init(__kfifo, buffer, size, sizeof(*__tmp->type)) : \
 390         -EINVAL; \
 391 })
 392
 393 /**
 394  * kfifo_put - put data into the fifo
 395  * @fifo: address of the fifo to be used
 396  * @val: the data to be added
 397  *
 398  * This macro copies the given value into the fifo.
 399  * It returns 0 if the fifo was full. Otherwise it returns the number
 400  * processed elements.
 401  *
 402  * Note that with only one concurrent reader and one concurrent
 403  * writer, you don't need extra locking to use these macro.
 404  */
 405 #define kfifo_put(fifo, val) \
 406 ({ \
 407         typeof((fifo) + 1) __tmp = (fifo); \
 408         typeof(*__tmp->const_type) __val = (val); \
 409         unsigned int __ret; \
 410         size_t __recsize = sizeof(*__tmp->rectype); \
 411         struct __kfifo *__kfifo = &__tmp->kfifo; \
 412         if (__recsize) \
 413                 __ret = __kfifo_in_r(__kfifo, &__val, sizeof(__val), \
 414                         __recsize); \
 415         else { \
 416                 __ret = !kfifo_is_full(__tmp); \
 417                 if (__ret) { \
 418                         (__is_kfifo_ptr(__tmp) ? \
 419                         ((typeof(__tmp->type))__kfifo->data) : \
 420                         (__tmp->buf) \
 421                         )[__kfifo->in & __tmp->kfifo.mask] = \
 422                                 *(typeof(__tmp->type))&__val; \
 423                         smp_wmb(); \
 424                         __kfifo->in++; \
 425                 } \
 426         } \
 427         __ret; \
 428 })
 429
 430 /**
 431  * kfifo_get - get data from the fifo
 432  * @fifo: address of the fifo to be used
 433  * @val: address where to store the data
 434  *
 435  * This macro reads the data from the fifo.
 436  * It returns 0 if the fifo was empty. Otherwise it returns the number
 437  * processed elements.
 438  *
 439  * Note that with only one concurrent reader and one concurrent
 440  * writer, you don't need extra locking to use these macro.
 441  */
 442 #define kfifo_get(fifo, val) \
 443 __kfifo_uint_must_check_helper( \
 444 ({ \
 445         typeof((fifo) + 1) __tmp = (fifo); \
 446         typeof(__tmp->ptr) __val = (val); \
 447         unsigned int __ret; \
 448         const size_t __recsize = sizeof(*__tmp->rectype); \
 449         struct __kfifo *__kfifo = &__tmp->kfifo; \
 450         if (__recsize) \
 451                 __ret = __kfifo_out_r(__kfifo, __val, sizeof(*__val), \
 452                         __recsize); \
 453         else { \
 454                 __ret = !kfifo_is_empty(__tmp); \
 455                 if (__ret) { \
 456                         *(typeof(__tmp->type))__val = \
 457                                 (__is_kfifo_ptr(__tmp) ? \
 458                                 ((typeof(__tmp->type))__kfifo->data) : \
 459                                 (__tmp->buf) \
 460                                 )[__kfifo->out & __tmp->kfifo.mask]; \
 461                         smp_wmb(); \
 462                         __kfifo->out++; \
 463                 } \
 464         } \
 465         __ret; \
 466 }) \
 467 )
 468
 469 /**
 470  * kfifo_peek - get data from the fifo without removing
 471  * @fifo: address of the fifo to be used
 472  * @val: address where to store the data
 473  *
 474  * This reads the data from the fifo without removing it from the fifo.
 475  * It returns 0 if the fifo was empty. Otherwise it returns the number
 476  * processed elements.
 477  *
 478  * Note that with only one concurrent reader and one concurrent
 479  * writer, you don't need extra locking to use these macro.
 480  */
 481 #define kfifo_peek(fifo, val) \
 482 __kfifo_uint_must_check_helper( \
 483 ({ \
 484         typeof((fifo) + 1) __tmp = (fifo); \
 485         typeof(__tmp->ptr) __val = (val); \
 486         unsigned int __ret; \
 487         const size_t __recsize = sizeof(*__tmp->rectype); \
 488         struct __kfifo *__kfifo = &__tmp->kfifo; \
 489         if (__recsize) \
 490                 __ret = __kfifo_out_peek_r(__kfifo, __val, sizeof(*__val), \
 491                         __recsize); \
 492         else { \
 493                 __ret = !kfifo_is_empty(__tmp); \
 494                 if (__ret) { \
 495                         *(typeof(__tmp->type))__val = \
 496                                 (__is_kfifo_ptr(__tmp) ? \
 497                                 ((typeof(__tmp->type))__kfifo->data) : \
 498                                 (__tmp->buf) \
 499                                 )[__kfifo->out & __tmp->kfifo.mask]; \
 500                         smp_wmb(); \
 501                 } \
 502         } \
 503         __ret; \
 504 }) \
 505 )
 506
 507 /**
 508  * kfifo_in - put data into the fifo
 509  * @fifo: address of the fifo to be used
 510  * @buf: the data to be added
 511  * @n: number of elements to be added
 512  *
 513  * This macro copies the given buffer into the fifo and returns the
 514  * number of copied elements.
 515  *
 516  * Note that with only one concurrent reader and one concurrent
 517  * writer, you don't need extra locking to use these macro.
 518  */
 519 #define kfifo_in(fifo, buf, n) \
 520 ({ \
 521         typeof((fifo) + 1) __tmp = (fifo); \
 522         typeof(__tmp->ptr_const) __buf = (buf); \
 523         unsigned long __n = (n); \
 524         const size_t __recsize = sizeof(*__tmp->rectype); \
 525         struct __kfifo *__kfifo = &__tmp->kfifo; \
 526         (__recsize) ?\
 527         __kfifo_in_r(__kfifo, __buf, __n, __recsize) : \
 528         __kfifo_in(__kfifo, __buf, __n); \
 529 })
 530
 531 /**
 532  * kfifo_in_spinlocked - put data into the fifo using a spinlock for locking
 533  * @fifo: address of the fifo to be used
 534  * @buf: the data to be added
 535  * @n: number of elements to be added
 536  * @lock: pointer to the spinlock to use for locking
 537  *
 538  * This macro copies the given values buffer into the fifo and returns the
 539  * number of copied elements.
 540  */
 541 #define kfifo_in_spinlocked(fifo, buf, n, lock) \
 542 ({ \
 543         unsigned long __flags; \
 544         unsigned int __ret; \
 545         spin_lock_irqsave(lock, __flags); \
 546         __ret = kfifo_in(fifo, buf, n); \
 547         spin_unlock_irqrestore(lock, __flags); \
 548         __ret; \
 549 })
 550
 551 /**
 552  * kfifo_in_spinlocked_noirqsave - put data into fifo using a spinlock for
 553  * locking, don't disable interrupts
 554  * @fifo: address of the fifo to be used
 555  * @buf: the data to be added
 556  * @n: number of elements to be added
 557  * @lock: pointer to the spinlock to use for locking
 558  *
 559  * This is a variant of kfifo_in_spinlocked() but uses spin_lock/unlock()
 560  * for locking and doesn't disable interrupts.
 561  */
 562 #define kfifo_in_spinlocked_noirqsave(fifo, buf, n, lock) \
 563 ({ \
 564         unsigned int __ret; \
 565         spin_lock(lock); \
 566         __ret = kfifo_in(fifo, buf, n); \
 567         spin_unlock(lock); \
 568         __ret; \
 569 })
 570
 571 /* alias for kfifo_in_spinlocked, will be removed in a future release */
 572 #define kfifo_in_locked(fifo, buf, n, lock) \
 573                 kfifo_in_spinlocked(fifo, buf, n, lock)
 574
 575 /**
 576  * kfifo_out - get data from the fifo
 577  * @fifo: address of the fifo to be used
 578  * @buf: pointer to the storage buffer
 579  * @n: max. number of elements to get
 580  *
 581  * This macro get some data from the fifo and return the numbers of elements
 582  * copied.
 583  *
 584  * Note that with only one concurrent reader and one concurrent
 585  * writer, you don't need extra locking to use these macro.
 586  */
 587 #define kfifo_out(fifo, buf, n) \
 588 __kfifo_uint_must_check_helper( \
 589 ({ \
 590         typeof((fifo) + 1) __tmp = (fifo); \
 591         typeof(__tmp->ptr) __buf = (buf); \
 592         unsigned long __n = (n); \
 593         const size_t __recsize = sizeof(*__tmp->rectype); \
 594         struct __kfifo *__kfifo = &__tmp->kfifo; \
 595         (__recsize) ?\
 596         __kfifo_out_r(__kfifo, __buf, __n, __recsize) : \
 597         __kfifo_out(__kfifo, __buf, __n); \
 598 }) \
 599 )
 600
 601 /**
 602  * kfifo_out_spinlocked - get data from the fifo using a spinlock for locking
 603  * @fifo: address of the fifo to be used
 604  * @buf: pointer to the storage buffer
 605  * @n: max. number of elements to get
 606  * @lock: pointer to the spinlock to use for locking
 607  *
 608  * This macro get the data from the fifo and return the numbers of elements
 609  * copied.
 610  */
 611 #define kfifo_out_spinlocked(fifo, buf, n, lock) \
 612 __kfifo_uint_must_check_helper( \
 613 ({ \
 614         unsigned long __flags; \
 615         unsigned int __ret; \
 616         spin_lock_irqsave(lock, __flags); \
 617         __ret = kfifo_out(fifo, buf, n); \
 618         spin_unlock_irqrestore(lock, __flags); \
 619         __ret; \
 620 }) \
 621 )
 622
 623 /**
 624  * kfifo_out_spinlocked_noirqsave - get data from the fifo using a spinlock
 625  * for locking, don't disable interrupts
 626  * @fifo: address of the fifo to be used
 627  * @buf: pointer to the storage buffer
 628  * @n: max. number of elements to get
 629  * @lock: pointer to the spinlock to use for locking
 630  *
 631  * This is a variant of kfifo_out_spinlocked() which uses spin_lock/unlock()
 632  * for locking and doesn't disable interrupts.
 633  */
 634 #define kfifo_out_spinlocked_noirqsave(fifo, buf, n, lock) \
 635 __kfifo_uint_must_check_helper( \
 636 ({ \
 637         unsigned int __ret; \
 638         spin_lock(lock); \
 639         __ret = kfifo_out(fifo, buf, n); \
 640         spin_unlock(lock); \
 641         __ret; \
 642 }) \
 643 )
 644
 645 /* alias for kfifo_out_spinlocked, will be removed in a future release */
 646 #define kfifo_out_locked(fifo, buf, n, lock) \
 647                 kfifo_out_spinlocked(fifo, buf, n, lock)
 648
 649 /**
 650  * kfifo_from_user - puts some data from user space into the fifo
 651  * @fifo: address of the fifo to be used
 652  * @from: pointer to the data to be added
 653  * @len: the length of the data to be added
 654  * @copied: pointer to output variable to store the number of copied bytes
 655  *
 656  * This macro copies at most @len bytes from the @from into the
 657  * fifo, depending of the available space and returns -EFAULT/0.
 658  *
 659  * Note that with only one concurrent reader and one concurrent
 660  * writer, you don't need extra locking to use these macro.
 661  */
 662 #define kfifo_from_user(fifo, from, len, copied) \
 663 __kfifo_uint_must_check_helper( \
 664 ({ \
 665         typeof((fifo) + 1) __tmp = (fifo); \
 666         const void __user *__from = (from); \
 667         unsigned int __len = (len); \
 668         unsigned int *__copied = (copied); \
 669         const size_t __recsize = sizeof(*__tmp->rectype); \
 670         struct __kfifo *__kfifo = &__tmp->kfifo; \
 671         (__recsize) ? \
 672         __kfifo_from_user_r(__kfifo, __from, __len,  __copied, __recsize) : \
 673         __kfifo_from_user(__kfifo, __from, __len, __copied); \
 674 }) \
 675 )
 676
 677 /**
 678  * kfifo_to_user - copies data from the fifo into user space
 679  * @fifo: address of the fifo to be used
 680  * @to: where the data must be copied
 681  * @len: the size of the destination buffer
 682  * @copied: pointer to output variable to store the number of copied bytes
 683  *
 684  * This macro copies at most @len bytes from the fifo into the
 685  * @to buffer and returns -EFAULT/0.
 686  *
 687  * Note that with only one concurrent reader and one concurrent
 688  * writer, you don't need extra locking to use these macro.
 689  */
 690 #define kfifo_to_user(fifo, to, len, copied) \
 691 __kfifo_uint_must_check_helper( \
 692 ({ \
 693         typeof((fifo) + 1) __tmp = (fifo); \
 694         void __user *__to = (to); \
 695         unsigned int __len = (len); \
 696         unsigned int *__copied = (copied); \
 697         const size_t __recsize = sizeof(*__tmp->rectype); \
 698         struct __kfifo *__kfifo = &__tmp->kfifo; \
 699         (__recsize) ? \
 700         __kfifo_to_user_r(__kfifo, __to, __len, __copied, __recsize) : \
 701         __kfifo_to_user(__kfifo, __to, __len, __copied); \
 702 }) \
 703 )
 704
 705 /**
 706  * kfifo_dma_in_prepare - setup a scatterlist for DMA input
 707  * @fifo: address of the fifo to be used
 708  * @sgl: pointer to the scatterlist array
 709  * @nents: number of entries in the scatterlist array
 710  * @len: number of elements to transfer
 711  *
 712  * This macro fills a scatterlist for DMA input.
 713  * It returns the number entries in the scatterlist array.
 714  *
 715  * Note that with only one concurrent reader and one concurrent
 716  * writer, you don't need extra locking to use these macros.
 717  */
 718 #define kfifo_dma_in_prepare(fifo, sgl, nents, len) \
 719 ({ \
 720         typeof((fifo) + 1) __tmp = (fifo); \
 721         struct scatterlist *__sgl = (sgl); \
 722         int __nents = (nents); \
 723         unsigned int __len = (len); \
 724         const size_t __recsize = sizeof(*__tmp->rectype); \
 725         struct __kfifo *__kfifo = &__tmp->kfifo; \
 726         (__recsize) ? \
 727         __kfifo_dma_in_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
 728         __kfifo_dma_in_prepare(__kfifo, __sgl, __nents, __len); \
 729 })
 730
 731 /**
 732  * kfifo_dma_in_finish - finish a DMA IN operation
 733  * @fifo: address of the fifo to be used
 734  * @len: number of bytes to received
 735  *
 736  * This macro finish a DMA IN operation. The in counter will be updated by
 737  * the len parameter. No error checking will be done.
 738  *
 739  * Note that with only one concurrent reader and one concurrent
 740  * writer, you don't need extra locking to use these macros.
 741  */
 742 #define kfifo_dma_in_finish(fifo, len) \
 743 (void)({ \
 744         typeof((fifo) + 1) __tmp = (fifo); \
 745         unsigned int __len = (len); \
 746         const size_t __recsize = sizeof(*__tmp->rectype); \
 747         struct __kfifo *__kfifo = &__tmp->kfifo; \
 748         if (__recsize) \
 749                 __kfifo_dma_in_finish_r(__kfifo, __len, __recsize); \
 750         else \
 751                 __kfifo->in += __len / sizeof(*__tmp->type); \
 752 })
 753
 754 /**
 755  * kfifo_dma_out_prepare - setup a scatterlist for DMA output
 756  * @fifo: address of the fifo to be used
 757  * @sgl: pointer to the scatterlist array
 758  * @nents: number of entries in the scatterlist array
 759  * @len: number of elements to transfer
 760  *
 761  * This macro fills a scatterlist for DMA output which at most @len bytes
 762  * to transfer.
 763  * It returns the number entries in the scatterlist array.
 764  * A zero means there is no space available and the scatterlist is not filled.
 765  *
 766  * Note that with only one concurrent reader and one concurrent
 767  * writer, you don't need extra locking to use these macros.
 768  */
 769 #define kfifo_dma_out_prepare(fifo, sgl, nents, len) \
 770 ({ \
 771         typeof((fifo) + 1) __tmp = (fifo);  \
 772         struct scatterlist *__sgl = (sgl); \
 773         int __nents = (nents); \
 774         unsigned int __len = (len); \
 775         const size_t __recsize = sizeof(*__tmp->rectype); \
 776         struct __kfifo *__kfifo = &__tmp->kfifo; \
 777         (__recsize) ? \
 778         __kfifo_dma_out_prepare_r(__kfifo, __sgl, __nents, __len, __recsize) : \
 779         __kfifo_dma_out_prepare(__kfifo, __sgl, __nents, __len); \
 780 })
 781
 782 /**
 783  * kfifo_dma_out_finish - finish a DMA OUT operation
 784  * @fifo: address of the fifo to be used
 785  * @len: number of bytes transferred
 786  *
 787  * This macro finish a DMA OUT operation. The out counter will be updated by
 788  * the len parameter. No error checking will be done.
 789  *
 790  * Note that with only one concurrent reader and one concurrent
 791  * writer, you don't need extra locking to use these macros.
 792  */
 793 #define kfifo_dma_out_finish(fifo, len) \
 794 (void)({ \
 795         typeof((fifo) + 1) __tmp = (fifo); \
 796         unsigned int __len = (len); \
 797         const size_t __recsize = sizeof(*__tmp->rectype); \
 798         struct __kfifo *__kfifo = &__tmp->kfifo; \
 799         if (__recsize) \
 800                 __kfifo_dma_out_finish_r(__kfifo, __recsize); \
 801         else \
 802                 __kfifo->out += __len / sizeof(*__tmp->type); \
 803 })
 804
 805 /**
 806  * kfifo_out_peek - gets some data from the fifo
 807  * @fifo: address of the fifo to be used
 808  * @buf: pointer to the storage buffer
 809  * @n: max. number of elements to get
 810  *
 811  * This macro get the data from the fifo and return the numbers of elements
 812  * copied. The data is not removed from the fifo.
 813  *
 814  * Note that with only one concurrent reader and one concurrent
 815  * writer, you don't need extra locking to use these macro.
 816  */
 817 #define kfifo_out_peek(fifo, buf, n) \
 818 __kfifo_uint_must_check_helper( \
 819 ({ \
 820         typeof((fifo) + 1) __tmp = (fifo); \
 821         typeof(__tmp->ptr) __buf = (buf); \
 822         unsigned long __n = (n); \
 823         const size_t __recsize = sizeof(*__tmp->rectype); \
 824         struct __kfifo *__kfifo = &__tmp->kfifo; \
 825         (__recsize) ? \
 826         __kfifo_out_peek_r(__kfifo, __buf, __n, __recsize) : \
 827         __kfifo_out_peek(__kfifo, __buf, __n); \
 828 }) \
 829 )
 830
 831 extern int __kfifo_alloc(struct __kfifo *fifo, unsigned int size,
 832         size_t esize, gfp_t gfp_mask);
 833
 834 extern void __kfifo_free(struct __kfifo *fifo);
 835
 836 extern int __kfifo_init(struct __kfifo *fifo, void *buffer,
 837         unsigned int size, size_t esize);
 838
 839 extern unsigned int __kfifo_in(struct __kfifo *fifo,
 840         const void *buf, unsigned int len);
 841
 842 extern unsigned int __kfifo_out(struct __kfifo *fifo,
 843         void *buf, unsigned int len);
 844
 845 extern int __kfifo_from_user(struct __kfifo *fifo,
 846         const void __user *from, unsigned long len, unsigned int *copied);
 847
 848 extern int __kfifo_to_user(struct __kfifo *fifo,
 849         void __user *to, unsigned long len, unsigned int *copied);
 850
 851 extern unsigned int __kfifo_dma_in_prepare(struct __kfifo *fifo,
 852         struct scatterlist *sgl, int nents, unsigned int len);
 853
 854 extern unsigned int __kfifo_dma_out_prepare(struct __kfifo *fifo,
 855         struct scatterlist *sgl, int nents, unsigned int len);
 856
 857 extern unsigned int __kfifo_out_peek(struct __kfifo *fifo,
 858         void *buf, unsigned int len);
 859
 860 extern unsigned int __kfifo_in_r(struct __kfifo *fifo,
 861         const void *buf, unsigned int len, size_t recsize);
 862
 863 extern unsigned int __kfifo_out_r(struct __kfifo *fifo,
 864         void *buf, unsigned int len, size_t recsize);
 865
 866 extern int __kfifo_from_user_r(struct __kfifo *fifo,
 867         const void __user *from, unsigned long len, unsigned int *copied,
 868         size_t recsize);
 869
 870 extern int __kfifo_to_user_r(struct __kfifo *fifo, void __user *to,
 871         unsigned long len, unsigned int *copied, size_t recsize);
 872
 873 extern unsigned int __kfifo_dma_in_prepare_r(struct __kfifo *fifo,
 874         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
 875
 876 extern void __kfifo_dma_in_finish_r(struct __kfifo *fifo,
 877         unsigned int len, size_t recsize);
 878
 879 extern unsigned int __kfifo_dma_out_prepare_r(struct __kfifo *fifo,
 880         struct scatterlist *sgl, int nents, unsigned int len, size_t recsize);
 881
 882 extern void __kfifo_dma_out_finish_r(struct __kfifo *fifo, size_t recsize);
 883
 884 extern unsigned int __kfifo_len_r(struct __kfifo *fifo, size_t recsize);
 885
 886 extern void __kfifo_skip_r(struct __kfifo *fifo, size_t recsize);
 887
 888 extern unsigned int __kfifo_out_peek_r(struct __kfifo *fifo,
 889         void *buf, unsigned int len, size_t recsize);
 890
 891 extern unsigned int __kfifo_max_r(unsigned int len, size_t recsize);
 892
 893 #endif