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