4 * Linux device interface for the IPMI message handler.
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
10 * Copyright 2002 MontaVista Software Inc.
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <linux/config.h>
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/errno.h>
38 #include <asm/system.h>
39 #include <linux/sched.h>
40 #include <linux/poll.h>
41 #include <linux/spinlock.h>
42 #include <linux/slab.h>
43 #include <linux/ipmi.h>
44 #include <linux/mutex.h>
45 #include <linux/init.h>
46 #include <linux/device.h>
47 #include <linux/compat.h>
49 struct ipmi_file_private
52 spinlock_t recv_msg_lock;
53 struct list_head recv_msgs;
55 struct fasync_struct *fasync_queue;
56 wait_queue_head_t wait;
57 struct mutex recv_mutex;
59 unsigned int default_retry_time_ms;
62 static void file_receive_handler(struct ipmi_recv_msg *msg,
65 struct ipmi_file_private *priv = handler_data;
69 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
71 was_empty = list_empty(&(priv->recv_msgs));
72 list_add_tail(&(msg->link), &(priv->recv_msgs));
75 wake_up_interruptible(&priv->wait);
76 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
79 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
82 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
84 struct ipmi_file_private *priv = file->private_data;
85 unsigned int mask = 0;
88 poll_wait(file, &priv->wait, wait);
90 spin_lock_irqsave(&priv->recv_msg_lock, flags);
92 if (!list_empty(&(priv->recv_msgs)))
93 mask |= (POLLIN | POLLRDNORM);
95 spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
100 static int ipmi_fasync(int fd, struct file *file, int on)
102 struct ipmi_file_private *priv = file->private_data;
105 result = fasync_helper(fd, file, on, &priv->fasync_queue);
110 static struct ipmi_user_hndl ipmi_hndlrs =
112 .ipmi_recv_hndl = file_receive_handler,
115 static int ipmi_open(struct inode *inode, struct file *file)
117 int if_num = iminor(inode);
119 struct ipmi_file_private *priv;
122 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
128 rv = ipmi_create_user(if_num,
137 file->private_data = priv;
139 spin_lock_init(&(priv->recv_msg_lock));
140 INIT_LIST_HEAD(&(priv->recv_msgs));
141 init_waitqueue_head(&priv->wait);
142 priv->fasync_queue = NULL;
143 mutex_init(&priv->recv_mutex);
145 /* Use the low-level defaults. */
146 priv->default_retries = -1;
147 priv->default_retry_time_ms = 0;
152 static int ipmi_release(struct inode *inode, struct file *file)
154 struct ipmi_file_private *priv = file->private_data;
157 rv = ipmi_destroy_user(priv->user);
161 ipmi_fasync (-1, file, 0);
163 /* FIXME - free the messages in the list. */
169 static int handle_send_req(ipmi_user_t user,
170 struct ipmi_req *req,
172 unsigned int retry_time_ms)
175 struct ipmi_addr addr;
176 struct kernel_ipmi_msg msg;
178 if (req->addr_len > sizeof(struct ipmi_addr))
181 if (copy_from_user(&addr, req->addr, req->addr_len))
184 msg.netfn = req->msg.netfn;
185 msg.cmd = req->msg.cmd;
186 msg.data_len = req->msg.data_len;
187 msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
191 /* From here out we cannot return, we must jump to "out" for
192 error exits to free msgdata. */
194 rv = ipmi_validate_addr(&addr, req->addr_len);
198 if (req->msg.data != NULL) {
199 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
204 if (copy_from_user(msg.data,
215 rv = ipmi_request_settime(user,
228 static int ipmi_ioctl(struct inode *inode,
234 struct ipmi_file_private *priv = file->private_data;
235 void __user *arg = (void __user *)data;
239 case IPMICTL_SEND_COMMAND:
243 if (copy_from_user(&req, arg, sizeof(req))) {
248 rv = handle_send_req(priv->user,
250 priv->default_retries,
251 priv->default_retry_time_ms);
255 case IPMICTL_SEND_COMMAND_SETTIME:
257 struct ipmi_req_settime req;
259 if (copy_from_user(&req, arg, sizeof(req))) {
264 rv = handle_send_req(priv->user,
271 case IPMICTL_RECEIVE_MSG:
272 case IPMICTL_RECEIVE_MSG_TRUNC:
274 struct ipmi_recv rsp;
276 struct list_head *entry;
277 struct ipmi_recv_msg *msg;
282 if (copy_from_user(&rsp, arg, sizeof(rsp))) {
287 /* We claim a mutex because we don't want two
288 users getting something from the queue at a time.
289 Since we have to release the spinlock before we can
290 copy the data to the user, it's possible another
291 user will grab something from the queue, too. Then
292 the messages might get out of order if something
293 fails and the message gets put back onto the
294 queue. This mutex prevents that problem. */
295 mutex_lock(&priv->recv_mutex);
297 /* Grab the message off the list. */
298 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
299 if (list_empty(&(priv->recv_msgs))) {
300 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
304 entry = priv->recv_msgs.next;
305 msg = list_entry(entry, struct ipmi_recv_msg, link);
307 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
309 addr_len = ipmi_addr_length(msg->addr.addr_type);
310 if (rsp.addr_len < addr_len)
313 goto recv_putback_on_err;
316 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
318 goto recv_putback_on_err;
320 rsp.addr_len = addr_len;
322 rsp.recv_type = msg->recv_type;
323 rsp.msgid = msg->msgid;
324 rsp.msg.netfn = msg->msg.netfn;
325 rsp.msg.cmd = msg->msg.cmd;
327 if (msg->msg.data_len > 0) {
328 if (rsp.msg.data_len < msg->msg.data_len) {
330 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
331 msg->msg.data_len = rsp.msg.data_len;
333 goto recv_putback_on_err;
337 if (copy_to_user(rsp.msg.data,
342 goto recv_putback_on_err;
344 rsp.msg.data_len = msg->msg.data_len;
346 rsp.msg.data_len = 0;
349 if (copy_to_user(arg, &rsp, sizeof(rsp))) {
351 goto recv_putback_on_err;
354 mutex_unlock(&priv->recv_mutex);
355 ipmi_free_recv_msg(msg);
359 /* If we got an error, put the message back onto
360 the head of the queue. */
361 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
362 list_add(entry, &(priv->recv_msgs));
363 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
364 mutex_unlock(&priv->recv_mutex);
368 mutex_unlock(&priv->recv_mutex);
372 case IPMICTL_REGISTER_FOR_CMD:
374 struct ipmi_cmdspec val;
376 if (copy_from_user(&val, arg, sizeof(val))) {
381 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
385 case IPMICTL_UNREGISTER_FOR_CMD:
387 struct ipmi_cmdspec val;
389 if (copy_from_user(&val, arg, sizeof(val))) {
394 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
398 case IPMICTL_SET_GETS_EVENTS_CMD:
402 if (copy_from_user(&val, arg, sizeof(val))) {
407 rv = ipmi_set_gets_events(priv->user, val);
411 /* The next four are legacy, not per-channel. */
412 case IPMICTL_SET_MY_ADDRESS_CMD:
416 if (copy_from_user(&val, arg, sizeof(val))) {
421 rv = ipmi_set_my_address(priv->user, 0, val);
425 case IPMICTL_GET_MY_ADDRESS_CMD:
430 rv = ipmi_get_my_address(priv->user, 0, &rval);
436 if (copy_to_user(arg, &val, sizeof(val))) {
443 case IPMICTL_SET_MY_LUN_CMD:
447 if (copy_from_user(&val, arg, sizeof(val))) {
452 rv = ipmi_set_my_LUN(priv->user, 0, val);
456 case IPMICTL_GET_MY_LUN_CMD:
461 rv = ipmi_get_my_LUN(priv->user, 0, &rval);
467 if (copy_to_user(arg, &val, sizeof(val))) {
474 case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD:
476 struct ipmi_channel_lun_address_set val;
478 if (copy_from_user(&val, arg, sizeof(val))) {
483 return ipmi_set_my_address(priv->user, val.channel, val.value);
487 case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD:
489 struct ipmi_channel_lun_address_set val;
491 if (copy_from_user(&val, arg, sizeof(val))) {
496 rv = ipmi_get_my_address(priv->user, val.channel, &val.value);
500 if (copy_to_user(arg, &val, sizeof(val))) {
507 case IPMICTL_SET_MY_CHANNEL_LUN_CMD:
509 struct ipmi_channel_lun_address_set val;
511 if (copy_from_user(&val, arg, sizeof(val))) {
516 rv = ipmi_set_my_LUN(priv->user, val.channel, val.value);
520 case IPMICTL_GET_MY_CHANNEL_LUN_CMD:
522 struct ipmi_channel_lun_address_set val;
524 if (copy_from_user(&val, arg, sizeof(val))) {
529 rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value);
533 if (copy_to_user(arg, &val, sizeof(val))) {
540 case IPMICTL_SET_TIMING_PARMS_CMD:
542 struct ipmi_timing_parms parms;
544 if (copy_from_user(&parms, arg, sizeof(parms))) {
549 priv->default_retries = parms.retries;
550 priv->default_retry_time_ms = parms.retry_time_ms;
555 case IPMICTL_GET_TIMING_PARMS_CMD:
557 struct ipmi_timing_parms parms;
559 parms.retries = priv->default_retries;
560 parms.retry_time_ms = priv->default_retry_time_ms;
562 if (copy_to_user(arg, &parms, sizeof(parms))) {
578 * The following code contains code for supporting 32-bit compatible
579 * ioctls on 64-bit kernels. This allows running 32-bit apps on the
582 #define COMPAT_IPMICTL_SEND_COMMAND \
583 _IOR(IPMI_IOC_MAGIC, 13, struct compat_ipmi_req)
584 #define COMPAT_IPMICTL_SEND_COMMAND_SETTIME \
585 _IOR(IPMI_IOC_MAGIC, 21, struct compat_ipmi_req_settime)
586 #define COMPAT_IPMICTL_RECEIVE_MSG \
587 _IOWR(IPMI_IOC_MAGIC, 12, struct compat_ipmi_recv)
588 #define COMPAT_IPMICTL_RECEIVE_MSG_TRUNC \
589 _IOWR(IPMI_IOC_MAGIC, 11, struct compat_ipmi_recv)
591 struct compat_ipmi_msg {
598 struct compat_ipmi_req {
600 compat_uint_t addr_len;
602 struct compat_ipmi_msg msg;
605 struct compat_ipmi_recv {
606 compat_int_t recv_type;
608 compat_uint_t addr_len;
610 struct compat_ipmi_msg msg;
613 struct compat_ipmi_req_settime {
614 struct compat_ipmi_req req;
615 compat_int_t retries;
616 compat_uint_t retry_time_ms;
620 * Define some helper functions for copying IPMI data
622 static long get_compat_ipmi_msg(struct ipmi_msg *p64,
623 struct compat_ipmi_msg __user *p32)
627 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
628 __get_user(p64->netfn, &p32->netfn) ||
629 __get_user(p64->cmd, &p32->cmd) ||
630 __get_user(p64->data_len, &p32->data_len) ||
631 __get_user(tmp, &p32->data))
633 p64->data = compat_ptr(tmp);
637 static long put_compat_ipmi_msg(struct ipmi_msg *p64,
638 struct compat_ipmi_msg __user *p32)
640 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
641 __put_user(p64->netfn, &p32->netfn) ||
642 __put_user(p64->cmd, &p32->cmd) ||
643 __put_user(p64->data_len, &p32->data_len))
648 static long get_compat_ipmi_req(struct ipmi_req *p64,
649 struct compat_ipmi_req __user *p32)
654 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
655 __get_user(tmp, &p32->addr) ||
656 __get_user(p64->addr_len, &p32->addr_len) ||
657 __get_user(p64->msgid, &p32->msgid) ||
658 get_compat_ipmi_msg(&p64->msg, &p32->msg))
660 p64->addr = compat_ptr(tmp);
664 static long get_compat_ipmi_req_settime(struct ipmi_req_settime *p64,
665 struct compat_ipmi_req_settime __user *p32)
667 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
668 get_compat_ipmi_req(&p64->req, &p32->req) ||
669 __get_user(p64->retries, &p32->retries) ||
670 __get_user(p64->retry_time_ms, &p32->retry_time_ms))
675 static long get_compat_ipmi_recv(struct ipmi_recv *p64,
676 struct compat_ipmi_recv __user *p32)
680 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
681 __get_user(p64->recv_type, &p32->recv_type) ||
682 __get_user(tmp, &p32->addr) ||
683 __get_user(p64->addr_len, &p32->addr_len) ||
684 __get_user(p64->msgid, &p32->msgid) ||
685 get_compat_ipmi_msg(&p64->msg, &p32->msg))
687 p64->addr = compat_ptr(tmp);
691 static long put_compat_ipmi_recv(struct ipmi_recv *p64,
692 struct compat_ipmi_recv __user *p32)
694 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
695 __put_user(p64->recv_type, &p32->recv_type) ||
696 __put_user(p64->addr_len, &p32->addr_len) ||
697 __put_user(p64->msgid, &p32->msgid) ||
698 put_compat_ipmi_msg(&p64->msg, &p32->msg))
704 * Handle compatibility ioctls
706 static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
710 struct ipmi_file_private *priv = filep->private_data;
713 case COMPAT_IPMICTL_SEND_COMMAND:
717 if (get_compat_ipmi_req(&rp, compat_ptr(arg)))
720 return handle_send_req(priv->user, &rp,
721 priv->default_retries,
722 priv->default_retry_time_ms);
724 case COMPAT_IPMICTL_SEND_COMMAND_SETTIME:
726 struct ipmi_req_settime sp;
728 if (get_compat_ipmi_req_settime(&sp, compat_ptr(arg)))
731 return handle_send_req(priv->user, &sp.req,
732 sp.retries, sp.retry_time_ms);
734 case COMPAT_IPMICTL_RECEIVE_MSG:
735 case COMPAT_IPMICTL_RECEIVE_MSG_TRUNC:
737 struct ipmi_recv __user *precv64;
738 struct ipmi_recv recv64;
740 if (get_compat_ipmi_recv(&recv64, compat_ptr(arg)))
743 precv64 = compat_alloc_user_space(sizeof(recv64));
744 if (copy_to_user(precv64, &recv64, sizeof(recv64)))
747 rc = ipmi_ioctl(filep->f_dentry->d_inode, filep,
748 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
749 ? IPMICTL_RECEIVE_MSG
750 : IPMICTL_RECEIVE_MSG_TRUNC),
751 (unsigned long) precv64);
755 if (copy_from_user(&recv64, precv64, sizeof(recv64)))
758 if (put_compat_ipmi_recv(&recv64, compat_ptr(arg)))
764 return ipmi_ioctl(filep->f_dentry->d_inode, filep, cmd, arg);
769 static struct file_operations ipmi_fops = {
770 .owner = THIS_MODULE,
773 .compat_ioctl = compat_ipmi_ioctl,
776 .release = ipmi_release,
777 .fasync = ipmi_fasync,
781 #define DEVICE_NAME "ipmidev"
783 static int ipmi_major = 0;
784 module_param(ipmi_major, int, 0);
785 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
786 " default, or if you set it to zero, it will choose the next"
787 " available device. Setting it to -1 will disable the"
788 " interface. Other values will set the major device number"
791 /* Keep track of the devices that are registered. */
792 struct ipmi_reg_list {
794 struct list_head link;
796 static LIST_HEAD(reg_list);
797 static DEFINE_MUTEX(reg_list_mutex);
799 static struct class *ipmi_class;
801 static void ipmi_new_smi(int if_num, struct device *device)
803 dev_t dev = MKDEV(ipmi_major, if_num);
804 struct ipmi_reg_list *entry;
806 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
808 printk(KERN_ERR "ipmi_devintf: Unable to create the"
809 " ipmi class device link\n");
814 mutex_lock(®_list_mutex);
815 class_device_create(ipmi_class, NULL, dev, device, "ipmi%d", if_num);
816 list_add(&entry->link, ®_list);
817 mutex_unlock(®_list_mutex);
820 static void ipmi_smi_gone(int if_num)
822 dev_t dev = MKDEV(ipmi_major, if_num);
823 struct ipmi_reg_list *entry;
825 mutex_lock(®_list_mutex);
826 list_for_each_entry(entry, ®_list, link) {
827 if (entry->dev == dev) {
828 list_del(&entry->link);
833 class_device_destroy(ipmi_class, dev);
834 mutex_unlock(®_list_mutex);
837 static struct ipmi_smi_watcher smi_watcher =
839 .owner = THIS_MODULE,
840 .new_smi = ipmi_new_smi,
841 .smi_gone = ipmi_smi_gone,
844 static __init int init_ipmi_devintf(void)
851 printk(KERN_INFO "ipmi device interface\n");
853 ipmi_class = class_create(THIS_MODULE, "ipmi");
854 if (IS_ERR(ipmi_class)) {
855 printk(KERN_ERR "ipmi: can't register device class\n");
856 return PTR_ERR(ipmi_class);
859 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
861 class_destroy(ipmi_class);
862 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
866 if (ipmi_major == 0) {
870 rv = ipmi_smi_watcher_register(&smi_watcher);
872 unregister_chrdev(ipmi_major, DEVICE_NAME);
873 class_destroy(ipmi_class);
874 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
880 module_init(init_ipmi_devintf);
882 static __exit void cleanup_ipmi(void)
884 struct ipmi_reg_list *entry, *entry2;
885 mutex_lock(®_list_mutex);
886 list_for_each_entry_safe(entry, entry2, ®_list, link) {
887 list_del(&entry->link);
888 class_device_destroy(ipmi_class, entry->dev);
891 mutex_unlock(®_list_mutex);
892 class_destroy(ipmi_class);
893 ipmi_smi_watcher_unregister(&smi_watcher);
894 unregister_chrdev(ipmi_major, DEVICE_NAME);
896 module_exit(cleanup_ipmi);
898 MODULE_LICENSE("GPL");
899 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
900 MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");