adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-27 03:06:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

kfifo: rename kfifo_put... into kfifo_in... and kfifo_get... into kfifo_out...

Browse source 
rename kfifo_put...  into kfifo_in...  to prevent miss use of old non in
kernel-tree drivers

ditto for kfifo_get...  -> kfifo_out...

Improve the prototypes of kfifo_in and kfifo_out to make the kerneldoc
annotations more readable.

Add mini "howto porting to the new API" in kfifo.h

Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Stefani Seibold 2009-12-21 14:37:28 -08:00 committed by Linus Torvalds
parent e64c026dd0
commit 7acd72eb85
15 changed files with 101 additions and 81 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
drivers/char/nozomi.c
View file

@ -798,7 +798,7 @@ static int send_data(enum port_type index, struct nozomi *dc)
struct tty_struct *tty = tty_port_tty_get(&port->port); struct tty_struct *tty = tty_port_tty_get(&port->port);
/* Get data from tty and place in buf for now */ /* Get data from tty and place in buf for now */
size = kfifo_get(&port->fifo_ul, dc->send_buf, size = kfifo_out(&port->fifo_ul, dc->send_buf,
ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX); ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX);
if (size == 0) { if (size == 0) {
@ -1672,7 +1672,7 @@ static int ntty_write(struct tty_struct *tty, const unsigned char *buffer,
goto exit; goto exit;
} }
rval = kfifo_put(&port->fifo_ul, (unsigned char *)buffer, count); rval = kfifo_in(&port->fifo_ul, (unsigned char *)buffer, count);
/* notify card */ /* notify card */
if (unlikely(dc == NULL)) { if (unlikely(dc == NULL)) {

8
drivers/char/sonypi.c
View file

@ -777,7 +777,7 @@ static void input_keyrelease(struct work_struct *work)
{ {
struct sonypi_keypress kp; struct sonypi_keypress kp;
while (kfifo_get_locked(&sonypi_device.input_fifo, (unsigned char *)&kp, while (kfifo_out_locked(&sonypi_device.input_fifo, (unsigned char *)&kp,
sizeof(kp), &sonypi_device.input_fifo_lock) sizeof(kp), &sonypi_device.input_fifo_lock)
== sizeof(kp)) { == sizeof(kp)) {
msleep(10); msleep(10);
@ -828,7 +828,7 @@ static void sonypi_report_input_event(u8 event)
if (kp.dev) { if (kp.dev) {
input_report_key(kp.dev, kp.key, 1); input_report_key(kp.dev, kp.key, 1);
input_sync(kp.dev); input_sync(kp.dev);
kfifo_put_locked(&sonypi_device.input_fifo, kfifo_in_locked(&sonypi_device.input_fifo,
(unsigned char *)&kp, sizeof(kp), (unsigned char *)&kp, sizeof(kp),
&sonypi_device.input_fifo_lock); &sonypi_device.input_fifo_lock);
schedule_work(&sonypi_device.input_work); schedule_work(&sonypi_device.input_work);
@ -882,7 +882,7 @@ found:
acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event); acpi_bus_generate_proc_event(sonypi_acpi_device, 1, event);
#endif #endif
kfifo_put_locked(&sonypi_device.fifo, (unsigned char *)&event, kfifo_in_locked(&sonypi_device.fifo, (unsigned char *)&event,
sizeof(event), &sonypi_device.fifo_lock); sizeof(event), &sonypi_device.fifo_lock);
kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN); kill_fasync(&sonypi_device.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_device.fifo_proc_list); wake_up_interruptible(&sonypi_device.fifo_proc_list);
@ -932,7 +932,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
return ret; return ret;
while (ret < count && while (ret < count &&
(kfifo_get_locked(&sonypi_device.fifo, &c, sizeof(c), (kfifo_out_locked(&sonypi_device.fifo, &c, sizeof(c),
&sonypi_device.fifo_lock) == sizeof(c))) { &sonypi_device.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++)) if (put_user(c, buf++))
return -EFAULT; return -EFAULT;

16
drivers/infiniband/hw/cxgb3/cxio_resource.c
View file

@ -59,7 +59,7 @@ static int __cxio_init_resource_fifo(struct kfifo *fifo,
return -ENOMEM; return -ENOMEM;
for (i = 0; i < skip_low + skip_high; i++) for (i = 0; i < skip_low + skip_high; i++)
kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)); kfifo_in(fifo, (unsigned char *) &entry, sizeof(u32));
if (random) { if (random) {
j = 0; j = 0;
random_bytes = random32(); random_bytes = random32();
@ -71,22 +71,22 @@ static int __cxio_init_resource_fifo(struct kfifo *fifo,
random_bytes = random32(); random_bytes = random32();
} }
idx = (random_bytes >> (j * 2)) & 0xF; idx = (random_bytes >> (j * 2)) & 0xF;
kfifo_put(fifo, kfifo_in(fifo,
(unsigned char *) &rarray[idx], (unsigned char *) &rarray[idx],
sizeof(u32)); sizeof(u32));
rarray[idx] = i; rarray[idx] = i;
j++; j++;
} }
for (i = 0; i < RANDOM_SIZE; i++) for (i = 0; i < RANDOM_SIZE; i++)
kfifo_put(fifo, kfifo_in(fifo,
(unsigned char *) &rarray[i], (unsigned char *) &rarray[i],
sizeof(u32)); sizeof(u32));
} else } else
for (i = skip_low; i < nr - skip_high; i++) for (i = skip_low; i < nr - skip_high; i++)
kfifo_put(fifo, (unsigned char *) &i, sizeof(u32)); kfifo_in(fifo, (unsigned char *) &i, sizeof(u32));
for (i = 0; i < skip_low + skip_high; i++) for (i = 0; i < skip_low + skip_high; i++)
kfifo_get_locked(fifo, (unsigned char *) &entry, kfifo_out_locked(fifo, (unsigned char *) &entry,
sizeof(u32), fifo_lock); sizeof(u32), fifo_lock);
return 0; return 0;
} }
@ -119,7 +119,7 @@ static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
for (i = 16; i < T3_MAX_NUM_QP; i++) for (i = 16; i < T3_MAX_NUM_QP; i++)
if (!(i & rdev_p->qpmask)) if (!(i & rdev_p->qpmask))
kfifo_put(&rdev_p->rscp->qpid_fifo, kfifo_in(&rdev_p->rscp->qpid_fifo,
(unsigned char *) &i, sizeof(u32)); (unsigned char *) &i, sizeof(u32));
return 0; return 0;
} }
@ -180,7 +180,7 @@ tpt_err:
static u32 cxio_hal_get_resource(struct kfifo *fifo, spinlock_t * lock) static u32 cxio_hal_get_resource(struct kfifo *fifo, spinlock_t * lock)
{ {
u32 entry; u32 entry;
if (kfifo_get_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)) if (kfifo_out_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock))
return entry; return entry;
else else
return 0; /* fifo emptry */ return 0; /* fifo emptry */
@ -190,7 +190,7 @@ static void cxio_hal_put_resource(struct kfifo *fifo, spinlock_t * lock,
u32 entry) u32 entry)
{ {
BUG_ON( BUG_ON(
kfifo_put_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock) kfifo_in_locked(fifo, (unsigned char *) &entry, sizeof(u32), lock)
== 0); == 0);
} }

