[PATCH] kfifo reorganization for a generic interface

Stefani Seibold
2009-08-09T14:56:09Z

Hello,

as promised: this is the first part of the new generic kfifo interfaces.

The current kernel fifo API is not very widely used, because it has to
many constrains. Only 13 files in the current 2.6.31 used it. FIFO's are
like list are a very basic thing and a kfifo API which handles the most
use case would save a lot of time and memory resources.

This is a series of patches which makes the kfifo API more generic.

This patch does reorganize the current kfifo to be ready for extensions.
The following changes are applied:

- move out spinlock of the struct kfifo because most users don't need it
- struct kfifo not longer be dynamically allocated.
- replace kfifo_put() by kfifo_put_locked() which need an additional
spinlock parameter.
- replace kfifo_get() by kfifo_get_locked() which need an additional
spinlock parameter.
- removed no longer needed __kfifo_len()
- removed no longer needed __kfifo_reset()
- kfifo_alloc() and kfifo_init() gets an additional parameter fifo, which
is the address of the associated stuct kfifo_fifo.
- fix all users of the kfifo API:
./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/media/video/meye.h
./drivers/media/video/meye.c
./drivers/infiniband/hw/cxgb3/cxio_hal.h
./drivers/infiniband/hw/cxgb3/cxio_resource.c
./drivers/char/nozomi.c
./drivers/char/sonypi.c
./drivers/usb/host/fhci-sched.c
./drivers/usb/host/fhci.h
./drivers/usb/host/fhci-tds.c
./drivers/net/wireless/libertas/main.c
./drivers/net/wireless/libertas/cmd.c
./drivers/net/wireless/libertas/dev.h
./include/scsi/libsrp.h
./include/scsi/libiscsi_tcp.h
./include/scsi/libiscsi.h
./net/dccp/probe.c

If i get an okay for this patch i will continue to send the new
functionalities step by step as single patches.

drivers/char/nozomi.c | 21 +++----
drivers/char/sonypi.c | 49 +++++++++---------
drivers/infiniband/hw/cxgb3/cxio_hal.h | 9 +--
drivers/infiniband/hw/cxgb3/cxio_resource.c | 75 ++++++++++++++--------------
drivers/media/video/meye.c | 59 +++++++++++-----------
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 | 30 +++++------
drivers/platform/x86/sony-laptop.c | 56 ++++++++++----------
drivers/scsi/libiscsi.c | 22 ++------
drivers/scsi/libiscsi_tcp.c | 29 +++++-----
drivers/scsi/libsrp.c | 13 ++--
drivers/usb/host/fhci-sched.c | 10 +--
drivers/usb/host/fhci-tds.c | 35 ++++++-------
drivers/usb/host/fhci.h | 12 ++--
include/linux/kfifo.h | 71 +++++++-------------------
include/scsi/libiscsi.h | 3 -
include/scsi/libiscsi_tcp.h | 2
include/scsi/libsrp.h | 2
kernel/kfifo.c | 68 +++++++++++--------------
net/dccp/probe.c | 20 +++----
23 files changed, 287 insertions(+), 326 deletions(-)

Signed-off-by: Stefani Seibold <stefani@seibold.net>

diff -u -N -r linux-2.6.31-rc4-kfifo0/drivers/char/nozomi.c linux-2.6.31-rc4-kfifo1/drivers/char/nozomi.c
--- linux-2.6.31-rc4-kfifo0/drivers/char/nozomi.c 2009-07-24 20:36:34.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/char/nozomi.c 2009-08-09 15:40:21.000000000 +0200
@@ -357,7 +357,7 @@
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;
@@ -684,8 +684,8 @@
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);
memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl));
memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul));
}
@@ -797,7 +797,7 @@
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) {
@@ -987,11 +987,11 @@

} 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...");
@@ -1535,8 +1535,7 @@
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);

@@ -1672,7 +1671,7 @@
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 +1719,7 @@
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 +1876,7 @@
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 linux-2.6.31-rc4-kfifo0/drivers/char/sonypi.c linux-2.6.31-rc4-kfifo1/drivers/char/sonypi.c
--- linux-2.6.31-rc4-kfifo0/drivers/char/sonypi.c 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/char/sonypi.c 2009-08-09 12:00:55.000000000 +0200
@@ -486,7 +486,7 @@
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;
@@ -495,7 +495,7 @@
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;

