drivers/block/aoe/aoechr.c

   1 /* Copyright (c) 2007 Coraid, Inc.  See COPYING for GPL terms. */
   2 /*
   3  * aoechr.c
   4  * AoE character device driver
   5  */
   6
   7 #include <linux/hdreg.h>
   8 #include <linux/blkdev.h>
   9 #include <linux/completion.h>
  10 #include <linux/delay.h>
  11 #include <linux/smp_lock.h>
  12 #include <linux/skbuff.h>
  13 #include "aoe.h"
  14
  15 enum {
  16         //MINOR_STAT = 1, (moved to sysfs)
  17         MINOR_ERR = 2,
  18         MINOR_DISCOVER,
  19         MINOR_INTERFACES,
  20         MINOR_REVALIDATE,
  21         MINOR_FLUSH,
  22         MSGSZ = 2048,
  23         NMSG = 100,             /* message backlog to retain */
  24 };
  25
  26 struct aoe_chardev {
  27         ulong minor;
  28         char name[32];
  29 };
  30
  31 enum { EMFL_VALID = 1 };
  32
  33 struct ErrMsg {
  34         short flags;
  35         short len;
  36         char *msg;
  37 };
  38
  39 static struct ErrMsg emsgs[NMSG];
  40 static int emsgs_head_idx, emsgs_tail_idx;
  41 static struct completion emsgs_comp;
  42 static spinlock_t emsgs_lock;
  43 static int nblocked_emsgs_readers;
  44 static struct class *aoe_class;
  45 static struct aoe_chardev chardevs[] = {
  46         { MINOR_ERR, "err" },
  47         { MINOR_DISCOVER, "discover" },
  48         { MINOR_INTERFACES, "interfaces" },
  49         { MINOR_REVALIDATE, "revalidate" },
  50         { MINOR_FLUSH, "flush" },
  51 };
  52
  53 static int
  54 discover(void)
  55 {
  56         aoecmd_cfg(0xffff, 0xff);
  57         return 0;
  58 }
  59
  60 static int
  61 interfaces(const char __user *str, size_t size)
  62 {
  63         if (set_aoe_iflist(str, size)) {
  64                 printk(KERN_ERR
  65                         "aoe: could not set interface list: too many interfaces\n");
  66                 return -EINVAL;
  67         }
  68         return 0;
  69 }
  70
  71 static int
  72 revalidate(const char __user *str, size_t size)
  73 {
  74         int major, minor, n;
  75         ulong flags;
  76         struct aoedev *d;
  77         struct sk_buff *skb;
  78         char buf[16];
  79
  80         if (size >= sizeof buf)
  81                 return -EINVAL;
  82         buf[sizeof buf - 1] = '\0';
  83         if (copy_from_user(buf, str, size))
  84                 return -EFAULT;
  85
  86         /* should be e%d.%d format */
  87         n = sscanf(buf, "e%d.%d", &major, &minor);
  88         if (n != 2) {
  89                 printk(KERN_ERR "aoe: invalid device specification\n");
  90                 return -EINVAL;
  91         }
  92         d = aoedev_by_aoeaddr(major, minor);
  93         if (!d)
  94                 return -EINVAL;
  95         spin_lock_irqsave(&d->lock, flags);
  96         aoecmd_cleanslate(d);
  97 loop:
  98         skb = aoecmd_ata_id(d);
  99         spin_unlock_irqrestore(&d->lock, flags);
 100         /* try again if we are able to sleep a bit,
 101          * otherwise give up this revalidation
 102          */
 103         if (!skb && !msleep_interruptible(200)) {
 104                 spin_lock_irqsave(&d->lock, flags);
 105                 goto loop;
 106         }
 107         if (skb) {
 108                 struct sk_buff_head queue;
 109                 __skb_queue_head_init(&queue);
 110                 __skb_queue_tail(&queue, skb);
 111                 aoenet_xmit(&queue);
 112         }
 113         aoecmd_cfg(major, minor);
 114         return 0;
 115 }
 116
 117 void
 118 aoechr_error(char *msg)
 119 {
 120         struct ErrMsg *em;
 121         char *mp;
 122         ulong flags, n;
 123
 124         n = strlen(msg);
 125
 126         spin_lock_irqsave(&emsgs_lock, flags);
 127
 128         em = emsgs + emsgs_tail_idx;
 129         if ((em->flags & EMFL_VALID)) {
 130 bail:           spin_unlock_irqrestore(&emsgs_lock, flags);
 131                 return;
 132         }
 133
 134         mp = kmalloc(n, GFP_ATOMIC);
 135         if (mp == NULL) {
 136                 printk(KERN_ERR "aoe: allocation failure, len=%ld\n", n);
 137                 goto bail;
 138         }
 139
 140         memcpy(mp, msg, n);
 141         em->msg = mp;
 142         em->flags |= EMFL_VALID;
 143         em->len = n;
 144
 145         emsgs_tail_idx++;
 146         emsgs_tail_idx %= ARRAY_SIZE(emsgs);
 147
 148         spin_unlock_irqrestore(&emsgs_lock, flags);
 149
 150         if (nblocked_emsgs_readers)
 151                 complete(&emsgs_comp);
 152 }
 153
 154 static ssize_t
 155 aoechr_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offp)
 156 {
 157         int ret = -EINVAL;
 158
 159         switch ((unsigned long) filp->private_data) {
 160         default:
 161                 printk(KERN_INFO "aoe: can't write to that file.\n");
 162                 break;
 163         case MINOR_DISCOVER:
 164                 ret = discover();
 165                 break;
 166         case MINOR_INTERFACES:
 167                 ret = interfaces(buf, cnt);
 168                 break;
 169         case MINOR_REVALIDATE:
 170                 ret = revalidate(buf, cnt);
 171                 break;
 172         case MINOR_FLUSH:
 173                 ret = aoedev_flush(buf, cnt);
 174         }
 175         if (ret == 0)
 176                 ret = cnt;
 177         return ret;
 178 }
 179
 180 static int
 181 aoechr_open(struct inode *inode, struct file *filp)
 182 {
 183         int n, i;
 184
 185         lock_kernel();
 186         n = iminor(inode);
 187         filp->private_data = (void *) (unsigned long) n;
 188
 189         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
 190                 if (chardevs[i].minor == n) {
 191                         unlock_kernel();
 192                         return 0;
 193                 }
 194         unlock_kernel();
 195         return -EINVAL;
 196 }
 197
 198 static int
 199 aoechr_rel(struct inode *inode, struct file *filp)
 200 {
 201         return 0;
 202 }
 203
 204 static ssize_t
 205 aoechr_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)
 206 {
 207         unsigned long n;
 208         char *mp;
 209         struct ErrMsg *em;
 210         ssize_t len;
 211         ulong flags;
 212
 213         n = (unsigned long) filp->private_data;
 214         if (n != MINOR_ERR)
 215                 return -EFAULT;
 216
 217         spin_lock_irqsave(&emsgs_lock, flags);
 218
 219         for (;;) {
 220                 em = emsgs + emsgs_head_idx;
 221                 if ((em->flags & EMFL_VALID) != 0)
 222                         break;
 223                 if (filp->f_flags & O_NDELAY) {
 224                         spin_unlock_irqrestore(&emsgs_lock, flags);
 225                         return -EAGAIN;
 226                 }
 227                 nblocked_emsgs_readers++;
 228
 229                 spin_unlock_irqrestore(&emsgs_lock, flags);
 230
 231                 n = wait_for_completion_interruptible(&emsgs_comp);
 232
 233                 spin_lock_irqsave(&emsgs_lock, flags);
 234
 235                 nblocked_emsgs_readers--;
 236
 237                 if (n) {
 238                         spin_unlock_irqrestore(&emsgs_lock, flags);
 239                         return -ERESTARTSYS;
 240                 }
 241         }
 242         if (em->len > cnt) {
 243                 spin_unlock_irqrestore(&emsgs_lock, flags);
 244                 return -EAGAIN;
 245         }
 246         mp = em->msg;
 247         len = em->len;
 248         em->msg = NULL;
 249         em->flags &= ~EMFL_VALID;
 250
 251         emsgs_head_idx++;
 252         emsgs_head_idx %= ARRAY_SIZE(emsgs);
 253
 254         spin_unlock_irqrestore(&emsgs_lock, flags);
 255
 256         n = copy_to_user(buf, mp, len);
 257         kfree(mp);
 258         return n == 0 ? len : -EFAULT;
 259 }
 260
 261 static const struct file_operations aoe_fops = {
 262         .write = aoechr_write,
 263         .read = aoechr_read,
 264         .open = aoechr_open,
 265         .release = aoechr_rel,
 266         .owner = THIS_MODULE,
 267 };
 268
 269 static char *aoe_devnode(struct device *dev, mode_t *mode)
 270 {
 271         return kasprintf(GFP_KERNEL, "etherd/%s", dev_name(dev));
 272 }
 273
 274 int __init
 275 aoechr_init(void)
 276 {
 277         int n, i;
 278
 279         n = register_chrdev(AOE_MAJOR, "aoechr", &aoe_fops);
 280         if (n < 0) {
 281                 printk(KERN_ERR "aoe: can't register char device\n");
 282                 return n;
 283         }
 284         init_completion(&emsgs_comp);
 285         spin_lock_init(&emsgs_lock);
 286         aoe_class = class_create(THIS_MODULE, "aoe");
 287         if (IS_ERR(aoe_class)) {
 288                 unregister_chrdev(AOE_MAJOR, "aoechr");
 289                 return PTR_ERR(aoe_class);
 290         }
 291         aoe_class->devnode = aoe_devnode;
 292
 293         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
 294                 device_create(aoe_class, NULL,
 295                               MKDEV(AOE_MAJOR, chardevs[i].minor), NULL,
 296                               chardevs[i].name);
 297
 298         return 0;
 299 }
 300
 301 void
 302 aoechr_exit(void)
 303 {
 304         int i;
 305
 306         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
 307                 device_destroy(aoe_class, MKDEV(AOE_MAJOR, chardevs[i].minor));
 308         class_destroy(aoe_class);
 309         unregister_chrdev(AOE_MAJOR, "aoechr");
 310 }
 311