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