Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / 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