lkml.org 
[lkml]   [2009]   [Aug]   [14]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Subject[PATCH 1/6] new kfifo API v0.3 - Code reorganization and move out spinlock
    From
    Date
    This is patch 1/6 of the new kfifo API:
    Remove spinlock
    Change kfifo_put() into kfifo_put_locked() which requires an additional spinlock argument
    Change kfifo_get() into kfifo_get_locked() which requires an additional spinlock argument
    Make kfifo itself a member of the using data structure
    kfifo_init() and kfifo_alloc() requieres now a kfifo-pointer argument and does not
    longer allocated a kfifo structure
    Lockless kfifo_len()
    Fix "char *buffer" in prototypes into "from" respectively "to" to express the direction
    Fix current user of the old kfifo API

    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 | 74 +++++++++++-----------
    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 | 10 +--
    include/linux/kfifo.h | 91 ++++++++++++----------------
    include/scsi/libiscsi.h | 3
    include/scsi/libiscsi_tcp.h | 2
    include/scsi/libsrp.h | 2
    kernel/kfifo.c | 85 ++++++++++++--------------
    net/dccp/probe.c | 20 ++----
    23 files changed, 315 insertions(+), 332 deletions(-)

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

    diff -u -N -r linux-2.6.31-rc4-kfifo1/drivers/char/nozomi.c linux-2.6.31-rc4-kfifo2/drivers/char/nozomi.c
    --- linux-2.6.31-rc4-kfifo1/drivers/char/nozomi.c 2009-07-24 20:36:34.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/char/nozomi.c 2009-08-11 12:46:56.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-kfifo1/drivers/char/sonypi.c linux-2.6.31-rc4-kfifo2/drivers/char/sonypi.c
    --- linux-2.6.31-rc4-kfifo1/drivers/char/sonypi.c 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/char/sonypi.c 2009-08-11 12:56:44.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-kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h linux-2.6.31-rc4-kfifo2/drivers/infiniband/hw/cxgb3/cxio_hal.h
    --- linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_hal.h 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c linux-2.6.31-rc4-kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c
    --- linux-2.6.31-rc4-kfifo1/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/infiniband/hw/cxgb3/cxio_resource.c 2009-08-11 12:47:57.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,37 @@
    /*
    * 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 +215,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-kfifo1/drivers/media/video/meye.c linux-2.6.31-rc4-kfifo2/drivers/media/video/meye.c
    --- linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.c 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/media/video/meye.h linux-2.6.31-rc4-kfifo2/drivers/media/video/meye.h
    --- linux-2.6.31-rc4-kfifo1/drivers/media/video/meye.h 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/net/wireless/libertas/cmd.c linux-2.6.31-rc4-kfifo2/drivers/net/wireless/libertas/cmd.c
    --- linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/cmd.c 2009-07-24 20:36:35.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/net/wireless/libertas/cmd.c 2009-08-11 12:51:53.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-kfifo1/drivers/net/wireless/libertas/dev.h linux-2.6.31-rc4-kfifo2/drivers/net/wireless/libertas/dev.h
    --- linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/dev.h 2009-07-24 20:36:35.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/net/wireless/libertas/main.c linux-2.6.31-rc4-kfifo2/drivers/net/wireless/libertas/main.c
    --- linux-2.6.31-rc4-kfifo1/drivers/net/wireless/libertas/main.c 2009-07-24 20:36:35.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/net/wireless/libertas/main.c 2009-08-11 12:45:53.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-kfifo1/drivers/platform/x86/fujitsu-laptop.c linux-2.6.31-rc4-kfifo2/drivers/platform/x86/fujitsu-laptop.c
    --- linux-2.6.31-rc4-kfifo1/drivers/platform/x86/fujitsu-laptop.c 2009-08-11 22:46:59.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/platform/x86/fujitsu-laptop.c 2009-08-11 22:46:08.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;
    @@ -833,12 +833,10 @@

    /* 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 +940,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 +957,7 @@

    fujitsu_hotkey->acpi_handle = NULL;

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

    return 0;
    }
    @@ -1009,9 +1007,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 +1021,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-kfifo1/drivers/platform/x86/sony-laptop.c linux-2.6.31-rc4-kfifo2/drivers/platform/x86/sony-laptop.c
    --- linux-2.6.31-rc4-kfifo1/drivers/platform/x86/sony-laptop.c 2009-07-24 20:36:35.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/platform/x86/sony-laptop.c 2009-08-11 12:49:23.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-kfifo1/drivers/scsi/libiscsi.c linux-2.6.31-rc4-kfifo2/drivers/scsi/libiscsi.c
    --- linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi.c 2009-07-24 20:36:36.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/scsi/libiscsi_tcp.c linux-2.6.31-rc4-kfifo2/drivers/scsi/libiscsi_tcp.c
    --- linux-2.6.31-rc4-kfifo1/drivers/scsi/libiscsi_tcp.c 2009-07-24 20:36:36.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/scsi/libiscsi_tcp.c 2009-08-11 22:41:11.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-kfifo1/drivers/scsi/libsrp.c linux-2.6.31-rc4-kfifo2/drivers/scsi/libsrp.c
    --- linux-2.6.31-rc4-kfifo1/drivers/scsi/libsrp.c 2009-07-24 20:36:36.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/usb/host/fhci.h linux-2.6.31-rc4-kfifo2/drivers/usb/host/fhci.h
    --- linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci.h 2009-08-09 15:04:56.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/drivers/usb/host/fhci.h 2009-08-11 12:46:08.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)
    diff -u -N -r linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-sched.c linux-2.6.31-rc4-kfifo2/drivers/usb/host/fhci-sched.c
    --- linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-sched.c 2009-08-09 15:04:51.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/drivers/usb/host/fhci-tds.c linux-2.6.31-rc4-kfifo2/drivers/usb/host/fhci-tds.c
    --- linux-2.6.31-rc4-kfifo1/drivers/usb/host/fhci-tds.c 2009-08-09 15:04:53.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/include/linux/kfifo.h linux-2.6.31-rc4-kfifo2/include/linux/kfifo.h
    --- linux-2.6.31-rc4-kfifo1/include/linux/kfifo.h 2009-08-14 09:43:52.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/include/linux/kfifo.h 2009-08-14 10:51:07.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,18 +30,17 @@
    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 __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_put(struct kfifo *fifo,
    + const unsigned char *from, unsigned int len);
    +extern __must_check unsigned int __kfifo_get(struct kfifo *fifo,
    + unsigned char *to, unsigned int len);

    /**
    * __kfifo_reset - removes the entire FIFO contents, no locking version
    @@ -57,58 +57,67 @@
    */
    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;
    + barrier();
    + 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.
    + * @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 @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.
    + * @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
    - * @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
    @@ -117,36 +126,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 __kfifo_len(fifo);
    }

    #endif
    diff -u -N -r linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi.h linux-2.6.31-rc4-kfifo2/include/scsi/libiscsi.h
    --- linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi.h 2009-07-24 20:36:39.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/include/scsi/libiscsi_tcp.h linux-2.6.31-rc4-kfifo2/include/scsi/libiscsi_tcp.h
    --- linux-2.6.31-rc4-kfifo1/include/scsi/libiscsi_tcp.h 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/include/scsi/libsrp.h linux-2.6.31-rc4-kfifo2/include/scsi/libsrp.h
    --- linux-2.6.31-rc4-kfifo1/include/scsi/libsrp.h 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/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-kfifo1/kernel/kfifo.c linux-2.6.31-rc4-kfifo2/kernel/kfifo.c
    --- linux-2.6.31-rc4-kfifo1/kernel/kfifo.c 2009-08-14 09:45:44.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/kernel/kfifo.c 2009-08-14 09:41:17.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,36 +77,34 @@
    }

    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);
    }
    EXPORT_SYMBOL(kfifo_free);

    /**
    * __kfifo_put - puts some data into the FIFO, no locking version
    * @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.
    *
    @@ -117,7 +112,7 @@
    * 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)
    + const unsigned char *from, unsigned int len)
    {
    unsigned int l;

    @@ -132,10 +127,10 @@

    /* 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-
    @@ -153,17 +148,17 @@
    /**
    * __kfifo_get - gets some data from the FIFO, no locking version
    * @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 char *to, unsigned int len)
    {
    unsigned int l;

    @@ -178,10 +173,10 @@

    /* 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-
    diff -u -N -r linux-2.6.31-rc4-kfifo1/net/dccp/probe.c linux-2.6.31-rc4-kfifo2/net/dccp/probe.c
    --- linux-2.6.31-rc4-kfifo1/net/dccp/probe.c 2009-06-10 05:05:27.000000000 +0200
    +++ linux-2.6.31-rc4-kfifo2/net/dccp/probe.c 2009-08-11 12:50:28.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);




    \
     
     \ /
      Last update: 2009-08-14 13:47    [W:0.170 / U:32.008 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site