16
drivers/media/video/meye.c
View file

@ -800,7 +800,7 @@ again:
return IRQ_HANDLED; return IRQ_HANDLED;
if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) { if (meye.mchip_mode == MCHIP_HIC_MODE_CONT_OUT) {
if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr, if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int), &meye.grabq_lock) != sizeof(int)) { sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame(); mchip_free_frame();
return IRQ_HANDLED; return IRQ_HANDLED;
@ -811,7 +811,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE; meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp); do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++; meye.grab_buffer[reqnr].sequence = sequence++;
kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr, kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock); sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list); wake_up_interruptible(&meye.proc_list);
} else { } else {
@ -821,7 +821,7 @@ again:
mchip_free_frame(); mchip_free_frame();
goto again; goto again;
} }
if (kfifo_get_locked(&meye.grabq, (unsigned char *)&reqnr, if (kfifo_out_locked(&meye.grabq, (unsigned char *)&reqnr,
sizeof(int), &meye.grabq_lock) != sizeof(int)) { sizeof(int), &meye.grabq_lock) != sizeof(int)) {
mchip_free_frame(); mchip_free_frame();
goto again; goto again;
@ -832,7 +832,7 @@ again:
meye.grab_buffer[reqnr].state = MEYE_BUF_DONE; meye.grab_buffer[reqnr].state = MEYE_BUF_DONE;
do_gettimeofday(&meye.grab_buffer[reqnr].timestamp); do_gettimeofday(&meye.grab_buffer[reqnr].timestamp);
meye.grab_buffer[reqnr].sequence = sequence++; meye.grab_buffer[reqnr].sequence = sequence++;
kfifo_put_locked(&meye.doneq, (unsigned char *)&reqnr, kfifo_in_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock); sizeof(int), &meye.doneq_lock);
wake_up_interruptible(&meye.proc_list); wake_up_interruptible(&meye.proc_list);
} }
@ -935,7 +935,7 @@ static int meyeioc_qbuf_capt(int *nb)
mchip_cont_compression_start(); mchip_cont_compression_start();
meye.grab_buffer[*nb].state = MEYE_BUF_USING; meye.grab_buffer[*nb].state = MEYE_BUF_USING;
kfifo_put_locked(&meye.grabq, (unsigned char *)nb, sizeof(int), kfifo_in_locked(&meye.grabq, (unsigned char *)nb, sizeof(int),
&meye.grabq_lock); &meye.grabq_lock);
mutex_unlock(&meye.lock); mutex_unlock(&meye.lock);
@ -968,7 +968,7 @@ static int meyeioc_sync(struct file *file, void *fh, int *i)
/* fall through */ /* fall through */
case MEYE_BUF_DONE: case MEYE_BUF_DONE:
meye.grab_buffer[*i].state = MEYE_BUF_UNUSED; meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
kfifo_get_locked(&meye.doneq, (unsigned char *)&unused, kfifo_out_locked(&meye.doneq, (unsigned char *)&unused,
sizeof(int), &meye.doneq_lock); sizeof(int), &meye.doneq_lock);
} }
*i = meye.grab_buffer[*i].size; *i = meye.grab_buffer[*i].size;
@ -1456,7 +1456,7 @@ static int vidioc_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
buf->flags |= V4L2_BUF_FLAG_QUEUED; buf->flags |= V4L2_BUF_FLAG_QUEUED;
buf->flags &= ~V4L2_BUF_FLAG_DONE; buf->flags &= ~V4L2_BUF_FLAG_DONE;
meye.grab_buffer[buf->index].state = MEYE_BUF_USING; meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
kfifo_put_locked(&meye.grabq, (unsigned char *)&buf->index, kfifo_in_locked(&meye.grabq, (unsigned char *)&buf->index,
sizeof(int), &meye.grabq_lock); sizeof(int), &meye.grabq_lock);
mutex_unlock(&meye.lock); mutex_unlock(&meye.lock);
@ -1483,7 +1483,7 @@ static int vidioc_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
return -EINTR; return -EINTR;
} }
if (!kfifo_get_locked(&meye.doneq, (unsigned char *)&reqnr, if (!kfifo_out_locked(&meye.doneq, (unsigned char *)&reqnr,
sizeof(int), &meye.doneq_lock)) { sizeof(int), &meye.doneq_lock)) {
mutex_unlock(&meye.lock); mutex_unlock(&meye.lock);
return -EBUSY; return -EBUSY;

5
drivers/net/wireless/libertas/main.c
View file

@ -513,7 +513,8 @@ static int lbs_thread(void *data)
spin_lock_irq(&priv->driver_lock); spin_lock_irq(&priv->driver_lock);
while (kfifo_len(&priv->event_fifo)) { while (kfifo_len(&priv->event_fifo)) {
u32 event; u32 event;
kfifo_get(&priv->event_fifo, (unsigned char *) &event,
kfifo_out(&priv->event_fifo, (unsigned char *) &event,
sizeof(event)); sizeof(event));
spin_unlock_irq(&priv->driver_lock); spin_unlock_irq(&priv->driver_lock);
lbs_process_event(priv, event); lbs_process_event(priv, event);
@ -1175,7 +1176,7 @@ void lbs_queue_event(struct lbs_private *priv, u32 event)
if (priv->psstate == PS_STATE_SLEEP) if (priv->psstate == PS_STATE_SLEEP)
priv->psstate = PS_STATE_AWAKE; priv->psstate = PS_STATE_AWAKE;
kfifo_put(&priv->event_fifo, (unsigned char *) &event, sizeof(u32)); kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
wake_up_interruptible(&priv->waitq); wake_up_interruptible(&priv->waitq);

4
drivers/platform/x86/fujitsu-laptop.c
View file

@ -1006,7 +1006,7 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
vdbg_printk(FUJLAPTOP_DBG_TRACE, vdbg_printk(FUJLAPTOP_DBG_TRACE,
"Push keycode into ringbuffer [%d]\n", "Push keycode into ringbuffer [%d]\n",
keycode); keycode);
status = kfifo_put_locked(&fujitsu_hotkey->fifo, status = kfifo_in_locked(&fujitsu_hotkey->fifo,
(unsigned char *)&keycode, (unsigned char *)&keycode,
sizeof(keycode), sizeof(keycode),
&fujitsu_hotkey->fifo_lock); &fujitsu_hotkey->fifo_lock);
@ -1020,7 +1020,7 @@ static void acpi_fujitsu_hotkey_notify(struct acpi_device *device, u32 event)
} }
} else if (keycode == 0) { } else if (keycode == 0) {
while ((status = while ((status =
kfifo_get_locked( kfifo_out_locked(
&fujitsu_hotkey->fifo, &fujitsu_hotkey->fifo,
(unsigned char *) &keycode_r, (unsigned char *) &keycode_r,
sizeof(keycode_r), sizeof(keycode_r),

8
drivers/platform/x86/sony-laptop.c
View file

@ -300,7 +300,7 @@ static void do_sony_laptop_release_key(struct work_struct *work)
{ {
struct sony_laptop_keypress kp; struct sony_laptop_keypress kp;
while (kfifo_get_locked(&sony_laptop_input.fifo, (unsigned char *)&kp, while (kfifo_out_locked(&sony_laptop_input.fifo, (unsigned char *)&kp,
sizeof(kp), &sony_laptop_input.fifo_lock) sizeof(kp), &sony_laptop_input.fifo_lock)
== sizeof(kp)) { == sizeof(kp)) {
msleep(10); msleep(10);
@ -363,7 +363,7 @@ static void sony_laptop_report_input_event(u8 event)
/* we emit the scancode so we can always remap the key */ /* we emit the scancode so we can always remap the key */
input_event(kp.dev, EV_MSC, MSC_SCAN, event); input_event(kp.dev, EV_MSC, MSC_SCAN, event);
input_sync(kp.dev); input_sync(kp.dev);
kfifo_put_locked(&sony_laptop_input.fifo, kfifo_in_locked(&sony_laptop_input.fifo,
(unsigned char *)&kp, sizeof(kp), (unsigned char *)&kp, sizeof(kp),
&sony_laptop_input.fifo_lock); &sony_laptop_input.fifo_lock);
@ -2130,7 +2130,7 @@ static ssize_t sonypi_misc_read(struct file *file, char __user *buf,
return ret; return ret;
while (ret < count && while (ret < count &&
(kfifo_get_locked(&sonypi_compat.fifo, &c, sizeof(c), (kfifo_out_locked(&sonypi_compat.fifo, &c, sizeof(c),
&sonypi_compat.fifo_lock) == sizeof(c))) { &sonypi_compat.fifo_lock) == sizeof(c))) {
if (put_user(c, buf++)) if (put_user(c, buf++))
return -EFAULT; return -EFAULT;
@ -2310,7 +2310,7 @@ static struct miscdevice sonypi_misc_device = {
static void sonypi_compat_report_event(u8 event) static void sonypi_compat_report_event(u8 event)
{ {
kfifo_put_locked(&sonypi_compat.fifo, (unsigned char *)&event, kfifo_in_locked(&sonypi_compat.fifo, (unsigned char *)&event,
sizeof(event), &sonypi_compat.fifo_lock); sizeof(event), &sonypi_compat.fifo_lock);
kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN); kill_fasync(&sonypi_compat.fifo_async, SIGIO, POLL_IN);
wake_up_interruptible(&sonypi_compat.fifo_proc_list); wake_up_interruptible(&sonypi_compat.fifo_proc_list);

14
drivers/scsi/libiscsi.c
View file

@ -517,7 +517,7 @@ static void iscsi_free_task(struct iscsi_task *task)
if (conn->login_task == task) if (conn->login_task == task)
return; return;
kfifo_put(&session->cmdpool.queue, (void*)&task, sizeof(void*)); kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
if (sc) { if (sc) {
task->sc = NULL; task->sc = NULL;
@ -737,7 +737,7 @@ __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
if (!kfifo_get(&session->cmdpool.queue, if (!kfifo_out(&session->cmdpool.queue,
(void*)&task, sizeof(void*))) (void*)&task, sizeof(void*)))
return NULL; return NULL;
} }
@ -1567,7 +1567,7 @@ static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
{ {
struct iscsi_task *task; struct iscsi_task *task;
if (!kfifo_get(&conn->session->cmdpool.queue, if (!kfifo_out(&conn->session->cmdpool.queue,
(void *) &task, sizeof(void *))) (void *) &task, sizeof(void *)))
return NULL; return NULL;
@ -2469,7 +2469,7 @@ iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
q->max = i; q->max = i;
goto enomem; goto enomem;
} }
kfifo_put(&q->queue, (void*)&q->pool[i], sizeof(void*)); kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
} }
if (items) { if (items) {
@ -2819,7 +2819,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
/* allocate login_task used for the login/text sequences */ /* allocate login_task used for the login/text sequences */
spin_lock_bh(&session->lock); spin_lock_bh(&session->lock);
if (!kfifo_get(&session->cmdpool.queue, if (!kfifo_out(&session->cmdpool.queue,
(void*)&conn->login_task, (void*)&conn->login_task,
sizeof(void*))) { sizeof(void*))) {
spin_unlock_bh(&session->lock); spin_unlock_bh(&session->lock);
@ -2839,7 +2839,7 @@ iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
return cls_conn; return cls_conn;
login_task_data_alloc_fail: login_task_data_alloc_fail:
kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task, kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*)); sizeof(void*));
login_task_alloc_fail: login_task_alloc_fail:
iscsi_destroy_conn(cls_conn); iscsi_destroy_conn(cls_conn);
@ -2902,7 +2902,7 @@ void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
free_pages((unsigned long) conn->data, free_pages((unsigned long) conn->data,
get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
kfree(conn->persistent_address); kfree(conn->persistent_address);
kfifo_put(&session->cmdpool.queue, (void*)&conn->login_task, kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
sizeof(void*)); sizeof(void*));
if (session->leadconn == conn) if (session->leadconn == conn)
session->leadconn = NULL; session->leadconn = NULL;

18
drivers/scsi/libiscsi_tcp.c
View file

@ -445,15 +445,15 @@ void iscsi_tcp_cleanup_task(struct iscsi_task *task)
return; return;
/* flush task's r2t queues */ /* flush task's r2t queues */
while (kfifo_get(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) { while (kfifo_out(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*))) {
kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t, kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*)); sizeof(void*));
ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n"); ISCSI_DBG_TCP(task->conn, "pending r2t dropped\n");
} }
r2t = tcp_task->r2t; r2t = tcp_task->r2t;
if (r2t != NULL) { if (r2t != NULL) {
kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t, kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*)); sizeof(void*));
tcp_task->r2t = NULL; tcp_task->r2t = NULL;
} }
@ -541,7 +541,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
return 0; return 0;
} }
rc = kfifo_get(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*)); rc = kfifo_out(&tcp_task->r2tpool.queue, (void*)&r2t, sizeof(void*));
if (!rc) { if (!rc) {
iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. " iscsi_conn_printk(KERN_ERR, conn, "Could not allocate R2T. "
"Target has sent more R2Ts than it " "Target has sent more R2Ts than it "
@ -554,7 +554,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
if (r2t->data_length == 0) { if (r2t->data_length == 0) {
iscsi_conn_printk(KERN_ERR, conn, iscsi_conn_printk(KERN_ERR, conn,
"invalid R2T with zero data len\n"); "invalid R2T with zero data len\n");
kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t, kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*)); sizeof(void*));
return ISCSI_ERR_DATALEN; return ISCSI_ERR_DATALEN;
} }
@ -570,7 +570,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
"invalid R2T with data len %u at offset %u " "invalid R2T with data len %u at offset %u "
"and total length %d\n", r2t->data_length, "and total length %d\n", r2t->data_length,
r2t->data_offset, scsi_out(task->sc)->length); r2t->data_offset, scsi_out(task->sc)->length);
kfifo_put(&tcp_task->r2tpool.queue, (void*)&r2t, kfifo_in(&tcp_task->r2tpool.queue, (void*)&r2t,
sizeof(void*)); sizeof(void*));
return ISCSI_ERR_DATALEN; return ISCSI_ERR_DATALEN;
} }
@ -580,7 +580,7 @@ static int iscsi_tcp_r2t_rsp(struct iscsi_conn *conn, struct iscsi_task *task)
r2t->sent = 0; r2t->sent = 0;
tcp_task->exp_datasn = r2tsn + 1; tcp_task->exp_datasn = r2tsn + 1;
kfifo_put(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*)); kfifo_in(&tcp_task->r2tqueue, (void*)&r2t, sizeof(void*));
conn->r2t_pdus_cnt++; conn->r2t_pdus_cnt++;
iscsi_requeue_task(task); iscsi_requeue_task(task);
@ -982,7 +982,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
if (r2t->data_length <= r2t->sent) { if (r2t->data_length <= r2t->sent) {
ISCSI_DBG_TCP(task->conn, ISCSI_DBG_TCP(task->conn,
" done with r2t %p\n", r2t); " done with r2t %p\n", r2t);
kfifo_put(&tcp_task->r2tpool.queue, kfifo_in(&tcp_task->r2tpool.queue,
(void *)&tcp_task->r2t, (void *)&tcp_task->r2t,
sizeof(void *)); sizeof(void *));
tcp_task->r2t = r2t = NULL; tcp_task->r2t = r2t = NULL;
@ -990,7 +990,7 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
} }
if (r2t == NULL) { if (r2t == NULL) {
kfifo_get(&tcp_task->r2tqueue, kfifo_out(&tcp_task->r2tqueue,
(void *)&tcp_task->r2t, sizeof(void *)); (void *)&tcp_task->r2t, sizeof(void *));
r2t = tcp_task->r2t; r2t = tcp_task->r2t;
} }

6
drivers/scsi/libsrp.c
View file

@ -61,7 +61,7 @@ static int srp_iu_pool_alloc(struct srp_queue *q, size_t max,
kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *)); kfifo_init(&q->queue, (void *) q->pool, max * sizeof(void *));
for (i = 0, iue = q->items; i < max; i++) { for (i = 0, iue = q->items; i < max; i++) {
kfifo_put(&q->queue, (void *) &iue, sizeof(void *)); kfifo_in(&q->queue, (void *) &iue, sizeof(void *));
iue->sbuf = ring[i]; iue->sbuf = ring[i];
iue++; iue++;
} }
@ -163,7 +163,7 @@ struct iu_entry *srp_iu_get(struct srp_target *target)
{ {
struct iu_entry *iue = NULL; struct iu_entry *iue = NULL;
kfifo_get_locked(&target->iu_queue.queue, (void *) &iue, kfifo_out_locked(&target->iu_queue.queue, (void *) &iue,
sizeof(void *), &target->iu_queue.lock); sizeof(void *), &target->iu_queue.lock);
if (!iue) if (!iue)
return iue; return iue;
@ -176,7 +176,7 @@ EXPORT_SYMBOL_GPL(srp_iu_get);
void srp_iu_put(struct iu_entry *iue) void srp_iu_put(struct iu_entry *iue)
{ {
kfifo_put_locked(&iue->target->iu_queue.queue, (void *) &iue, kfifo_in_locked(&iue->target->iu_queue.queue, (void *) &iue,
sizeof(void *), &iue->target->iu_queue.lock); sizeof(void *), &iue->target->iu_queue.lock);
} }
EXPORT_SYMBOL_GPL(srp_iu_put); EXPORT_SYMBOL_GPL(srp_iu_put);

4
drivers/usb/host/fhci.h
View file

@ -510,14 +510,14 @@ static inline unsigned int cq_howmany(struct kfifo *kfifo)
static inline int cq_put(struct kfifo *kfifo, void *p) static inline int cq_put(struct kfifo *kfifo, void *p)
{ {
return kfifo_put(kfifo, (void *)&p, sizeof(p)); return kfifo_in(kfifo, (void *)&p, sizeof(p));
} }
static inline void *cq_get(struct kfifo *kfifo) static inline void *cq_get(struct kfifo *kfifo)
{ {
void *p = NULL; void *p = NULL;
kfifo_get(kfifo, (void *)&p, sizeof(p)); kfifo_out(kfifo, (void *)&p, sizeof(p));
return p; return p;
} }

4
drivers/usb/serial/generic.c
View file

@ -285,7 +285,7 @@ static int usb_serial_generic_write_start(struct usb_serial_port *port)
return 0; return 0;
data = port->write_urb->transfer_buffer; data = port->write_urb->transfer_buffer;
count = kfifo_get_locked(port->write_fifo, data, port->bulk_out_size, &port->lock); count = kfifo_out_locked(port->write_fifo, data, port->bulk_out_size, &port->lock);
usb_serial_debug_data(debug, &port->dev, __func__, count, data); usb_serial_debug_data(debug, &port->dev, __func__, count, data);
/* set up our urb */ /* set up our urb */
@ -345,7 +345,7 @@ int usb_serial_generic_write(struct tty_struct *tty,
return usb_serial_multi_urb_write(tty, port, return usb_serial_multi_urb_write(tty, port,
buf, count); buf, count);
count = kfifo_put_locked(port->write_fifo, buf, count, &port->lock); count = kfifo_in_locked(port->write_fifo, buf, count, &port->lock);
result = usb_serial_generic_write_start(port); result = usb_serial_generic_write_start(port);
if (result >= 0) if (result >= 0)

39
include/linux/kfifo.h
View file

@ -19,6 +19,25 @@
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *
*/ */
/*
* Howto porting drivers to the new generic fifo API:
*
* - Modify the declaration of the "struct kfifo *" object into a
* in-place "struct kfifo" object
* - Init the in-place object with kfifo_alloc() or kfifo_init()
* Note: The address of the in-place "struct kfifo" object must be
* passed as the first argument to this functions
* - Replace the use of __kfifo_put into kfifo_in and __kfifo_get
* into kfifo_out
* - Replace the use of kfifo_put into kfifo_in_locked and kfifo_get
* into kfifo_out_locked
* Note: the spinlock pointer formerly passed to kfifo_init/kfifo_alloc
* must be passed now to the kfifo_in_locked and kfifo_out_locked
* as the last parameter.
* - All formerly name __kfifo_* functions has been renamed into kfifo_*
*/
#ifndef _LINUX_KFIFO_H #ifndef _LINUX_KFIFO_H
#define _LINUX_KFIFO_H #define _LINUX_KFIFO_H
@ -37,10 +56,10 @@ extern void kfifo_init(struct kfifo *fifo, unsigned char *buffer,
extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size, extern __must_check int kfifo_alloc(struct kfifo *fifo, unsigned int size,
gfp_t gfp_mask); gfp_t gfp_mask);
extern void kfifo_free(struct kfifo *fifo); extern void kfifo_free(struct kfifo *fifo);
extern unsigned int kfifo_put(struct kfifo *fifo, extern __must_check unsigned int kfifo_in(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len); const unsigned char *from, unsigned int len);
extern unsigned int kfifo_get(struct kfifo *fifo, extern __must_check unsigned int kfifo_out(struct kfifo *fifo,
unsigned char *buffer, unsigned int len); unsigned char *to, unsigned int len);
/** /**
* kfifo_reset - removes the entire FIFO contents * kfifo_reset - removes the entire FIFO contents
@ -65,7 +84,7 @@ static inline unsigned int kfifo_len(struct kfifo *fifo)
} }
/** /**
* kfifo_put_locked - puts some data into the FIFO using a spinlock for locking * kfifo_in_locked - puts some data into the FIFO using a spinlock for locking
* @fifo: the fifo to be used. * @fifo: the fifo to be used.
* @from: the data to be added. * @from: the data to be added.
* @n: the length of the data to be added. * @n: the length of the data to be added.
@ -75,7 +94,7 @@ static inline unsigned int kfifo_len(struct kfifo *fifo)
* the FIFO depending on the free space, and returns the number of * the FIFO depending on the free space, and returns the number of
* bytes copied. * bytes copied.
*/ */
static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo, static inline __must_check unsigned int kfifo_in_locked(struct kfifo *fifo,
const unsigned char *from, unsigned int n, spinlock_t *lock) const unsigned char *from, unsigned int n, spinlock_t *lock)
{ {
unsigned long flags; unsigned long flags;
@ -83,7 +102,7 @@ static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo,
spin_lock_irqsave(lock, flags); spin_lock_irqsave(lock, flags);
ret = kfifo_put(fifo, from, n); ret = kfifo_in(fifo, from, n);
spin_unlock_irqrestore(lock, flags); spin_unlock_irqrestore(lock, flags);
@ -91,7 +110,7 @@ static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo,
} }
/** /**
* kfifo_get_locked - gets some data from the FIFO using a spinlock for locking * kfifo_out_locked - gets some data from the FIFO using a spinlock for locking
* @fifo: the fifo to be used. * @fifo: the fifo to be used.
* @to: where the data must be copied. * @to: where the data must be copied.
* @n: the size of the destination buffer. * @n: the size of the destination buffer.
@ -100,7 +119,7 @@ static inline __must_check unsigned int kfifo_put_locked(struct kfifo *fifo,
* This function copies at most @len bytes from the FIFO into the * This function copies at most @len bytes from the FIFO into the
* @to buffer and returns the number of copied bytes. * @to buffer and returns the number of copied bytes.
*/ */
static inline __must_check unsigned int kfifo_get_locked(struct kfifo *fifo, static inline __must_check unsigned int kfifo_out_locked(struct kfifo *fifo,
unsigned char *to, unsigned int n, spinlock_t *lock) unsigned char *to, unsigned int n, spinlock_t *lock)
{ {
unsigned long flags; unsigned long flags;
@ -108,7 +127,7 @@ static inline __must_check unsigned int kfifo_get_locked(struct kfifo *fifo,
spin_lock_irqsave(lock, flags); spin_lock_irqsave(lock, flags);
ret = kfifo_get(fifo, to, n); ret = kfifo_out(fifo, to, n);
/* /*
* optimization: if the FIFO is empty, set the indices to 0 * optimization: if the FIFO is empty, set the indices to 0

32
kernel/kfifo.c
View file

@ -100,20 +100,20 @@ void kfifo_free(struct kfifo *fifo)
EXPORT_SYMBOL(kfifo_free); EXPORT_SYMBOL(kfifo_free);
/** /**
* kfifo_put - puts some data into the FIFO, no locking version * kfifo_in - puts some data into the FIFO
* @fifo: the fifo to be used. * @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. * @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 * the FIFO depending on the free space, and returns the number of
* bytes copied. * bytes copied.
* *
* Note that with only one concurrent reader and one concurrent * Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions. * writer, you don't need extra locking to use these functions.
*/ */
unsigned int kfifo_put(struct kfifo *fifo, unsigned int kfifo_in(struct kfifo *fifo,
const unsigned char *buffer, unsigned int len) const unsigned char *from, unsigned int len)
{ {
unsigned int l; unsigned int l;
@ -128,10 +128,10 @@ unsigned int kfifo_put(struct kfifo *fifo,
/* first put the data starting from fifo->in to buffer end */ /* first put the data starting from fifo->in to buffer end */
l = min(len, fifo->size - (fifo->in & (fifo->size - 1))); 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 */ /* 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- * Ensure that we add the bytes to the kfifo -before-
@ -144,22 +144,22 @@ unsigned int kfifo_put(struct kfifo *fifo,
return len; return len;
} }
EXPORT_SYMBOL(kfifo_put); EXPORT_SYMBOL(kfifo_in);
/** /**
* kfifo_get - gets some data from the FIFO, no locking version * kfifo_out - gets some data from the FIFO
* @fifo: the fifo to be used. * @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. * @len: the size of the destination buffer.
* *
* This function copies at most @len bytes from the FIFO into the * 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 * Note that with only one concurrent reader and one concurrent
* writer, you don't need extra locking to use these functions. * writer, you don't need extra locking to use these functions.
*/ */
unsigned int kfifo_get(struct kfifo *fifo, unsigned int kfifo_out(struct kfifo *fifo,
unsigned char *buffer, unsigned int len) unsigned char *to, unsigned int len)
{ {
unsigned int l; unsigned int l;
@ -174,10 +174,10 @@ unsigned int kfifo_get(struct kfifo *fifo,
/* first get the data from fifo->out until the end of the buffer */ /* first get the data from fifo->out until the end of the buffer */
l = min(len, fifo->size - (fifo->out & (fifo->size - 1))); 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 */ /* 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- * Ensure that we remove the bytes from the kfifo -before-
@ -190,4 +190,4 @@ unsigned int kfifo_get(struct kfifo *fifo,
return len; return len;
} }
EXPORT_SYMBOL(kfifo_get); EXPORT_SYMBOL(kfifo_out);

4
net/dccp/probe.c
View file

@ -67,7 +67,7 @@ static void printl(const char *fmt, ...)
len += vscnprintf(tbuf+len, sizeof(tbuf)-len, fmt, args); len += vscnprintf(tbuf+len, sizeof(tbuf)-len, fmt, args);
va_end(args); va_end(args);
kfifo_put_locked(&dccpw.fifo, tbuf, len, &dccpw.lock); kfifo_in_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
wake_up(&dccpw.wait); wake_up(&dccpw.wait);
} }
@ -135,7 +135,7 @@ static ssize_t dccpprobe_read(struct file *file, char __user *buf,
if (error) if (error)
goto out_free; goto out_free;
cnt = kfifo_get_locked(&dccpw.fifo, tbuf, len, &dccpw.lock); cnt = kfifo_out_locked(&dccpw.fifo, tbuf, len, &dccpw.lock);
error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0; error = copy_to_user(buf, tbuf, cnt) ? -EFAULT : 0;
out_free: out_free: