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/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/errno.h>
37 #include <asm/system.h>
38 #include <linux/poll.h>
39 #include <linux/sched.h>
40 #include <linux/spinlock.h>
41 #include <linux/slab.h>
42 #include <linux/ipmi.h>
43 #include <linux/mutex.h>
44 #include <linux/init.h>
45 #include <linux/device.h>
46 #include <linux/compat.h>
48 struct ipmi_file_private
51 spinlock_t recv_msg_lock;
52 struct list_head recv_msgs;
54 struct fasync_struct *fasync_queue;
55 wait_queue_head_t wait;
56 struct mutex recv_mutex;
58 unsigned int default_retry_time_ms;
61 static DEFINE_MUTEX(ipmi_mutex);
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 mutex_lock(&ipmi_mutex); /* could race against open() otherwise */
106 result = fasync_helper(fd, file, on, &priv->fasync_queue);
107 mutex_unlock(&ipmi_mutex);
112 static struct ipmi_user_hndl ipmi_hndlrs =
114 .ipmi_recv_hndl = file_receive_handler,
117 static int ipmi_open(struct inode *inode, struct file *file)
119 int if_num = iminor(inode);
121 struct ipmi_file_private *priv;
124 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
128 mutex_lock(&ipmi_mutex);
131 rv = ipmi_create_user(if_num,
140 file->private_data = priv;
142 spin_lock_init(&(priv->recv_msg_lock));
143 INIT_LIST_HEAD(&(priv->recv_msgs));
144 init_waitqueue_head(&priv->wait);
145 priv->fasync_queue = NULL;
146 mutex_init(&priv->recv_mutex);
148 /* Use the low-level defaults. */
149 priv->default_retries = -1;
150 priv->default_retry_time_ms = 0;
153 mutex_unlock(&ipmi_mutex);
157 static int ipmi_release(struct inode *inode, struct file *file)
159 struct ipmi_file_private *priv = file->private_data;
162 rv = ipmi_destroy_user(priv->user);
166 /* FIXME - free the messages in the list. */
172 static int handle_send_req(ipmi_user_t user,
173 struct ipmi_req *req,
175 unsigned int retry_time_ms)
178 struct ipmi_addr addr;
179 struct kernel_ipmi_msg msg;
181 if (req->addr_len > sizeof(struct ipmi_addr))
184 if (copy_from_user(&addr, req->addr, req->addr_len))
187 msg.netfn = req->msg.netfn;
188 msg.cmd = req->msg.cmd;
189 msg.data_len = req->msg.data_len;
190 msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
194 /* From here out we cannot return, we must jump to "out" for
195 error exits to free msgdata. */
197 rv = ipmi_validate_addr(&addr, req->addr_len);
201 if (req->msg.data != NULL) {
202 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
207 if (copy_from_user(msg.data,
218 rv = ipmi_request_settime(user,
231 static int ipmi_ioctl(struct file *file,
236 struct ipmi_file_private *priv = file->private_data;
237 void __user *arg = (void __user *)data;
241 case IPMICTL_SEND_COMMAND:
245 if (copy_from_user(&req, arg, sizeof(req))) {
250 rv = handle_send_req(priv->user,
252 priv->default_retries,
253 priv->default_retry_time_ms);
257 case IPMICTL_SEND_COMMAND_SETTIME:
259 struct ipmi_req_settime req;
261 if (copy_from_user(&req, arg, sizeof(req))) {
266 rv = handle_send_req(priv->user,
273 case IPMICTL_RECEIVE_MSG:
274 case IPMICTL_RECEIVE_MSG_TRUNC:
276 struct ipmi_recv rsp;
278 struct list_head *entry;
279 struct ipmi_recv_msg *msg;
284 if (copy_from_user(&rsp, arg, sizeof(rsp))) {
289 /* We claim a mutex because we don't want two
290 users getting something from the queue at a time.
291 Since we have to release the spinlock before we can
292 copy the data to the user, it's possible another
293 user will grab something from the queue, too. Then
294 the messages might get out of order if something
295 fails and the message gets put back onto the
296 queue. This mutex prevents that problem. */
297 mutex_lock(&priv->recv_mutex);
299 /* Grab the message off the list. */
300 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
301 if (list_empty(&(priv->recv_msgs))) {
302 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
306 entry = priv->recv_msgs.next;
307 msg = list_entry(entry, struct ipmi_recv_msg, link);
309 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
311 addr_len = ipmi_addr_length(msg->addr.addr_type);
312 if (rsp.addr_len < addr_len)
315 goto recv_putback_on_err;
318 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
320 goto recv_putback_on_err;
322 rsp.addr_len = addr_len;
324 rsp.recv_type = msg->recv_type;
325 rsp.msgid = msg->msgid;
326 rsp.msg.netfn = msg->msg.netfn;
327 rsp.msg.cmd = msg->msg.cmd;
329 if (msg->msg.data_len > 0) {
330 if (rsp.msg.data_len < msg->msg.data_len) {
332 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
333 msg->msg.data_len = rsp.msg.data_len;
335 goto recv_putback_on_err;
339 if (copy_to_user(rsp.msg.data,
344 goto recv_putback_on_err;
346 rsp.msg.data_len = msg->msg.data_len;
348 rsp.msg.data_len = 0;
351 if (copy_to_user(arg, &rsp, sizeof(rsp))) {
353 goto recv_putback_on_err;
356 mutex_unlock(&priv->recv_mutex);
357 ipmi_free_recv_msg(msg);
361 /* If we got an error, put the message back onto
362 the head of the queue. */
363 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
364 list_add(entry, &(priv->recv_msgs));
365 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
366 mutex_unlock(&priv->recv_mutex);
370 mutex_unlock(&priv->recv_mutex);
374 case IPMICTL_REGISTER_FOR_CMD:
376 struct ipmi_cmdspec val;
378 if (copy_from_user(&val, arg, sizeof(val))) {
383 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
388 case IPMICTL_UNREGISTER_FOR_CMD:
390 struct ipmi_cmdspec val;
392 if (copy_from_user(&val, arg, sizeof(val))) {
397 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
402 case IPMICTL_REGISTER_FOR_CMD_CHANS:
404 struct ipmi_cmdspec_chans val;
406 if (copy_from_user(&val, arg, sizeof(val))) {
411 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
416 case IPMICTL_UNREGISTER_FOR_CMD_CHANS:
418 struct ipmi_cmdspec_chans val;
420 if (copy_from_user(&val, arg, sizeof(val))) {
425 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd,
430 case IPMICTL_SET_GETS_EVENTS_CMD:
434 if (copy_from_user(&val, arg, sizeof(val))) {
439 rv = ipmi_set_gets_events(priv->user, val);
443 /* The next four are legacy, not per-channel. */
444 case IPMICTL_SET_MY_ADDRESS_CMD:
448 if (copy_from_user(&val, arg, sizeof(val))) {
453 rv = ipmi_set_my_address(priv->user, 0, val);
457 case IPMICTL_GET_MY_ADDRESS_CMD:
462 rv = ipmi_get_my_address(priv->user, 0, &rval);
468 if (copy_to_user(arg, &val, sizeof(val))) {
475 case IPMICTL_SET_MY_LUN_CMD:
479 if (copy_from_user(&val, arg, sizeof(val))) {
484 rv = ipmi_set_my_LUN(priv->user, 0, val);
488 case IPMICTL_GET_MY_LUN_CMD:
493 rv = ipmi_get_my_LUN(priv->user, 0, &rval);
499 if (copy_to_user(arg, &val, sizeof(val))) {
506 case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD:
508 struct ipmi_channel_lun_address_set val;
510 if (copy_from_user(&val, arg, sizeof(val))) {
515 return ipmi_set_my_address(priv->user, val.channel, val.value);
519 case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD:
521 struct ipmi_channel_lun_address_set val;
523 if (copy_from_user(&val, arg, sizeof(val))) {
528 rv = ipmi_get_my_address(priv->user, val.channel, &val.value);
532 if (copy_to_user(arg, &val, sizeof(val))) {
539 case IPMICTL_SET_MY_CHANNEL_LUN_CMD:
541 struct ipmi_channel_lun_address_set val;
543 if (copy_from_user(&val, arg, sizeof(val))) {
548 rv = ipmi_set_my_LUN(priv->user, val.channel, val.value);
552 case IPMICTL_GET_MY_CHANNEL_LUN_CMD:
554 struct ipmi_channel_lun_address_set val;
556 if (copy_from_user(&val, arg, sizeof(val))) {
561 rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value);
565 if (copy_to_user(arg, &val, sizeof(val))) {
572 case IPMICTL_SET_TIMING_PARMS_CMD:
574 struct ipmi_timing_parms parms;
576 if (copy_from_user(&parms, arg, sizeof(parms))) {
581 priv->default_retries = parms.retries;
582 priv->default_retry_time_ms = parms.retry_time_ms;
587 case IPMICTL_GET_TIMING_PARMS_CMD:
589 struct ipmi_timing_parms parms;
591 parms.retries = priv->default_retries;
592 parms.retry_time_ms = priv->default_retry_time_ms;
594 if (copy_to_user(arg, &parms, sizeof(parms))) {
603 case IPMICTL_GET_MAINTENANCE_MODE_CMD:
607 mode = ipmi_get_maintenance_mode(priv->user);
608 if (copy_to_user(arg, &mode, sizeof(mode))) {
616 case IPMICTL_SET_MAINTENANCE_MODE_CMD:
620 if (copy_from_user(&mode, arg, sizeof(mode))) {
624 rv = ipmi_set_maintenance_mode(priv->user, mode);
633 * Note: it doesn't make sense to take the BKL here but
634 * not in compat_ipmi_ioctl. -arnd
636 static long ipmi_unlocked_ioctl(struct file *file,
642 mutex_lock(&ipmi_mutex);
643 ret = ipmi_ioctl(file, cmd, data);
644 mutex_unlock(&ipmi_mutex);
652 * The following code contains code for supporting 32-bit compatible
653 * ioctls on 64-bit kernels. This allows running 32-bit apps on the
656 #define COMPAT_IPMICTL_SEND_COMMAND \
657 _IOR(IPMI_IOC_MAGIC, 13, struct compat_ipmi_req)
658 #define COMPAT_IPMICTL_SEND_COMMAND_SETTIME \
659 _IOR(IPMI_IOC_MAGIC, 21, struct compat_ipmi_req_settime)
660 #define COMPAT_IPMICTL_RECEIVE_MSG \
661 _IOWR(IPMI_IOC_MAGIC, 12, struct compat_ipmi_recv)
662 #define COMPAT_IPMICTL_RECEIVE_MSG_TRUNC \
663 _IOWR(IPMI_IOC_MAGIC, 11, struct compat_ipmi_recv)
665 struct compat_ipmi_msg {
672 struct compat_ipmi_req {
674 compat_uint_t addr_len;
676 struct compat_ipmi_msg msg;
679 struct compat_ipmi_recv {
680 compat_int_t recv_type;
682 compat_uint_t addr_len;
684 struct compat_ipmi_msg msg;
687 struct compat_ipmi_req_settime {
688 struct compat_ipmi_req req;
689 compat_int_t retries;
690 compat_uint_t retry_time_ms;
694 * Define some helper functions for copying IPMI data
696 static long get_compat_ipmi_msg(struct ipmi_msg *p64,
697 struct compat_ipmi_msg __user *p32)
701 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
702 __get_user(p64->netfn, &p32->netfn) ||
703 __get_user(p64->cmd, &p32->cmd) ||
704 __get_user(p64->data_len, &p32->data_len) ||
705 __get_user(tmp, &p32->data))
707 p64->data = compat_ptr(tmp);
711 static long put_compat_ipmi_msg(struct ipmi_msg *p64,
712 struct compat_ipmi_msg __user *p32)
714 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
715 __put_user(p64->netfn, &p32->netfn) ||
716 __put_user(p64->cmd, &p32->cmd) ||
717 __put_user(p64->data_len, &p32->data_len))
722 static long get_compat_ipmi_req(struct ipmi_req *p64,
723 struct compat_ipmi_req __user *p32)
728 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
729 __get_user(tmp, &p32->addr) ||
730 __get_user(p64->addr_len, &p32->addr_len) ||
731 __get_user(p64->msgid, &p32->msgid) ||
732 get_compat_ipmi_msg(&p64->msg, &p32->msg))
734 p64->addr = compat_ptr(tmp);
738 static long get_compat_ipmi_req_settime(struct ipmi_req_settime *p64,
739 struct compat_ipmi_req_settime __user *p32)
741 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
742 get_compat_ipmi_req(&p64->req, &p32->req) ||
743 __get_user(p64->retries, &p32->retries) ||
744 __get_user(p64->retry_time_ms, &p32->retry_time_ms))
749 static long get_compat_ipmi_recv(struct ipmi_recv *p64,
750 struct compat_ipmi_recv __user *p32)
754 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
755 __get_user(p64->recv_type, &p32->recv_type) ||
756 __get_user(tmp, &p32->addr) ||
757 __get_user(p64->addr_len, &p32->addr_len) ||
758 __get_user(p64->msgid, &p32->msgid) ||
759 get_compat_ipmi_msg(&p64->msg, &p32->msg))
761 p64->addr = compat_ptr(tmp);
765 static long put_compat_ipmi_recv(struct ipmi_recv *p64,
766 struct compat_ipmi_recv __user *p32)
768 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
769 __put_user(p64->recv_type, &p32->recv_type) ||
770 __put_user(p64->addr_len, &p32->addr_len) ||
771 __put_user(p64->msgid, &p32->msgid) ||
772 put_compat_ipmi_msg(&p64->msg, &p32->msg))
778 * Handle compatibility ioctls
780 static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
784 struct ipmi_file_private *priv = filep->private_data;
787 case COMPAT_IPMICTL_SEND_COMMAND:
791 if (get_compat_ipmi_req(&rp, compat_ptr(arg)))
794 return handle_send_req(priv->user, &rp,
795 priv->default_retries,
796 priv->default_retry_time_ms);
798 case COMPAT_IPMICTL_SEND_COMMAND_SETTIME:
800 struct ipmi_req_settime sp;
802 if (get_compat_ipmi_req_settime(&sp, compat_ptr(arg)))
805 return handle_send_req(priv->user, &sp.req,
806 sp.retries, sp.retry_time_ms);
808 case COMPAT_IPMICTL_RECEIVE_MSG:
809 case COMPAT_IPMICTL_RECEIVE_MSG_TRUNC:
811 struct ipmi_recv __user *precv64;
812 struct ipmi_recv recv64;
814 if (get_compat_ipmi_recv(&recv64, compat_ptr(arg)))
817 precv64 = compat_alloc_user_space(sizeof(recv64));
818 if (copy_to_user(precv64, &recv64, sizeof(recv64)))
821 rc = ipmi_ioctl(filep,
822 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
823 ? IPMICTL_RECEIVE_MSG
824 : IPMICTL_RECEIVE_MSG_TRUNC),
825 (unsigned long) precv64);
829 if (copy_from_user(&recv64, precv64, sizeof(recv64)))
832 if (put_compat_ipmi_recv(&recv64, compat_ptr(arg)))
838 return ipmi_ioctl(filep, cmd, arg);
843 static const struct file_operations ipmi_fops = {
844 .owner = THIS_MODULE,
845 .unlocked_ioctl = ipmi_unlocked_ioctl,
847 .compat_ioctl = compat_ipmi_ioctl,
850 .release = ipmi_release,
851 .fasync = ipmi_fasync,
853 .llseek = noop_llseek,
856 #define DEVICE_NAME "ipmidev"
858 static int ipmi_major;
859 module_param(ipmi_major, int, 0);
860 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
861 " default, or if you set it to zero, it will choose the next"
862 " available device. Setting it to -1 will disable the"
863 " interface. Other values will set the major device number"
866 /* Keep track of the devices that are registered. */
867 struct ipmi_reg_list {
869 struct list_head link;
871 static LIST_HEAD(reg_list);
872 static DEFINE_MUTEX(reg_list_mutex);
874 static struct class *ipmi_class;
876 static void ipmi_new_smi(int if_num, struct device *device)
878 dev_t dev = MKDEV(ipmi_major, if_num);
879 struct ipmi_reg_list *entry;
881 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
883 printk(KERN_ERR "ipmi_devintf: Unable to create the"
884 " ipmi class device link\n");
889 mutex_lock(®_list_mutex);
890 device_create(ipmi_class, device, dev, NULL, "ipmi%d", if_num);
891 list_add(&entry->link, ®_list);
892 mutex_unlock(®_list_mutex);
895 static void ipmi_smi_gone(int if_num)
897 dev_t dev = MKDEV(ipmi_major, if_num);
898 struct ipmi_reg_list *entry;
900 mutex_lock(®_list_mutex);
901 list_for_each_entry(entry, ®_list, link) {
902 if (entry->dev == dev) {
903 list_del(&entry->link);
908 device_destroy(ipmi_class, dev);
909 mutex_unlock(®_list_mutex);
912 static struct ipmi_smi_watcher smi_watcher =
914 .owner = THIS_MODULE,
915 .new_smi = ipmi_new_smi,
916 .smi_gone = ipmi_smi_gone,
919 static __init int init_ipmi_devintf(void)
926 printk(KERN_INFO "ipmi device interface\n");
928 ipmi_class = class_create(THIS_MODULE, "ipmi");
929 if (IS_ERR(ipmi_class)) {
930 printk(KERN_ERR "ipmi: can't register device class\n");
931 return PTR_ERR(ipmi_class);
934 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
936 class_destroy(ipmi_class);
937 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
941 if (ipmi_major == 0) {
945 rv = ipmi_smi_watcher_register(&smi_watcher);
947 unregister_chrdev(ipmi_major, DEVICE_NAME);
948 class_destroy(ipmi_class);
949 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
955 module_init(init_ipmi_devintf);
957 static __exit void cleanup_ipmi(void)
959 struct ipmi_reg_list *entry, *entry2;
960 mutex_lock(®_list_mutex);
961 list_for_each_entry_safe(entry, entry2, ®_list, link) {
962 list_del(&entry->link);
963 device_destroy(ipmi_class, entry->dev);
966 mutex_unlock(®_list_mutex);
967 class_destroy(ipmi_class);
968 ipmi_smi_watcher_unregister(&smi_watcher);
969 unregister_chrdev(ipmi_major, DEVICE_NAME);
971 module_exit(cleanup_ipmi);
973 MODULE_LICENSE("GPL");
974 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
975 MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");
976 MODULE_ALIAS("platform:ipmi_si");