@@ -776,8 +776,9 @@
{
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);
@@ -826,8 +827,9 @@
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);
}
}
@@ -879,7 +881,8 @@
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);

@@ -905,7 +908,7 @@
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();
@@ -918,17 +921,18 @@
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_locked(&sonypi_device.fifo, &c, sizeof(c),
+ &sonypi_device.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -945,7 +949,7 @@
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;
}
@@ -1312,11 +1316,10 @@
"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,
- &sonypi_device.fifo_lock);
- if (IS_ERR(sonypi_device.fifo)) {
+ error = kfifo_alloc(&sonypi_device.fifo, SONYPI_BUF_SIZE, GFP_KERNEL);
+ 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);
@@ -1392,12 +1395,10 @@
}

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);
+ if (error) {
printk(KERN_ERR "sonypi: kfifo_alloc failed\n");
- error = PTR_ERR(sonypi_device.input_fifo);
goto err_inpdev_unregister;
}

@@ -1422,7 +1423,7 @@
pci_disable_device(pcidev);
err_put_pcidev:
pci_dev_put(pcidev);
- kfifo_free(sonypi_device.fifo);
+ kfifo_free(&sonypi_device.fifo);

return error;
}
@@ -1437,7 +1438,7 @@
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);
@@ -1450,7 +1451,7 @@
pci_dev_put(sonypi_device.dev);
}

- kfifo_free(sonypi_device.fifo);
+ kfifo_free(&sonypi_device.fifo);

return 0;
}
diff -u -N -r linux-2.6.31-rc4-kfifo0/drivers/infiniband/hw/cxgb3/cxio_hal.h linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h
--- linux-2.6.31-rc4-kfifo0/drivers/infiniband/hw/cxgb3/cxio_hal.h 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h 2009-08-09 15:40:00.000000000 +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_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 linux-2.6.31-rc4-kfifo0/drivers/infiniband/hw/cxgb3/cxio_resource.c linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c
--- linux-2.6.31-rc4-kfifo0/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-08-09 15:50:16.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 @@
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))
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,34 @@
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_locked(fifo, (unsigned char *) &entry,
+ sizeof(u32), fifo_lock);
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 +113,13 @@

spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);

