Sorry, the last version was corrupted by the mail client.
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to many
constrains. Only 17 files in the current 2.6.31-rc5 used it. FIFO's are
like list's a very basic thing and a kfifo API which handles the most use
case would save a lot of development time and memory resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a need of a spinlock despite you need it or not
- There is no support for data records inside a fifo
So i decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
ChangeLog:
v.0 03.08.2009
First proposal, post a draft
v.1 04.08.2009
add kfifo_init()
kfifo_put() and kfifo_get() restored to the original behavior (but without locking)
introduce new kfifo_put_rec() and kfifo_put_rec() for FIFO record handling
kfifo_alloc() does only allocate the FIFO buffer
kfifo_free() does only release the FIFO buffer
revert to power of two buffer sizes
v.2 12.08.2009
simplify record handling
add new kfifo_reset_out() function
rename kfifo_put_* into kfifo_in_* to prevent miss-use by non in-kernel-tree drivers
rename kfifo_get_* into kfifo_out_* to prevent miss-use by non in-kernel-tree drivers
split it into separated patches
v.3 14.08.2009
fix documentation
fix some issues
refactorized code
refactorized patches
v.4 16.08.2009
kfifo_in_rec(): change @from type into a void pointer
kfifo_out_rec(): change @to type into a void pointer
rename internal used KFIFO_INIT() macro into __kfifo_initializer()
fix bug in record handling - sorry, i posted an intermediate version
fix bug in kfifo_in() - sorry, i posted an intermediate version
renamed the buffer used by the macros into name##kfifo_buffer (was name##_buffer)
fix source comments
cleanup and fix proposal document
v.5 19.08.2009
Cleaned up record functionality
Add mini "how to porting to the new API" guide
Update some inline comments
v.6 24.10.2009
Synchronized with kernel 2.6.32-rc5
New function kfifo_avail_rec
v.7 20.11.2009
Fix typos (thanks to Roger Quadros)
Fix tab's
The API:
--------
int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask)
Allocates a new FIFO internal buffer
The size will be rounded-up to a power of 2.
The buffer will be release with kfifo_free().
Return 0 if no error, otherwise the an error code.
@fifo: the fifo to assign then new buffer
@size: the size of the internal buffer to be allocated.
@gfp_mask: get_free_pages mask, passed to kmalloc()
void kfifo_init(struct kfifo *fifo, unsigned char *buffer, unsigned int size)
Initialize a FIFO using a preallocated buffer
@fifo: the fifo to assign the buffer
@buffer: the preallocated buffer to be used.
@size: the size of the internal buffer, this have to be a power of 2.
void kfifo_free(struct kfifo *fifo)
frees a dynamic allocated FIFO
@fifo: the fifo to be freed.
void kfifo_reset(struct kfifo *fifo)
removes the entire FIFO contents
@fifo: the fifo to be emptied.
void kfifo_reset_out(struct kfifo *fifo)
Skip output FIFO contents
@fifo: the fifo to be emptied.
unsigned int kfifo_len(struct kfifo *fifo)
Returns the number of used bytes in the FIFO
@fifo: the fifo to be used.
unsigned int kfifo_size(struct kfifo *fifo)
returns the size of the fifo in bytes
@fifo: the fifo to be used.
kfifo_is_empty(struct kfifo *fifo)
returns true if the fifo is empty
@fifo: the fifo to be used.
kfifo_is_full(struct kfifo *fifo)
Returns true if the fifo is full
@fifo: the fifo to be used.
unsigned int kfifo_avail(struct kfifo *fifo)
Returns the number of bytes available in the FIFO
@fifo: the fifo to be used.
unsigned int kfifo_in(struct kfifo *fifo, unsigned char *from, unsigned int n)
Puts some data into the FIFO.
This function copies at most @n bytes from @from into
the FIFO depending on the free space, and returns the number of
bytes copied.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@from: the data to be added.
@n: the length of the data to be added.
unsigned int kfifo_out(struct kfifo *fifo, unsigned char *to, unsigned int n)
Gets some data from the FIFO.
This function copies at most @n bytes from the FIFO into
@to and returns the number of copied bytes.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@to: where the data must be copied.
@n: the size of the destination buffer.
unsigned int kfifo_from_user(struct kfifo *fifo, const void __user *from, unsigned int n)
Puts some data from user space into the FIFO.
This function copies at most @n bytes from the @from into the FIFO
and returns the number of copied bytes.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@from: pointer to the data to be added.
@n: the length of the data to be added.
unsigned int kfifo_to_user(struct kfifo *fifo, void __user *to, unsigned int n)
Gets data from the FIFO and write it to user space.
@fifo: the fifo to be used.
@to: where the data must be copied.
@n: the size of the destination buffer.
This function copies at most @n bytes from the FIFO into @to
and returns the number of copied bytes.
Note that with only one concurrent reader and one concurrent writer, you don't
need extra locking to use these functions.
void kfifo_skip(struct kfifo *fifo, unsigned int len)
Skip output data
@fifo: the fifo to be used.
@len: number of bytes to skip
Functions for simplify porting:
-------------------------------
unsigned int kfifo_in_locked(struct kfifo *fifo,
const unsigned char *from, unsigned int n, spinlock_t *lock)
Puts some data into the FIFO using a spinlock for locking
@fifo: the fifo to be used.
@from: the data to be added.
@len: the length of the data to be added.
@lock: pointer to the spinlock to use for locking.
This function copies at most @len bytes from the @from buffer into
the FIFO depending on the free space, and returns the number of
bytes copied.
unsigned int kfifo_out_locked(struct kfifo *fifo,
unsigned char *to, unsigned int n, spinlock_t *lock)
Gets some data from the FIFO using a spinlock for locking
@fifo: the fifo to be used.
@to: where the data must be copied.
@len: the size of the destination buffer.
@lock: pointer to the spinlock to use for locking.
This function copies at most @len bytes from the FIFO into the
@to buffer and returns the number of copied bytes.
These are the functions for handling records:
---------------------------------------------
The functions supports three different kinds of records:
- Fix size records.
The @recsize parameter is 0 and exactly @len bytes will be copied
- Varible size records with 1 byte length field
The @recsize parameter is 1 and a record of 0-255 bytes will be copied
- Varible size records with 2 byte length field
The @recsize parameter is 2 and a record of 0-65535 bytes will be copied
unsigned int kfifo_in_rec(struct kfifo *fifo,
void *from, unsigned int n, unsigned int recsize)
Puts some record data into the FIFO.
This function copies @n bytes from the @from into
the FIFO and returns the number of bytes which cannot be copied.
A returned value greater than the @n value means that the record doesn't
fit into the buffer.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@from: the data to be added.
@n: the length of the data to be added.
@recsize: size of record field
unsigned int kfifo_out_rec(struct kfifo *fifo,
void *to, unsigned int n, unsigned int recsize,
unsigned int *total)
Gets some record data from the FIFO.
This function copies at most @n bytes from the @to into
the FIFO and returns the number of bytes which cannot be copied.
A returned value greater than the @n value means that the record doesn't
fit into the @to buffer.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@to: where the data must be copied.
@n: the size of the destination buffer.
@recsize: size of record field
@total: pointer where the total number of to copied bytes should stored
unsigned int kfifo_from_user_rec(struct kfifo *fifo,
const void __user *from, unsigned int n, unsigned int recsize)
Puts some data from user space into the FIFO
This function copies @n bytes from the @from into the
FIFO and returns the number of bytes which cannot be copied. If the
returned value is equal or less the @n value, the copy_from_user() functions has
failed. Otherwise the record doesn't fit into the buffer.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@from: pointer to the data to be added.
@n: the length of the data to be added.
@recsize: size of record field
unsigned int kfifo_to_user_rec(struct kfifo *fifo,
void __user *to, unsigned int n, unsigned int recsize,
unsigned int *total)
Gets data from the FIFO and write it to user space
This function copies at most @n bytes from the FIFO into @to.
In case of an error, the function returns the number of bytes which cannot
be copied. If the returned value is equal or less the @n value, the
copy_to_user() functions has failed. Otherwise the record doesn't fit into
the @to buffer.
Note that with only one concurrent reader and one concurrent
writer, you don't need extra locking to use these functions.
@fifo: the fifo to be used.
@to: where the data must be copied.
@n: the size of the destination buffer.
@recsize: size of record field
@total: pointer where the total number of to copied bytes should stored
unsigned long kfifo_peek_rec(struct kfifo *fifo, unsigned long recsize)
Gets the size of the next FIFO record data.
This function returns the size of the next FIFO record in number of bytes
@fifo: the fifo to be used.
@recsize: size of record field
unsigned int kfifo_skip_rec(struct kfifo *fifo, unsigned int recsize)
Skip the next output record
This function skips the next FIFO record
@fifo: the fifo to be used.
@recsize: size of record field
unsigned int kfifo_avail_rec(struct kfifo *fifo, unsigned int recsize)
Returns the number of bytes available in a record FIFO
@fifo: the fifo to be used
@recsize: size of record field
Macros defined for kernel FIFO:
-------------------------------
DECLARE_KFIFO(name, size)
Macro to declare a kfifo and the associated buffer
Note: the macro can be used inside struct or union declaration
@name: name of the declared kfifo datatype
@size: size of the fifo buffer
INIT_KFIFO(name)
Macro to initialize a with DECLARE_KFIFO declared kfifo
@name: name of the declared kfifo datatype
@size: size of the fifo buffer
DEFINE_KFIFO(name, size)
Macro to define and initialize a kfifo
Note: the macro can be used for global and local kfifo data type variables
@name: name of the declared kfifo datatype
@size: size of the fifo buffer
<End of API Documentation>
One thing is that the new API is not compatible with the old one. I had
a look at the current user of the old kfifo API and it is was easy to adapt it to
the new API. These are the files which currently use the kfifo API:
drivers/char/nozomi.c
drivers/char/sonypi.c
drivers/infiniband/hw/cxgb3/cxio_resource.c
drivers/media/video/meye.c
drivers/net/wireless/libertas/main.c
drivers/platform/x86/fujitsu-laptop.c
drivers/platform/x86/sony-laptop.c
drivers/scsi/libiscsi.c
drivers/scsi/libiscsi_tcp.c
drivers/scsi/libsrp.c
drivers/usb/host/fhci.h
net/dccp/probe.c
drivers/usb/serial/usb-serial.c
drivers/usb/serial/generic.c
The patch is splitted into 7 parts:
Part 1: move struct kfifo in place
Part 2: move out spinlock
Part 3: Cleanup namespace
Part 4: rename kfifo_put... -> kfifo_in... and kfifo_get... -> kfifo_out...
Part 5: add DEFINE_KFIFO and friends, add very tiny functions
Part 6: add kfifo_skip, kfifo_from_user and kfifo_to_user (does some reorg)
Part 7: add record handling functions (does some reorg)
The patch-set is against linux-2.6.32-rc5.
Greetings,
Stefani
Since most users want to have the kfifo as part of another
object, reorganize the code to allow including struct kfifo
in another data structure. This requires changing the kfifo_alloc
and kfifo_init prototypes so that we pass an existing kfifo
pointer into them. This patch changes the implementation and
all existing users.
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
drivers/char/nozomi.c | 21 ++++-----
drivers/char/sonypi.c | 40 ++++++++---------
drivers/infiniband/hw/cxgb3/cxio_hal.h | 9 ++-
drivers/infiniband/hw/cxgb3/cxio_resource.c | 60 ++++++++++++-------------
drivers/media/video/meye.c | 48 +++++++++-----------
drivers/media/video/meye.h | 4 -
drivers/net/wireless/libertas/cmd.c | 4 -
drivers/net/wireless/libertas/dev.h | 3 -
drivers/net/wireless/libertas/main.c | 16 +++---
drivers/platform/x86/fujitsu-laptop.c | 18 +++----
drivers/platform/x86/sony-laptop.c | 46 +++++++++----------
drivers/scsi/libiscsi.c | 22 +++------
drivers/scsi/libiscsi_tcp.c | 29 ++++++------
drivers/scsi/libsrp.c | 12 ++---
drivers/usb/host/fhci-sched.c | 10 ++--
drivers/usb/host/fhci-tds.c | 35 +++++++--------
drivers/usb/host/fhci.h | 10 ++--
drivers/usb/serial/usb-serial.c | 5 --
include/linux/kfifo.h | 11 ++--
include/scsi/libiscsi.h | 3 -
include/scsi/libiscsi_tcp.h | 2
include/scsi/libsrp.h | 2
kernel/kfifo.c | 65 ++++++++++++++--------------
net/dccp/probe.c | 20 +++-----
24 files changed, 238 insertions(+), 257 deletions(-)
diff -u -N -r -p kfifo0/drivers/char/nozomi.c kfifo1/drivers/char/nozomi.c
--- kfifo0/drivers/char/nozomi.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/char/nozomi.c 2009-10-19 20:39:24.367550786 +0200
@@ -358,7 +358,7 @@ struct port {
u8 update_flow_control;
struct ctrl_ul ctrl_ul;
struct ctrl_dl ctrl_dl;
- struct kfifo *fifo_ul;
+ struct kfifo fifo_ul;
void __iomem *dl_addr[2];
u32 dl_size[2];
u8 toggle_dl;
@@ -685,8 +685,8 @@ static int nozomi_read_config_table(stru
dump_table(dc);
for (i = PORT_MDM; i < MAX_PORT; i++) {
- dc->port[i].fifo_ul =
- kfifo_alloc(FIFO_BUFFER_SIZE_UL, GFP_ATOMIC, NULL);
+ kfifo_alloc(&dc->port[i].fifo_ul,
+ FIFO_BUFFER_SIZE_UL, GFP_ATOMIC, NULL);
memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
}
@@ -798,7 +798,7 @@ static int send_data(enum port_type inde
struct tty_struct *tty = tty_port_tty_get(&port->port);
/* Get data from tty and place in buf for now */
- size = __kfifo_get(port->fifo_ul, dc->send_buf,
+ size = __kfifo_get(&port->fifo_ul, dc->send_buf,
ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX);
if (size == 0) {
@@ -988,11 +988,11 @@ static int receive_flow_control(struct n
} else if (old_ctrl.CTS == 0 && ctrl_dl.CTS == 1) {
- if (__kfifo_len(dc->port[port].fifo_ul)) {
+ if (__kfifo_len(&dc->port[port].fifo_ul)) {
DBG1("Enable interrupt (0x%04X) on port: %d",
enable_ier, port);
DBG1("Data in buffer [%d], enable transmit! ",
- __kfifo_len(dc->port[port].fifo_ul));
+ __kfifo_len(&dc->port[port].fifo_ul));
enable_transmit_ul(port, dc);
} else {
DBG1("No data in buffer...");
@@ -1536,8 +1536,7 @@ static void __devexit nozomi_card_exit(s
free_irq(pdev->irq, dc);
for (i = 0; i < MAX_PORT; i++)
- if (dc->port[i].fifo_ul)
- kfifo_free(dc->port[i].fifo_ul);
+ kfifo_free(&dc->port[i].fifo_ul);
kfree(dc->send_buf);
@@ -1673,7 +1672,7 @@ static int ntty_write(struct tty_struct
goto exit;
}
- rval = __kfifo_put(port->fifo_ul, (unsigned char *)buffer, count);
+ rval = __kfifo_put(&port->fifo_ul, (unsigned char *)buffer, count);
/* notify card */
if (unlikely(dc == NULL)) {
@@ -1721,7 +1720,7 @@ static int ntty_write_room(struct tty_st
if (!port->port.count)
goto exit;
- room = port->fifo_ul->size - __kfifo_len(port->fifo_ul);
+ room = port->fifo_ul.size - __kfifo_len(&port->fifo_ul);
exit:
mutex_unlock(&port->tty_sem);
@@ -1878,7 +1877,7 @@ static s32 ntty_chars_in_buffer(struct t
goto exit_in_buffer;
}
- rval = __kfifo_len(port->fifo_ul);
+ rval = __kfifo_len(&port->fifo_ul);
exit_in_buffer:
return rval;
diff -u -N -r -p kfifo0/drivers/char/sonypi.c kfifo1/drivers/char/sonypi.c
--- kfifo0/drivers/char/sonypi.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/char/sonypi.c 2009-10-19 20:39:24.462844882 +0200
@@ -487,7 +487,7 @@ static struct sonypi_device {
int camera_power;
int bluetooth_power;
struct mutex lock;
- struct kfifo *fifo;
+ struct kfifo fifo;
spinlock_t fifo_lock;
wait_queue_head_t fifo_proc_list;
struct fasync_struct *fifo_async;
@@ -496,7 +496,7 @@ static struct sonypi_device {
struct input_dev *input_jog_dev;
struct input_dev *input_key_dev;
struct work_struct input_work;
- struct kfifo *input_fifo;
+ struct kfifo input_fifo;
spinlock_t input_fifo_lock;
} sonypi_device;
@@ -777,7 +777,7 @@ static void input_keyrelease(struct work
{
struct sonypi_keypress kp;
- while (kfifo_get(sonypi_device.input_fifo, (unsigned char *)&kp,
+ while (kfifo_get(&sonypi_device.input_fifo, (unsigned char *)&kp,
sizeof(kp)) == sizeof(kp)) {
msleep(10);
input_report_key(kp.dev, kp.key, 0);
@@ -827,7 +827,7 @@ static void sonypi_report_input_event(u8
if (kp.dev) {
input_report_key(kp.dev, kp.key, 1);
input_sync(kp.dev);
- kfifo_put(sonypi_device.input_fifo,
+ kfifo_put(&sonypi_device.input_fifo,
(unsigned char *)&kp, sizeof(kp));
schedule_work(&sonypi_device.input_work);
}
@@ -880,7 +880,7 @@ found:
acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
#endif
- kfifo_put(sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
+ kfifo_put(&sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_device.fifo_proc_list);
@@ -906,7 +906,7 @@ static int sonypi_misc_open(struct inode
mutex_lock(&sonypi_device.lock);
/* Flush input queue on first open */
if (!sonypi_device.open_count)
- kfifo_reset(sonypi_device.fifo);
+ kfifo_reset(&sonypi_device.fifo);
sonypi_device.open_count++;
mutex_unlock(&sonypi_device.lock);
unlock_kernel();
@@ -919,17 +919,17 @@ static ssize_t sonypi_misc_read(struct f
ssize_t ret;
unsigned char c;
- if ((kfifo_len(sonypi_device.fifo) == 0) &&
+ if ((kfifo_len(&sonypi_device.fifo) == 0) &&
(file->f_flags & O_NONBLOCK))
return -EAGAIN;
ret = wait_event_interruptible(sonypi_device.fifo_proc_list,
- kfifo_len(sonypi_device.fifo) != 0);
+ kfifo_len(&sonypi_device.fifo) != 0);
if (ret)
return ret;
while (ret < count &&
- (kfifo_get(sonypi_device.fifo, &c, sizeof(c)) == sizeof(c))) {
+ (kfifo_get(&sonypi_device.fifo, &c, sizeof(c)) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -946,7 +946,7 @@ static ssize_t sonypi_misc_read(struct f
static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
{
poll_wait(file, &sonypi_device.fifo_proc_list, wait);
- if (kfifo_len(sonypi_device.fifo))
+ if (kfifo_len(&sonypi_device.fifo))
return POLLIN | POLLRDNORM;
return 0;
}
@@ -1313,11 +1313,11 @@ static int __devinit sonypi_probe(struct
"http://www.linux.it/~malattia/wiki/index.php/Sony_drivers\n");
spin_lock_init(&sonypi_device.fifo_lock);
- sonypi_device.fifo = kfifo_alloc(SONYPI_BUF_SIZE, GFP_KERNEL,
+ error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL,
&sonypi_device.fifo_lock);
- if (IS_ERR(sonypi_device.fifo)) {
+ if (error) {
printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
- return PTR_ERR(sonypi_device.fifo);
+ return error;
}
init_waitqueue_head(&sonypi_device.fifo_proc_list);
@@ -1393,12 +1393,10 @@ static int __devinit sonypi_probe(struct
}
spin_lock_init(&sonypi_device.input_fifo_lock);
- sonypi_device.input_fifo =
- kfifo_alloc(SONYPI_BUF_SIZE, GFP_KERNEL,
- &sonypi_device.input_fifo_lock);
- if (IS_ERR(sonypi_device.input_fifo)) {
+ error = kfifo_alloc(&sonypi_device.input_fifo, SONYPI_BUF_SIZE,
+ GFP_KERNEL, &sonypi_device.input_fifo_lock);
+ if (error) {
printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
- error = PTR_ERR(sonypi_device.input_fifo);
goto err_inpdev_unregister;
}
@@ -1423,7 +1421,7 @@ static int __devinit sonypi_probe(struct
pci_disable_device(pcidev);
err_put_pcidev:
pci_dev_put(pcidev);
- kfifo_free(sonypi_device.fifo);
+ kfifo_free(&sonypi_device.fifo);
return error;
}
@@ -1438,7 +1436,7 @@ static int __devexit sonypi_remove(struc
if (useinput) {
input_unregister_device(sonypi_device.input_key_dev);
input_unregister_device(sonypi_device.input_jog_dev);
- kfifo_free(sonypi_device.input_fifo);
+ kfifo_free(&sonypi_device.input_fifo);
}
misc_deregister(&sonypi_misc_device);
@@ -1451,7 +1449,7 @@ static int __devexit sonypi_remove(struc
pci_dev_put(sonypi_device.dev);
}
- kfifo_free(sonypi_device.fifo);
+ kfifo_free(&sonypi_device.fifo);
return 0;
}
diff -u -N -r -p kfifo0/drivers/infiniband/hw/cxgb3/cxio_hal.h kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h
--- kfifo0/drivers/infiniband/hw/cxgb3/cxio_hal.h 2009-10-19 20:39:11.091211875 +0200
+++ kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h 2009-10-19 20:39:24.056212384 +0200
@@ -34,6 +34,7 @@
#include <linux/list.h>
#include <linux/mutex.h>
+#include <linux/kfifo.h>
#include "t3_cpl.h"
#include "t3cdev.h"
@@ -75,13 +76,13 @@ struct cxio_hal_ctrl_qp {
};
struct cxio_hal_resource {
- struct kfifo *tpt_fifo;
+ struct kfifo tpt_fifo;
spinlock_t tpt_fifo_lock;
- struct kfifo *qpid_fifo;
+ struct kfifo qpid_fifo;
spinlock_t qpid_fifo_lock;
- struct kfifo *cqid_fifo;
+ struct kfifo cqid_fifo;
spinlock_t cqid_fifo_lock;
- struct kfifo *pdid_fifo;
+ struct kfifo pdid_fifo;
spinlock_t pdid_fifo_lock;
};
diff -u -N -r -p kfifo0/drivers/infiniband/hw/cxgb3/cxio_resource.c kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c
--- kfifo0/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 20:39:11.534211979 +0200
+++ kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 20:39:24.000000000 +0200
@@ -39,12 +39,12 @@
#include "cxio_resource.h"
#include "cxio_hal.h"
-static struct kfifo *rhdl_fifo;
+static struct kfifo rhdl_fifo;
static spinlock_t rhdl_fifo_lock;
#define RANDOM_SIZE 16
-static int __cxio_init_resource_fifo(struct kfifo **fifo,
+static int __cxio_init_resource_fifo(struct kfifo *fifo,
spinlock_t *fifo_lock,
u32 nr, u32 skip_low,
u32 skip_high,
@@ -55,12 +55,11 @@ static int __cxio_init_resource_fifo(str
u32 rarray[16];
spin_lock_init(fifo_lock);
- *fifo = kfifo_alloc(nr * sizeof(u32), GFP_KERNEL, fifo_lock);
- if (IS_ERR(*fifo))
+ if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL, fifo_lock))
return -ENOMEM;
for (i = 0; i < skip_low + skip_high; i++)
- __kfifo_put(*fifo, (unsigned char *) &entry, sizeof(u32));
+ __kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32));
if (random) {
j = 0;
random_bytes = random32();
@@ -72,33 +71,33 @@ static int __cxio_init_resource_fifo(str
random_bytes = random32();
}
idx = (random_bytes >> (j * 2)) & 0xF;
- __kfifo_put(*fifo,
+ __kfifo_put(fifo,
(unsigned char *) &rarray[idx],
sizeof(u32));
rarray[idx] = i;
j++;
}
for (i = 0; i < RANDOM_SIZE; i++)
- __kfifo_put(*fifo,
+ __kfifo_put(fifo,
(unsigned char *) &rarray[i],
sizeof(u32));
} else
for (i = skip_low; i < nr - skip_high; i++)
- __kfifo_put(*fifo, (unsigned char *) &i, sizeof(u32));
+ __kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
for (i = 0; i < skip_low + skip_high; i++)
- kfifo_get(*fifo, (unsigned char *) &entry, sizeof(u32));
+ kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32));
return 0;
}
-static int cxio_init_resource_fifo(struct kfifo **fifo, spinlock_t * fifo_lock,
+static int cxio_init_resource_fifo(struct kfifo *fifo, spinlock_t * fifo_lock,
u32 nr, u32 skip_low, u32 skip_high)
{
return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
skip_high, 0));
}
-static int cxio_init_resource_fifo_random(struct kfifo **fifo,
+static int cxio_init_resource_fifo_random(struct kfifo *fifo,
spinlock_t * fifo_lock,
u32 nr, u32 skip_low, u32 skip_high)
{
@@ -113,15 +112,14 @@ static int cxio_init_qpid_fifo(struct cx
spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
- rdev_p->rscp->qpid_fifo = kfifo_alloc(T3_MAX_NUM_QP * sizeof(u32),
+ if (kfifo_alloc(&rdev_p->rscp->qpid_fifo, T3_MAX_NUM_QP * sizeof(u32),
GFP_KERNEL,
- &rdev_p->rscp->qpid_fifo_lock);
- if (IS_ERR(rdev_p->rscp->qpid_fifo))
+ &rdev_p->rscp->qpid_fifo_lock))
return -ENOMEM;
for (i = 16; i < T3_MAX_NUM_QP; i++)
if (!(i & rdev_p->qpmask))
- __kfifo_put(rdev_p->rscp->qpid_fifo,
+ __kfifo_put(&rdev_p->rscp->qpid_fifo,
(unsigned char *) &i, sizeof(u32));
return 0;
}
@@ -134,7 +132,7 @@ int cxio_hal_init_rhdl_resource(u32 nr_r
void cxio_hal_destroy_rhdl_resource(void)
{
- kfifo_free(rhdl_fifo);
+ kfifo_free(&rhdl_fifo);
}
/* nr_* must be power of 2 */
@@ -167,11 +165,11 @@ int cxio_hal_init_resource(struct cxio_r
goto pdid_err;
return 0;
pdid_err:
- kfifo_free(rscp->cqid_fifo);
+ kfifo_free(&rscp->cqid_fifo);
cqid_err:
- kfifo_free(rscp->qpid_fifo);
+ kfifo_free(&rscp->qpid_fifo);
qpid_err:
- kfifo_free(rscp->tpt_fifo);
+ kfifo_free(&rscp->tpt_fifo);
tpt_err:
return -ENOMEM;
}
@@ -195,17 +193,17 @@ static void cxio_hal_put_resource(struct
u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(rscp->tpt_fifo);
+ return cxio_hal_get_resource(&rscp->tpt_fifo);
}
void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
{
- cxio_hal_put_resource(rscp->tpt_fifo, stag);
+ cxio_hal_put_resource(&rscp->tpt_fifo, stag);
}
u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
{
- u32 qpid = cxio_hal_get_resource(rscp->qpid_fifo);
+ u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo);
PDBG("%s qpid 0x%x\n", __func__, qpid);
return qpid;
}
@@ -213,35 +211,35 @@ u32 cxio_hal_get_qpid(struct cxio_hal_re
void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
{
PDBG("%s qpid 0x%x\n", __func__, qpid);
- cxio_hal_put_resource(rscp->qpid_fifo, qpid);
+ cxio_hal_put_resource(&rscp->qpid_fifo, qpid);
}
u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(rscp->cqid_fifo);
+ return cxio_hal_get_resource(&rscp->cqid_fifo);
}
void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
{
- cxio_hal_put_resource(rscp->cqid_fifo, cqid);
+ cxio_hal_put_resource(&rscp->cqid_fifo, cqid);
}
u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(rscp->pdid_fifo);
+ return cxio_hal_get_resource(&rscp->pdid_fifo);
}
void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
{
- cxio_hal_put_resource(rscp->pdid_fifo, pdid);
+ cxio_hal_put_resource(&rscp->pdid_fifo, pdid);
}
void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
{
- kfifo_free(rscp->tpt_fifo);
- kfifo_free(rscp->cqid_fifo);
- kfifo_free(rscp->qpid_fifo);
- kfifo_free(rscp->pdid_fifo);
+ kfifo_free(&rscp->tpt_fifo);
+ kfifo_free(&rscp->cqid_fifo);
+ kfifo_free(&rscp->qpid_fifo);
+ kfifo_free(&rscp->pdid_fifo);
kfree(rscp);
}
diff -u -N -r -p kfifo0/drivers/media/video/meye.c kfifo1/drivers/media/video/meye.c
--- kfifo0/drivers/media/video/meye.c 2009-10-19 20:39:11.116565614 +0200
+++ kfifo1/drivers/media/video/meye.c 2009-10-19 20:39:24.000000000 +0200
@@ -800,7 +800,7 @@ again:
return IRQ_HANDLED;
if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
- if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
+ if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int)) != sizeof(int)) {
mchip_free_frame();
return IRQ_HANDLED;
@@ -811,7 +811,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+ kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
wake_up_interruptible(&meye.proc_list);
} else {
int size;
@@ -820,7 +820,7 @@ again:
mchip_free_frame();
goto again;
}
- if (kfifo_get(meye.grabq, (unsigned char *)&reqnr,
+ if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int)) != sizeof(int)) {
mchip_free_frame();
goto again;
@@ -831,7 +831,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put(meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+ kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
wake_up_interruptible(&meye.proc_list);
}
mchip_free_frame();
@@ -859,8 +859,8 @@ static int meye_open(struct file *file)
for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
- kfifo_reset(meye.grabq);
- kfifo_reset(meye.doneq);
+ kfifo_reset(&meye.grabq);
+ kfifo_reset(&meye.doneq);
return 0;
}
@@ -933,7 +933,7 @@ static int meyeioc_qbuf_capt(int *nb)
mchip_cont_compression_start();
meye.grab_buffer[*nb].state = MEYE_BUF_USING;
- kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
+ kfifo_put(&meye.grabq, (unsigned char *)nb, sizeof(int));
mutex_unlock(&meye.lock);
return 0;
@@ -965,7 +965,7 @@ static int meyeioc_sync(struct file *fil
/* fall through */
case MEYE_BUF_DONE:
meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
- kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
+ kfifo_get(&meye.doneq, (unsigned char *)&unused, sizeof(int));
}
*i = meye.grab_buffer[*i].size;
mutex_unlock(&meye.lock);
@@ -1452,7 +1452,7 @@ static int vidioc_qbuf(struct file *file
buf->flags |= V4L2_BUF_FLAG_QUEUED;
buf->flags &= ~V4L2_BUF_FLAG_DONE;
meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
- kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
+ kfifo_put(&meye.grabq, (unsigned char *)&buf->index, sizeof(int));
mutex_unlock(&meye.lock);
return 0;
@@ -1467,18 +1467,18 @@ static int vidioc_dqbuf(struct file *fil
mutex_lock(&meye.lock);
- if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
+ if (kfifo_len(&meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
mutex_unlock(&meye.lock);
return -EAGAIN;
}
if (wait_event_interruptible(meye.proc_list,
- kfifo_len(meye.doneq) != 0) < 0) {
+ kfifo_len(&meye.doneq) != 0) < 0) {
mutex_unlock(&meye.lock);
return -EINTR;
}
- if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
+ if (!kfifo_get(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int))) {
mutex_unlock(&meye.lock);
return -EBUSY;
@@ -1529,8 +1529,8 @@ static int vidioc_streamoff(struct file
{
mutex_lock(&meye.lock);
mchip_hic_stop();
- kfifo_reset(meye.grabq);
- kfifo_reset(meye.doneq);
+ kfifo_reset(&meye.grabq);
+ kfifo_reset(&meye.doneq);
for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
@@ -1572,7 +1572,7 @@ static unsigned int meye_poll(struct fil
mutex_lock(&meye.lock);
poll_wait(file, &meye.proc_list, wait);
- if (kfifo_len(meye.doneq))
+ if (kfifo_len(&meye.doneq))
res = POLLIN | POLLRDNORM;
mutex_unlock(&meye.lock);
return res;
@@ -1746,16 +1746,14 @@ static int __devinit meye_probe(struct p
}
spin_lock_init(&meye.grabq_lock);
- meye.grabq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
- &meye.grabq_lock);
- if (IS_ERR(meye.grabq)) {
+ if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
+ &meye.grabq_lock)) {
printk(KERN_ERR "meye: fifo allocation failed\n");
goto outkfifoalloc1;
}
spin_lock_init(&meye.doneq_lock);
- meye.doneq = kfifo_alloc(sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
- &meye.doneq_lock);
- if (IS_ERR(meye.doneq)) {
+ if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
+ &meye.doneq_lock)) {
printk(KERN_ERR "meye: fifo allocation failed\n");
goto outkfifoalloc2;
}
@@ -1869,9 +1867,9 @@ outregions:
outenabledev:
sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
outsonypienable:
- kfifo_free(meye.doneq);
+ kfifo_free(&meye.doneq);
outkfifoalloc2:
- kfifo_free(meye.grabq);
+ kfifo_free(&meye.grabq);
outkfifoalloc1:
vfree(meye.grab_temp);
outvmalloc:
@@ -1902,8 +1900,8 @@ static void __devexit meye_remove(struct
sony_pic_camera_command(SONY_PIC_COMMAND_SETCAMERA, 0);
- kfifo_free(meye.doneq);
- kfifo_free(meye.grabq);
+ kfifo_free(&meye.doneq);
+ kfifo_free(&meye.grabq);
vfree(meye.grab_temp);
diff -u -N -r -p kfifo0/drivers/media/video/meye.h kfifo1/drivers/media/video/meye.h
--- kfifo0/drivers/media/video/meye.h 2009-10-19 20:39:11.941587250 +0200
+++ kfifo1/drivers/media/video/meye.h 2009-10-19 20:39:24.889747909 +0200
@@ -303,9 +303,9 @@ struct meye {
struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS];
int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */
struct mutex lock; /* mutex for open/mmap... */
- struct kfifo *grabq; /* queue for buffers to be grabbed */
+ struct kfifo grabq; /* queue for buffers to be grabbed */
spinlock_t grabq_lock; /* lock protecting the queue */
- struct kfifo *doneq; /* queue for grabbed buffers */
+ struct kfifo doneq; /* queue for grabbed buffers */
spinlock_t doneq_lock; /* lock protecting the queue */
wait_queue_head_t proc_list; /* wait queue */
struct video_device *video_dev; /* video device parameters */
diff -u -N -r -p kfifo0/drivers/net/wireless/libertas/cmd.c kfifo1/drivers/net/wireless/libertas/cmd.c
--- kfifo0/drivers/net/wireless/libertas/cmd.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/net/wireless/libertas/cmd.c 2009-10-19 20:39:24.000000000 +0200
@@ -1869,7 +1869,7 @@ static void lbs_send_confirmsleep(struct
priv->dnld_sent = DNLD_RES_RECEIVED;
/* If nothing to do, go back to sleep (?) */
- if (!__kfifo_len(priv->event_fifo) && !priv->resp_len[priv->resp_idx])
+ if (!__kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
priv->psstate = PS_STATE_SLEEP;
spin_unlock_irqrestore(&priv->driver_lock, flags);
@@ -1943,7 +1943,7 @@ void lbs_ps_confirm_sleep(struct lbs_pri
}
/* Pending events or command responses? */
- if (__kfifo_len(priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
+ if (__kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
allowed = 0;
lbs_deb_host("pending events or command responses\n");
}
diff -u -N -r -p kfifo0/drivers/net/wireless/libertas/dev.h kfifo1/drivers/net/wireless/libertas/dev.h
--- kfifo0/drivers/net/wireless/libertas/dev.h 2009-10-19 20:39:11.936097114 +0200
+++ kfifo1/drivers/net/wireless/libertas/dev.h 2009-10-19 20:39:24.000000000 +0200
@@ -10,6 +10,7 @@
#include <linux/wireless.h>
#include <linux/ethtool.h>
#include <linux/debugfs.h>
+#include <linux/kfifo.h>
#include "defs.h"
#include "hostcmd.h"
@@ -194,7 +195,7 @@ struct lbs_private {
u32 resp_len[2];
/* Events sent from hardware to driver */
- struct kfifo *event_fifo;
+ struct kfifo event_fifo;
/* nickname */
u8 nodename[16];
diff -u -N -r -p kfifo0/drivers/net/wireless/libertas/main.c kfifo1/drivers/net/wireless/libertas/main.c
--- kfifo0/drivers/net/wireless/libertas/main.c 2009-10-19 20:39:11.814587241 +0200
+++ kfifo1/drivers/net/wireless/libertas/main.c 2009-10-19 20:39:24.000000000 +0200
@@ -772,7 +772,7 @@ static int lbs_thread(void *data)
shouldsleep = 1; /* Can't send a command; one already running */
else if (!list_empty(&priv->cmdpendingq))
shouldsleep = 0; /* We have a command to send */
- else if (__kfifo_len(priv->event_fifo))
+ else if (__kfifo_len(&priv->event_fifo))
shouldsleep = 0; /* We have an event to process */
else
shouldsleep = 1; /* No command */
@@ -851,10 +851,10 @@ static int lbs_thread(void *data)
/* Process hardware events, e.g. card removed, link lost */
spin_lock_irq(&priv->driver_lock);
- while (__kfifo_len(priv->event_fifo)) {
+ while (__kfifo_len(&priv->event_fifo)) {
u32 event;
- __kfifo_get(priv->event_fifo, (unsigned char *) &event,
+ __kfifo_get(&priv->event_fifo, (unsigned char *) &event,
sizeof(event));
spin_unlock_irq(&priv->driver_lock);
lbs_process_event(priv, event);
@@ -1121,10 +1121,9 @@ static int lbs_init_adapter(struct lbs_p
priv->resp_len[0] = priv->resp_len[1] = 0;
/* Create the event FIFO */
- priv->event_fifo = kfifo_alloc(sizeof(u32) * 16, GFP_KERNEL, NULL);
- if (IS_ERR(priv->event_fifo)) {
+ ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL, NULL);
+ if (ret) {
lbs_pr_err("Out of memory allocating event FIFO buffer\n");
- ret = -ENOMEM;
goto out;
}
@@ -1139,8 +1138,7 @@ static void lbs_free_adapter(struct lbs_
lbs_deb_enter(LBS_DEB_MAIN);
lbs_free_cmd_buffer(priv);
- if (priv->event_fifo)
- kfifo_free(priv->event_fifo);
+ kfifo_free(&priv->event_fifo);
del_timer(&priv->command_timer);
kfree(priv->networks);
priv->networks = NULL;
@@ -1581,7 +1579,7 @@ void lbs_queue_event(struct lbs_private
if (priv->psstate == PS_STATE_SLEEP)
priv->psstate = PS_STATE_AWAKE;
- __kfifo_put(priv->event_fifo, (unsigned char *) &event, sizeof(u32));
+ __kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
wake_up_interruptible(&priv->waitq);
diff -u -N -r -p kfifo0/drivers/platform/x86/fujitsu-laptop.c kfifo1/drivers/platform/x86/fujitsu-laptop.c
--- kfifo0/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 20:39:24.111587921 +0200
@@ -164,7 +164,7 @@ struct fujitsu_hotkey_t {
struct input_dev *input;
char phys[32];
struct platform_device *pf_device;
- struct kfifo *fifo;
+ struct kfifo fifo;
spinlock_t fifo_lock;
int rfkill_supported;
int rfkill_state;
@@ -824,12 +824,10 @@ static int acpi_fujitsu_hotkey_add(struc
/* kfifo */
spin_lock_init(&fujitsu_hotkey->fifo_lock);
- fujitsu_hotkey->fifo =
- kfifo_alloc(RINGBUFFERSIZE * sizeof(int), GFP_KERNEL,
- &fujitsu_hotkey->fifo_lock);
- if (IS_ERR(fujitsu_hotkey->fifo)) {
+ error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
+ GFP_KERNEL, &fujitsu_hotkey->fifo_lock);
+ if (error) {
printk(KERN_ERR "kfifo_alloc failed\n");
- error = PTR_ERR(fujitsu_hotkey->fifo);
goto err_stop;
}
@@ -934,7 +932,7 @@ err_unregister_input_dev:
err_free_input_dev:
input_free_device(input);
err_free_fifo:
- kfifo_free(fujitsu_hotkey->fifo);
+ kfifo_free(&fujitsu_hotkey->fifo);
err_stop:
return result;
}
@@ -956,7 +954,7 @@ static int acpi_fujitsu_hotkey_remove(st
input_free_device(input);
- kfifo_free(fujitsu_hotkey->fifo);
+ kfifo_free(&fujitsu_hotkey->fifo);
fujitsu_hotkey->acpi_handle = NULL;
@@ -1008,7 +1006,7 @@ static void acpi_fujitsu_hotkey_notify(s
vdbg_printk(FUJLAPTOP_DBG_TRACE,
"Push keycode into ringbuffer [%d]\n",
keycode);
- status = kfifo_put(fujitsu_hotkey->fifo,
+ status = kfifo_put(&fujitsu_hotkey->fifo,
(unsigned char *)&keycode,
sizeof(keycode));
if (status != sizeof(keycode)) {
@@ -1022,7 +1020,7 @@ static void acpi_fujitsu_hotkey_notify(s
} else if (keycode == 0) {
while ((status =
kfifo_get
- (fujitsu_hotkey->fifo, (unsigned char *)
+ (&fujitsu_hotkey->fifo, (unsigned char *)
&keycode_r,
sizeof
(keycode_r))) == sizeof(keycode_r)) {
diff -u -N -r -p kfifo0/drivers/platform/x86/sony-laptop.c kfifo1/drivers/platform/x86/sony-laptop.c
--- kfifo0/drivers/platform/x86/sony-laptop.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/platform/x86/sony-laptop.c 2009-10-19 20:39:24.000000000 +0200
@@ -142,7 +142,7 @@ struct sony_laptop_input_s {
atomic_t users;
struct input_dev *jog_dev;
struct input_dev *key_dev;
- struct kfifo *fifo;
+ struct kfifo fifo;
spinlock_t fifo_lock;
struct workqueue_struct *wq;
};
@@ -300,7 +300,7 @@ static void do_sony_laptop_release_key(s
{
struct sony_laptop_keypress kp;
- while (kfifo_get(sony_laptop_input.fifo, (unsigned char *)&kp,
+ while (kfifo_get(&sony_laptop_input.fifo, (unsigned char *)&kp,
sizeof(kp)) == sizeof(kp)) {
msleep(10);
input_report_key(kp.dev, kp.key, 0);
@@ -362,7 +362,7 @@ static void sony_laptop_report_input_eve
/* we emit the scancode so we can always remap the key */
input_event(kp.dev, EV_MSC, MSC_SCAN, event);
input_sync(kp.dev);
- kfifo_put(sony_laptop_input.fifo,
+ kfifo_put(&sony_laptop_input.fifo,
(unsigned char *)&kp, sizeof(kp));
if (!work_pending(&sony_laptop_release_key_work))
@@ -385,12 +385,11 @@ static int sony_laptop_setup_input(struc
/* kfifo */
spin_lock_init(&sony_laptop_input.fifo_lock);
- sony_laptop_input.fifo =
- kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
+ error =
+ kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
&sony_laptop_input.fifo_lock);
- if (IS_ERR(sony_laptop_input.fifo)) {
+ if (error) {
printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
- error = PTR_ERR(sony_laptop_input.fifo);
goto err_dec_users;
}
@@ -474,7 +473,7 @@ err_destroy_wq:
destroy_workqueue(sony_laptop_input.wq);
err_free_kfifo:
- kfifo_free(sony_laptop_input.fifo);
+ kfifo_free(&sony_laptop_input.fifo);
err_dec_users:
atomic_dec(&sony_laptop_input.users);
@@ -500,7 +499,7 @@ static void sony_laptop_remove_input(voi
}
destroy_workqueue(sony_laptop_input.wq);
- kfifo_free(sony_laptop_input.fifo);
+ kfifo_free(&sony_laptop_input.fifo);
}
/*********** Platform Device ***********/
@@ -2079,7 +2078,7 @@ static struct attribute_group spic_attri
struct sonypi_compat_s {
struct fasync_struct *fifo_async;
- struct kfifo *fifo;
+ struct kfifo fifo;
spinlock_t fifo_lock;
wait_queue_head_t fifo_proc_list;
atomic_t open_count;
@@ -2104,12 +2103,12 @@ static int sonypi_misc_open(struct inode
/* Flush input queue on first open */
unsigned long flags;
- spin_lock_irqsave(sonypi_compat.fifo->lock, flags);
+ spin_lock_irqsave(&sonypi_compat.fifo_lock, flags);
if (atomic_inc_return(&sonypi_compat.open_count) == 1)
- __kfifo_reset(sonypi_compat.fifo);
+ __kfifo_reset(&sonypi_compat.fifo);
- spin_unlock_irqrestore(sonypi_compat.fifo->lock, flags);
+ spin_unlock_irqrestore(&sonypi_compat.fifo_lock, flags);
return 0;
}
@@ -2120,17 +2119,17 @@ static ssize_t sonypi_misc_read(struct f
ssize_t ret;
unsigned char c;
- if ((kfifo_len(sonypi_compat.fifo) == 0) &&
+ if ((kfifo_len(&sonypi_compat.fifo) == 0) &&
(file->f_flags & O_NONBLOCK))
return -EAGAIN;
ret = wait_event_interruptible(sonypi_compat.fifo_proc_list,
- kfifo_len(sonypi_compat.fifo) != 0);
+ kfifo_len(&sonypi_compat.fifo) != 0);
if (ret)
return ret;
while (ret < count &&
- (kfifo_get(sonypi_compat.fifo, &c, sizeof(c)) == sizeof(c))) {
+ (kfifo_get(&sonypi_compat.fifo, &c, sizeof(c)) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -2147,7 +2146,7 @@ static ssize_t sonypi_misc_read(struct f
static unsigned int sonypi_misc_poll(struct file *file, poll_table *wait)
{
poll_wait(file, &sonypi_compat.fifo_proc_list, wait);
- if (kfifo_len(sonypi_compat.fifo))
+ if (kfifo_len(&sonypi_compat.fifo))
return POLLIN | POLLRDNORM;
return 0;
}
@@ -2309,7 +2308,7 @@ static struct miscdevice sonypi_misc_dev
static void sonypi_compat_report_event(u8 event)
{
- kfifo_put(sonypi_compat.fifo, (unsigned char *)&event, sizeof(event));
+ kfifo_put(&sonypi_compat.fifo, (unsigned char *)&event, sizeof(event));
kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_compat.fifo_proc_list);
}
@@ -2319,11 +2318,12 @@ static int sonypi_compat_init(void)
int error;
spin_lock_init(&sonypi_compat.fifo_lock);
- sonypi_compat.fifo = kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
+ error =
+ kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
&sonypi_compat.fifo_lock);
- if (IS_ERR(sonypi_compat.fifo)) {
+ if (error) {
printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
- return PTR_ERR(sonypi_compat.fifo);
+ return error;
}
init_waitqueue_head(&sonypi_compat.fifo_proc_list);
@@ -2342,14 +2342,14 @@ static int sonypi_compat_init(void)
return 0;
err_free_kfifo:
- kfifo_free(sonypi_compat.fifo);
+ kfifo_free(&sonypi_compat.fifo);
return error;
}
static void sonypi_compat_exit(void)
{
misc_deregister(&sonypi_misc_device);
- kfifo_free(sonypi_compat.fifo);
+ kfifo_free(&sonypi_compat.fifo);
}
#else
static int sonypi_compat_init(void) { return 0; }
diff -u -N -r -p kfifo0/drivers/scsi/libiscsi.c kfifo1/drivers/scsi/libiscsi.c
--- kfifo0/drivers/scsi/libiscsi.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/scsi/libiscsi.c 2009-10-19 20:39:24.000000000 +0200
@@ -431,7 +431,7 @@ static void iscsi_free_task(struct iscsi
if (conn->login_task == task)
return;
- __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*));
+ __kfifo_put(&session->cmdpool.queue, (void*)&task, sizeof(void*));
if (sc) {
task->sc = NULL;
@@ -642,7 +642,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn
BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
- if (!__kfifo_get(session->cmdpool.queue,
+ if (!__kfifo_get(&session->cmdpool.queue,
(void*)&task, sizeof(void*)))
return NULL;
}
@@ -1473,7 +1473,7 @@ static inline struct iscsi_task *iscsi_a
{
struct iscsi_task *task;
- if (!__kfifo_get(conn->session->cmdpool.queue,
+ if (!__kfifo_get(&conn->session->cmdpool.queue,
(void *) &task, sizeof(void *)))
return NULL;
@@ -2252,12 +2252,7 @@ iscsi_pool_init(struct iscsi_pool *q, in
if (q->pool == NULL)
return -ENOMEM;
- q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
- GFP_KERNEL, NULL);
- if (IS_ERR(q->queue)) {
- q->queue = NULL;
- goto enomem;
- }
+ kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*), NULL);
for (i = 0; i < max; i++) {
q->pool[i] = kzalloc(item_size, GFP_KERNEL);
@@ -2265,7 +2260,7 @@ iscsi_pool_init(struct iscsi_pool *q, in
q->max = i;
goto enomem;
}
- __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
+ __kfifo_put(&q->queue, (void*)&q->pool[i], sizeof(void*));
}
if (items) {
@@ -2288,7 +2283,6 @@ void iscsi_pool_free(struct iscsi_pool *
for (i = 0; i < q->max; i++)
kfree(q->pool[i]);
kfree(q->pool);
- kfree(q->queue);
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);
@@ -2615,7 +2609,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
/* allocate login_task used for the login/text sequences */
spin_lock_bh(&session->lock);
- if (!__kfifo_get(session->cmdpool.queue,
+ if (!__kfifo_get(&session->cmdpool.queue,
(void*)&conn->login_task,
sizeof(void*))) {
spin_unlock_bh(&session->lock);
@@ -2635,7 +2629,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
return cls_conn;
login_task_data_alloc_fail:
- __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
+ __kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
login_task_alloc_fail:
iscsi_destroy_conn(cls_conn);
@@ -2698,7 +2692,7 @@ void iscsi_conn_teardown(struct iscsi_cl
free_pages((unsigned long) conn->data,
get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
kfree(conn->persistent_address);
- __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
+ __kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
if (session->leadconn == conn)
session->leadconn = NULL;
diff -u -N -r -p kfifo0/drivers/scsi/libiscsi_tcp.c kfifo1/drivers/scsi/libiscsi_tcp.c
--- kfifo0/drivers/scsi/libiscsi_tcp.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/drivers/scsi/libiscsi_tcp.c 2009-10-19 20:39:24.000000000 +0200
@@ -445,15 +445,15 @@ void iscsi_tcp_cleanup_task(struct iscsi
return;
/* flush task's r2t queues */
- while (__kfifo_get(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
- __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+ while (__kfifo_get(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
+ __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
}
r2t = tcp_task->r2t;
if (r2t != NULL) {
- __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+ __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
tcp_task->r2t = NULL;
}
@@ -541,7 +541,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
return 0;
}
- rc = __kfifo_get(tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
+ rc = __kfifo_get(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
if (!rc) {
iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
"Target has sent more R2Ts than it "
@@ -554,7 +554,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
if (r2t->data_length == 0) {
iscsi_conn_printk(KERN_ERR, conn,
"invalid R2T with zero data len\n");
- __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+ __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -570,7 +570,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
"invalid R2T with data len %u at offset %u "
"and total length %d\n", r2t->data_length,
r2t->data_offset, scsi_out(task->sc)->length);
- __kfifo_put(tcp_task->r2tpool.queue, (void*)&r2t,
+ __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -580,7 +580,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
r2t->sent = 0;
tcp_task->exp_datasn = r2tsn + 1;
- __kfifo_put(tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
+ __kfifo_put(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
conn->r2t_pdus_cnt++;
iscsi_requeue_task(task);
@@ -951,7 +951,7 @@ int iscsi_tcp_task_init(struct iscsi_tas
return conn->session->tt->init_pdu(task, 0, task->data_count);
}
- BUG_ON(__kfifo_len(tcp_task->r2tqueue));
+ BUG_ON(__kfifo_len(&tcp_task->r2tqueue));
tcp_task->exp_datasn = 0;
/* Prepare PDU, optionally w/ immediate data */
@@ -982,7 +982,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
if (r2t->data_length <= r2t->sent) {
ISCSI_DBG_TCP(task->conn,
" done with r2t %p\n", r2t);
- __kfifo_put(tcp_task->r2tpool.queue,
+ __kfifo_put(&tcp_task->r2tpool.queue,
(void *)&tcp_task->r2t,
sizeof(void *));
tcp_task->r2t = r2t = NULL;
@@ -990,7 +990,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
}
if (r2t == NULL) {
- __kfifo_get(tcp_task->r2tqueue,
+ __kfifo_get(&tcp_task->r2tqueue,
(void *)&tcp_task->r2t, sizeof(void *));
r2t = tcp_task->r2t;
}
@@ -1127,9 +1127,8 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi
}
/* R2T xmit queue */
- tcp_task->r2tqueue = kfifo_alloc(
- session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL);
- if (tcp_task->r2tqueue == ERR_PTR(-ENOMEM)) {
+ if (kfifo_alloc(&tcp_task->r2tqueue,
+ session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL)) {
iscsi_pool_free(&tcp_task->r2tpool);
goto r2t_alloc_fail;
}
@@ -1142,7 +1141,7 @@ r2t_alloc_fail:
struct iscsi_task *task = session->cmds[i];
struct iscsi_tcp_task *tcp_task = task->dd_data;
- kfifo_free(tcp_task->r2tqueue);
+ kfifo_free(&tcp_task->r2tqueue);
iscsi_pool_free(&tcp_task->r2tpool);
}
return -ENOMEM;
@@ -1157,7 +1156,7 @@ void iscsi_tcp_r2tpool_free(struct iscsi
struct iscsi_task *task = session->cmds[i];
struct iscsi_tcp_task *tcp_task = task->dd_data;
- kfifo_free(tcp_task->r2tqueue);
+ kfifo_free(&tcp_task->r2tqueue);
iscsi_pool_free(&tcp_task->r2tpool);
}
}
diff -u -N -r -p kfifo0/drivers/scsi/libsrp.c kfifo1/drivers/scsi/libsrp.c
--- kfifo0/drivers/scsi/libsrp.c 2009-10-19 20:39:11.792333200 +0200
+++ kfifo1/drivers/scsi/libsrp.c 2009-10-19 20:39:24.000000000 +0200
@@ -58,13 +58,11 @@ static int srp_iu_pool_alloc(struct srp_
goto free_pool;
spin_lock_init(&q->lock);
- q->queue = kfifo_init((void *) q->pool, max * sizeof(void *),
- GFP_KERNEL, &q->lock);
- if (IS_ERR(q->queue))
- goto free_item;
+ kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *),
+ &q->lock);
for (i = 0, iue = q->items; i < max; i++) {
- __kfifo_put(q->queue, (void *) &iue, sizeof(void *));
+ __kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
iue->sbuf = ring[i];
iue++;
}
@@ -167,7 +165,7 @@ struct iu_entry *srp_iu_get(struct srp_t
{
struct iu_entry *iue = NULL;
- kfifo_get(target->iu_queue.queue, (void *) &iue, sizeof(void *));
+ kfifo_get(&target->iu_queue.queue, (void *) &iue, sizeof(void *));
if (!iue)
return iue;
iue->target = target;
@@ -179,7 +177,7 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
void srp_iu_put(struct iu_entry *iue)
{
- kfifo_put(iue->target->iu_queue.queue, (void *) &iue, sizeof(void *));
+ kfifo_put(&iue->target->iu_queue.queue, (void *) &iue, sizeof(void *));
}
EXPORT_SYMBOL_GPL(srp_iu_put);
diff -u -N -r -p kfifo0/drivers/usb/host/fhci.h kfifo1/drivers/usb/host/fhci.h
--- kfifo0/drivers/usb/host/fhci.h 2009-10-19 20:39:11.703356713 +0200
+++ kfifo1/drivers/usb/host/fhci.h 2009-10-19 20:39:24.022212548 +0200
@@ -423,9 +423,9 @@ struct endpoint {
struct usb_td __iomem *td_base; /* first TD in the ring */
struct usb_td __iomem *conf_td; /* next TD for confirm after transac */
struct usb_td __iomem *empty_td;/* next TD for new transaction req. */
- struct kfifo *empty_frame_Q; /* Empty frames list to use */
- struct kfifo *conf_frame_Q; /* frames passed to TDs,waiting for tx */
- struct kfifo *dummy_packets_Q;/* dummy packets for the CRC overun */
+ struct kfifo empty_frame_Q; /* Empty frames list to use */
+ struct kfifo conf_frame_Q; /* frames passed to TDs,waiting for tx */
+ struct kfifo dummy_packets_Q;/* dummy packets for the CRC overun */
bool already_pushed_dummy_bd;
};
@@ -493,9 +493,9 @@ static inline struct usb_hcd *fhci_to_hc
}
/* fifo of pointers */
-static inline struct kfifo *cq_new(int size)
+static inline int cq_new(struct kfifo *fifo, int size)
{
- return kfifo_alloc(size * sizeof(void *), GFP_KERNEL, NULL);
+ return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL, NULL);
}
static inline void cq_delete(struct kfifo *kfifo)
diff -u -N -r -p kfifo0/drivers/usb/host/fhci-sched.c kfifo1/drivers/usb/host/fhci-sched.c
--- kfifo0/drivers/usb/host/fhci-sched.c 2009-10-19 20:39:11.051891585 +0200
+++ kfifo1/drivers/usb/host/fhci-sched.c 2009-10-19 20:39:24.658339795 +0200
@@ -37,7 +37,7 @@ static void recycle_frame(struct fhci_us
pkt->info = 0;
pkt->priv_data = NULL;
- cq_put(usb->ep0->empty_frame_Q, pkt);
+ cq_put(&usb->ep0->empty_frame_Q, pkt);
}
/* confirm submitted packet */
@@ -57,7 +57,7 @@ void fhci_transaction_confirm(struct fhc
if ((td->data + td->actual_len) && trans_len)
memcpy(td->data + td->actual_len, pkt->data,
trans_len);
- cq_put(usb->ep0->dummy_packets_Q, pkt->data);
+ cq_put(&usb->ep0->dummy_packets_Q, pkt->data);
}
recycle_frame(usb, pkt);
@@ -213,7 +213,7 @@ static int add_packet(struct fhci_usb *u
}
/* update frame object fields before transmitting */
- pkt = cq_get(usb->ep0->empty_frame_Q);
+ pkt = cq_get(&usb->ep0->empty_frame_Q);
if (!pkt) {
fhci_dbg(usb->fhci, "there is no empty frame\n");
return -1;
@@ -222,7 +222,7 @@ static int add_packet(struct fhci_usb *u
pkt->info = 0;
if (data == NULL) {
- data = cq_get(usb->ep0->dummy_packets_Q);
+ data = cq_get(&usb->ep0->dummy_packets_Q);
BUG_ON(!data);
pkt->info = PKT_DUMMY_PACKET;
}
@@ -246,7 +246,7 @@ static int add_packet(struct fhci_usb *u
list_del_init(&td->frame_lh);
td->status = USB_TD_OK;
if (pkt->info & PKT_DUMMY_PACKET)
- cq_put(usb->ep0->dummy_packets_Q, pkt->data);
+ cq_put(&usb->ep0->dummy_packets_Q, pkt->data);
recycle_frame(usb, pkt);
usb->actual_frame->total_bytes -= (len + PROTOCOL_OVERHEAD);
fhci_err(usb->fhci, "host transaction failed\n");
diff -u -N -r -p kfifo0/drivers/usb/host/fhci-tds.c kfifo1/drivers/usb/host/fhci-tds.c
--- kfifo0/drivers/usb/host/fhci-tds.c 2009-10-19 20:39:11.965534282 +0200
+++ kfifo1/drivers/usb/host/fhci-tds.c 2009-10-19 20:39:24.108102402 +0200
@@ -106,33 +106,33 @@ void fhci_ep0_free(struct fhci_usb *usb)
cpm_muram_free(cpm_muram_offset(ep->td_base));
if (ep->conf_frame_Q) {
- size = cq_howmany(ep->conf_frame_Q);
+ size = cq_howmany(&ep->conf_frame_Q);
for (; size; size--) {
- struct packet *pkt = cq_get(ep->conf_frame_Q);
+ struct packet *pkt = cq_get(&ep->conf_frame_Q);
kfree(pkt);
}
- cq_delete(ep->conf_frame_Q);
+ cq_delete(&ep->conf_frame_Q);
}
if (ep->empty_frame_Q) {
- size = cq_howmany(ep->empty_frame_Q);
+ size = cq_howmany(&ep->empty_frame_Q);
for (; size; size--) {
- struct packet *pkt = cq_get(ep->empty_frame_Q);
+ struct packet *pkt = cq_get(&ep->empty_frame_Q);
kfree(pkt);
}
- cq_delete(ep->empty_frame_Q);
+ cq_delete(&ep->empty_frame_Q);
}
if (ep->dummy_packets_Q) {
- size = cq_howmany(ep->dummy_packets_Q);
+ size = cq_howmany(&ep->dummy_packets_Q);
for (; size; size--) {
- u8 *buff = cq_get(ep->dummy_packets_Q);
+ u8 *buff = cq_get(&ep->dummy_packets_Q);
kfree(buff);
}
- cq_delete(ep->dummy_packets_Q);
+ cq_delete(&ep->dummy_packets_Q);
}
kfree(ep);
@@ -175,10 +175,9 @@ u32 fhci_create_ep(struct fhci_usb *usb,
ep->td_base = cpm_muram_addr(ep_offset);
/* zero all queue pointers */
- ep->conf_frame_Q = cq_new(ring_len + 2);
- ep->empty_frame_Q = cq_new(ring_len + 2);
- ep->dummy_packets_Q = cq_new(ring_len + 2);
- if (!ep->conf_frame_Q || !ep->empty_frame_Q || !ep->dummy_packets_Q) {
+ if (cq_new(&ep->conf_frame_Q, ring_len + 2) ||
+ cq_new(&ep->empty_frame_Q, ring_len + 2) ||
+ cq_new(&ep->dummy_packets_Q, ring_len + 2)) {
err_for = "frame_queues";
goto err;
}
@@ -199,8 +198,8 @@ u32 fhci_create_ep(struct fhci_usb *usb,
err_for = "buffer";
goto err;
}
- cq_put(ep->empty_frame_Q, pkt);
- cq_put(ep->dummy_packets_Q, buff);
+ cq_put(&ep->empty_frame_Q, pkt);
+ cq_put(&ep->dummy_packets_Q, buff);
}
/* we put the endpoint parameter RAM right behind the TD ring */
@@ -319,7 +318,7 @@ static void fhci_td_transaction_confirm(
if ((buf == DUMMY2_BD_BUFFER) && !(td_status & ~TD_W))
continue;
- pkt = cq_get(ep->conf_frame_Q);
+ pkt = cq_get(&ep->conf_frame_Q);
if (!pkt)
fhci_err(usb->fhci, "no frame to confirm\n");
@@ -460,9 +459,9 @@ u32 fhci_host_transaction(struct fhci_us
out_be16(&td->length, pkt->len);
/* put the frame to the confirmation queue */
- cq_put(ep->conf_frame_Q, pkt);
+ cq_put(&ep->conf_frame_Q, pkt);
- if (cq_howmany(ep->conf_frame_Q) == 1)
+ if (cq_howmany(&ep->conf_frame_Q) == 1)
out_8(&usb->fhci->regs->usb_comm, USB_CMD_STR_FIFO);
return 0;
diff -u -N -r -p kfifo0/drivers/usb/serial/usb-serial.c kfifo1/drivers/usb/serial/usb-serial.c
--- kfifo0/drivers/usb/serial/usb-serial.c 2009-10-19 20:39:11.791588706 +0200
+++ kfifo1/drivers/usb/serial/usb-serial.c 2009-10-19 20:39:24.969443191 +0200
@@ -966,9 +966,8 @@ int usb_serial_probe(struct usb_interfac
dev_err(&interface->dev, "No free urbs available\n");
goto probe_error;
}
- port->write_fifo = kfifo_alloc(PAGE_SIZE, GFP_KERNEL,
- &port->lock);
- if (IS_ERR(port->write_fifo))
+ if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL,
+ &port->lock))
goto probe_error;
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->bulk_out_size = buffer_size;
diff -u -N -r -p kfifo0/include/linux/kfifo.h kfifo1/include/linux/kfifo.h
--- kfifo0/include/linux/kfifo.h 2009-10-19 20:39:11.789622162 +0200
+++ kfifo1/include/linux/kfifo.h 2009-10-19 20:39:24.361587054 +0200
@@ -1,6 +1,7 @@
/*
- * A simple kernel FIFO implementation.
+ * A generic kernel FIFO implementation.
*
+ * Copyright (C) 2009 Stefani Seibold <[email protected]>
* Copyright (C) 2004 Stelian Pop <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
@@ -32,10 +33,10 @@ struct kfifo {
spinlock_t *lock; /* protects concurrent modifications */
};
-extern struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
- gfp_t gfp_mask, spinlock_t *lock);
-extern struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask,
- spinlock_t *lock);
+extern void kfifo_init(struct kfifo *fifo, unsigned char *buffer,
+ unsigned int size, spinlock_t *lock);
+extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
+ gfp_t gfp_mask, spinlock_t *lock);
extern void kfifo_free(struct kfifo *fifo);
extern unsigned int __kfifo_put(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len);
diff -u -N -r -p kfifo0/include/scsi/libiscsi.h kfifo1/include/scsi/libiscsi.h
--- kfifo0/include/scsi/libiscsi.h 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/include/scsi/libiscsi.h 2009-10-19 20:39:24.000000000 +0200
@@ -28,6 +28,7 @@
#include <linux/mutex.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
+#include <linux/kfifo.h>
#include <scsi/iscsi_proto.h>
#include <scsi/iscsi_if.h>
#include <scsi/scsi_transport_iscsi.h>
@@ -231,7 +232,7 @@ struct iscsi_conn {
};
struct iscsi_pool {
- struct kfifo *queue; /* FIFO Queue */
+ struct kfifo queue; /* FIFO Queue */
void **pool; /* Pool of elements */
int max; /* Max number of elements */
};
diff -u -N -r -p kfifo0/include/scsi/libiscsi_tcp.h kfifo1/include/scsi/libiscsi_tcp.h
--- kfifo0/include/scsi/libiscsi_tcp.h 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/include/scsi/libiscsi_tcp.h 2009-10-19 20:39:24.190836376 +0200
@@ -80,7 +80,7 @@ struct iscsi_tcp_task {
int data_offset;
struct iscsi_r2t_info *r2t; /* in progress solict R2T */
struct iscsi_pool r2tpool;
- struct kfifo *r2tqueue;
+ struct kfifo r2tqueue;
void *dd_data;
};
diff -u -N -r -p kfifo0/include/scsi/libsrp.h kfifo1/include/scsi/libsrp.h
--- kfifo0/include/scsi/libsrp.h 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/include/scsi/libsrp.h 2009-10-19 20:39:24.000000000 +0200
@@ -21,7 +21,7 @@ struct srp_buf {
struct srp_queue {
void *pool;
void *items;
- struct kfifo *queue;
+ struct kfifo queue;
spinlock_t lock;
};
diff -u -N -r -p kfifo0/kernel/kfifo.c kfifo1/kernel/kfifo.c
--- kfifo0/kernel/kfifo.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/kernel/kfifo.c 2009-10-19 20:39:24.000000000 +0200
@@ -1,6 +1,7 @@
/*
- * A simple kernel FIFO implementation.
+ * A generic kernel FIFO implementation.
*
+ * Copyright (C) 2009 Stefani Seibold <[email protected]>
* Copyright (C) 2004 Stelian Pop <[email protected]>
*
* This program is free software; you can redistribute it and/or modify
@@ -26,49 +27,51 @@
#include <linux/kfifo.h>
#include <linux/log2.h>
+static void _kfifo_init(struct kfifo *fifo, unsigned char *buffer,
+ unsigned int size, spinlock_t *lock)
+{
+ fifo->buffer = buffer;
+ fifo->size = size;
+ fifo->lock = lock;
+
+ kfifo_reset(fifo);
+}
+
/**
- * kfifo_init - allocates a new FIFO using a preallocated buffer
+ * kfifo_init - initialize a FIFO using a preallocated buffer
+ * @fifo: the fifo to assign the buffer
* @buffer: the preallocated buffer to be used.
* @size: the size of the internal buffer, this have to be a power of 2.
- * @gfp_mask: get_free_pages mask, passed to kmalloc()
* @lock: the lock to be used to protect the fifo buffer
*
- * Do NOT pass the kfifo to kfifo_free() after use! Simply free the
- * &struct kfifo with kfree().
*/
-struct kfifo *kfifo_init(unsigned char *buffer, unsigned int size,
- gfp_t gfp_mask, spinlock_t *lock)
+void kfifo_init(struct kfifo *fifo, unsigned char *buffer, unsigned int size,
+ spinlock_t *lock)
{
- struct kfifo *fifo;
-
/* size must be a power of 2 */
BUG_ON(!is_power_of_2(size));
- fifo = kmalloc(sizeof(struct kfifo), gfp_mask);
- if (!fifo)
- return ERR_PTR(-ENOMEM);
-
- fifo->buffer = buffer;
- fifo->size = size;
- fifo->in = fifo->out = 0;
- fifo->lock = lock;
-
- return fifo;
+ _kfifo_init(fifo, buffer, size, lock);
}
EXPORT_SYMBOL(kfifo_init);
/**
- * kfifo_alloc - allocates a new FIFO and its internal buffer
- * @size: the size of the internal buffer to be allocated.
+ * kfifo_alloc - allocates a new FIFO internal buffer
+ * @fifo: the fifo to assign then new buffer
+ * @size: the size of the buffer to be allocated, this have to be a power of 2.
* @gfp_mask: get_free_pages mask, passed to kmalloc()
* @lock: the lock to be used to protect the fifo buffer
*
+ * This function dynamically allocates a new fifo internal buffer
+ *
* The size will be rounded-up to a power of 2.
+ * The buffer will be release with kfifo_free().
+ * Return 0 if no error, otherwise the an error code
*/
-struct kfifo *kfifo_alloc(unsigned int size, gfp_t gfp_mask, spinlock_t *lock)
+int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask,
+ spinlock_t *lock)
{
unsigned char *buffer;
- struct kfifo *ret;
/*
* round up to the next power of 2, since our 'let the indices
@@ -80,26 +83,24 @@ struct kfifo *kfifo_alloc(unsigned int s
}
buffer = kmalloc(size, gfp_mask);
- if (!buffer)
- return ERR_PTR(-ENOMEM);
-
- ret = kfifo_init(buffer, size, gfp_mask, lock);
+ if (!buffer) {
+ _kfifo_init(fifo, 0, 0, NULL);
+ return -ENOMEM;
+ }
- if (IS_ERR(ret))
- kfree(buffer);
+ _kfifo_init(fifo, buffer, size, lock);
- return ret;
+ return 0;
}
EXPORT_SYMBOL(kfifo_alloc);
/**
- * kfifo_free - frees the FIFO
+ * kfifo_free - frees the FIFO internal buffer
* @fifo: the fifo to be freed.
*/
void kfifo_free(struct kfifo *fifo)
{
kfree(fifo->buffer);
- kfree(fifo);
}
EXPORT_SYMBOL(kfifo_free);
diff -u -N -r -p kfifo0/net/dccp/probe.c kfifo1/net/dccp/probe.c
--- kfifo0/net/dccp/probe.c 2009-10-19 20:39:11.000000000 +0200
+++ kfifo1/net/dccp/probe.c 2009-10-19 20:39:24.000000000 +0200
@@ -43,7 +43,7 @@ static int bufsize = 64 * 1024;
static const char procname[] = "dccpprobe";
static struct {
- struct kfifo *fifo;
+ struct kfifo fifo;
spinlock_t lock;
wait_queue_head_t wait;
struct timespec tstart;
@@ -67,7 +67,7 @@ static void printl(const char *fmt, ...)
len += vscnprintf(tbuf+len, sizeof(tbuf)-len, fmt, args);
va_end(args);
- kfifo_put(dccpw.fifo, tbuf, len);
+ kfifo_put(&dccpw.fifo, tbuf, len);
wake_up(&dccpw.wait);
}
@@ -110,7 +110,7 @@ static struct jprobe dccp_send_probe = {
static int dccpprobe_open(struct inode *inode, struct file *file)
{
- kfifo_reset(dccpw.fifo);
+ kfifo_reset(&dccpw.fifo);
getnstimeofday(&dccpw.tstart);
return 0;
}
@@ -132,11 +132,11 @@ static ssize_t dccpprobe_read(struct fil
return -ENOMEM;
error = wait_event_interruptible(dccpw.wait,
- __kfifo_len(dccpw.fifo) != 0);
+ __kfifo_len(&dccpw.fifo) != 0);
if (error)
goto out_free;
- cnt = kfifo_get(dccpw.fifo, tbuf, len);
+ cnt = kfifo_get(&dccpw.fifo, tbuf, len);
error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;
out_free:
@@ -157,10 +157,8 @@ static __init int dccpprobe_init(void)
init_waitqueue_head(&dccpw.wait);
spin_lock_init(&dccpw.lock);
- dccpw.fifo = kfifo_alloc(bufsize, GFP_KERNEL, &dccpw.lock);
- if (IS_ERR(dccpw.fifo))
- return PTR_ERR(dccpw.fifo);
-
+ if (kfifo_alloc(&dccpw.fifo, bufsize, GFP_KERNEL, &dccpw.lock))
+ return ret;
if (!proc_net_fops_create(&init_net, procname, S_IRUSR, &dccpprobe_fops))
goto err0;
@@ -173,14 +171,14 @@ static __init int dccpprobe_init(void)
err1:
proc_net_remove(&init_net, procname);
err0:
- kfifo_free(dccpw.fifo);
+ kfifo_free(&dccpw.fifo);
return ret;
}
module_init(dccpprobe_init);
static __exit void dccpprobe_exit(void)
{
- kfifo_free(dccpw.fifo);
+ kfifo_free(&dccpw.fifo);
proc_net_remove(&init_net, procname);
unregister_jprobe(&dccp_send_probe);
Move the pointer to the spinlock out of struct kfifo. Most
users in tree do not actually use a spinlock, so the few
exceptions now have to call kfifo_{get,put}_locked, which takes
an extra argument to a spinlock.
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
drivers/char/nozomi.c | 2
drivers/char/sonypi.c | 21 ++++---
drivers/infiniband/hw/cxgb3/cxio_resource.c | 36 +++++++-----
drivers/media/video/meye.c | 35 +++++++-----
drivers/net/wireless/libertas/main.c | 2
drivers/platform/x86/fujitsu-laptop.c | 18 +++---
drivers/platform/x86/sony-laptop.c | 22 ++++---
drivers/scsi/libiscsi.c | 2
drivers/scsi/libiscsi_tcp.c | 2
drivers/scsi/libsrp.c | 9 +--
drivers/usb/host/fhci.h | 2
drivers/usb/serial/generic.c | 4 -
drivers/usb/serial/usb-serial.c | 3 -
include/linux/kfifo.h | 80 ++++++++++++----------------
kernel/kfifo.c | 17 ++---
net/dccp/probe.c | 6 +-
16 files changed, 131 insertions(+), 130 deletions(-)
diff -u -N -r -p kfifo1/drivers/char/nozomi.c kfifo2/drivers/char/nozomi.c
--- kfifo1/drivers/char/nozomi.c 2009-10-19 20:39:24.367550786 +0200
+++ kfifo2/drivers/char/nozomi.c 2009-10-19 20:58:34.000000000 +0200
@@ -686,7 +686,7 @@ static int nozomi_read_config_table(stru
for (i = PORT_MDM; i < MAX_PORT; i++) {
kfifo_alloc(&dc->port[i].fifo_ul,
- FIFO_BUFFER_SIZE_UL, GFP_ATOMIC, NULL);
+ FIFO_BUFFER_SIZE_UL, GFP_ATOMIC);
memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
}
diff -u -N -r -p kfifo1/drivers/char/sonypi.c kfifo2/drivers/char/sonypi.c
--- kfifo1/drivers/char/sonypi.c 2009-10-19 20:39:24.462844882 +0200
+++ kfifo2/drivers/char/sonypi.c 2009-10-19 20:58:34.000000000 +0200
@@ -777,8 +777,9 @@ static void input_keyrelease(struct work
{
struct sonypi_keypress kp;
- while (kfifo_get(&sonypi_device.input_fifo, (unsigned char *)&kp,
- sizeof(kp)) == sizeof(kp)) {
+ while (kfifo_get_locked(&sonypi_device.input_fifo, (unsigned char *)&kp,
+ sizeof(kp), &sonypi_device.input_fifo_lock)
+ == sizeof(kp)) {
msleep(10);
input_report_key(kp.dev, kp.key, 0);
input_sync(kp.dev);
@@ -827,8 +828,9 @@ static void sonypi_report_input_event(u8
if (kp.dev) {
input_report_key(kp.dev, kp.key, 1);
input_sync(kp.dev);
- kfifo_put(&sonypi_device.input_fifo,
- (unsigned char *)&kp, sizeof(kp));
+ kfifo_put_locked(&sonypi_device.input_fifo,
+ (unsigned char *)&kp, sizeof(kp),
+ &sonypi_device.input_fifo_lock);
schedule_work(&sonypi_device.input_work);
}
}
@@ -880,7 +882,8 @@ found:
acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
#endif
- kfifo_put(&sonypi_device.fifo, (unsigned char *)&event, sizeof(event));
+ kfifo_put_locked(&sonypi_device.fifo, (unsigned char *)&event,
+ sizeof(event), &sonypi_device.fifo_lock);
kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_device.fifo_proc_list);
@@ -929,7 +932,8 @@ static ssize_t sonypi_misc_read(struct f
return ret;
while (ret < count &&
- (kfifo_get(&sonypi_device.fifo, &c, sizeof(c)) == sizeof(c))) {
+ (kfifo_get_locked(&sonypi_device.fifo, &c, sizeof(c),
+ &sonypi_device.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -1313,8 +1317,7 @@ static int __devinit sonypi_probe(struct
"http://www.linux.it/~malattia/wiki/index.php/Sony_drivers\n");
spin_lock_init(&sonypi_device.fifo_lock);
- error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL,
- &sonypi_device.fifo_lock);
+ error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL);
if (error) {
printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
return error;
@@ -1394,7 +1397,7 @@ static int __devinit sonypi_probe(struct
spin_lock_init(&sonypi_device.input_fifo_lock);
error = kfifo_alloc(&sonypi_device.input_fifo, SONYPI_BUF_SIZE,
- GFP_KERNEL, &sonypi_device.input_fifo_lock);
+ GFP_KERNEL);
if (error) {
printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
goto err_inpdev_unregister;
diff -u -N -r -p kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c
--- kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 20:58:34.000000000 +0200
@@ -55,7 +55,7 @@ static int __cxio_init_resource_fifo(str
u32 rarray[16];
spin_lock_init(fifo_lock);
- if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL, fifo_lock))
+ if (kfifo_alloc(fifo, nr * sizeof(u32), GFP_KERNEL))
return -ENOMEM;
for (i = 0; i < skip_low + skip_high; i++)
@@ -86,7 +86,8 @@ static int __cxio_init_resource_fifo(str
__kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
for (i = 0; i < skip_low + skip_high; i++)
- kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32));
+ kfifo_get_locked(fifo, (unsigned char *) &entry,
+ sizeof(u32), fifo_lock);
return 0;
}
@@ -113,8 +114,7 @@ static int cxio_init_qpid_fifo(struct cx
spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
if (kfifo_alloc(&rdev_p->rscp->qpid_fifo, T3_MAX_NUM_QP * sizeof(u32),
- GFP_KERNEL,
- &rdev_p->rscp->qpid_fifo_lock))
+ GFP_KERNEL))
return -ENOMEM;
for (i = 16; i < T3_MAX_NUM_QP; i++)
@@ -177,33 +177,37 @@ tpt_err:
/*
* returns 0 if no resource available
*/
-static u32 cxio_hal_get_resource(struct kfifo *fifo)
+static u32 cxio_hal_get_resource(struct kfifo *fifo, spinlock_t * lock)
{
u32 entry;
- if (kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32)))
+ if (kfifo_get_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
return entry;
else
return 0; /* fifo emptry */
}
-static void cxio_hal_put_resource(struct kfifo *fifo, u32 entry)
+static void cxio_hal_put_resource(struct kfifo *fifo, spinlock_t * lock,
+ u32 entry)
{
- BUG_ON(kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)) == 0);
+ BUG_ON(
+ kfifo_put_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)
+ == 0);
}
u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(&rscp->tpt_fifo);
+ return cxio_hal_get_resource(&rscp->tpt_fifo, &rscp->tpt_fifo_lock);
}
void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
{
- cxio_hal_put_resource(&rscp->tpt_fifo, stag);
+ cxio_hal_put_resource(&rscp->tpt_fifo, &rscp->tpt_fifo_lock, stag);
}
u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
{
- u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo);
+ u32 qpid = cxio_hal_get_resource(&rscp->qpid_fifo,
+ &rscp->qpid_fifo_lock);
PDBG("%s qpid 0x%x\n", __func__, qpid);
return qpid;
}
@@ -211,27 +215,27 @@ u32 cxio_hal_get_qpid(struct cxio_hal_re
void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
{
PDBG("%s qpid 0x%x\n", __func__, qpid);
- cxio_hal_put_resource(&rscp->qpid_fifo, qpid);
+ cxio_hal_put_resource(&rscp->qpid_fifo, &rscp->qpid_fifo_lock, qpid);
}
u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(&rscp->cqid_fifo);
+ return cxio_hal_get_resource(&rscp->cqid_fifo, &rscp->cqid_fifo_lock);
}
void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
{
- cxio_hal_put_resource(&rscp->cqid_fifo, cqid);
+ cxio_hal_put_resource(&rscp->cqid_fifo, &rscp->cqid_fifo_lock, cqid);
}
u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
{
- return cxio_hal_get_resource(&rscp->pdid_fifo);
+ return cxio_hal_get_resource(&rscp->pdid_fifo, &rscp->pdid_fifo_lock);
}
void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
{
- cxio_hal_put_resource(&rscp->pdid_fifo, pdid);
+ cxio_hal_put_resource(&rscp->pdid_fifo, &rscp->pdid_fifo_lock, pdid);
}
void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
diff -u -N -r -p kfifo1/drivers/media/video/meye.c kfifo2/drivers/media/video/meye.c
--- kfifo1/drivers/media/video/meye.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/media/video/meye.c 2009-10-19 20:58:34.000000000 +0200
@@ -800,8 +800,8 @@ again:
return IRQ_HANDLED;
if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
- if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
- sizeof(int)) != sizeof(int)) {
+ if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame();
return IRQ_HANDLED;
}
@@ -811,7 +811,8 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+ kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list);
} else {
int size;
@@ -820,8 +821,8 @@ again:
mchip_free_frame();
goto again;
}
- if (kfifo_get(&meye.grabq, (unsigned char *)&reqnr,
- sizeof(int)) != sizeof(int)) {
+ if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame();
goto again;
}
@@ -831,7 +832,8 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put(&meye.doneq, (unsigned char *)&reqnr, sizeof(int));
+ kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list);
}
mchip_free_frame();
@@ -933,7 +935,8 @@ static int meyeioc_qbuf_capt(int *nb)
mchip_cont_compression_start();
meye.grab_buffer[*nb].state = MEYE_BUF_USING;
- kfifo_put(&meye.grabq, (unsigned char *)nb, sizeof(int));
+ kfifo_put_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
+ &meye.grabq_lock);
mutex_unlock(&meye.lock);
return 0;
@@ -965,7 +968,8 @@ static int meyeioc_sync(struct file *fil
/* fall through */
case MEYE_BUF_DONE:
meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
- kfifo_get(&meye.doneq, (unsigned char *)&unused, sizeof(int));
+ kfifo_get_locked(&meye.doneq, (unsigned char *)&unused,
+ sizeof(int), &meye.doneq_lock);
}
*i = meye.grab_buffer[*i].size;
mutex_unlock(&meye.lock);
@@ -1452,7 +1456,8 @@ static int vidioc_qbuf(struct file *file
buf->flags |= V4L2_BUF_FLAG_QUEUED;
buf->flags &= ~V4L2_BUF_FLAG_DONE;
meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
- kfifo_put(&meye.grabq, (unsigned char *)&buf->index, sizeof(int));
+ kfifo_put_locked(&meye.grabq, (unsigned char *)&buf->index,
+ sizeof(int), &meye.grabq_lock);
mutex_unlock(&meye.lock);
return 0;
@@ -1478,8 +1483,8 @@ static int vidioc_dqbuf(struct file *fil
return -EINTR;
}
- if (!kfifo_get(&meye.doneq, (unsigned char *)&reqnr,
- sizeof(int))) {
+ if (!kfifo_get_locked(&meye.doneq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.doneq_lock)) {
mutex_unlock(&meye.lock);
return -EBUSY;
}
@@ -1746,14 +1751,14 @@ static int __devinit meye_probe(struct p
}
spin_lock_init(&meye.grabq_lock);
- if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
- &meye.grabq_lock)) {
+ if (kfifo_alloc(&meye.grabq, sizeof(int) * MEYE_MAX_BUFNBRS,
+ GFP_KERNEL)) {
printk(KERN_ERR "meye: fifo allocation failed\n");
goto outkfifoalloc1;
}
spin_lock_init(&meye.doneq_lock);
- if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS, GFP_KERNEL,
- &meye.doneq_lock)) {
+ if (kfifo_alloc(&meye.doneq, sizeof(int) * MEYE_MAX_BUFNBRS,
+ GFP_KERNEL)) {
printk(KERN_ERR "meye: fifo allocation failed\n");
goto outkfifoalloc2;
}
diff -u -N -r -p kfifo1/drivers/net/wireless/libertas/main.c kfifo2/drivers/net/wireless/libertas/main.c
--- kfifo1/drivers/net/wireless/libertas/main.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/net/wireless/libertas/main.c 2009-10-19 20:58:34.000000000 +0200
@@ -1121,7 +1121,7 @@ static int lbs_init_adapter(struct lbs_p
priv->resp_len[0] = priv->resp_len[1] = 0;
/* Create the event FIFO */
- ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL, NULL);
+ ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
if (ret) {
lbs_pr_err("Out of memory allocating event FIFO buffer\n");
goto out;
diff -u -N -r -p kfifo1/drivers/platform/x86/fujitsu-laptop.c kfifo2/drivers/platform/x86/fujitsu-laptop.c
--- kfifo1/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 20:39:24.111587921 +0200
+++ kfifo2/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 20:58:34.000000000 +0200
@@ -825,7 +825,7 @@ static int acpi_fujitsu_hotkey_add(struc
/* kfifo */
spin_lock_init(&fujitsu_hotkey->fifo_lock);
error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
- GFP_KERNEL, &fujitsu_hotkey->fifo_lock);
+ GFP_KERNEL);
if (error) {
printk(KERN_ERR "kfifo_alloc failed\n");
goto err_stop;
@@ -1006,9 +1006,10 @@ static void acpi_fujitsu_hotkey_notify(s
vdbg_printk(FUJLAPTOP_DBG_TRACE,
"Push keycode into ringbuffer [%d]\n",
keycode);
- status = kfifo_put(&fujitsu_hotkey->fifo,
+ status = kfifo_put_locked(&fujitsu_hotkey->fifo,
(unsigned char *)&keycode,
- sizeof(keycode));
+ sizeof(keycode),
+ &fujitsu_hotkey->fifo_lock);
if (status != sizeof(keycode)) {
vdbg_printk(FUJLAPTOP_DBG_WARN,
"Could not push keycode [0x%x]\n",
@@ -1019,11 +1020,12 @@ static void acpi_fujitsu_hotkey_notify(s
}
} else if (keycode == 0) {
while ((status =
- kfifo_get
- (&fujitsu_hotkey->fifo, (unsigned char *)
- &keycode_r,
- sizeof
- (keycode_r))) == sizeof(keycode_r)) {
+ kfifo_get_locked(
+ &fujitsu_hotkey->fifo,
+ (unsigned char *) &keycode_r,
+ sizeof(keycode_r),
+ &fujitsu_hotkey->fifo_lock))
+ == sizeof(keycode_r)) {
input_report_key(input, keycode_r, 0);
input_sync(input);
vdbg_printk(FUJLAPTOP_DBG_TRACE,
diff -u -N -r -p kfifo1/drivers/platform/x86/sony-laptop.c kfifo2/drivers/platform/x86/sony-laptop.c
--- kfifo1/drivers/platform/x86/sony-laptop.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/platform/x86/sony-laptop.c 2009-10-19 20:58:34.482782781 +0200
@@ -300,8 +300,9 @@ static void do_sony_laptop_release_key(s
{
struct sony_laptop_keypress kp;
- while (kfifo_get(&sony_laptop_input.fifo, (unsigned char *)&kp,
- sizeof(kp)) == sizeof(kp)) {
+ while (kfifo_get_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
+ sizeof(kp), &sony_laptop_input.fifo_lock)
+ == sizeof(kp)) {
msleep(10);
input_report_key(kp.dev, kp.key, 0);
input_sync(kp.dev);
@@ -362,8 +363,9 @@ static void sony_laptop_report_input_eve
/* we emit the scancode so we can always remap the key */
input_event(kp.dev, EV_MSC, MSC_SCAN, event);
input_sync(kp.dev);
- kfifo_put(&sony_laptop_input.fifo,
- (unsigned char *)&kp, sizeof(kp));
+ kfifo_put_locked(&sony_laptop_input.fifo,
+ (unsigned char *)&kp, sizeof(kp),
+ &sony_laptop_input.fifo_lock);
if (!work_pending(&sony_laptop_release_key_work))
queue_work(sony_laptop_input.wq,
@@ -386,8 +388,7 @@ static int sony_laptop_setup_input(struc
/* kfifo */
spin_lock_init(&sony_laptop_input.fifo_lock);
error =
- kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
- &sony_laptop_input.fifo_lock);
+ kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
if (error) {
printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
goto err_dec_users;
@@ -2129,7 +2130,8 @@ static ssize_t sonypi_misc_read(struct f
return ret;
while (ret < count &&
- (kfifo_get(&sonypi_compat.fifo, &c, sizeof(c)) == sizeof(c))) {
+ (kfifo_get_locked(&sonypi_compat.fifo, &c, sizeof(c),
+ &sonypi_compat.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -2308,7 +2310,8 @@ static struct miscdevice sonypi_misc_dev
static void sonypi_compat_report_event(u8 event)
{
- kfifo_put(&sonypi_compat.fifo, (unsigned char *)&event, sizeof(event));
+ kfifo_put_locked(&sonypi_compat.fifo, (unsigned char *)&event,
+ sizeof(event), &sonypi_compat.fifo_lock);
kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_compat.fifo_proc_list);
}
@@ -2319,8 +2322,7 @@ static int sonypi_compat_init(void)
spin_lock_init(&sonypi_compat.fifo_lock);
error =
- kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
- &sonypi_compat.fifo_lock);
+ kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
if (error) {
printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
return error;
diff -u -N -r -p kfifo1/drivers/scsi/libiscsi.c kfifo2/drivers/scsi/libiscsi.c
--- kfifo1/drivers/scsi/libiscsi.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/scsi/libiscsi.c 2009-10-19 20:58:34.000000000 +0200
@@ -2252,7 +2252,7 @@ iscsi_pool_init(struct iscsi_pool *q, in
if (q->pool == NULL)
return -ENOMEM;
- kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*), NULL);
+ kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
for (i = 0; i < max; i++) {
q->pool[i] = kzalloc(item_size, GFP_KERNEL);
diff -u -N -r -p kfifo1/drivers/scsi/libiscsi_tcp.c kfifo2/drivers/scsi/libiscsi_tcp.c
--- kfifo1/drivers/scsi/libiscsi_tcp.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/scsi/libiscsi_tcp.c 2009-10-19 20:58:34.863588144 +0200
@@ -1128,7 +1128,7 @@ int iscsi_tcp_r2tpool_alloc(struct iscsi
/* R2T xmit queue */
if (kfifo_alloc(&tcp_task->r2tqueue,
- session->max_r2t * 4 * sizeof(void*), GFP_KERNEL, NULL)) {
+ session->max_r2t * 4 * sizeof(void*), GFP_KERNEL)) {
iscsi_pool_free(&tcp_task->r2tpool);
goto r2t_alloc_fail;
}
diff -u -N -r -p kfifo1/drivers/scsi/libsrp.c kfifo2/drivers/scsi/libsrp.c
--- kfifo1/drivers/scsi/libsrp.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/drivers/scsi/libsrp.c 2009-10-19 20:58:34.419253835 +0200
@@ -58,8 +58,7 @@ static int srp_iu_pool_alloc(struct srp_
goto free_pool;
spin_lock_init(&q->lock);
- kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *),
- &q->lock);
+ kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
for (i = 0, iue = q->items; i < max; i++) {
__kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
@@ -165,7 +164,8 @@ struct iu_entry *srp_iu_get(struct srp_t
{
struct iu_entry *iue = NULL;
- kfifo_get(&target->iu_queue.queue, (void *) &iue, sizeof(void *));
+ kfifo_get_locked(&target->iu_queue.queue, (void *) &iue,
+ sizeof(void *), &target->iu_queue.lock);
if (!iue)
return iue;
iue->target = target;
@@ -177,7 +177,8 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
void srp_iu_put(struct iu_entry *iue)
{
- kfifo_put(&iue->target->iu_queue.queue, (void *) &iue, sizeof(void *));
+ kfifo_put_locked(&iue->target->iu_queue.queue, (void *) &iue,
+ sizeof(void *), &iue->target->iu_queue.lock);
}
EXPORT_SYMBOL_GPL(srp_iu_put);
diff -u -N -r -p kfifo1/drivers/usb/host/fhci.h kfifo2/drivers/usb/host/fhci.h
--- kfifo1/drivers/usb/host/fhci.h 2009-10-19 20:39:24.022212548 +0200
+++ kfifo2/drivers/usb/host/fhci.h 2009-10-19 20:58:34.893303070 +0200
@@ -495,7 +495,7 @@ static inline struct usb_hcd *fhci_to_hc
/* fifo of pointers */
static inline int cq_new(struct kfifo *fifo, int size)
{
- return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL, NULL);
+ return kfifo_alloc(fifo, size * sizeof(void *), GFP_KERNEL);
}
static inline void cq_delete(struct kfifo *kfifo)
diff -u -N -r -p kfifo1/drivers/usb/serial/generic.c kfifo2/drivers/usb/serial/generic.c
--- kfifo1/drivers/usb/serial/generic.c 2009-10-19 21:00:10.423587193 +0200
+++ kfifo2/drivers/usb/serial/generic.c 2009-10-19 20:58:34.197586887 +0200
@@ -285,7 +285,7 @@ static int usb_serial_generic_write_star
return 0;
data = port->write_urb->transfer_buffer;
- count = kfifo_get(port->write_fifo, data, port->bulk_out_size);
+ count = kfifo_get_locked(port->write_fifo, data, port->bulk_out_size, &port->lock);
usb_serial_debug_data(debug, &port->dev, __func__, count, data);
/* set up our urb */
@@ -345,7 +345,7 @@ int usb_serial_generic_write(struct tty_
return usb_serial_multi_urb_write(tty, port,
buf, count);
- count = kfifo_put(port->write_fifo, buf, count);
+ count = kfifo_put_locked(port->write_fifo, buf, count, &port->lock);
result = usb_serial_generic_write_start(port);
if (result >= 0)
diff -u -N -r -p kfifo1/drivers/usb/serial/usb-serial.c kfifo2/drivers/usb/serial/usb-serial.c
--- kfifo1/drivers/usb/serial/usb-serial.c 2009-10-19 20:39:24.969443191 +0200
+++ kfifo2/drivers/usb/serial/usb-serial.c 2009-10-19 20:58:34.175586396 +0200
@@ -966,8 +966,7 @@ int usb_serial_probe(struct usb_interfac
dev_err(&interface->dev, "No free urbs available\n");
goto probe_error;
}
- if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL,
- &port->lock))
+ if (kfifo_alloc(port->write_fifo, PAGE_SIZE, GFP_KERNEL))
goto probe_error;
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->bulk_out_size = buffer_size;
diff -u -N -r -p kfifo1/include/linux/kfifo.h kfifo2/include/linux/kfifo.h
--- kfifo1/include/linux/kfifo.h 2009-10-19 20:39:24.361587054 +0200
+++ kfifo2/include/linux/kfifo.h 2009-11-19 20:53:21.526214294 +0100
@@ -30,13 +30,12 @@ struct kfifo {
unsigned int size; /* the size of the allocated buffer */
unsigned int in; /* data is added at offset (in % size) */
unsigned int out; /* data is extracted from off. (out % size) */
- spinlock_t *lock; /* protects concurrent modifications */
};
extern void kfifo_init(struct kfifo *fifo, unsigned char *buffer,
- unsigned int size, spinlock_t *lock);
+ unsigned int size);
extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
- gfp_t gfp_mask, spinlock_t *lock);
+ gfp_t gfp_mask);
extern void kfifo_free(struct kfifo *fifo);
extern unsigned int __kfifo_put(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len);
@@ -58,58 +57,67 @@ static inline void __kfifo_reset(struct
*/
static inline void kfifo_reset(struct kfifo *fifo)
{
- unsigned long flags;
-
- spin_lock_irqsave(fifo->lock, flags);
-
__kfifo_reset(fifo);
+}
+
+/**
+ * __kfifo_len - returns the number of bytes available in the FIFO
+ * @fifo: the fifo to be used.
+ */
+static inline unsigned int __kfifo_len(struct kfifo *fifo)
+{
+ register unsigned int out;
- spin_unlock_irqrestore(fifo->lock, flags);
+ out = fifo->out;
+ smp_rmb();
+ return fifo->in - out;
}
/**
- * kfifo_put - puts some data into the FIFO
+ * kfifo_put_locked - puts some data into the FIFO using a spinlock for locking
* @fifo: the fifo to be used.
- * @buffer: the data to be added.
- * @len: the length of the data to be added.
+ * @from: the data to be added.
+ * @n: the length of the data to be added.
+ * @lock: pointer to the spinlock to use for locking.
*
- * This function copies at most @len bytes from the @buffer into
+ * This function copies at most @len bytes from the @from buffer into
* the FIFO depending on the free space, and returns the number of
* bytes copied.
*/
-static inline unsigned int kfifo_put(struct kfifo *fifo,
- const unsigned char *buffer, unsigned int len)
+static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo,
+ const unsigned char *from, unsigned int n, spinlock_t *lock)
{
unsigned long flags;
unsigned int ret;
- spin_lock_irqsave(fifo->lock, flags);
+ spin_lock_irqsave(lock, flags);
- ret = __kfifo_put(fifo, buffer, len);
+ ret = __kfifo_put(fifo, from, n);
- spin_unlock_irqrestore(fifo->lock, flags);
+ spin_unlock_irqrestore(lock, flags);
return ret;
}
/**
- * kfifo_get - gets some data from the FIFO
+ * kfifo_get_locked - gets some data from the FIFO using a spinlock for locking
* @fifo: the fifo to be used.
- * @buffer: where the data must be copied.
- * @len: the size of the destination buffer.
+ * @to: where the data must be copied.
+ * @n: the size of the destination buffer.
+ * @lock: pointer to the spinlock to use for locking.
*
* This function copies at most @len bytes from the FIFO into the
- * @buffer and returns the number of copied bytes.
+ * @to buffer and returns the number of copied bytes.
*/
-static inline unsigned int kfifo_get(struct kfifo *fifo,
- unsigned char *buffer, unsigned int len)
+static inline __must_check unsigned int kfifo_get_locked(struct kfifo *fifo,
+ unsigned char *to, unsigned int n, spinlock_t *lock)
{
unsigned long flags;
unsigned int ret;
- spin_lock_irqsave(fifo->lock, flags);
+ spin_lock_irqsave(lock, flags);
- ret = __kfifo_get(fifo, buffer, len);
+ ret = __kfifo_get(fifo, to, n);
/*
* optimization: if the FIFO is empty, set the indices to 0
@@ -118,36 +126,18 @@ static inline unsigned int kfifo_get(str
if (fifo->in == fifo->out)
fifo->in = fifo->out = 0;
- spin_unlock_irqrestore(fifo->lock, flags);
+ spin_unlock_irqrestore(lock, flags);
return ret;
}
/**
- * __kfifo_len - returns the number of bytes available in the FIFO, no locking version
- * @fifo: the fifo to be used.
- */
-static inline unsigned int __kfifo_len(struct kfifo *fifo)
-{
- return fifo->in - fifo->out;
-}
-
-/**
* kfifo_len - returns the number of bytes available in the FIFO
* @fifo: the fifo to be used.
*/
static inline unsigned int kfifo_len(struct kfifo *fifo)
{
- unsigned long flags;
- unsigned int ret;
-
- spin_lock_irqsave(fifo->lock, flags);
-
- ret = __kfifo_len(fifo);
-
- spin_unlock_irqrestore(fifo->lock, flags);
-
- return ret;
+ return __kfifo_len(fifo);
}
#endif
diff -u -N -r -p kfifo1/kernel/kfifo.c kfifo2/kernel/kfifo.c
--- kfifo1/kernel/kfifo.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/kernel/kfifo.c 2009-10-19 20:58:34.000000000 +0200
@@ -28,11 +28,10 @@
#include <linux/log2.h>
static void _kfifo_init(struct kfifo *fifo, unsigned char *buffer,
- unsigned int size, spinlock_t *lock)
+ unsigned int size)
{
fifo->buffer = buffer;
fifo->size = size;
- fifo->lock = lock;
kfifo_reset(fifo);
}
@@ -42,16 +41,14 @@ static void _kfifo_init(struct kfifo *fi
* @fifo: the fifo to assign the buffer
* @buffer: the preallocated buffer to be used.
* @size: the size of the internal buffer, this have to be a power of 2.
- * @lock: the lock to be used to protect the fifo buffer
*
*/
-void kfifo_init(struct kfifo *fifo, unsigned char *buffer, unsigned int size,
- spinlock_t *lock)
+void kfifo_init(struct kfifo *fifo, unsigned char *buffer, unsigned int size)
{
/* size must be a power of 2 */
BUG_ON(!is_power_of_2(size));
- _kfifo_init(fifo, buffer, size, lock);
+ _kfifo_init(fifo, buffer, size);
}
EXPORT_SYMBOL(kfifo_init);
@@ -60,7 +57,6 @@ EXPORT_SYMBOL(kfifo_init);
* @fifo: the fifo to assign then new buffer
* @size: the size of the buffer to be allocated, this have to be a power of 2.
* @gfp_mask: get_free_pages mask, passed to kmalloc()
- * @lock: the lock to be used to protect the fifo buffer
*
* This function dynamically allocates a new fifo internal buffer
*
@@ -68,8 +64,7 @@ EXPORT_SYMBOL(kfifo_init);
* The buffer will be release with kfifo_free().
* Return 0 if no error, otherwise the an error code
*/
-int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask,
- spinlock_t *lock)
+int kfifo_alloc(struct kfifo *fifo, unsigned int size, gfp_t gfp_mask)
{
unsigned char *buffer;
@@ -84,11 +79,11 @@ int kfifo_alloc(struct kfifo *fifo, unsi
buffer = kmalloc(size, gfp_mask);
if (!buffer) {
- _kfifo_init(fifo, 0, 0, NULL);
+ _kfifo_init(fifo, 0, 0);
return -ENOMEM;
}
- _kfifo_init(fifo, buffer, size, lock);
+ _kfifo_init(fifo, buffer, size);
return 0;
}
diff -u -N -r -p kfifo1/net/dccp/probe.c kfifo2/net/dccp/probe.c
--- kfifo1/net/dccp/probe.c 2009-10-19 20:39:24.000000000 +0200
+++ kfifo2/net/dccp/probe.c 2009-10-19 20:58:34.000000000 +0200
@@ -67,7 +67,7 @@ static void printl(const char *fmt, ...)
len += vscnprintf(tbuf+len, sizeof(tbuf)-len, fmt, args);
va_end(args);
- kfifo_put(&dccpw.fifo, tbuf, len);
+ kfifo_put_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
wake_up(&dccpw.wait);
}
@@ -136,7 +136,7 @@ static ssize_t dccpprobe_read(struct fil
if (error)
goto out_free;
- cnt = kfifo_get(&dccpw.fifo, tbuf, len);
+ cnt = kfifo_get_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;
out_free:
@@ -157,7 +157,7 @@ static __init int dccpprobe_init(void)
init_waitqueue_head(&dccpw.wait);
spin_lock_init(&dccpw.lock);
- if (kfifo_alloc(&dccpw.fifo, bufsize, GFP_KERNEL, &dccpw.lock))
+ if (kfifo_alloc(&dccpw.fifo, bufsize, GFP_KERNEL))
return ret;
if (!proc_net_fops_create(&init_net, procname, S_IRUSR, &dccpprobe_fops))
goto err0;
change name of __kfifo_* functions to kfifo_*, because
the prefix __kfifo should be reserved for internal functions only.
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
drivers/char/nozomi.c | 12 +++++-----
drivers/infiniband/hw/cxgb3/cxio_resource.c | 10 ++++----
drivers/net/wireless/libertas/cmd.c | 4 +--
drivers/net/wireless/libertas/main.c | 8 +++----
drivers/platform/x86/sony-laptop.c | 2 -
drivers/scsi/libiscsi.c | 14 ++++++------
drivers/scsi/libiscsi_tcp.c | 20 ++++++++---------
drivers/scsi/libsrp.c | 2 -
drivers/usb/host/fhci.h | 6 ++---
drivers/usb/serial/generic.c | 4 +--
include/linux/kfifo.h | 32 ++++++----------------------
kernel/kfifo.c | 12 +++++-----
net/dccp/probe.c | 2 -
13 files changed, 55 insertions(+), 73 deletions(-)
diff -u -N -r -p kfifo2/drivers/char/nozomi.c kfifo3/drivers/char/nozomi.c
--- kfifo2/drivers/char/nozomi.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/drivers/char/nozomi.c 2009-10-19 21:13:38.000000000 +0200
@@ -798,7 +798,7 @@ static int send_data(enum port_type inde
struct tty_struct *tty = tty_port_tty_get(&port->port);
/* Get data from tty and place in buf for now */
- size = __kfifo_get(&port->fifo_ul, dc->send_buf,
+ size = kfifo_get(&port->fifo_ul, dc->send_buf,
ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX);
if (size == 0) {
@@ -988,11 +988,11 @@ static int receive_flow_control(struct n
} else if (old_ctrl.CTS == 0 && ctrl_dl.CTS == 1) {
- if (__kfifo_len(&dc->port[port].fifo_ul)) {
+ if (kfifo_len(&dc->port[port].fifo_ul)) {
DBG1("Enable interrupt (0x%04X) on port: %d",
enable_ier, port);
DBG1("Data in buffer [%d], enable transmit! ",
- __kfifo_len(&dc->port[port].fifo_ul));
+ kfifo_len(&dc->port[port].fifo_ul));
enable_transmit_ul(port, dc);
} else {
DBG1("No data in buffer...");
@@ -1672,7 +1672,7 @@ static int ntty_write(struct tty_struct
goto exit;
}
- rval = __kfifo_put(&port->fifo_ul, (unsigned char *)buffer, count);
+ rval = kfifo_put(&port->fifo_ul, (unsigned char *)buffer, count);
/* notify card */
if (unlikely(dc == NULL)) {
@@ -1720,7 +1720,7 @@ static int ntty_write_room(struct tty_st
if (!port->port.count)
goto exit;
- room = port->fifo_ul.size - __kfifo_len(&port->fifo_ul);
+ room = port->fifo_ul.size - kfifo_len(&port->fifo_ul);
exit:
mutex_unlock(&port->tty_sem);
@@ -1877,7 +1877,7 @@ static s32 ntty_chars_in_buffer(struct t
goto exit_in_buffer;
}
- rval = __kfifo_len(&port->fifo_ul);
+ rval = kfifo_len(&port->fifo_ul);
exit_in_buffer:
return rval;
diff -u -N -r -p kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c kfifo3/drivers/infiniband/hw/cxgb3/cxio_resource.c
--- kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 21:13:38.000000000 +0200
@@ -59,7 +59,7 @@ static int __cxio_init_resource_fifo(str
return -ENOMEM;
for (i = 0; i < skip_low + skip_high; i++)
- __kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32));
+ kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32));
if (random) {
j = 0;
random_bytes = random32();
@@ -71,19 +71,19 @@ static int __cxio_init_resource_fifo(str
random_bytes = random32();
}
idx = (random_bytes >> (j * 2)) & 0xF;
- __kfifo_put(fifo,
+ kfifo_put(fifo,
(unsigned char *) &rarray[idx],
sizeof(u32));
rarray[idx] = i;
j++;
}
for (i = 0; i < RANDOM_SIZE; i++)
- __kfifo_put(fifo,
+ kfifo_put(fifo,
(unsigned char *) &rarray[i],
sizeof(u32));
} else
for (i = skip_low; i < nr - skip_high; i++)
- __kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
+ kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
for (i = 0; i < skip_low + skip_high; i++)
kfifo_get_locked(fifo, (unsigned char *) &entry,
@@ -119,7 +119,7 @@ static int cxio_init_qpid_fifo(struct cx
for (i = 16; i < T3_MAX_NUM_QP; i++)
if (!(i & rdev_p->qpmask))
- __kfifo_put(&rdev_p->rscp->qpid_fifo,
+ kfifo_put(&rdev_p->rscp->qpid_fifo,
(unsigned char *) &i, sizeof(u32));
return 0;
}
diff -u -N -r -p kfifo2/drivers/net/wireless/libertas/cmd.c kfifo3/drivers/net/wireless/libertas/cmd.c
--- kfifo2/drivers/net/wireless/libertas/cmd.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/drivers/net/wireless/libertas/cmd.c 2009-10-19 21:13:38.000000000 +0200
@@ -1869,7 +1869,7 @@ static void lbs_send_confirmsleep(struct
priv->dnld_sent = DNLD_RES_RECEIVED;
/* If nothing to do, go back to sleep (?) */
- if (!__kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
+ if (!kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
priv->psstate = PS_STATE_SLEEP;
spin_unlock_irqrestore(&priv->driver_lock, flags);
@@ -1943,7 +1943,7 @@ void lbs_ps_confirm_sleep(struct lbs_pri
}
/* Pending events or command responses? */
- if (__kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
+ if (kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
allowed = 0;
lbs_deb_host("pending events or command responses\n");
}
diff -u -N -r -p kfifo2/drivers/net/wireless/libertas/main.c kfifo3/drivers/net/wireless/libertas/main.c
--- kfifo2/drivers/net/wireless/libertas/main.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/drivers/net/wireless/libertas/main.c 2009-10-19 21:13:38.000000000 +0200
@@ -772,7 +772,7 @@ static int lbs_thread(void *data)
shouldsleep = 1; /* Can't send a command; one already running */
else if (!list_empty(&priv->cmdpendingq))
shouldsleep = 0; /* We have a command to send */
- else if (__kfifo_len(&priv->event_fifo))
+ else if (kfifo_len(&priv->event_fifo))
shouldsleep = 0; /* We have an event to process */
else
shouldsleep = 1; /* No command */
@@ -851,10 +851,10 @@ static int lbs_thread(void *data)
/* Process hardware events, e.g. card removed, link lost */
spin_lock_irq(&priv->driver_lock);
- while (__kfifo_len(&priv->event_fifo)) {
+ while (kfifo_len(&priv->event_fifo)) {
u32 event;
- __kfifo_get(&priv->event_fifo, (unsigned char *) &event,
+ kfifo_get(&priv->event_fifo, (unsigned char *) &event,
sizeof(event));
spin_unlock_irq(&priv->driver_lock);
lbs_process_event(priv, event);
@@ -1579,7 +1579,7 @@ void lbs_queue_event(struct lbs_private
if (priv->psstate == PS_STATE_SLEEP)
priv->psstate = PS_STATE_AWAKE;
- __kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
+ kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
wake_up_interruptible(&priv->waitq);
diff -u -N -r -p kfifo2/drivers/platform/x86/sony-laptop.c kfifo3/drivers/platform/x86/sony-laptop.c
--- kfifo2/drivers/platform/x86/sony-laptop.c 2009-10-19 20:58:34.482782781 +0200
+++ kfifo3/drivers/platform/x86/sony-laptop.c 2009-10-19 21:13:38.000000000 +0200
@@ -2107,7 +2107,7 @@ static int sonypi_misc_open(struct inode
spin_lock_irqsave(&sonypi_compat.fifo_lock, flags);
if (atomic_inc_return(&sonypi_compat.open_count) == 1)
- __kfifo_reset(&sonypi_compat.fifo);
+ kfifo_reset(&sonypi_compat.fifo);
spin_unlock_irqrestore(&sonypi_compat.fifo_lock, flags);
diff -u -N -r -p kfifo2/drivers/scsi/libiscsi.c kfifo3/drivers/scsi/libiscsi.c
--- kfifo2/drivers/scsi/libiscsi.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/drivers/scsi/libiscsi.c 2009-10-19 21:13:38.000000000 +0200
@@ -431,7 +431,7 @@ static void iscsi_free_task(struct iscsi
if (conn->login_task == task)
return;
- __kfifo_put(&session->cmdpool.queue, (void*)&task, sizeof(void*));
+ kfifo_put(&session->cmdpool.queue, (void*)&task, sizeof(void*));
if (sc) {
task->sc = NULL;
@@ -642,7 +642,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn
BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
- if (!__kfifo_get(&session->cmdpool.queue,
+ if (!kfifo_get(&session->cmdpool.queue,
(void*)&task, sizeof(void*)))
return NULL;
}
@@ -1473,7 +1473,7 @@ static inline struct iscsi_task *iscsi_a
{
struct iscsi_task *task;
- if (!__kfifo_get(&conn->session->cmdpool.queue,
+ if (!kfifo_get(&conn->session->cmdpool.queue,
(void *) &task, sizeof(void *)))
return NULL;
@@ -2260,7 +2260,7 @@ iscsi_pool_init(struct iscsi_pool *q, in
q->max = i;
goto enomem;
}
- __kfifo_put(&q->queue, (void*)&q->pool[i], sizeof(void*));
+ kfifo_put(&q->queue, (void*)&q->pool[i], sizeof(void*));
}
if (items) {
@@ -2609,7 +2609,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
/* allocate login_task used for the login/text sequences */
spin_lock_bh(&session->lock);
- if (!__kfifo_get(&session->cmdpool.queue,
+ if (!kfifo_get(&session->cmdpool.queue,
(void*)&conn->login_task,
sizeof(void*))) {
spin_unlock_bh(&session->lock);
@@ -2629,7 +2629,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
return cls_conn;
login_task_data_alloc_fail:
- __kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
+ kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
login_task_alloc_fail:
iscsi_destroy_conn(cls_conn);
@@ -2692,7 +2692,7 @@ void iscsi_conn_teardown(struct iscsi_cl
free_pages((unsigned long) conn->data,
get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
kfree(conn->persistent_address);
- __kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
+ kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
if (session->leadconn == conn)
session->leadconn = NULL;
diff -u -N -r -p kfifo2/drivers/scsi/libiscsi_tcp.c kfifo3/drivers/scsi/libiscsi_tcp.c
--- kfifo2/drivers/scsi/libiscsi_tcp.c 2009-10-19 20:58:34.863588144 +0200
+++ kfifo3/drivers/scsi/libiscsi_tcp.c 2009-10-19 21:13:38.000000000 +0200
@@ -445,15 +445,15 @@ void iscsi_tcp_cleanup_task(struct iscsi
return;
/* flush task's r2t queues */
- while (__kfifo_get(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
- __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ while (kfifo_get(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
+ kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
}
r2t = tcp_task->r2t;
if (r2t != NULL) {
- __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
tcp_task->r2t = NULL;
}
@@ -541,7 +541,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
return 0;
}
- rc = __kfifo_get(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
+ rc = kfifo_get(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
if (!rc) {
iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
"Target has sent more R2Ts than it "
@@ -554,7 +554,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
if (r2t->data_length == 0) {
iscsi_conn_printk(KERN_ERR, conn,
"invalid R2T with zero data len\n");
- __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -570,7 +570,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
"invalid R2T with data len %u at offset %u "
"and total length %d\n", r2t->data_length,
r2t->data_offset, scsi_out(task->sc)->length);
- __kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -580,7 +580,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
r2t->sent = 0;
tcp_task->exp_datasn = r2tsn + 1;
- __kfifo_put(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
+ kfifo_put(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
conn->r2t_pdus_cnt++;
iscsi_requeue_task(task);
@@ -951,7 +951,7 @@ int iscsi_tcp_task_init(struct iscsi_tas
return conn->session->tt->init_pdu(task, 0, task->data_count);
}
- BUG_ON(__kfifo_len(&tcp_task->r2tqueue));
+ BUG_ON(kfifo_len(&tcp_task->r2tqueue));
tcp_task->exp_datasn = 0;
/* Prepare PDU, optionally w/ immediate data */
@@ -982,7 +982,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
if (r2t->data_length <= r2t->sent) {
ISCSI_DBG_TCP(task->conn,
" done with r2t %p\n", r2t);
- __kfifo_put(&tcp_task->r2tpool.queue,
+ kfifo_put(&tcp_task->r2tpool.queue,
(void *)&tcp_task->r2t,
sizeof(void *));
tcp_task->r2t = r2t = NULL;
@@ -990,7 +990,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
}
if (r2t == NULL) {
- __kfifo_get(&tcp_task->r2tqueue,
+ kfifo_get(&tcp_task->r2tqueue,
(void *)&tcp_task->r2t, sizeof(void *));
r2t = tcp_task->r2t;
}
diff -u -N -r -p kfifo2/drivers/scsi/libsrp.c kfifo3/drivers/scsi/libsrp.c
--- kfifo2/drivers/scsi/libsrp.c 2009-10-19 20:58:34.419253835 +0200
+++ kfifo3/drivers/scsi/libsrp.c 2009-10-19 21:13:38.943924131 +0200
@@ -61,7 +61,7 @@ static int srp_iu_pool_alloc(struct srp_
kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
for (i = 0, iue = q->items; i < max; i++) {
- __kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
+ kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
iue->sbuf = ring[i];
iue++;
}
diff -u -N -r -p kfifo2/drivers/usb/host/fhci.h kfifo3/drivers/usb/host/fhci.h
--- kfifo2/drivers/usb/host/fhci.h 2009-10-19 20:58:34.893303070 +0200
+++ kfifo3/drivers/usb/host/fhci.h 2009-10-19 21:13:38.762150583 +0200
@@ -505,19 +505,19 @@ static inline void cq_delete(struct kfif
static inline unsigned int cq_howmany(struct kfifo *kfifo)
{
- return __kfifo_len(kfifo) / sizeof(void *);
+ return kfifo_len(kfifo) / sizeof(void *);
}
static inline int cq_put(struct kfifo *kfifo, void *p)
{
- return __kfifo_put(kfifo, (void *)&p, sizeof(p));
+ return kfifo_put(kfifo, (void *)&p, sizeof(p));
}
static inline void *cq_get(struct kfifo *kfifo)
{
void *p = NULL;
- __kfifo_get(kfifo, (void *)&p, sizeof(p));
+ kfifo_get(kfifo, (void *)&p, sizeof(p));
return p;
}
diff -u -N -r -p kfifo2/drivers/usb/serial/generic.c kfifo3/drivers/usb/serial/generic.c
--- kfifo2/drivers/usb/serial/generic.c 2009-10-19 20:58:34.197586887 +0200
+++ kfifo3/drivers/usb/serial/generic.c 2009-10-19 21:13:38.852212480 +0200
@@ -276,7 +276,7 @@ static int usb_serial_generic_write_star
if (port->write_urb_busy)
start_io = false;
else {
- start_io = (__kfifo_len(port->write_fifo) != 0);
+ start_io = (kfifo_len(port->write_fifo) != 0);
port->write_urb_busy = start_io;
}
spin_unlock_irqrestore(&port->lock, flags);
@@ -370,7 +370,7 @@ int usb_serial_generic_write_room(struct
(serial->type->max_in_flight_urbs -
port->urbs_in_flight);
} else if (serial->num_bulk_out)
- room = port->write_fifo->size - __kfifo_len(port->write_fifo);
+ room = port->write_fifo->size - kfifo_len(port->write_fifo);
spin_unlock_irqrestore(&port->lock, flags);
dbg("%s - returns %d", __func__, room);
diff -u -N -r -p kfifo2/include/linux/kfifo.h kfifo3/include/linux/kfifo.h
--- kfifo2/include/linux/kfifo.h 2009-11-19 20:53:21.526214294 +0100
+++ kfifo3/include/linux/kfifo.h 2009-11-19 20:53:37.620542297 +0100
@@ -37,34 +37,25 @@ extern void kfifo_init(struct kfifo *fif
extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
gfp_t gfp_mask);
extern void kfifo_free(struct kfifo *fifo);
-extern unsigned int __kfifo_put(struct kfifo *fifo,
+extern unsigned int kfifo_put(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len);
-extern unsigned int __kfifo_get(struct kfifo *fifo,
+extern unsigned int kfifo_get(struct kfifo *fifo,
unsigned char *buffer, unsigned int len);
/**
- * __kfifo_reset - removes the entire FIFO contents, no locking version
- * @fifo: the fifo to be emptied.
- */
-static inline void __kfifo_reset(struct kfifo *fifo)
-{
- fifo->in = fifo->out = 0;
-}
-
-/**
* kfifo_reset - removes the entire FIFO contents
* @fifo: the fifo to be emptied.
*/
static inline void kfifo_reset(struct kfifo *fifo)
{
- __kfifo_reset(fifo);
+ fifo->in = fifo->out = 0;
}
/**
- * __kfifo_len - returns the number of bytes available in the FIFO
+ * kfifo_len - returns the number of used bytes in the FIFO
* @fifo: the fifo to be used.
*/
-static inline unsigned int __kfifo_len(struct kfifo *fifo)
+static inline unsigned int kfifo_len(struct kfifo *fifo)
{
register unsigned int out;
@@ -92,7 +83,7 @@ static inline __must_check unsigned int
spin_lock_irqsave(lock, flags);
- ret = __kfifo_put(fifo, from, n);
+ ret = kfifo_put(fifo, from, n);
spin_unlock_irqrestore(lock, flags);
@@ -117,7 +108,7 @@ static inline __must_check unsigned int
spin_lock_irqsave(lock, flags);
- ret = __kfifo_get(fifo, to, n);
+ ret = kfifo_get(fifo, to, n);
/*
* optimization: if the FIFO is empty, set the indices to 0
@@ -131,13 +122,4 @@ static inline __must_check unsigned int
return ret;
}
-/**
- * kfifo_len - returns the number of bytes available in the FIFO
- * @fifo: the fifo to be used.
- */
-static inline unsigned int kfifo_len(struct kfifo *fifo)
-{
- return __kfifo_len(fifo);
-}
-
#endif
diff -u -N -r -p kfifo2/kernel/kfifo.c kfifo3/kernel/kfifo.c
--- kfifo2/kernel/kfifo.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/kernel/kfifo.c 2009-10-19 21:13:38.000000000 +0200
@@ -100,7 +100,7 @@ void kfifo_free(struct kfifo *fifo)
EXPORT_SYMBOL(kfifo_free);
/**
- * __kfifo_put - puts some data into the FIFO, no locking version
+ * kfifo_put - puts some data into the FIFO, no locking version
* @fifo: the fifo to be used.
* @buffer: the data to be added.
* @len: the length of the data to be added.
@@ -112,7 +112,7 @@ EXPORT_SYMBOL(kfifo_free);
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
-unsigned int __kfifo_put(struct kfifo *fifo,
+unsigned int kfifo_put(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len)
{
unsigned int l;
@@ -144,10 +144,10 @@ unsigned int __kfifo_put(struct kfifo *f
return len;
}
-EXPORT_SYMBOL(__kfifo_put);
+EXPORT_SYMBOL(kfifo_put);
/**
- * __kfifo_get - gets some data from the FIFO, no locking version
+ * kfifo_get - gets some data from the FIFO, no locking version
* @fifo: the fifo to be used.
* @buffer: where the data must be copied.
* @len: the size of the destination buffer.
@@ -158,7 +158,7 @@ EXPORT_SYMBOL(__kfifo_put);
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
-unsigned int __kfifo_get(struct kfifo *fifo,
+unsigned int kfifo_get(struct kfifo *fifo,
unsigned char *buffer, unsigned int len)
{
unsigned int l;
@@ -190,4 +190,4 @@ unsigned int __kfifo_get(struct kfifo *f
return len;
}
-EXPORT_SYMBOL(__kfifo_get);
+EXPORT_SYMBOL(kfifo_get);
diff -u -N -r -p kfifo2/net/dccp/probe.c kfifo3/net/dccp/probe.c
--- kfifo2/net/dccp/probe.c 2009-10-19 20:58:34.000000000 +0200
+++ kfifo3/net/dccp/probe.c 2009-10-19 21:13:38.000000000 +0200
@@ -132,7 +132,7 @@ static ssize_t dccpprobe_read(struct fil
return -ENOMEM;
error = wait_event_interruptible(dccpw.wait,
- __kfifo_len(&dccpw.fifo) != 0);
+ kfifo_len(&dccpw.fifo) != 0);
if (error)
goto out_free;
rename kfifo_put... into kfifo_in... to prevent miss use of old non in
kernel-tree drivers
ditto for kfifo_get... -> kfifo_out...
Improve the prototypes of kfifo_in and kfifo_out to make the kerneldoc
annotations more readable.
Add mini "howto porting to the new API" in kfifo.h
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
drivers/char/nozomi.c | 4 +-
drivers/char/sonypi.c | 8 ++---
drivers/infiniband/hw/cxgb3/cxio_resource.c | 16 +++++------
drivers/media/video/meye.c | 16 +++++------
drivers/net/wireless/libertas/main.c | 4 +-
drivers/platform/x86/fujitsu-laptop.c | 4 +-
drivers/platform/x86/sony-laptop.c | 8 ++---
drivers/scsi/libiscsi.c | 14 +++++-----
drivers/scsi/libiscsi_tcp.c | 18 ++++++------
drivers/scsi/libsrp.c | 6 ++--
drivers/usb/host/fhci.h | 4 +-
drivers/usb/serial/generic.c | 4 +-
include/linux/kfifo.h | 39 ++++++++++++++++++++--------
kernel/kfifo.c | 32 +++++++++++-----------
net/dccp/probe.c | 4 +-
15 files changed, 100 insertions(+), 81 deletions(-)
diff -u -N -r -p kfifo3/drivers/char/nozomi.c kfifo4/drivers/char/nozomi.c
--- kfifo3/drivers/char/nozomi.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/char/nozomi.c 2009-10-19 21:21:36.000000000 +0200
@@ -798,7 +798,7 @@ static int send_data(enum port_type inde
struct tty_struct *tty = tty_port_tty_get(&port->port);
/* Get data from tty and place in buf for now */
- size = kfifo_get(&port->fifo_ul, dc->send_buf,
+ size = kfifo_out(&port->fifo_ul, dc->send_buf,
ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX);
if (size == 0) {
@@ -1672,7 +1672,7 @@ static int ntty_write(struct tty_struct
goto exit;
}
- rval = kfifo_put(&port->fifo_ul, (unsigned char *)buffer, count);
+ rval = kfifo_in(&port->fifo_ul, (unsigned char *)buffer, count);
/* notify card */
if (unlikely(dc == NULL)) {
diff -u -N -r -p kfifo3/drivers/char/sonypi.c kfifo4/drivers/char/sonypi.c
--- kfifo3/drivers/char/sonypi.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/char/sonypi.c 2009-10-19 21:21:36.786541278 +0200
@@ -777,7 +777,7 @@ static void input_keyrelease(struct work
{
struct sonypi_keypress kp;
- while (kfifo_get_locked(&sonypi_device.input_fifo, (unsigned char *)&kp,
+ while (kfifo_out_locked(&sonypi_device.input_fifo, (unsigned char *)&kp,
sizeof(kp), &sonypi_device.input_fifo_lock)
== sizeof(kp)) {
msleep(10);
@@ -828,7 +828,7 @@ static void sonypi_report_input_event(u8
if (kp.dev) {
input_report_key(kp.dev, kp.key, 1);
input_sync(kp.dev);
- kfifo_put_locked(&sonypi_device.input_fifo,
+ kfifo_in_locked(&sonypi_device.input_fifo,
(unsigned char *)&kp, sizeof(kp),
&sonypi_device.input_fifo_lock);
schedule_work(&sonypi_device.input_work);
@@ -882,7 +882,7 @@ found:
acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
#endif
- kfifo_put_locked(&sonypi_device.fifo, (unsigned char *)&event,
+ kfifo_in_locked(&sonypi_device.fifo, (unsigned char *)&event,
sizeof(event), &sonypi_device.fifo_lock);
kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_device.fifo_proc_list);
@@ -932,7 +932,7 @@ static ssize_t sonypi_misc_read(struct f
return ret;
while (ret < count &&
- (kfifo_get_locked(&sonypi_device.fifo, &c, sizeof(c),
+ (kfifo_out_locked(&sonypi_device.fifo, &c, sizeof(c),
&sonypi_device.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
diff -u -N -r -p kfifo3/drivers/infiniband/hw/cxgb3/cxio_resource.c kfifo4/drivers/infiniband/hw/cxgb3/cxio_resource.c
--- kfifo3/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-10-19 21:21:36.000000000 +0200
@@ -59,7 +59,7 @@ static int __cxio_init_resource_fifo(str
return -ENOMEM;
for (i = 0; i < skip_low + skip_high; i++)
- kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32));
+ kfifo_in(fifo, (unsigned char *) &entry, sizeof(u32));
if (random) {
j = 0;
random_bytes = random32();
@@ -71,22 +71,22 @@ static int __cxio_init_resource_fifo(str
random_bytes = random32();
}
idx = (random_bytes >> (j * 2)) & 0xF;
- kfifo_put(fifo,
+ kfifo_in(fifo,
(unsigned char *) &rarray[idx],
sizeof(u32));
rarray[idx] = i;
j++;
}
for (i = 0; i < RANDOM_SIZE; i++)
- kfifo_put(fifo,
+ kfifo_in(fifo,
(unsigned char *) &rarray[i],
sizeof(u32));
} else
for (i = skip_low; i < nr - skip_high; i++)
- kfifo_put(fifo, (unsigned char *) &i, sizeof(u32));
+ kfifo_in(fifo, (unsigned char *) &i, sizeof(u32));
for (i = 0; i < skip_low + skip_high; i++)
- kfifo_get_locked(fifo, (unsigned char *) &entry,
+ kfifo_out_locked(fifo, (unsigned char *) &entry,
sizeof(u32), fifo_lock);
return 0;
}
@@ -119,7 +119,7 @@ static int cxio_init_qpid_fifo(struct cx
for (i = 16; i < T3_MAX_NUM_QP; i++)
if (!(i & rdev_p->qpmask))
- kfifo_put(&rdev_p->rscp->qpid_fifo,
+ kfifo_in(&rdev_p->rscp->qpid_fifo,
(unsigned char *) &i, sizeof(u32));
return 0;
}
@@ -180,7 +180,7 @@ tpt_err:
static u32 cxio_hal_get_resource(struct kfifo *fifo, spinlock_t * lock)
{
u32 entry;
- if (kfifo_get_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
+ if (kfifo_out_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
return entry;
else
return 0; /* fifo emptry */
@@ -190,7 +190,7 @@ static void cxio_hal_put_resource(struct
u32 entry)
{
BUG_ON(
- kfifo_put_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)
+ kfifo_in_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)
== 0);
}
diff -u -N -r -p kfifo3/drivers/media/video/meye.c kfifo4/drivers/media/video/meye.c
--- kfifo3/drivers/media/video/meye.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/media/video/meye.c 2009-10-19 21:21:36.000000000 +0200
@@ -800,7 +800,7 @@ again:
return IRQ_HANDLED;
if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
- if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+ if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame();
return IRQ_HANDLED;
@@ -811,7 +811,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+ kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list);
} else {
@@ -821,7 +821,7 @@ again:
mchip_free_frame();
goto again;
}
- if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr,
+ if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame();
goto again;
@@ -832,7 +832,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++;
- kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr,
+ kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list);
}
@@ -935,7 +935,7 @@ static int meyeioc_qbuf_capt(int *nb)
mchip_cont_compression_start();
meye.grab_buffer[*nb].state = MEYE_BUF_USING;
- kfifo_put_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
+ kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
&meye.grabq_lock);
mutex_unlock(&meye.lock);
@@ -968,7 +968,7 @@ static int meyeioc_sync(struct file *fil
/* fall through */
case MEYE_BUF_DONE:
meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
- kfifo_get_locked(&meye.doneq, (unsigned char *)&unused,
+ kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
sizeof(int), &meye.doneq_lock);
}
*i = meye.grab_buffer[*i].size;
@@ -1456,7 +1456,7 @@ static int vidioc_qbuf(struct file *file
buf->flags |= V4L2_BUF_FLAG_QUEUED;
buf->flags &= ~V4L2_BUF_FLAG_DONE;
meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
- kfifo_put_locked(&meye.grabq, (unsigned char *)&buf->index,
+ kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
sizeof(int), &meye.grabq_lock);
mutex_unlock(&meye.lock);
@@ -1483,7 +1483,7 @@ static int vidioc_dqbuf(struct file *fil
return -EINTR;
}
- if (!kfifo_get_locked(&meye.doneq, (unsigned char *)&reqnr,
+ if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock)) {
mutex_unlock(&meye.lock);
return -EBUSY;
diff -u -N -r -p kfifo3/drivers/net/wireless/libertas/main.c kfifo4/drivers/net/wireless/libertas/main.c
--- kfifo3/drivers/net/wireless/libertas/main.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/net/wireless/libertas/main.c 2009-10-19 21:21:36.000000000 +0200
@@ -854,7 +854,7 @@ static int lbs_thread(void *data)
while (kfifo_len(&priv->event_fifo)) {
u32 event;
- kfifo_get(&priv->event_fifo, (unsigned char *) &event,
+ kfifo_out(&priv->event_fifo, (unsigned char *) &event,
sizeof(event));
spin_unlock_irq(&priv->driver_lock);
lbs_process_event(priv, event);
@@ -1579,7 +1579,7 @@ void lbs_queue_event(struct lbs_private
if (priv->psstate == PS_STATE_SLEEP)
priv->psstate = PS_STATE_AWAKE;
- kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
+ kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
wake_up_interruptible(&priv->waitq);
diff -u -N -r -p kfifo3/drivers/platform/x86/fujitsu-laptop.c kfifo4/drivers/platform/x86/fujitsu-laptop.c
--- kfifo3/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 21:13:38.723655780 +0200
+++ kfifo4/drivers/platform/x86/fujitsu-laptop.c 2009-10-19 21:21:36.761706916 +0200
@@ -1006,7 +1006,7 @@ static void acpi_fujitsu_hotkey_notify(s
vdbg_printk(FUJLAPTOP_DBG_TRACE,
"Push keycode into ringbuffer [%d]\n",
keycode);
- status = kfifo_put_locked(&fujitsu_hotkey->fifo,
+ status = kfifo_in_locked(&fujitsu_hotkey->fifo,
(unsigned char *)&keycode,
sizeof(keycode),
&fujitsu_hotkey->fifo_lock);
@@ -1020,7 +1020,7 @@ static void acpi_fujitsu_hotkey_notify(s
}
} else if (keycode == 0) {
while ((status =
- kfifo_get_locked(
+ kfifo_out_locked(
&fujitsu_hotkey->fifo,
(unsigned char *) &keycode_r,
sizeof(keycode_r),
diff -u -N -r -p kfifo3/drivers/platform/x86/sony-laptop.c kfifo4/drivers/platform/x86/sony-laptop.c
--- kfifo3/drivers/platform/x86/sony-laptop.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/platform/x86/sony-laptop.c 2009-10-19 21:21:36.000000000 +0200
@@ -300,7 +300,7 @@ static void do_sony_laptop_release_key(s
{
struct sony_laptop_keypress kp;
- while (kfifo_get_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
+ while (kfifo_out_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
sizeof(kp), &sony_laptop_input.fifo_lock)
== sizeof(kp)) {
msleep(10);
@@ -363,7 +363,7 @@ static void sony_laptop_report_input_eve
/* we emit the scancode so we can always remap the key */
input_event(kp.dev, EV_MSC, MSC_SCAN, event);
input_sync(kp.dev);
- kfifo_put_locked(&sony_laptop_input.fifo,
+ kfifo_in_locked(&sony_laptop_input.fifo,
(unsigned char *)&kp, sizeof(kp),
&sony_laptop_input.fifo_lock);
@@ -2130,7 +2130,7 @@ static ssize_t sonypi_misc_read(struct f
return ret;
while (ret < count &&
- (kfifo_get_locked(&sonypi_compat.fifo, &c, sizeof(c),
+ (kfifo_out_locked(&sonypi_compat.fifo, &c, sizeof(c),
&sonypi_compat.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
@@ -2310,7 +2310,7 @@ static struct miscdevice sonypi_misc_dev
static void sonypi_compat_report_event(u8 event)
{
- kfifo_put_locked(&sonypi_compat.fifo, (unsigned char *)&event,
+ kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event,
sizeof(event), &sonypi_compat.fifo_lock);
kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_compat.fifo_proc_list);
diff -u -N -r -p kfifo3/drivers/scsi/libiscsi.c kfifo4/drivers/scsi/libiscsi.c
--- kfifo3/drivers/scsi/libiscsi.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/scsi/libiscsi.c 2009-10-19 21:21:36.121824417 +0200
@@ -431,7 +431,7 @@ static void iscsi_free_task(struct iscsi
if (conn->login_task == task)
return;
- kfifo_put(&session->cmdpool.queue, (void*)&task, sizeof(void*));
+ kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
if (sc) {
task->sc = NULL;
@@ -642,7 +642,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn
BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
- if (!kfifo_get(&session->cmdpool.queue,
+ if (!kfifo_out(&session->cmdpool.queue,
(void*)&task, sizeof(void*)))
return NULL;
}
@@ -1473,7 +1473,7 @@ static inline struct iscsi_task *iscsi_a
{
struct iscsi_task *task;
- if (!kfifo_get(&conn->session->cmdpool.queue,
+ if (!kfifo_out(&conn->session->cmdpool.queue,
(void *) &task, sizeof(void *)))
return NULL;
@@ -2260,7 +2260,7 @@ iscsi_pool_init(struct iscsi_pool *q, in
q->max = i;
goto enomem;
}
- kfifo_put(&q->queue, (void*)&q->pool[i], sizeof(void*));
+ kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
}
if (items) {
@@ -2609,7 +2609,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
/* allocate login_task used for the login/text sequences */
spin_lock_bh(&session->lock);
- if (!kfifo_get(&session->cmdpool.queue,
+ if (!kfifo_out(&session->cmdpool.queue,
(void*)&conn->login_task,
sizeof(void*))) {
spin_unlock_bh(&session->lock);
@@ -2629,7 +2629,7 @@ iscsi_conn_setup(struct iscsi_cls_sessio
return cls_conn;
login_task_data_alloc_fail:
- kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
+ kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
login_task_alloc_fail:
iscsi_destroy_conn(cls_conn);
@@ -2692,7 +2692,7 @@ void iscsi_conn_teardown(struct iscsi_cl
free_pages((unsigned long) conn->data,
get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
kfree(conn->persistent_address);
- kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task,
+ kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*));
if (session->leadconn == conn)
session->leadconn = NULL;
diff -u -N -r -p kfifo3/drivers/scsi/libiscsi_tcp.c kfifo4/drivers/scsi/libiscsi_tcp.c
--- kfifo3/drivers/scsi/libiscsi_tcp.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/drivers/scsi/libiscsi_tcp.c 2009-10-19 21:21:36.143587591 +0200
@@ -445,15 +445,15 @@ void iscsi_tcp_cleanup_task(struct iscsi
return;
/* flush task's r2t queues */
- while (kfifo_get(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
- kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
+ kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
}
r2t = tcp_task->r2t;
if (r2t != NULL) {
- kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
tcp_task->r2t = NULL;
}
@@ -541,7 +541,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
return 0;
}
- rc = kfifo_get(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
+ rc = kfifo_out(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
if (!rc) {
iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
"Target has sent more R2Ts than it "
@@ -554,7 +554,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
if (r2t->data_length == 0) {
iscsi_conn_printk(KERN_ERR, conn,
"invalid R2T with zero data len\n");
- kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -570,7 +570,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
"invalid R2T with data len %u at offset %u "
"and total length %d\n", r2t->data_length,
r2t->data_offset, scsi_out(task->sc)->length);
- kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t,
+ kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*));
return ISCSI_ERR_DATALEN;
}
@@ -580,7 +580,7 @@ static int iscsi_tcp_r2t_rsp(struct iscs
r2t->sent = 0;
tcp_task->exp_datasn = r2tsn + 1;
- kfifo_put(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
+ kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
conn->r2t_pdus_cnt++;
iscsi_requeue_task(task);
@@ -982,7 +982,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
if (r2t->data_length <= r2t->sent) {
ISCSI_DBG_TCP(task->conn,
" done with r2t %p\n", r2t);
- kfifo_put(&tcp_task->r2tpool.queue,
+ kfifo_in(&tcp_task->r2tpool.queue,
(void *)&tcp_task->r2t,
sizeof(void *));
tcp_task->r2t = r2t = NULL;
@@ -990,7 +990,7 @@ static struct iscsi_r2t_info *iscsi_tcp_
}
if (r2t == NULL) {
- kfifo_get(&tcp_task->r2tqueue,
+ kfifo_out(&tcp_task->r2tqueue,
(void *)&tcp_task->r2t, sizeof(void *));
r2t = tcp_task->r2t;
}
diff -u -N -r -p kfifo3/drivers/scsi/libsrp.c kfifo4/drivers/scsi/libsrp.c
--- kfifo3/drivers/scsi/libsrp.c 2009-10-19 21:13:38.943924131 +0200
+++ kfifo4/drivers/scsi/libsrp.c 2009-10-19 21:21:36.000000000 +0200
@@ -61,7 +61,7 @@ static int srp_iu_pool_alloc(struct srp_
kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
for (i = 0, iue = q->items; i < max; i++) {
- kfifo_put(&q->queue, (void *) &iue, sizeof(void *));
+ kfifo_in(&q->queue, (void *) &iue, sizeof(void *));
iue->sbuf = ring[i];
iue++;
}
@@ -164,7 +164,7 @@ struct iu_entry *srp_iu_get(struct srp_t
{
struct iu_entry *iue = NULL;
- kfifo_get_locked(&target->iu_queue.queue, (void *) &iue,
+ kfifo_out_locked(&target->iu_queue.queue, (void *) &iue,
sizeof(void *), &target->iu_queue.lock);
if (!iue)
return iue;
@@ -177,7 +177,7 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
void srp_iu_put(struct iu_entry *iue)
{
- kfifo_put_locked(&iue->target->iu_queue.queue, (void *) &iue,
+ kfifo_in_locked(&iue->target->iu_queue.queue, (void *) &iue,
sizeof(void *), &iue->target->iu_queue.lock);
}
EXPORT_SYMBOL_GPL(srp_iu_put);
diff -u -N -r -p kfifo3/drivers/usb/host/fhci.h kfifo4/drivers/usb/host/fhci.h
--- kfifo3/drivers/usb/host/fhci.h 2009-10-19 21:13:38.762150583 +0200
+++ kfifo4/drivers/usb/host/fhci.h 2009-10-19 21:21:36.487985733 +0200
@@ -510,14 +510,14 @@ static inline unsigned int cq_howmany(st
static inline int cq_put(struct kfifo *kfifo, void *p)
{
- return kfifo_put(kfifo, (void *)&p, sizeof(p));
+ return kfifo_in(kfifo, (void *)&p, sizeof(p));
}
static inline void *cq_get(struct kfifo *kfifo)
{
void *p = NULL;
- kfifo_get(kfifo, (void *)&p, sizeof(p));
+ kfifo_out(kfifo, (void *)&p, sizeof(p));
return p;
}
diff -u -N -r -p kfifo3/drivers/usb/serial/generic.c kfifo4/drivers/usb/serial/generic.c
--- kfifo3/drivers/usb/serial/generic.c 2009-10-19 21:13:38.852212480 +0200
+++ kfifo4/drivers/usb/serial/generic.c 2009-10-19 21:21:36.279587394 +0200
@@ -285,7 +285,7 @@ static int usb_serial_generic_write_star
return 0;
data = port->write_urb->transfer_buffer;
- count = kfifo_get_locked(port->write_fifo, data, port->bulk_out_size, &port->lock);
+ count = kfifo_out_locked(port->write_fifo, data, port->bulk_out_size, &port->lock);
usb_serial_debug_data(debug, &port->dev, __func__, count, data);
/* set up our urb */
@@ -345,7 +345,7 @@ int usb_serial_generic_write(struct tty_
return usb_serial_multi_urb_write(tty, port,
buf, count);
- count = kfifo_put_locked(port->write_fifo, buf, count, &port->lock);
+ count = kfifo_in_locked(port->write_fifo, buf, count, &port->lock);
result = usb_serial_generic_write_start(port);
if (result >= 0)
diff -u -N -r -p kfifo3/include/linux/kfifo.h kfifo4/include/linux/kfifo.h
--- kfifo3/include/linux/kfifo.h 2009-11-19 20:53:37.620542297 +0100
+++ kfifo4/include/linux/kfifo.h 2009-11-19 20:54:08.154568958 +0100
@@ -19,6 +19,25 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
+
+/*
+ * Howto porting drivers to the new generic fifo API:
+ *
+ * - Modify the declaration of the "struct kfifo *" object into a
+ * in-place "struct kfifo" object
+ * - Init the in-place object with kfifo_alloc() or kfifo_init()
+ * Note: The address of the in-place "struct kfifo" object must be
+ * passed as the first argument to this functions
+ * - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
+ * into kfifo_out
+ * - Replace the use of kfifo_put into kfifo_in_locked and kfifo_get
+ * into kfifo_out_locked
+ * Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
+ * must be passed now to the kfifo_in_locked and kfifo_out_locked
+ * as the last parameter.
+ * - All formerly name __kfifo_* functions has been renamed into kfifo_*
+ */
+
#ifndef _LINUX_KFIFO_H
#define _LINUX_KFIFO_H
@@ -37,10 +56,10 @@ extern void kfifo_init(struct kfifo *fif
extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
gfp_t gfp_mask);
extern void kfifo_free(struct kfifo *fifo);
-extern unsigned int kfifo_put(struct kfifo *fifo,
- const unsigned char *buffer, unsigned int len);
-extern unsigned int kfifo_get(struct kfifo *fifo,
- unsigned char *buffer, unsigned int len);
+extern __must_check unsigned int kfifo_in(struct kfifo *fifo,
+ const unsigned char *from, unsigned int len);
+extern __must_check unsigned int kfifo_out(struct kfifo *fifo,
+ unsigned char *to, unsigned int len);
/**
* kfifo_reset - removes the entire FIFO contents
@@ -65,7 +84,7 @@ static inline unsigned int kfifo_len(str
}
/**
- * kfifo_put_locked - puts some data into the FIFO using a spinlock for locking
+ * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
* @fifo: the fifo to be used.
* @from: the data to be added.
* @n: the length of the data to be added.
@@ -75,7 +94,7 @@ static inline unsigned int kfifo_len(str
* the FIFO depending on the free space, and returns the number of
* bytes copied.
*/
-static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo,
+static inline __must_check unsigned int kfifo_in_locked(struct kfifo *fifo,
const unsigned char *from, unsigned int n, spinlock_t *lock)
{
unsigned long flags;
@@ -83,7 +102,7 @@ static inline __must_check unsigned int
spin_lock_irqsave(lock, flags);
- ret = kfifo_put(fifo, from, n);
+ ret = kfifo_in(fifo, from, n);
spin_unlock_irqrestore(lock, flags);
@@ -91,7 +110,7 @@ static inline __must_check unsigned int
}
/**
- * kfifo_get_locked - gets some data from the FIFO using a spinlock for locking
+ * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
* @fifo: the fifo to be used.
* @to: where the data must be copied.
* @n: the size of the destination buffer.
@@ -100,7 +119,7 @@ static inline __must_check unsigned int
* This function copies at most @len bytes from the FIFO into the
* @to buffer and returns the number of copied bytes.
*/
-static inline __must_check unsigned int kfifo_get_locked(struct kfifo *fifo,
+static inline __must_check unsigned int kfifo_out_locked(struct kfifo *fifo,
unsigned char *to, unsigned int n, spinlock_t *lock)
{
unsigned long flags;
@@ -108,7 +127,7 @@ static inline __must_check unsigned int
spin_lock_irqsave(lock, flags);
- ret = kfifo_get(fifo, to, n);
+ ret = kfifo_out(fifo, to, n);
/*
* optimization: if the FIFO is empty, set the indices to 0
diff -u -N -r -p kfifo3/kernel/kfifo.c kfifo4/kernel/kfifo.c
--- kfifo3/kernel/kfifo.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/kernel/kfifo.c 2009-10-19 21:21:36.548996954 +0200
@@ -100,20 +100,20 @@ void kfifo_free(struct kfifo *fifo)
EXPORT_SYMBOL(kfifo_free);
/**
- * kfifo_put - puts some data into the FIFO, no locking version
+ * kfifo_in - puts some data into the FIFO
* @fifo: the fifo to be used.
- * @buffer: the data to be added.
+ * @from: the data to be added.
* @len: the length of the data to be added.
*
- * This function copies at most @len bytes from the @buffer into
+ * This function copies at most @len bytes from the @from buffer into
* the FIFO depending on the free space, and returns the number of
* bytes copied.
*
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
-unsigned int kfifo_put(struct kfifo *fifo,
- const unsigned char *buffer, unsigned int len)
+unsigned int kfifo_in(struct kfifo *fifo,
+ const unsigned char *from, unsigned int len)
{
unsigned int l;
@@ -128,10 +128,10 @@ unsigned int kfifo_put(struct kfifo *fif
/* first put the data starting from fifo->in to buffer end */
l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
- memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), buffer, l);
+ memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), from, l);
/* then put the rest (if any) at the beginning of the buffer */
- memcpy(fifo->buffer, buffer + l, len - l);
+ memcpy(fifo->buffer, from + l, len - l);
/*
* Ensure that we add the bytes to the kfifo -before-
@@ -144,22 +144,22 @@ unsigned int kfifo_put(struct kfifo *fif
return len;
}
-EXPORT_SYMBOL(kfifo_put);
+EXPORT_SYMBOL(kfifo_in);
/**
- * kfifo_get - gets some data from the FIFO, no locking version
+ * kfifo_out - gets some data from the FIFO
* @fifo: the fifo to be used.
- * @buffer: where the data must be copied.
+ * @to: where the data must be copied.
* @len: the size of the destination buffer.
*
* This function copies at most @len bytes from the FIFO into the
- * @buffer and returns the number of copied bytes.
+ * @to buffer and returns the number of copied bytes.
*
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
-unsigned int kfifo_get(struct kfifo *fifo,
- unsigned char *buffer, unsigned int len)
+unsigned int kfifo_out(struct kfifo *fifo,
+ unsigned char *to, unsigned int len)
{
unsigned int l;
@@ -174,10 +174,10 @@ unsigned int kfifo_get(struct kfifo *fif
/* first get the data from fifo->out until the end of the buffer */
l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
- memcpy(buffer, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
+ memcpy(to, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
/* then get the rest (if any) from the beginning of the buffer */
- memcpy(buffer + l, fifo->buffer, len - l);
+ memcpy(to + l, fifo->buffer, len - l);
/*
* Ensure that we remove the bytes from the kfifo -before-
@@ -190,4 +190,4 @@ unsigned int kfifo_get(struct kfifo *fif
return len;
}
-EXPORT_SYMBOL(kfifo_get);
+EXPORT_SYMBOL(kfifo_out);
diff -u -N -r -p kfifo3/net/dccp/probe.c kfifo4/net/dccp/probe.c
--- kfifo3/net/dccp/probe.c 2009-10-19 21:13:38.000000000 +0200
+++ kfifo4/net/dccp/probe.c 2009-10-19 21:21:36.000000000 +0200
@@ -67,7 +67,7 @@ static void printl(const char *fmt, ...)
len += vscnprintf(tbuf+len, sizeof(tbuf)-len, fmt, args);
va_end(args);
- kfifo_put_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
+ kfifo_in_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
wake_up(&dccpw.wait);
}
@@ -136,7 +136,7 @@ static ssize_t dccpprobe_read(struct fil
if (error)
goto out_free;
- cnt = kfifo_get_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
+ cnt = kfifo_out_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;
out_free:
Add DECLARE_KFIFO - macro to declare a kfifo and the associated buffer inside a struct
Add INIT_KFIFO - Initialize a kfifo declared by DECLARED_KFIFO
Add DEFINE_KFIFO - macro to define and initialize a kfifo as a global or local object
Add kfifo_size() - returns the size of the fifo in bytes
Add kfifo_is_empty() - returns true if the fifo is empty
Add kfifo_is_full() - returns true if the fifo is full
Add kfifo_avail() - returns the number of bytes available in the FIFO
Do some code cleanup
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
kfifo.h | 91 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 89 insertions(+), 2 deletions(-)
diff -u -N -r -p kfifo4/include/linux/kfifo.h kfifo5/include/linux/kfifo.h
--- kfifo4/include/linux/kfifo.h 2009-11-19 20:54:08.154568958 +0100
+++ kfifo5/include/linux/kfifo.h 2009-11-19 20:54:36.294317779 +0100
@@ -51,6 +51,57 @@ struct kfifo {
unsigned int out; /* data is extracted from off. (out % size) */
};
+/*
+ * Macros for declaration and initialization of the kfifo datatype
+ */
+
+#define __kfifo_initializer(s, b) \
+ (struct kfifo) { \
+ .size = s, \
+ .in = 0, \
+ .out = 0, \
+ .buffer = b \
+ }
+
+/**
+ * DECLARE_KFIFO - macro to declare a kfifo and the associated buffer
+ * @name: name of the declared kfifo datatype
+ * @size: size of the fifo buffer
+ *
+ * Note: the macro can be used inside struct or union declaration
+ * Note: the macro creates two objects:
+ * A kfifo object with the given name and a buffer for the kfifo
+ * object named name##kfifo_buffer
+ */
+#define DECLARE_KFIFO(name, size) \
+union { \
+ struct kfifo name; \
+ unsigned char name##kfifo_buffer[size + sizeof(struct kfifo)]; \
+}
+
+/**
+ * INIT_KFIFO - Initialize a kfifo declared by DECLARED_KFIFO
+ * @name: name of the declared kfifo datatype
+ * @size: size of the fifo buffer
+ */
+#define INIT_KFIFO(name) \
+ name = __kfifo_initializer(sizeof(name##kfifo_buffer) - \
+ sizeof(struct kfifo), name##kfifo_buffer)
+
+/**
+ * DEFINE_KFIFO - macro to define and initialize a kfifo
+ * @name: name of the declared kfifo datatype
+ * @size: size of the fifo buffer
+ *
+ * Note: the macro can be used for global and local kfifo data type variables
+ * Note: the macro creates two objects:
+ * A kfifo object with the given name and a buffer for the kfifo
+ * object named name##kfifo_buffer
+ */
+#define DEFINE_KFIFO(name, size) \
+ unsigned char name##kfifo_buffer[size]; \
+ struct kfifo name = __kfifo_initializer(size, name##kfifo_buffer)
+
extern void kfifo_init(struct kfifo *fifo, unsigned char *buffer,
unsigned int size);
extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
@@ -71,6 +122,15 @@ static inline void kfifo_reset(struct kf
}
/**
+ * kfifo_size - returns the size of the fifo in bytes
+ * @fifo: the fifo to be used.
+ */
+static inline __must_check unsigned int kfifo_size(struct kfifo *fifo)
+{
+ return fifo->size;
+}
+
+/**
* kfifo_len - returns the number of used bytes in the FIFO
* @fifo: the fifo to be used.
*/
@@ -84,6 +144,33 @@ static inline unsigned int kfifo_len(str
}
/**
+ * kfifo_is_empty - returns true if the fifo is empty
+ * @fifo: the fifo to be used.
+ */
+static inline __must_check int kfifo_is_empty(struct kfifo *fifo)
+{
+ return fifo->in == fifo->out;
+}
+
+/**
+ * kfifo_is_full - returns true if the fifo is full
+ * @fifo: the fifo to be used.
+ */
+static inline __must_check int kfifo_is_full(struct kfifo *fifo)
+{
+ return kfifo_len(fifo) == kfifo_size(fifo);
+}
+
+/**
+ * kfifo_avail - returns the number of bytes available in the FIFO
+ * @fifo: the fifo to be used.
+ */
+static inline __must_check unsigned int kfifo_avail(struct kfifo *fifo)
+{
+ return kfifo_size(fifo) - kfifo_len(fifo);
+}
+
+/**
* kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
* @fifo: the fifo to be used.
* @from: the data to be added.
@@ -133,8 +220,8 @@ static inline __must_check unsigned int
* optimization: if the FIFO is empty, set the indices to 0
* so we don't wrap the next time
*/
- if (fifo->in == fifo->out)
- fifo->in = fifo->out = 0;
+ if (kfifo_is_empty(fifo))
+ kfifo_reset(fifo);
spin_unlock_irqrestore(lock, flags);
Add kfifo_reset_out() for save lockless discard the fifo output
Add kfifo_skip() to skip a number of output bytes
Add kfifo_from_user() to copy user space data into the fifo
Add kfifo_to_user() to copy fifo data to user space
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
Acked-by: Arnd Bergmann <[email protected]>
---
include/linux/kfifo.h | 47 ++++++++++++++++
kernel/kfifo.c | 139 ++++++++++++++++++++++++++++++++++++++++++++------
2 files changed, 170 insertions(+), 16 deletions(-)
diff -u -N -r -p kfifo5/include/linux/kfifo.h kfifo6/include/linux/kfifo.h
--- kfifo5/include/linux/kfifo.h 2009-11-19 20:54:36.294317779 +0100
+++ kfifo6/include/linux/kfifo.h 2009-11-19 20:54:56.275420767 +0100
@@ -122,6 +122,16 @@ static inline void kfifo_reset(struct kf
}
/**
+ * kfifo_reset_out - skip FIFO contents
+ * @fifo: the fifo to be emptied.
+ */
+static inline void kfifo_reset_out(struct kfifo *fifo)
+{
+ smp_mb();
+ fifo->out = fifo->in;
+}
+
+/**
* kfifo_size - returns the size of the fifo in bytes
* @fifo: the fifo to be used.
*/
@@ -228,4 +238,41 @@ static inline __must_check unsigned int
return ret;
}
+extern void kfifo_skip(struct kfifo *fifo, unsigned int len);
+
+extern __must_check unsigned int kfifo_from_user(struct kfifo *fifo,
+ const void __user *from, unsigned int n);
+
+extern __must_check unsigned int kfifo_to_user(struct kfifo *fifo,
+ void __user *to, unsigned int n);
+
+/**
+ * __kfifo_add_out internal helper function for updating the out offset
+ */
+static inline void __kfifo_add_out(struct kfifo *fifo,
+ unsigned int off)
+{
+ smp_mb();
+ fifo->out += off;
+}
+
+/**
+ * __kfifo_add_in internal helper function for updating the in offset
+ */
+static inline void __kfifo_add_in(struct kfifo *fifo,
+ unsigned int off)
+{
+ smp_wmb();
+ fifo->in += off;
+}
+
+/**
+ * __kfifo_off internal helper function for calculating the index of a
+ * given offeset
+ */
+static inline unsigned int __kfifo_off(struct kfifo *fifo, unsigned int off)
+{
+ return off & (fifo->size - 1);
+}
+
#endif
diff -u -N -r -p kfifo5/kernel/kfifo.c kfifo6/kernel/kfifo.c
--- kfifo5/kernel/kfifo.c 2009-10-19 21:25:25.763176479 +0200
+++ kfifo6/kernel/kfifo.c 2009-10-19 21:29:14.000000000 +0200
@@ -26,6 +26,7 @@
#include <linux/err.h>
#include <linux/kfifo.h>
#include <linux/log2.h>
+#include <linux/uaccess.h>
static void _kfifo_init(struct kfifo *fifo, unsigned char *buffer,
unsigned int size)
@@ -100,6 +101,21 @@ void kfifo_free(struct kfifo *fifo)
EXPORT_SYMBOL(kfifo_free);
/**
+ * kfifo_skip - skip output data
+ * @fifo: the fifo to be used.
+ * @len: number of bytes to skip
+ */
+void kfifo_skip(struct kfifo *fifo, unsigned int len)
+{
+ if (len < kfifo_len(fifo)) {
+ __kfifo_add_out(fifo, len);
+ return;
+ }
+ kfifo_reset_out(fifo);
+}
+EXPORT_SYMBOL(kfifo_skip);
+
+/**
* kfifo_in - puts some data into the FIFO
* @fifo: the fifo to be used.
* @from: the data to be added.
@@ -115,6 +131,7 @@ EXPORT_SYMBOL(kfifo_free);
unsigned int kfifo_in(struct kfifo *fifo,
const unsigned char *from, unsigned int len)
{
+ unsigned int off;
unsigned int l;
len = min(len, fifo->size - fifo->in + fifo->out);
@@ -126,21 +143,16 @@ unsigned int kfifo_in(struct kfifo *fifo
smp_mb();
+ off = __kfifo_off(fifo, fifo->in);
+
/* first put the data starting from fifo->in to buffer end */
- l = min(len, fifo->size - (fifo->in & (fifo->size - 1)));
- memcpy(fifo->buffer + (fifo->in & (fifo->size - 1)), from, l);
+ l = min(len, fifo->size - off);
+ memcpy(fifo->buffer + off, from, l);
/* then put the rest (if any) at the beginning of the buffer */
memcpy(fifo->buffer, from + l, len - l);
- /*
- * Ensure that we add the bytes to the kfifo -before-
- * we update the fifo->in index.
- */
-
- smp_wmb();
-
- fifo->in += len;
+ __kfifo_add_in(fifo, len);
return len;
}
@@ -161,6 +173,7 @@ EXPORT_SYMBOL(kfifo_in);
unsigned int kfifo_out(struct kfifo *fifo,
unsigned char *to, unsigned int len)
{
+ unsigned int off;
unsigned int l;
len = min(len, fifo->in - fifo->out);
@@ -172,22 +185,116 @@ unsigned int kfifo_out(struct kfifo *fif
smp_rmb();
+ off = __kfifo_off(fifo, fifo->out);
+
/* first get the data from fifo->out until the end of the buffer */
- l = min(len, fifo->size - (fifo->out & (fifo->size - 1)));
- memcpy(to, fifo->buffer + (fifo->out & (fifo->size - 1)), l);
+ l = min(len, fifo->size - off);
+ memcpy(to, fifo->buffer + off, l);
/* then get the rest (if any) from the beginning of the buffer */
memcpy(to + l, fifo->buffer, len - l);
+ __kfifo_add_out(fifo, len);
+
+ return len;
+}
+EXPORT_SYMBOL(kfifo_out);
+
+/**
+ * kfifo_from_user - puts some data from user space into the FIFO
+ * @fifo: the fifo to be used.
+ * @from: pointer to the data to be added.
+ * @len: the length of the data to be added.
+ *
+ * This function copies at most @len bytes from the @from into the
+ * FIFO depending and returns the number of copied bytes.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+unsigned int kfifo_from_user(struct kfifo *fifo,
+ const void __user *from, unsigned int len)
+{
+ unsigned int off;
+ unsigned int l;
+ int ret;
+
+ len = min(len, fifo->size - fifo->in + fifo->out);
+
/*
- * Ensure that we remove the bytes from the kfifo -before-
- * we update the fifo->out index.
+ * Ensure that we sample the fifo->out index -before- we
+ * start putting bytes into the kfifo.
*/
smp_mb();
- fifo->out += len;
+ off = __kfifo_off(fifo, fifo->in);
+
+ /* first put the data starting from fifo->in to buffer end */
+ l = min(len, fifo->size - off);
+ ret = copy_from_user(fifo->buffer + off, from, l);
+
+ if (unlikely(ret))
+ return l - ret;
+
+ /* then put the rest (if any) at the beginning of the buffer */
+ ret = copy_from_user(fifo->buffer, from + l, len - l);
+
+ if (unlikely(ret))
+ return len - ret;
+
+ __kfifo_add_in(fifo, len);
return len;
}
-EXPORT_SYMBOL(kfifo_out);
+EXPORT_SYMBOL(kfifo_from_user);
+
+/**
+ * kfifo_to_user - gets data from the FIFO and write it to user space
+ * @fifo: the fifo to be used.
+ * @to: where the data must be copied.
+ * @len: the size of the destination buffer.
+ *
+ * This function copies at most @len bytes from the FIFO into the
+ * @to buffer and returns the number of copied bytes.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+unsigned int kfifo_to_user(struct kfifo *fifo,
+ void __user *to, unsigned int len)
+{
+ unsigned int off;
+ unsigned int l;
+ int ret;
+
+ len = min(len, fifo->in - fifo->out);
+
+ /*
+ * Ensure that we sample the fifo->in index -before- we
+ * start removing bytes from the kfifo.
+ */
+
+ smp_rmb();
+
+ off = __kfifo_off(fifo, fifo->out);
+
+ /* first get the data from fifo->out until the end of the buffer */
+ l = min(len, fifo->size - off);
+ ret = copy_to_user(to, fifo->buffer + off, l);
+
+ if (unlikely(ret))
+ return l - ret;
+
+ /* then get the rest (if any) from the beginning of the buffer */
+ ret = copy_to_user(to + l, fifo->buffer, len - l);
+
+ if (unlikely(ret))
+ return len - ret;
+
+ __kfifo_add_out(fifo, len);
+
+ return len;
+}
+EXPORT_SYMBOL(kfifo_to_user);
+
Add kfifo_in_rec() - puts some record data into the FIFO
Add kfifo_out_rec() - gets some record data from the FIFO
Add kfifo_from_user_rec() - puts some data from user space into the FIFO
Add kfifo_to_user_rec() - gets data from the FIFO and write it to user space
Add kfifo_peek_rec() - gets the size of the next FIFO record field
Add kfifo_skip_rec() - skip the next fifo out record
Add kfifo_avail_rec() - determinate the number of bytes available in a record FIFO
Signed-off-by: Stefani Seibold <[email protected]>
Acked-by: Greg Kroah-Hartman <[email protected]>
Acked-by: Mauro Carvalho Chehab <[email protected]>
Acked-by: Andi Kleen <[email protected]>
---
include/linux/kfifo.h | 328 ++++++++++++++++++++++++++++++++++++++++++++++++++
kernel/kfifo.c | 286 +++++++++++++++++++++++++++++--------------
2 files changed, 521 insertions(+), 93 deletions(-)
diff -u -N -r -p kfifo6/include/linux/kfifo.h kfifo7/include/linux/kfifo.h
--- kfifo6/include/linux/kfifo.h 2009-11-19 20:54:56.275420767 +0100
+++ kfifo7/include/linux/kfifo.h 2009-11-19 20:55:16.596339811 +0100
@@ -275,4 +275,332 @@ static inline unsigned int __kfifo_off(s
return off & (fifo->size - 1);
}
+/**
+ * __kfifo_peek_n internal helper function for determinate the length of
+ * the next record in the fifo
+ */
+static inline unsigned int __kfifo_peek_n(struct kfifo *fifo,
+ unsigned int recsize)
+{
+#define __KFIFO_GET(fifo, off, shift) \
+ ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
+
+ unsigned int l;
+
+ l = __KFIFO_GET(fifo, 0, 0);
+
+ if (--recsize)
+ l |= __KFIFO_GET(fifo, 1, 8);
+
+ return l;
+}
+
+/**
+ * __kfifo_poke_n internal helper function for storing the length of
+ * the next record into the fifo
+ */
+static inline void __kfifo_poke_n(struct kfifo *fifo,
+ unsigned int recsize, unsigned int n)
+{
+#define __KFIFO_PUT(fifo, off, val, shift) \
+ ( \
+ (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
+ (unsigned char)((val) >> (shift)) \
+ )
+
+ __KFIFO_PUT(fifo, 0, n, 0);
+
+ if (--recsize)
+ __KFIFO_PUT(fifo, 1, n, 8);
+}
+
+/**
+ * __kfifo_in_... internal functions for put date into the fifo
+ * do not call it directly, use kfifo_in_rec() instead
+ */
+extern unsigned int __kfifo_in_n(struct kfifo *fifo,
+ const void *from, unsigned int n, unsigned int recsize);
+
+extern unsigned int __kfifo_in_generic(struct kfifo *fifo,
+ const void *from, unsigned int n, unsigned int recsize);
+
+static inline unsigned int __kfifo_in_rec(struct kfifo *fifo,
+ const void *from, unsigned int n, unsigned int recsize)
+{
+ unsigned int ret;
+
+ ret = __kfifo_in_n(fifo, from, n, recsize);
+
+ if (likely(ret == 0)) {
+ if (recsize)
+ __kfifo_poke_n(fifo, recsize, n);
+ __kfifo_add_in(fifo, n + recsize);
+ }
+ return ret;
+}
+
+/**
+ * kfifo_in_rec - puts some record data into the FIFO
+ * @fifo: the fifo to be used.
+ * @from: the data to be added.
+ * @n: the length of the data to be added.
+ * @recsize: size of record field
+ *
+ * This function copies @n bytes from the @from into the FIFO and returns
+ * the number of bytes which cannot be copied.
+ * A returned value greater than the @n value means that the record doesn't
+ * fit into the buffer.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+static inline __must_check unsigned int kfifo_in_rec(struct kfifo *fifo,
+ void *from, unsigned int n, unsigned int recsize)
+{
+ if (!__builtin_constant_p(recsize))
+ return __kfifo_in_generic(fifo, from, n, recsize);
+ return __kfifo_in_rec(fifo, from, n, recsize);
+}
+
+/**
+ * __kfifo_out_... internal functions for get date from the fifo
+ * do not call it directly, use kfifo_out_rec() instead
+ */
+extern unsigned int __kfifo_out_n(struct kfifo *fifo,
+ void *to, unsigned int reclen, unsigned int recsize);
+
+extern unsigned int __kfifo_out_generic(struct kfifo *fifo,
+ void *to, unsigned int n,
+ unsigned int recsize, unsigned int *total);
+
+static inline unsigned int __kfifo_out_rec(struct kfifo *fifo,
+ void *to, unsigned int n, unsigned int recsize,
+ unsigned int *total)
+{
+ unsigned int l;
+
+ if (!recsize) {
+ l = n;
+ if (total)
+ *total = l;
+ } else {
+ l = __kfifo_peek_n(fifo, recsize);
+ if (total)
+ *total = l;
+ if (n < l)
+ return l;
+ }
+
+ return __kfifo_out_n(fifo, to, l, recsize);
+}
+
+/**
+ * kfifo_out_rec - gets some record data from the FIFO
+ * @fifo: the fifo to be used.
+ * @to: where the data must be copied.
+ * @n: the size of the destination buffer.
+ * @recsize: size of record field
+ * @total: pointer where the total number of to copied bytes should stored
+ *
+ * This function copies at most @n bytes from the FIFO to @to and returns the
+ * number of bytes which cannot be copied.
+ * A returned value greater than the @n value means that the record doesn't
+ * fit into the @to buffer.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+static inline __must_check unsigned int kfifo_out_rec(struct kfifo *fifo,
+ void *to, unsigned int n, unsigned int recsize,
+ unsigned int *total)
+
+{
+ if (!__builtin_constant_p(recsize))
+ return __kfifo_out_generic(fifo, to, n, recsize, total);
+ return __kfifo_out_rec(fifo, to, n, recsize, total);
+}
+
+/**
+ * __kfifo_from_user_... internal functions for transfer from user space into
+ * the fifo. do not call it directly, use kfifo_from_user_rec() instead
+ */
+extern unsigned int __kfifo_from_user_n(struct kfifo *fifo,
+ const void __user *from, unsigned int n, unsigned int recsize);
+
+extern unsigned int __kfifo_from_user_generic(struct kfifo *fifo,
+ const void __user *from, unsigned int n, unsigned int recsize);
+
+static inline unsigned int __kfifo_from_user_rec(struct kfifo *fifo,
+ const void __user *from, unsigned int n, unsigned int recsize)
+{
+ unsigned int ret;
+
+ ret = __kfifo_from_user_n(fifo, from, n, recsize);
+
+ if (likely(ret == 0)) {
+ if (recsize)
+ __kfifo_poke_n(fifo, recsize, n);
+ __kfifo_add_in(fifo, n + recsize);
+ }
+ return ret;
+}
+
+/**
+ * kfifo_from_user_rec - puts some data from user space into the FIFO
+ * @fifo: the fifo to be used.
+ * @from: pointer to the data to be added.
+ * @n: the length of the data to be added.
+ * @recsize: size of record field
+ *
+ * This function copies @n bytes from the @from into the
+ * FIFO and returns the number of bytes which cannot be copied.
+ *
+ * If the returned value is equal or less the @n value, the copy_from_user()
+ * functions has failed. Otherwise the record doesn't fit into the buffer.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+static inline __must_check unsigned int kfifo_from_user_rec(struct kfifo *fifo,
+ const void __user *from, unsigned int n, unsigned int recsize)
+{
+ if (!__builtin_constant_p(recsize))
+ return __kfifo_from_user_generic(fifo, from, n, recsize);
+ return __kfifo_from_user_rec(fifo, from, n, recsize);
+}
+
+/**
+ * __kfifo_to_user_... internal functions for transfer fifo data into user space
+ * do not call it directly, use kfifo_to_user_rec() instead
+ */
+extern unsigned int __kfifo_to_user_n(struct kfifo *fifo,
+ void __user *to, unsigned int n, unsigned int reclen,
+ unsigned int recsize);
+
+extern unsigned int __kfifo_to_user_generic(struct kfifo *fifo,
+ void __user *to, unsigned int n, unsigned int recsize,
+ unsigned int *total);
+
+static inline unsigned int __kfifo_to_user_rec(struct kfifo *fifo,
+ void __user *to, unsigned int n,
+ unsigned int recsize, unsigned int *total)
+{
+ unsigned int l;
+
+ if (!recsize) {
+ l = n;
+ if (total)
+ *total = l;
+ } else {
+ l = __kfifo_peek_n(fifo, recsize);
+ if (total)
+ *total = l;
+ if (n < l)
+ return l;
+ }
+
+ return __kfifo_to_user_n(fifo, to, n, l, recsize);
+}
+
+/**
+ * kfifo_to_user_rec - gets data from the FIFO and write it to user space
+ * @fifo: the fifo to be used.
+ * @to: where the data must be copied.
+ * @n: the size of the destination buffer.
+ * @recsize: size of record field
+ * @total: pointer where the total number of to copied bytes should stored
+ *
+ * This function copies at most @n bytes from the FIFO to the @to.
+ * In case of an error, the function returns the number of bytes which cannot
+ * be copied.
+ * If the returned value is equal or less the @n value, the copy_to_user()
+ * functions has failed. Otherwise the record doesn't fit into the @to buffer.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+static inline __must_check unsigned int kfifo_to_user_rec(struct kfifo *fifo,
+ void __user *to, unsigned int n, unsigned int recsize,
+ unsigned int *total)
+{
+ if (!__builtin_constant_p(recsize))
+ return __kfifo_to_user_generic(fifo, to, n, recsize, total);
+ return __kfifo_to_user_rec(fifo, to, n, recsize, total);
+}
+
+/**
+ * __kfifo_peek_... internal functions for peek into the next fifo record
+ * do not call it directly, use kfifo_peek_rec() instead
+ */
+extern unsigned int __kfifo_peek_generic(struct kfifo *fifo,
+ unsigned int recsize);
+
+/**
+ * kfifo_peek_rec - gets the size of the next FIFO record data
+ * @fifo: the fifo to be used.
+ * @recsize: size of record field
+ *
+ * This function returns the size of the next FIFO record in number of bytes
+ */
+static inline __must_check unsigned int kfifo_peek_rec(struct kfifo *fifo,
+ unsigned int recsize)
+{
+ if (!__builtin_constant_p(recsize))
+ return __kfifo_peek_generic(fifo, recsize);
+ if (!recsize)
+ return kfifo_len(fifo);
+ return __kfifo_peek_n(fifo, recsize);
+}
+
+/**
+ * __kfifo_skip_... internal functions for skip the next fifo record
+ * do not call it directly, use kfifo_skip_rec() instead
+ */
+extern void __kfifo_skip_generic(struct kfifo *fifo, unsigned int recsize);
+
+static inline void __kfifo_skip_rec(struct kfifo *fifo,
+ unsigned int recsize)
+{
+ unsigned int l;
+
+ if (recsize) {
+ l = __kfifo_peek_n(fifo, recsize);
+
+ if (l + recsize <= kfifo_len(fifo)) {
+ __kfifo_add_out(fifo, l + recsize);
+ return;
+ }
+ }
+ kfifo_reset_out(fifo);
+}
+
+/**
+ * kfifo_skip_rec - skip the next fifo out record
+ * @fifo: the fifo to be used.
+ * @recsize: size of record field
+ *
+ * This function skips the next FIFO record
+ */
+static inline void kfifo_skip_rec(struct kfifo *fifo,
+ unsigned int recsize)
+{
+ if (!__builtin_constant_p(recsize))
+ __kfifo_skip_generic(fifo, recsize);
+ else
+ __kfifo_skip_rec(fifo, recsize);
+}
+
+/**
+ * kfifo_avail_rec - returns the number of bytes available in a record FIFO
+ * @fifo: the fifo to be used.
+ * @recsize: size of record field
+ */
+static inline __must_check unsigned int kfifo_avail_rec(struct kfifo *fifo,
+ unsigned int recsize)
+{
+ unsigned int l = kfifo_size(fifo) - kfifo_len(fifo);
+
+ return (l > recsize) ? l - recsize : 0;
+}
+
#endif
diff -u -N -r -p kfifo6/kernel/kfifo.c kfifo7/kernel/kfifo.c
--- kfifo6/kernel/kfifo.c 2009-10-19 21:29:14.000000000 +0200
+++ kfifo7/kernel/kfifo.c 2009-10-19 21:41:44.508999764 +0200
@@ -115,27 +115,11 @@ void kfifo_skip(struct kfifo *fifo, unsi
}
EXPORT_SYMBOL(kfifo_skip);
-/**
- * kfifo_in - puts some data into the FIFO
- * @fifo: the fifo to be used.
- * @from: the data to be added.
- * @len: the length of the data to be added.
- *
- * This function copies at most @len bytes from the @from buffer into
- * the FIFO depending on the free space, and returns the number of
- * bytes copied.
- *
- * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-unsigned int kfifo_in(struct kfifo *fifo,
- const unsigned char *from, unsigned int len)
+static inline void __kfifo_in_data(struct kfifo *fifo,
+ const void *from, unsigned int len, unsigned int off)
{
- unsigned int off;
unsigned int l;
- len = min(len, fifo->size - fifo->in + fifo->out);
-
/*
* Ensure that we sample the fifo->out index -before- we
* start putting bytes into the kfifo.
@@ -143,7 +127,7 @@ unsigned int kfifo_in(struct kfifo *fifo
smp_mb();
- off = __kfifo_off(fifo, fifo->in);
+ off = __kfifo_off(fifo, fifo->in + off);
/* first put the data starting from fifo->in to buffer end */
l = min(len, fifo->size - off);
@@ -151,33 +135,13 @@ unsigned int kfifo_in(struct kfifo *fifo
/* then put the rest (if any) at the beginning of the buffer */
memcpy(fifo->buffer, from + l, len - l);
-
- __kfifo_add_in(fifo, len);
-
- return len;
}
-EXPORT_SYMBOL(kfifo_in);
-/**
- * kfifo_out - gets some data from the FIFO
- * @fifo: the fifo to be used.
- * @to: where the data must be copied.
- * @len: the size of the destination buffer.
- *
- * This function copies at most @len bytes from the FIFO into the
- * @to buffer and returns the number of copied bytes.
- *
- * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-unsigned int kfifo_out(struct kfifo *fifo,
- unsigned char *to, unsigned int len)
+static inline void __kfifo_out_data(struct kfifo *fifo,
+ void *to, unsigned int len, unsigned int off)
{
- unsigned int off;
unsigned int l;
- len = min(len, fifo->in - fifo->out);
-
/*
* Ensure that we sample the fifo->in index -before- we
* start removing bytes from the kfifo.
@@ -185,7 +149,7 @@ unsigned int kfifo_out(struct kfifo *fif
smp_rmb();
- off = __kfifo_off(fifo, fifo->out);
+ off = __kfifo_off(fifo, fifo->out + off);
/* first get the data from fifo->out until the end of the buffer */
l = min(len, fifo->size - off);
@@ -193,34 +157,14 @@ unsigned int kfifo_out(struct kfifo *fif
/* then get the rest (if any) from the beginning of the buffer */
memcpy(to + l, fifo->buffer, len - l);
-
- __kfifo_add_out(fifo, len);
-
- return len;
}
-EXPORT_SYMBOL(kfifo_out);
-/**
- * kfifo_from_user - puts some data from user space into the FIFO
- * @fifo: the fifo to be used.
- * @from: pointer to the data to be added.
- * @len: the length of the data to be added.
- *
- * This function copies at most @len bytes from the @from into the
- * FIFO depending and returns the number of copied bytes.
- *
- * Note that with only one concurrent reader and one concurrent
- * writer, you don't need extra locking to use these functions.
- */
-unsigned int kfifo_from_user(struct kfifo *fifo,
- const void __user *from, unsigned int len)
+static inline unsigned int __kfifo_from_user_data(struct kfifo *fifo,
+ const void __user *from, unsigned int len, unsigned int off)
{
- unsigned int off;
unsigned int l;
int ret;
- len = min(len, fifo->size - fifo->in + fifo->out);
-
/*
* Ensure that we sample the fifo->out index -before- we
* start putting bytes into the kfifo.
@@ -228,29 +172,101 @@ unsigned int kfifo_from_user(struct kfif
smp_mb();
- off = __kfifo_off(fifo, fifo->in);
+ off = __kfifo_off(fifo, fifo->in + off);
/* first put the data starting from fifo->in to buffer end */
l = min(len, fifo->size - off);
ret = copy_from_user(fifo->buffer + off, from, l);
if (unlikely(ret))
- return l - ret;
+ return ret + len - l;
/* then put the rest (if any) at the beginning of the buffer */
- ret = copy_from_user(fifo->buffer, from + l, len - l);
+ return copy_from_user(fifo->buffer, from + l, len - l);
+}
+
+static inline unsigned int __kfifo_to_user_data(struct kfifo *fifo,
+ void __user *to, unsigned int len, unsigned int off)
+{
+ unsigned int l;
+ int ret;
+
+ /*
+ * Ensure that we sample the fifo->in index -before- we
+ * start removing bytes from the kfifo.
+ */
+
+ smp_rmb();
+
+ off = __kfifo_off(fifo, fifo->out + off);
+
+ /* first get the data from fifo->out until the end of the buffer */
+ l = min(len, fifo->size - off);
+ ret = copy_to_user(to, fifo->buffer + off, l);
if (unlikely(ret))
- return len - ret;
+ return ret + len - l;
- __kfifo_add_in(fifo, len);
+ /* then get the rest (if any) from the beginning of the buffer */
+ return copy_to_user(to + l, fifo->buffer, len - l);
+}
+
+unsigned int __kfifo_in_n(struct kfifo *fifo,
+ const void *from, unsigned int len, unsigned int recsize)
+{
+ if (kfifo_avail(fifo) < len + recsize)
+ return len + 1;
+ __kfifo_in_data(fifo, from, len, recsize);
+ return 0;
+}
+EXPORT_SYMBOL(__kfifo_in_n);
+
+/**
+ * kfifo_in - puts some data into the FIFO
+ * @fifo: the fifo to be used.
+ * @from: the data to be added.
+ * @len: the length of the data to be added.
+ *
+ * This function copies at most @len bytes from the @from buffer into
+ * the FIFO depending on the free space, and returns the number of
+ * bytes copied.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+unsigned int kfifo_in(struct kfifo *fifo, const unsigned char *from,
+ unsigned int len)
+{
+ len = min(kfifo_avail(fifo), len);
+
+ __kfifo_in_data(fifo, from, len, 0);
+ __kfifo_add_in(fifo, len);
return len;
}
-EXPORT_SYMBOL(kfifo_from_user);
+EXPORT_SYMBOL(kfifo_in);
+
+unsigned int __kfifo_in_generic(struct kfifo *fifo,
+ const void *from, unsigned int len, unsigned int recsize)
+{
+ return __kfifo_in_rec(fifo, from, len, recsize);
+}
+EXPORT_SYMBOL(__kfifo_in_generic);
+
+unsigned int __kfifo_out_n(struct kfifo *fifo,
+ void *to, unsigned int len, unsigned int recsize)
+{
+ if (kfifo_len(fifo) < len + recsize)
+ return len;
+
+ __kfifo_out_data(fifo, to, len, recsize);
+ __kfifo_add_out(fifo, len + recsize);
+ return 0;
+}
+EXPORT_SYMBOL(__kfifo_out_n);
/**
- * kfifo_to_user - gets data from the FIFO and write it to user space
+ * kfifo_out - gets some data from the FIFO
* @fifo: the fifo to be used.
* @to: where the data must be copied.
* @len: the size of the destination buffer.
@@ -261,40 +277,124 @@ EXPORT_SYMBOL(kfifo_from_user);
* Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions.
*/
-unsigned int kfifo_to_user(struct kfifo *fifo,
- void __user *to, unsigned int len)
+unsigned int kfifo_out(struct kfifo *fifo, unsigned char *to, unsigned int len)
{
- unsigned int off;
- unsigned int l;
- int ret;
+ len = min(kfifo_len(fifo), len);
- len = min(len, fifo->in - fifo->out);
+ __kfifo_out_data(fifo, to, len, 0);
+ __kfifo_add_out(fifo, len);
- /*
- * Ensure that we sample the fifo->in index -before- we
- * start removing bytes from the kfifo.
- */
+ return len;
+}
+EXPORT_SYMBOL(kfifo_out);
- smp_rmb();
+unsigned int __kfifo_out_generic(struct kfifo *fifo,
+ void *to, unsigned int len, unsigned int recsize,
+ unsigned int *total)
+{
+ return __kfifo_out_rec(fifo, to, len, recsize, total);
+}
+EXPORT_SYMBOL(__kfifo_out_generic);
- off = __kfifo_off(fifo, fifo->out);
+unsigned int __kfifo_from_user_n(struct kfifo *fifo,
+ const void __user *from, unsigned int len, unsigned int recsize)
+{
+ if (kfifo_avail(fifo) < len + recsize)
+ return len + 1;
- /* first get the data from fifo->out until the end of the buffer */
- l = min(len, fifo->size - off);
- ret = copy_to_user(to, fifo->buffer + off, l);
+ return __kfifo_from_user_data(fifo, from, len, recsize);
+}
+EXPORT_SYMBOL(__kfifo_from_user_n);
- if (unlikely(ret))
- return l - ret;
+/**
+ * kfifo_from_user - puts some data from user space into the FIFO
+ * @fifo: the fifo to be used.
+ * @from: pointer to the data to be added.
+ * @len: the length of the data to be added.
+ *
+ * This function copies at most @len bytes from the @from into the
+ * FIFO depending and returns the number of copied bytes.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+unsigned int kfifo_from_user(struct kfifo *fifo,
+ const void __user *from, unsigned int len)
+{
+ len = min(kfifo_avail(fifo), len);
+ len -= __kfifo_from_user_data(fifo, from, len, 0);
+ __kfifo_add_in(fifo, len);
+ return len;
+}
+EXPORT_SYMBOL(kfifo_from_user);
- /* then get the rest (if any) from the beginning of the buffer */
- ret = copy_to_user(to + l, fifo->buffer, len - l);
+unsigned int __kfifo_from_user_generic(struct kfifo *fifo,
+ const void __user *from, unsigned int len, unsigned int recsize)
+{
+ return __kfifo_from_user_rec(fifo, from, len, recsize);
+}
+EXPORT_SYMBOL(__kfifo_from_user_generic);
- if (unlikely(ret))
- return len - ret;
+unsigned int __kfifo_to_user_n(struct kfifo *fifo,
+ void __user *to, unsigned int len, unsigned int reclen,
+ unsigned int recsize)
+{
+ unsigned int ret;
- __kfifo_add_out(fifo, len);
+ if (kfifo_len(fifo) < reclen + recsize)
+ return len;
+ ret = __kfifo_to_user_data(fifo, to, reclen, recsize);
+
+ if (likely(ret == 0))
+ __kfifo_add_out(fifo, reclen + recsize);
+
+ return ret;
+}
+EXPORT_SYMBOL(__kfifo_to_user_n);
+
+/**
+ * kfifo_to_user - gets data from the FIFO and write it to user space
+ * @fifo: the fifo to be used.
+ * @to: where the data must be copied.
+ * @len: the size of the destination buffer.
+ *
+ * This function copies at most @len bytes from the FIFO into the
+ * @to buffer and returns the number of copied bytes.
+ *
+ * Note that with only one concurrent reader and one concurrent
+ * writer, you don't need extra locking to use these functions.
+ */
+unsigned int kfifo_to_user(struct kfifo *fifo,
+ void __user *to, unsigned int len)
+{
+ len = min(kfifo_len(fifo), len);
+ len -= __kfifo_to_user_data(fifo, to, len, 0);
+ __kfifo_add_out(fifo, len);
return len;
}
EXPORT_SYMBOL(kfifo_to_user);
+unsigned int __kfifo_to_user_generic(struct kfifo *fifo,
+ void __user *to, unsigned int len, unsigned int recsize,
+ unsigned int *total)
+{
+ return __kfifo_to_user_rec(fifo, to, len, recsize, total);
+}
+EXPORT_SYMBOL(__kfifo_to_user_generic);
+
+unsigned int __kfifo_peek_generic(struct kfifo *fifo, unsigned int recsize)
+{
+ if (recsize == 0)
+ return kfifo_avail(fifo);
+
+ return __kfifo_peek_n(fifo, recsize);
+}
+EXPORT_SYMBOL(__kfifo_peek_generic);
+
+void __kfifo_skip_generic(struct kfifo *fifo, unsigned int recsize)
+{
+ __kfifo_skip_rec(fifo, recsize);
+}
+EXPORT_SYMBOL(__kfifo_skip_generic);
+
On Fri, 20 Nov 2009 09:27:13 +0100
Stefani Seibold <[email protected]> wrote:
> +#define __kfifo_initializer(s, b) \
> + (struct kfifo) { \
> + .size = s, \
> + .in = 0, \
> + .out = 0, \
> + .buffer = b \
> + }
This could be #undef'ed after its last invokation, assuming that it is
not intended that .c files use __kfifo_initializer().
On Fri, 20 Nov 2009 09:33:08 +0100
Stefani Seibold <[email protected]> wrote:
> Add kfifo_in_rec() - puts some record data into the FIFO
> Add kfifo_out_rec() - gets some record data from the FIFO
> Add kfifo_from_user_rec() - puts some data from user space into the FIFO
> Add kfifo_to_user_rec() - gets data from the FIFO and write it to user space
> Add kfifo_peek_rec() - gets the size of the next FIFO record field
> Add kfifo_skip_rec() - skip the next fifo out record
> Add kfifo_avail_rec() - determinate the number of bytes available in a record FIFO
>
> Signed-off-by: Stefani Seibold <[email protected]>
> Acked-by: Greg Kroah-Hartman <[email protected]>
> Acked-by: Mauro Carvalho Chehab <[email protected]>
> Acked-by: Andi Kleen <[email protected]>
> ---
> include/linux/kfifo.h | 328 ++++++++++++++++++++++++++++++++++++++++++++++++++
> kernel/kfifo.c | 286 +++++++++++++++++++++++++++++--------------
> 2 files changed, 521 insertions(+), 93 deletions(-)
>
> diff -u -N -r -p kfifo6/include/linux/kfifo.h kfifo7/include/linux/kfifo.h
> --- kfifo6/include/linux/kfifo.h 2009-11-19 20:54:56.275420767 +0100
> +++ kfifo7/include/linux/kfifo.h 2009-11-19 20:55:16.596339811 +0100
> @@ -275,4 +275,332 @@ static inline unsigned int __kfifo_off(s
> return off & (fifo->size - 1);
> }
>
> +/**
> + * __kfifo_peek_n internal helper function for determinate the length of
> + * the next record in the fifo
> + */
> +static inline unsigned int __kfifo_peek_n(struct kfifo *fifo,
> + unsigned int recsize)
> +{
> +#define __KFIFO_GET(fifo, off, shift) \
> + ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
> +
> + unsigned int l;
> +
> + l = __KFIFO_GET(fifo, 0, 0);
> +
> + if (--recsize)
> + l |= __KFIFO_GET(fifo, 1, 8);
> +
> + return l;
> +}
> +
> +/**
> + * __kfifo_poke_n internal helper function for storing the length of
> + * the next record into the fifo
> + */
> +static inline void __kfifo_poke_n(struct kfifo *fifo,
> + unsigned int recsize, unsigned int n)
> +{
> +#define __KFIFO_PUT(fifo, off, val, shift) \
> + ( \
> + (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
> + (unsigned char)((val) >> (shift)) \
> + )
> +
> + __KFIFO_PUT(fifo, 0, n, 0);
> +
> + if (--recsize)
> + __KFIFO_PUT(fifo, 1, n, 8);
> +}
This will leave the __KFIFO_GET and __KFIFO_PUT macros defined in the
.c files which use this header file. That's messy and undesired, to it
would be better to #undef these macros as early as possible.
but...
> +static inline unsigned int __kfifo_out_rec(struct kfifo *fifo,
> + void *to, unsigned int n, unsigned int recsize,
> + unsigned int *total)
> +{
> + unsigned int l;
> +
> + if (!recsize) {
> + l = n;
> + if (total)
> + *total = l;
> + } else {
> + l = __kfifo_peek_n(fifo, recsize);
> + if (total)
> + *total = l;
> + if (n < l)
> + return l;
> + }
> +
> + return __kfifo_out_n(fifo, to, l, recsize);
> +}
The amount of inlining in this header is pretty wild. These are large
functions! Inlining them will create a large kernel and most likely a
slower one, due to the increased instruction cache footprint.
So please, let's see a "kfifo: uninline everything" patch?
but...
> +/**
> + * kfifo_out_rec - gets some record data from the FIFO
> + * @fifo: the fifo to be used.
> + * @to: where the data must be copied.
> + * @n: the size of the destination buffer.
> + * @recsize: size of record field
> + * @total: pointer where the total number of to copied bytes should stored
> + *
> + * This function copies at most @n bytes from the FIFO to @to and returns the
> + * number of bytes which cannot be copied.
> + * A returned value greater than the @n value means that the record doesn't
> + * fit into the @to buffer.
> + *
> + * Note that with only one concurrent reader and one concurrent
> + * writer, you don't need extra locking to use these functions.
> + */
> +static inline __must_check unsigned int kfifo_out_rec(struct kfifo *fifo,
> + void *to, unsigned int n, unsigned int recsize,
> + unsigned int *total)
> +
> +{
> + if (!__builtin_constant_p(recsize))
> + return __kfifo_out_generic(fifo, to, n, recsize, total);
> + return __kfifo_out_rec(fifo, to, n, recsize, total);
> +}
OK, so I see that some attention has been paid to the text footprint issue.
But how much, and was it successful?
Am Montag, den 23.11.2009, 14:19 -0800 schrieb Andrew Morton:
> On Fri, 20 Nov 2009 09:33:08 +0100
> Stefani Seibold <[email protected]> wrote:
>
> > Add kfifo_in_rec() - puts some record data into the FIFO
> > Add kfifo_out_rec() - gets some record data from the FIFO
> > Add kfifo_from_user_rec() - puts some data from user space into the FIFO
> > Add kfifo_to_user_rec() - gets data from the FIFO and write it to user space
> > Add kfifo_peek_rec() - gets the size of the next FIFO record field
> > Add kfifo_skip_rec() - skip the next fifo out record
> > Add kfifo_avail_rec() - determinate the number of bytes available in a record FIFO
> >
> > Signed-off-by: Stefani Seibold <[email protected]>
> > Acked-by: Greg Kroah-Hartman <[email protected]>
> > Acked-by: Mauro Carvalho Chehab <[email protected]>
> > Acked-by: Andi Kleen <[email protected]>
> > ---
> > include/linux/kfifo.h | 328 ++++++++++++++++++++++++++++++++++++++++++++++++++
> > kernel/kfifo.c | 286 +++++++++++++++++++++++++++++--------------
> > 2 files changed, 521 insertions(+), 93 deletions(-)
> >
> > diff -u -N -r -p kfifo6/include/linux/kfifo.h kfifo7/include/linux/kfifo.h
> > --- kfifo6/include/linux/kfifo.h 2009-11-19 20:54:56.275420767 +0100
> > +++ kfifo7/include/linux/kfifo.h 2009-11-19 20:55:16.596339811 +0100
> > @@ -275,4 +275,332 @@ static inline unsigned int __kfifo_off(s
> > return off & (fifo->size - 1);
> > }
> >
> > +/**
> > + * __kfifo_peek_n internal helper function for determinate the length of
> > + * the next record in the fifo
> > + */
> > +static inline unsigned int __kfifo_peek_n(struct kfifo *fifo,
> > + unsigned int recsize)
> > +{
> > +#define __KFIFO_GET(fifo, off, shift) \
> > + ((fifo)->buffer[__kfifo_off((fifo), (fifo)->out+(off))] << (shift))
> > +
> > + unsigned int l;
> > +
> > + l = __KFIFO_GET(fifo, 0, 0);
> > +
> > + if (--recsize)
> > + l |= __KFIFO_GET(fifo, 1, 8);
> > +
> > + return l;
> > +}
> > +
> > +/**
> > + * __kfifo_poke_n internal helper function for storing the length of
> > + * the next record into the fifo
> > + */
> > +static inline void __kfifo_poke_n(struct kfifo *fifo,
> > + unsigned int recsize, unsigned int n)
> > +{
> > +#define __KFIFO_PUT(fifo, off, val, shift) \
> > + ( \
> > + (fifo)->buffer[__kfifo_off((fifo), (fifo)->in+(off))] = \
> > + (unsigned char)((val) >> (shift)) \
> > + )
> > +
> > + __KFIFO_PUT(fifo, 0, n, 0);
> > +
> > + if (--recsize)
> > + __KFIFO_PUT(fifo, 1, n, 8);
> > +}
>
> This will leave the __KFIFO_GET and __KFIFO_PUT macros defined in the
> .c files which use this header file. That's messy and undesired, to it
> would be better to #undef these macros as early as possible.
>
> but...
Will be fixed ...
>
> > +static inline unsigned int __kfifo_out_rec(struct kfifo *fifo,
> > + void *to, unsigned int n, unsigned int recsize,
> > + unsigned int *total)
> > +{
> > + unsigned int l;
> > +
> > + if (!recsize) {
> > + l = n;
> > + if (total)
> > + *total = l;
> > + } else {
> > + l = __kfifo_peek_n(fifo, recsize);
> > + if (total)
> > + *total = l;
> > + if (n < l)
> > + return l;
> > + }
> > +
> > + return __kfifo_out_n(fifo, to, l, recsize);
> > +}
>
> The amount of inlining in this header is pretty wild. These are large
> functions! Inlining them will create a large kernel and most likely a
> slower one, due to the increased instruction cache footprint.
>
> So please, let's see a "kfifo: uninline everything" patch?
>
> but...
>
> > +/**
> > + * kfifo_out_rec - gets some record data from the FIFO
> > + * @fifo: the fifo to be used.
> > + * @to: where the data must be copied.
> > + * @n: the size of the destination buffer.
> > + * @recsize: size of record field
> > + * @total: pointer where the total number of to copied bytes should stored
> > + *
> > + * This function copies at most @n bytes from the FIFO to @to and returns the
> > + * number of bytes which cannot be copied.
> > + * A returned value greater than the @n value means that the record doesn't
> > + * fit into the @to buffer.
> > + *
> > + * Note that with only one concurrent reader and one concurrent
> > + * writer, you don't need extra locking to use these functions.
> > + */
> > +static inline __must_check unsigned int kfifo_out_rec(struct kfifo *fifo,
> > + void *to, unsigned int n, unsigned int recsize,
> > + unsigned int *total)
> > +
> > +{
> > + if (!__builtin_constant_p(recsize))
> > + return __kfifo_out_generic(fifo, to, n, recsize, total);
> > + return __kfifo_out_rec(fifo, to, n, recsize, total);
> > +}
>
> OK, so I see that some attention has been paid to the text footprint issue.
>
> But how much, and was it successful?
>
I will think about it.
Am Montag, den 23.11.2009, 14:19 -0800 schrieb Andrew Morton:
> On Fri, 20 Nov 2009 09:27:13 +0100
> Stefani Seibold <[email protected]> wrote:
>
> > +#define __kfifo_initializer(s, b) \
> > + (struct kfifo) { \
> > + .size = s, \
> > + .in = 0, \
> > + .out = 0, \
> > + .buffer = b \
> > + }
>
> This could be #undef'ed after its last invokation, assuming that it is
> not intended that .c files use __kfifo_initializer().
Will be fixed...
On Fri, 20 Nov 2009 09:27:13 +0100
Stefani Seibold <[email protected]> wrote:
> Add DECLARE_KFIFO - macro to declare a kfifo and the associated buffer inside a struct
> Add INIT_KFIFO - Initialize a kfifo declared by DECLARED_KFIFO
> Add DEFINE_KFIFO - macro to define and initialize a kfifo as a global or local object
> Add kfifo_size() - returns the size of the fifo in bytes
> Add kfifo_is_empty() - returns true if the fifo is empty
> Add kfifo_is_full() - returns true if the fifo is full
> Add kfifo_avail() - returns the number of bytes available in the FIFO
> Do some code cleanup
Causes this:
drivers/scsi/libiscsi_tcp.c: In function 'iscsi_tcp_cleanup_task':
drivers/scsi/libiscsi_tcp.c:449: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c:456: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c: In function 'iscsi_tcp_r2t_rsp':
drivers/scsi/libiscsi_tcp.c:557: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c:573: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c:583: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c: In function 'iscsi_tcp_get_curr_r2t':
drivers/scsi/libiscsi_tcp.c:985: warning: ignoring return value of 'kfifo_in', declared with attribute warn_unused_result
drivers/scsi/libiscsi_tcp.c:993: warning: ignoring return value of 'kfifo_out', declared with attribute warn_unused_result
> > +static inline unsigned int __kfifo_out_rec(struct kfifo *fifo,
> > + void *to, unsigned int n, unsigned int recsize,
> > + unsigned int *total)
> > +{
> > + unsigned int l;
> > +
> > + if (!recsize) {
> > + l = n;
> > + if (total)
> > + *total = l;
> > + } else {
> > + l = __kfifo_peek_n(fifo, recsize);
> > + if (total)
> > + *total = l;
> > + if (n < l)
> > + return l;
> > + }
> > +
> > + return __kfifo_out_n(fifo, to, l, recsize);
> > +}
>
> The amount of inlining in this header is pretty wild. These are large
> functions! Inlining them will create a large kernel and most likely a
> slower one, due to the increased instruction cache footprint.
>
> So please, let's see a "kfifo: uninline everything" patch?
>
> but...
>
> > +/**
> > + * kfifo_out_rec - gets some record data from the FIFO
> > + * @fifo: the fifo to be used.
> > + * @to: where the data must be copied.
> > + * @n: the size of the destination buffer.
> > + * @recsize: size of record field
> > + * @total: pointer where the total number of to copied bytes should stored
> > + *
> > + * This function copies at most @n bytes from the FIFO to @to and returns the
> > + * number of bytes which cannot be copied.
> > + * A returned value greater than the @n value means that the record doesn't
> > + * fit into the @to buffer.
> > + *
> > + * Note that with only one concurrent reader and one concurrent
> > + * writer, you don't need extra locking to use these functions.
> > + */
> > +static inline __must_check unsigned int kfifo_out_rec(struct kfifo *fifo,
> > + void *to, unsigned int n, unsigned int recsize,
> > + unsigned int *total)
> > +
> > +{
> > + if (!__builtin_constant_p(recsize))
> > + return __kfifo_out_generic(fifo, to, n, recsize, total);
> > + return __kfifo_out_rec(fifo, to, n, recsize, total);
> > +}
>
> OK, so I see that some attention has been paid to the text footprint issue.
>
> But how much, and was it successful?
>
I analyzed the code and most of them will be optimized away by the
compiler. The reason for this design decision was that i want no
performance regression against the old kfifo implementation.
But if the majority vote for an non inline version i will do it. It will
make the code more readable and slim down the footprint.
On Thu, Nov 26, 2009 at 05:07:12PM +0100, Stefani Seibold wrote:
> I analyzed the code and most of them will be optimized away by the
> compiler. The reason for this design decision was that i want no
> performance regression against the old kfifo implementation.
>
> But if the majority vote for an non inline version i will do it. It will
> make the code more readable and slim down the footprint.
I vote for smaller text size if possible. I doubt kfifo is used in any
circumstances where a function call or two is a big problem. But of course
some inlines might be smaller than calls.
But then this code has been pending for a long time and I
have some potential users. It would be good to merge ASAP and do such tweaks
later in tree.
-Andi
--
[email protected] -- Speaking for myself only.
On Fri, Nov 20, 2009 at 6:15 AM, Stefani Seibold <[email protected]> wrote:
> The API:
>
> Macros defined for kernel FIFO:
> -------------------------------
>
> INIT_KFIFO(name)
> Macro to initialize a with DECLARE_KFIFO declared kfifo
Maybe: "Macro to initialize a kfifo declared by DECLARE_KFIFO"?