2006-09-20 12:36:48 -06:00
|
|
|
/* Copyright (c) 2006 Coraid, Inc. See COPYING for GPL terms. */
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* aoechr.c
|
|
|
|
* AoE character device driver
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/hdreg.h>
|
|
|
|
#include <linux/blkdev.h>
|
aoe: handle multiple network paths to AoE device
A remote AoE device is something can process ATA commands and is identified by
an AoE shelf number and an AoE slot number. Such a device might have more
than one network interface, and it might be reachable by more than one local
network interface. This patch tracks the available network paths available to
each AoE device, allowing them to be used more efficiently.
Andrew Morton asked about the call to msleep_interruptible in the revalidate
function. Yes, if a signal is pending, then msleep_interruptible will not
return 0. That means we will not loop but will call aoenet_xmit with a NULL
skb, which is a noop. If the system is too low on memory or the aoe driver is
too low on frames, then the user can hit control-C to interrupt the attempt to
do a revalidate. I have added a comment to the code summarizing that.
Andrew Morton asked whether the allocation performed inside addtgt could use a
more relaxed allocation like GFP_KERNEL, but addtgt is called when the aoedev
lock has been locked with spin_lock_irqsave. It would be nice to allocate the
memory under fewer restrictions, but targets are only added when the device is
being discovered, and if the target can't be added right now, we can try again
in a minute when then next AoE config query broadcast goes out.
Andrew Morton pointed out that the "too many targets" message could be printed
for failing GFP_ATOMIC allocations. The last patch in this series makes the
messages more specific.
Signed-off-by: Ed L. Cashin <ecashin@coraid.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-08 05:20:00 -07:00
|
|
|
#include <linux/delay.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "aoe.h"
|
|
|
|
|
|
|
|
enum {
|
|
|
|
//MINOR_STAT = 1, (moved to sysfs)
|
|
|
|
MINOR_ERR = 2,
|
|
|
|
MINOR_DISCOVER,
|
|
|
|
MINOR_INTERFACES,
|
2006-01-19 11:46:19 -07:00
|
|
|
MINOR_REVALIDATE,
|
2008-02-08 05:20:03 -07:00
|
|
|
MINOR_FLUSH,
|
2005-04-16 16:20:36 -06:00
|
|
|
MSGSZ = 2048,
|
|
|
|
NMSG = 100, /* message backlog to retain */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct aoe_chardev {
|
|
|
|
ulong minor;
|
|
|
|
char name[32];
|
|
|
|
};
|
|
|
|
|
|
|
|
enum { EMFL_VALID = 1 };
|
|
|
|
|
|
|
|
struct ErrMsg {
|
|
|
|
short flags;
|
|
|
|
short len;
|
|
|
|
char *msg;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct ErrMsg emsgs[NMSG];
|
|
|
|
static int emsgs_head_idx, emsgs_tail_idx;
|
|
|
|
static struct semaphore emsgs_sema;
|
|
|
|
static spinlock_t emsgs_lock;
|
|
|
|
static int nblocked_emsgs_readers;
|
2005-03-23 10:52:10 -07:00
|
|
|
static struct class *aoe_class;
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct aoe_chardev chardevs[] = {
|
|
|
|
{ MINOR_ERR, "err" },
|
|
|
|
{ MINOR_DISCOVER, "discover" },
|
|
|
|
{ MINOR_INTERFACES, "interfaces" },
|
2006-01-19 11:46:19 -07:00
|
|
|
{ MINOR_REVALIDATE, "revalidate" },
|
2008-02-08 05:20:03 -07:00
|
|
|
{ MINOR_FLUSH, "flush" },
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
discover(void)
|
|
|
|
{
|
|
|
|
aoecmd_cfg(0xffff, 0xff);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
interfaces(const char __user *str, size_t size)
|
|
|
|
{
|
|
|
|
if (set_aoe_iflist(str, size)) {
|
2006-09-20 12:36:51 -06:00
|
|
|
printk(KERN_ERR
|
|
|
|
"aoe: could not set interface list: too many interfaces\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-19 11:46:19 -07:00
|
|
|
static int
|
|
|
|
revalidate(const char __user *str, size_t size)
|
|
|
|
{
|
|
|
|
int major, minor, n;
|
|
|
|
ulong flags;
|
|
|
|
struct aoedev *d;
|
aoe: handle multiple network paths to AoE device
A remote AoE device is something can process ATA commands and is identified by
an AoE shelf number and an AoE slot number. Such a device might have more
than one network interface, and it might be reachable by more than one local
network interface. This patch tracks the available network paths available to
each AoE device, allowing them to be used more efficiently.
Andrew Morton asked about the call to msleep_interruptible in the revalidate
function. Yes, if a signal is pending, then msleep_interruptible will not
return 0. That means we will not loop but will call aoenet_xmit with a NULL
skb, which is a noop. If the system is too low on memory or the aoe driver is
too low on frames, then the user can hit control-C to interrupt the attempt to
do a revalidate. I have added a comment to the code summarizing that.
Andrew Morton asked whether the allocation performed inside addtgt could use a
more relaxed allocation like GFP_KERNEL, but addtgt is called when the aoedev
lock has been locked with spin_lock_irqsave. It would be nice to allocate the
memory under fewer restrictions, but targets are only added when the device is
being discovered, and if the target can't be added right now, we can try again
in a minute when then next AoE config query broadcast goes out.
Andrew Morton pointed out that the "too many targets" message could be printed
for failing GFP_ATOMIC allocations. The last patch in this series makes the
messages more specific.
Signed-off-by: Ed L. Cashin <ecashin@coraid.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-08 05:20:00 -07:00
|
|
|
struct sk_buff *skb;
|
2006-01-19 11:46:19 -07:00
|
|
|
char buf[16];
|
|
|
|
|
|
|
|
if (size >= sizeof buf)
|
|
|
|
return -EINVAL;
|
|
|
|
buf[sizeof buf - 1] = '\0';
|
|
|
|
if (copy_from_user(buf, str, size))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/* should be e%d.%d format */
|
|
|
|
n = sscanf(buf, "e%d.%d", &major, &minor);
|
|
|
|
if (n != 2) {
|
2006-09-20 12:36:51 -06:00
|
|
|
printk(KERN_ERR "aoe: invalid device specification\n");
|
2006-01-19 11:46:19 -07:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
d = aoedev_by_aoeaddr(major, minor);
|
|
|
|
if (!d)
|
|
|
|
return -EINVAL;
|
|
|
|
spin_lock_irqsave(&d->lock, flags);
|
aoe: handle multiple network paths to AoE device
A remote AoE device is something can process ATA commands and is identified by
an AoE shelf number and an AoE slot number. Such a device might have more
than one network interface, and it might be reachable by more than one local
network interface. This patch tracks the available network paths available to
each AoE device, allowing them to be used more efficiently.
Andrew Morton asked about the call to msleep_interruptible in the revalidate
function. Yes, if a signal is pending, then msleep_interruptible will not
return 0. That means we will not loop but will call aoenet_xmit with a NULL
skb, which is a noop. If the system is too low on memory or the aoe driver is
too low on frames, then the user can hit control-C to interrupt the attempt to
do a revalidate. I have added a comment to the code summarizing that.
Andrew Morton asked whether the allocation performed inside addtgt could use a
more relaxed allocation like GFP_KERNEL, but addtgt is called when the aoedev
lock has been locked with spin_lock_irqsave. It would be nice to allocate the
memory under fewer restrictions, but targets are only added when the device is
being discovered, and if the target can't be added right now, we can try again
in a minute when then next AoE config query broadcast goes out.
Andrew Morton pointed out that the "too many targets" message could be printed
for failing GFP_ATOMIC allocations. The last patch in this series makes the
messages more specific.
Signed-off-by: Ed L. Cashin <ecashin@coraid.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-08 05:20:00 -07:00
|
|
|
aoecmd_cleanslate(d);
|
|
|
|
loop:
|
|
|
|
skb = aoecmd_ata_id(d);
|
2006-01-19 11:46:19 -07:00
|
|
|
spin_unlock_irqrestore(&d->lock, flags);
|
aoe: handle multiple network paths to AoE device
A remote AoE device is something can process ATA commands and is identified by
an AoE shelf number and an AoE slot number. Such a device might have more
than one network interface, and it might be reachable by more than one local
network interface. This patch tracks the available network paths available to
each AoE device, allowing them to be used more efficiently.
Andrew Morton asked about the call to msleep_interruptible in the revalidate
function. Yes, if a signal is pending, then msleep_interruptible will not
return 0. That means we will not loop but will call aoenet_xmit with a NULL
skb, which is a noop. If the system is too low on memory or the aoe driver is
too low on frames, then the user can hit control-C to interrupt the attempt to
do a revalidate. I have added a comment to the code summarizing that.
Andrew Morton asked whether the allocation performed inside addtgt could use a
more relaxed allocation like GFP_KERNEL, but addtgt is called when the aoedev
lock has been locked with spin_lock_irqsave. It would be nice to allocate the
memory under fewer restrictions, but targets are only added when the device is
being discovered, and if the target can't be added right now, we can try again
in a minute when then next AoE config query broadcast goes out.
Andrew Morton pointed out that the "too many targets" message could be printed
for failing GFP_ATOMIC allocations. The last patch in this series makes the
messages more specific.
Signed-off-by: Ed L. Cashin <ecashin@coraid.com>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-08 05:20:00 -07:00
|
|
|
/* try again if we are able to sleep a bit,
|
|
|
|
* otherwise give up this revalidation
|
|
|
|
*/
|
|
|
|
if (!skb && !msleep_interruptible(200)) {
|
|
|
|
spin_lock_irqsave(&d->lock, flags);
|
|
|
|
goto loop;
|
|
|
|
}
|
|
|
|
aoenet_xmit(skb);
|
2006-01-19 11:46:19 -07:00
|
|
|
aoecmd_cfg(major, minor);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void
|
|
|
|
aoechr_error(char *msg)
|
|
|
|
{
|
|
|
|
struct ErrMsg *em;
|
|
|
|
char *mp;
|
|
|
|
ulong flags, n;
|
|
|
|
|
|
|
|
n = strlen(msg);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&emsgs_lock, flags);
|
|
|
|
|
|
|
|
em = emsgs + emsgs_tail_idx;
|
|
|
|
if ((em->flags & EMFL_VALID)) {
|
|
|
|
bail: spin_unlock_irqrestore(&emsgs_lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
mp = kmalloc(n, GFP_ATOMIC);
|
|
|
|
if (mp == NULL) {
|
2006-09-20 12:36:51 -06:00
|
|
|
printk(KERN_ERR "aoe: allocation failure, len=%ld\n", n);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto bail;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(mp, msg, n);
|
|
|
|
em->msg = mp;
|
|
|
|
em->flags |= EMFL_VALID;
|
|
|
|
em->len = n;
|
|
|
|
|
|
|
|
emsgs_tail_idx++;
|
|
|
|
emsgs_tail_idx %= ARRAY_SIZE(emsgs);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
|
|
|
|
|
|
|
if (nblocked_emsgs_readers)
|
|
|
|
up(&emsgs_sema);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
aoechr_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offp)
|
|
|
|
{
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
switch ((unsigned long) filp->private_data) {
|
|
|
|
default:
|
2006-09-20 12:36:51 -06:00
|
|
|
printk(KERN_INFO "aoe: can't write to that file.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case MINOR_DISCOVER:
|
|
|
|
ret = discover();
|
|
|
|
break;
|
|
|
|
case MINOR_INTERFACES:
|
|
|
|
ret = interfaces(buf, cnt);
|
|
|
|
break;
|
2006-01-19 11:46:19 -07:00
|
|
|
case MINOR_REVALIDATE:
|
|
|
|
ret = revalidate(buf, cnt);
|
2008-02-08 05:20:03 -07:00
|
|
|
break;
|
|
|
|
case MINOR_FLUSH:
|
|
|
|
ret = aoedev_flush(buf, cnt);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
if (ret == 0)
|
|
|
|
ret = cnt;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
aoechr_open(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
int n, i;
|
|
|
|
|
2006-07-10 05:45:32 -06:00
|
|
|
n = iminor(inode);
|
2005-04-16 16:20:36 -06:00
|
|
|
filp->private_data = (void *) (unsigned long) n;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
|
|
|
|
if (chardevs[i].minor == n)
|
|
|
|
return 0;
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
aoechr_rel(struct inode *inode, struct file *filp)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t
|
|
|
|
aoechr_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
|
|
|
|
{
|
|
|
|
unsigned long n;
|
|
|
|
char *mp;
|
|
|
|
struct ErrMsg *em;
|
|
|
|
ssize_t len;
|
|
|
|
ulong flags;
|
|
|
|
|
|
|
|
n = (unsigned long) filp->private_data;
|
2008-02-08 05:20:03 -07:00
|
|
|
if (n != MINOR_ERR)
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&emsgs_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
for (;;) {
|
|
|
|
em = emsgs + emsgs_head_idx;
|
|
|
|
if ((em->flags & EMFL_VALID) != 0)
|
|
|
|
break;
|
|
|
|
if (filp->f_flags & O_NDELAY) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
2008-02-08 05:20:03 -07:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
nblocked_emsgs_readers++;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
n = down_interruptible(&emsgs_sema);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
spin_lock_irqsave(&emsgs_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
nblocked_emsgs_readers--;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
if (n) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
2008-02-08 05:20:03 -07:00
|
|
|
return -ERESTARTSYS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-02-08 05:20:03 -07:00
|
|
|
}
|
|
|
|
if (em->len > cnt) {
|
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
mp = em->msg;
|
|
|
|
len = em->len;
|
|
|
|
em->msg = NULL;
|
|
|
|
em->flags &= ~EMFL_VALID;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
emsgs_head_idx++;
|
|
|
|
emsgs_head_idx %= ARRAY_SIZE(emsgs);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
spin_unlock_irqrestore(&emsgs_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-02-08 05:20:03 -07:00
|
|
|
n = copy_to_user(buf, mp, len);
|
|
|
|
kfree(mp);
|
|
|
|
return n == 0 ? len : -EFAULT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:32 -07:00
|
|
|
static const struct file_operations aoe_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.write = aoechr_write,
|
|
|
|
.read = aoechr_read,
|
|
|
|
.open = aoechr_open,
|
|
|
|
.release = aoechr_rel,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
int __init
|
|
|
|
aoechr_init(void)
|
|
|
|
{
|
|
|
|
int n, i;
|
|
|
|
|
|
|
|
n = register_chrdev(AOE_MAJOR, "aoechr", &aoe_fops);
|
|
|
|
if (n < 0) {
|
2006-09-20 12:36:51 -06:00
|
|
|
printk(KERN_ERR "aoe: can't register char device\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
sema_init(&emsgs_sema, 0);
|
|
|
|
spin_lock_init(&emsgs_lock);
|
2005-03-23 10:52:10 -07:00
|
|
|
aoe_class = class_create(THIS_MODULE, "aoe");
|
2005-04-16 16:20:36 -06:00
|
|
|
if (IS_ERR(aoe_class)) {
|
|
|
|
unregister_chrdev(AOE_MAJOR, "aoechr");
|
|
|
|
return PTR_ERR(aoe_class);
|
|
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
|
2007-09-24 18:03:03 -06:00
|
|
|
device_create(aoe_class, NULL,
|
|
|
|
MKDEV(AOE_MAJOR, chardevs[i].minor), chardevs[i].name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
aoechr_exit(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
|
2007-09-24 18:03:03 -06:00
|
|
|
device_destroy(aoe_class, MKDEV(AOE_MAJOR, chardevs[i].minor));
|
2005-03-23 10:52:10 -07:00
|
|
|
class_destroy(aoe_class);
|
2005-04-16 16:20:36 -06:00
|
|
|
unregister_chrdev(AOE_MAJOR, "aoechr");
|
|
|
|
}
|
|
|
|
|