- rdev_p->rscp->qpid_fifo = kfifo_alloc(T3_MAX_NUM_QP * sizeof(u32),
- GFP_KERNEL,
- &rdev_p->rscp->qpid_fifo_lock);
- if (IS_ERR(rdev_p->rscp->qpid_fifo))
+ if (kfifo_alloc(&rdev_p->rscp->qpid_fifo, T3_MAX_NUM_QP * sizeof(u32),
+ GFP_KERNEL))
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 @@

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 @@
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;
}
@@ -179,33 +177,38 @@
/*
* 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;
}
@@ -213,35 +216,35 @@
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)
{
- 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 linux-2.6.31-rc4-kfifo0/drivers/media/video/meye.c linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.c
--- linux-2.6.31-rc4-kfifo0/drivers/media/video/meye.c 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.c 2009-08-09 11:40:34.000000000 +0200
@@ -799,8 +799,8 @@
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;
}
@@ -810,7 +810,8 @@
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;
@@ -819,8 +820,8 @@
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;
}
@@ -830,7 +831,8 @@
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();
@@ -858,8 +860,8 @@

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;
}

@@ -932,7 +934,8 @@
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;
@@ -964,7 +967,8 @@
/* 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);
@@ -1451,7 +1455,8 @@
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;
@@ -1466,19 +1471,19 @@

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,
- sizeof(int))) {
+ if (!kfifo_get_locked(&meye.doneq, (unsigned char *)&reqnr,
+ sizeof(int), &meye.doneq_lock)) {
mutex_unlock(&meye.lock);
return -EBUSY;
}
@@ -1528,8 +1533,8 @@
{
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;
@@ -1571,7 +1576,7 @@

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;
@@ -1745,16 +1750,14 @@
}

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)) {
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)) {
printk(KERN_ERR "meye: fifo allocation failed\n");
goto outkfifoalloc2;
}
@@ -1868,9 +1871,9 @@
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:
@@ -1901,8 +1904,8 @@

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 linux-2.6.31-rc4-kfifo0/drivers/media/video/meye.h linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.h
--- linux-2.6.31-rc4-kfifo0/drivers/media/video/meye.h 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.h 2009-08-09 11:29:50.000000000 +0200
@@ -303,9 +303,9 @@
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 linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/cmd.c linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/cmd.c
--- linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/cmd.c 2009-07-24 20:36:35.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/cmd.c 2009-08-09 12:10:41.000000000 +0200
@@ -1862,7 +1862,7 @@
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);
@@ -1936,7 +1936,7 @@
}

/* 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 linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/dev.h linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/dev.h
--- linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/dev.h 2009-07-24 20:36:35.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/dev.h 2009-08-09 16:07:09.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 @@
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 linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/main.c linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/main.c
--- linux-2.6.31-rc4-kfifo0/drivers/net/wireless/libertas/main.c 2009-07-24 20:36:35.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/main.c 2009-08-09 15:53:32.000000000 +0200
@@ -772,7 +772,7 @@
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 @@

/* 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 @@
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);
+ if (ret) {
lbs_pr_err("Out of memory allocating event FIFO buffer\n");
- ret = -ENOMEM;
goto out;
}

@@ -1139,8 +1138,7 @@
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;
@@ -1580,7 +1578,7 @@
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 linux-2.6.31-rc4-kfifo0/drivers/platform/x86/fujitsu-laptop.c linux-2.6.31-rc4-kfifo1/drivers/platform/x86/fujitsu-laptop.c
--- linux-2.6.31-rc4-kfifo0/drivers/platform/x86/fujitsu-laptop.c 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/platform/x86/fujitsu-laptop.c 2009-08-09 11:17:03.000000000 +0200
@@ -164,7 +164,7 @@
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;
@@ -832,13 +832,9 @@
device->driver_data = fujitsu_hotkey;

/* 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);
+ if (error) {
printk(KERN_ERR "kfifo_alloc failed\n");
- error = PTR_ERR(fujitsu_hotkey->fifo);
goto err_stop;
}

@@ -942,7 +938,7 @@
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;
@@ -959,7 +955,7 @@

fujitsu_hotkey->acpi_handle = NULL;

- kfifo_free(fujitsu_hotkey->fifo);
+ kfifo_free(&fujitsu_hotkey->fifo);

return 0;
}
@@ -1009,9 +1005,10 @@
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",
@@ -1022,11 +1019,12 @@
}
} 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 linux-2.6.31-rc4-kfifo0/drivers/platform/x86/sony-laptop.c linux-2.6.31-rc4-kfifo1/drivers/platform/x86/sony-laptop.c
--- linux-2.6.31-rc4-kfifo0/drivers/platform/x86/sony-laptop.c 2009-07-24 20:36:35.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/platform/x86/sony-laptop.c 2009-08-09 16:11:52.000000000 +0200
@@ -142,7 +142,7 @@
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,8 +300,9 @@
{
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 @@
/* 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,
@@ -385,12 +387,10 @@

/* kfifo */
spin_lock_init(&sony_laptop_input.fifo_lock);
- sony_laptop_input.fifo =
- kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
- &sony_laptop_input.fifo_lock);
- if (IS_ERR(sony_laptop_input.fifo)) {
+ error =
+ kfifo_alloc(&sony_laptop_input.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
+ if (error) {
printk(KERN_ERR DRV_PFX "kfifo_alloc failed\n");
- error = PTR_ERR(sony_laptop_input.fifo);
goto err_dec_users;
}

@@ -474,7 +474,7 @@
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 +500,7 @@
}

destroy_workqueue(sony_laptop_input.wq);
- kfifo_free(sony_laptop_input.fifo);
+ kfifo_free(&sony_laptop_input.fifo);
}

