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 894