/drivers/block/aoe/aoechr.c

https://bitbucket.org/cresqo/cm7-p500-kernel · C · 312 lines · 255 code · 47 blank · 10 comment · 32 complexity · 98ea00d2d03001f150495b5d8bef8dee MD5 · raw file

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