/*********** Platform Device ***********/
@@ -2093,7 +2093,7 @@

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;
@@ -2118,12 +2118,12 @@
/* 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;
}
@@ -2134,17 +2134,18 @@
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_locked(&sonypi_compat.fifo, &c, sizeof(c),
+ &sonypi_compat.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++))
return -EFAULT;
ret++;
@@ -2161,7 +2162,7 @@
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;
}
@@ -2323,7 +2324,8 @@

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);
}
@@ -2333,11 +2335,11 @@
int error;

spin_lock_init(&sonypi_compat.fifo_lock);
- sonypi_compat.fifo = kfifo_alloc(SONY_LAPTOP_BUF_SIZE, GFP_KERNEL,
- &sonypi_compat.fifo_lock);
- if (IS_ERR(sonypi_compat.fifo)) {
+ error =
+ kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
+ 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);
@@ -2356,14 +2358,14 @@
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 linux-2.6.31-rc4-kfifo0/drivers/scsi/libiscsi.c linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi.c
--- linux-2.6.31-rc4-kfifo0/drivers/scsi/libiscsi.c 2009-07-24 20:36:36.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi.c 2009-08-09 16:15:00.000000000 +0200
@@ -428,7 +428,7 @@
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;
@@ -614,7 +614,7 @@
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;
}
@@ -1376,7 +1376,7 @@
{
struct iscsi_task *task;

- if (!__kfifo_get(conn->session->cmdpool.queue,
+ if (!__kfifo_get(&conn->session->cmdpool.queue,
(void *) &task, sizeof(void *)))
return NULL;

@@ -2121,12 +2121,7 @@
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*));

for (i = 0; i < max; i++) {
q->pool[i] = kzalloc(item_size, GFP_KERNEL);
@@ -2134,7 +2129,7 @@
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) {
@@ -2157,7 +2152,6 @@
for (i = 0; i < q->max; i++)
kfree(q->pool[i]);
kfree(q->pool);
- kfree(q->queue);
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);

@@ -2482,7 +2476,7 @@

/* 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);
@@ -2502,7 +2496,7 @@
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);
@@ -2565,7 +2559,7 @@
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 linux-2.6.31-rc4-kfifo0/drivers/scsi/libiscsi_tcp.c linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi_tcp.c
--- linux-2.6.31-rc4-kfifo0/drivers/scsi/libiscsi_tcp.c 2009-07-24 20:36:36.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi_tcp.c 2009-08-09 16:16:19.000000000 +0200
@@ -445,15 +445,15 @@
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 @@
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 @@
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 @@
"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 @@
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 @@
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 @@
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 @@
}

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 @@
}

/* 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)) {
iscsi_pool_free(&tcp_task->r2tpool);
goto r2t_alloc_fail;
}
@@ -1142,7 +1141,7 @@
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 @@
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 linux-2.6.31-rc4-kfifo0/drivers/scsi/libsrp.c linux-2.6.31-rc4-kfifo1/drivers/scsi/libsrp.c
--- linux-2.6.31-rc4-kfifo0/drivers/scsi/libsrp.c 2009-07-24 20:36:36.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/scsi/libsrp.c 2009-08-09 16:18:53.000000000 +0200
@@ -58,13 +58,10 @@
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 *));

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++;
}
@@ -166,7 +163,8 @@
{
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;
@@ -178,7 +176,8 @@

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 linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci.h linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci.h
--- linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci.h 2009-08-09 15:04:56.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci.h 2009-08-09 16:29:22.000000000 +0200
@@ -423,9 +423,9 @@
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 @@
}

/* 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);
}

static inline void cq_delete(struct kfifo *kfifo)
@@ -505,7 +505,7 @@

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)
diff -u -N -r linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci-sched.c linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-sched.c
--- linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci-sched.c 2009-08-09 15:04:51.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-sched.c 2009-08-09 15:07:58.000000000 +0200
@@ -37,7 +37,7 @@
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 @@
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 @@
}

/* 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 @@

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 @@
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 linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci-tds.c linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-tds.c
--- linux-2.6.31-rc4-kfifo0/drivers/usb/host/fhci-tds.c 2009-08-09 15:04:53.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-tds.c 2009-08-09 15:11:22.000000000 +0200
@@ -106,33 +106,33 @@
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 @@
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 @@
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 @@
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 @@
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 linux-2.6.31-rc4-kfifo0/include/linux/kfifo.h linux-2.6.31-rc4-kfifo1/include/linux/kfifo.h
--- linux-2.6.31-rc4-kfifo0/include/linux/kfifo.h 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/include/linux/kfifo.h 2009-08-09 15:40:52.000000000 +0200
@@ -1,6 +1,7 @@
/*
- * A simple kernel FIFO implementation.
+ * A generic kernel FIFO implementation.
*
+ * Copyright (C) 2009 Stefani Seibold <stefani@seibold.net>
* Copyright (C) 2004 Stelian Pop <stelian@popies.net>
*
* This program is free software; you can redistribute it and/or modify
@@ -29,13 +30,12 @@
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 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);
+extern 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,
unsigned char *buffer, unsigned int len);
@@ -43,27 +43,12 @@
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)
{
- unsigned long flags;
-
- spin_lock_irqsave(fifo->lock, flags);
-
- __kfifo_reset(fifo);
-
- spin_unlock_irqrestore(fifo->lock, flags);
+ fifo->in = fifo->out = 0;
}

/**
@@ -71,22 +56,23 @@
* @fifo: the fifo to be used.
* @buffer: 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 @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,
- unsigned char *buffer, unsigned int len)
+static inline __must_check unsigned long kfifo_put_locked(struct kfifo *fifo,
+ unsigned char *from, unsigned long 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;
}
@@ -96,19 +82,20 @@
* @fifo: the fifo to be used.
* @buffer: 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
* @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 long kfifo_get_locked(struct kfifo *fifo,
+ unsigned char *to, unsigned long 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
@@ -117,36 +104,18 @@
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 fifo->in - fifo->out;
}

#endif
diff -u -N -r linux-2.6.31-rc4-kfifo0/include/scsi/libiscsi.h linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi.h
--- linux-2.6.31-rc4-kfifo0/include/scsi/libiscsi.h 2009-07-24 20:36:39.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi.h 2009-08-09 15:51:58.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_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 linux-2.6.31-rc4-kfifo0/include/scsi/libiscsi_tcp.h linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi_tcp.h
--- linux-2.6.31-rc4-kfifo0/include/scsi/libiscsi_tcp.h 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi_tcp.h 2009-08-09 12:15:46.000000000 +0200
@@ -80,7 +80,7 @@
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 linux-2.6.31-rc4-kfifo0/include/scsi/libsrp.h linux-2.6.31-rc4-kfifo1/include/scsi/libsrp.h
--- linux-2.6.31-rc4-kfifo0/include/scsi/libsrp.h 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/include/scsi/libsrp.h 2009-08-09 12:15:39.000000000 +0200
@@ -21,7 +21,7 @@
struct srp_queue {
void *pool;
void *items;
- struct kfifo *queue;
+ struct kfifo queue;
spinlock_t lock;
};

diff -u -N -r linux-2.6.31-rc4-kfifo0/kernel/kfifo.c linux-2.6.31-rc4-kfifo1/kernel/kfifo.c
--- linux-2.6.31-rc4-kfifo0/kernel/kfifo.c 2009-07-24 20:36:39.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/kernel/kfifo.c 2009-08-09 15:40:36.000000000 +0200
@@ -1,6 +1,7 @@
/*
- * A simple kernel FIFO implementation.
+ * A generic kernel FIFO implementation.
*
+ * Copyright (C) 2009 Stefani Seibold <stefani@seibold.net>
* Copyright (C) 2004 Stelian Pop <stelian@popies.net>
*
* This program is free software; you can redistribute it and/or modify
@@ -26,49 +27,45 @@
#include <linux/kfifo.h>
#include <linux/log2.h>

+static void _kfifo_init(struct kfifo *fifo, unsigned char *buffer,
+ unsigned int size)
+{
+ fifo->buffer = buffer;
+ fifo->size = size;
+
+ 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().
+ * The buffer will be release with kfifo_free().
*/
-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)
{
- 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);
}
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
*
- * The size will be rounded-up to a power of 2.
+ * This function dynamically allocates a new fifo internal buffer
+ *
+ * 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)
{
unsigned char *buffer;
- struct kfifo *ret;

/*
* round up to the next power of 2, since our 'let the indices
@@ -80,26 +77,25 @@
}

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);
+ return -ENOMEM;
+ }

- if (IS_ERR(ret))
- kfree(buffer);
+ _kfifo_init(fifo, buffer, size);

- 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);
+ if (fifo->buffer)
+ kfree(fifo->buffer);
}
EXPORT_SYMBOL(kfifo_free);

diff -u -N -r linux-2.6.31-rc4-kfifo0/net/dccp/probe.c linux-2.6.31-rc4-kfifo1/net/dccp/probe.c
--- linux-2.6.31-rc4-kfifo0/net/dccp/probe.c 2009-06-10 05:05:27.000000000 +0200
+++ linux-2.6.31-rc4-kfifo1/net/dccp/probe.c 2009-08-09 16:21:22.000000000 +0200
@@ -43,7 +43,7 @@
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 @@
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);
}

@@ -110,7 +110,7 @@

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 @@
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_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;

out_free:
@@ -157,10 +157,8 @@

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))
+ return ret;
if (!proc_net_fops_create(&init_net, procname, S_IRUSR, &dccpprobe_fops))
goto err0;

@@ -173,14 +171,14 @@
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);