ia64/linux-2.6.18-xen.hg

view drivers/char/ipmi/ipmi_devintf.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
1 /*
2 * ipmi_devintf.c
3 *
4 * Linux device interface for the IPMI message handler.
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2002 MontaVista Software Inc.
11 *
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.
16 *
17 *
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.
28 *
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.
32 */
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/errno.h>
37 #include <asm/system.h>
38 #include <linux/sched.h>
39 #include <linux/poll.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
49 {
50 ipmi_user_t user;
51 spinlock_t recv_msg_lock;
52 struct list_head recv_msgs;
53 struct file *file;
54 struct fasync_struct *fasync_queue;
55 wait_queue_head_t wait;
56 struct mutex recv_mutex;
57 int default_retries;
58 unsigned int default_retry_time_ms;
59 };
61 static void file_receive_handler(struct ipmi_recv_msg *msg,
62 void *handler_data)
63 {
64 struct ipmi_file_private *priv = handler_data;
65 int was_empty;
66 unsigned long flags;
68 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
70 was_empty = list_empty(&(priv->recv_msgs));
71 list_add_tail(&(msg->link), &(priv->recv_msgs));
73 if (was_empty) {
74 wake_up_interruptible(&priv->wait);
75 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
76 }
78 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
79 }
81 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
82 {
83 struct ipmi_file_private *priv = file->private_data;
84 unsigned int mask = 0;
85 unsigned long flags;
87 poll_wait(file, &priv->wait, wait);
89 spin_lock_irqsave(&priv->recv_msg_lock, flags);
91 if (!list_empty(&(priv->recv_msgs)))
92 mask |= (POLLIN | POLLRDNORM);
94 spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
96 return mask;
97 }
99 static int ipmi_fasync(int fd, struct file *file, int on)
100 {
101 struct ipmi_file_private *priv = file->private_data;
102 int result;
104 result = fasync_helper(fd, file, on, &priv->fasync_queue);
106 return (result);
107 }
109 static struct ipmi_user_hndl ipmi_hndlrs =
110 {
111 .ipmi_recv_hndl = file_receive_handler,
112 };
114 static int ipmi_open(struct inode *inode, struct file *file)
115 {
116 int if_num = iminor(inode);
117 int rv;
118 struct ipmi_file_private *priv;
121 priv = kmalloc(sizeof(*priv), GFP_KERNEL);
122 if (!priv)
123 return -ENOMEM;
125 priv->file = file;
127 rv = ipmi_create_user(if_num,
128 &ipmi_hndlrs,
129 priv,
130 &(priv->user));
131 if (rv) {
132 kfree(priv);
133 return rv;
134 }
136 file->private_data = priv;
138 spin_lock_init(&(priv->recv_msg_lock));
139 INIT_LIST_HEAD(&(priv->recv_msgs));
140 init_waitqueue_head(&priv->wait);
141 priv->fasync_queue = NULL;
142 mutex_init(&priv->recv_mutex);
144 /* Use the low-level defaults. */
145 priv->default_retries = -1;
146 priv->default_retry_time_ms = 0;
148 return 0;
149 }
151 static int ipmi_release(struct inode *inode, struct file *file)
152 {
153 struct ipmi_file_private *priv = file->private_data;
154 int rv;
156 rv = ipmi_destroy_user(priv->user);
157 if (rv)
158 return rv;
160 ipmi_fasync (-1, file, 0);
162 /* FIXME - free the messages in the list. */
163 kfree(priv);
165 return 0;
166 }
168 static int handle_send_req(ipmi_user_t user,
169 struct ipmi_req *req,
170 int retries,
171 unsigned int retry_time_ms)
172 {
173 int rv;
174 struct ipmi_addr addr;
175 struct kernel_ipmi_msg msg;
177 if (req->addr_len > sizeof(struct ipmi_addr))
178 return -EINVAL;
180 if (copy_from_user(&addr, req->addr, req->addr_len))
181 return -EFAULT;
183 msg.netfn = req->msg.netfn;
184 msg.cmd = req->msg.cmd;
185 msg.data_len = req->msg.data_len;
186 msg.data = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
187 if (!msg.data)
188 return -ENOMEM;
190 /* From here out we cannot return, we must jump to "out" for
191 error exits to free msgdata. */
193 rv = ipmi_validate_addr(&addr, req->addr_len);
194 if (rv)
195 goto out;
197 if (req->msg.data != NULL) {
198 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) {
199 rv = -EMSGSIZE;
200 goto out;
201 }
203 if (copy_from_user(msg.data,
204 req->msg.data,
205 req->msg.data_len))
206 {
207 rv = -EFAULT;
208 goto out;
209 }
210 } else {
211 msg.data_len = 0;
212 }
214 rv = ipmi_request_settime(user,
215 &addr,
216 req->msgid,
217 &msg,
218 NULL,
219 0,
220 retries,
221 retry_time_ms);
222 out:
223 kfree(msg.data);
224 return rv;
225 }
227 static int ipmi_ioctl(struct inode *inode,
228 struct file *file,
229 unsigned int cmd,
230 unsigned long data)
231 {
232 int rv = -EINVAL;
233 struct ipmi_file_private *priv = file->private_data;
234 void __user *arg = (void __user *)data;
236 switch (cmd)
237 {
238 case IPMICTL_SEND_COMMAND:
239 {
240 struct ipmi_req req;
242 if (copy_from_user(&req, arg, sizeof(req))) {
243 rv = -EFAULT;
244 break;
245 }
247 rv = handle_send_req(priv->user,
248 &req,
249 priv->default_retries,
250 priv->default_retry_time_ms);
251 break;
252 }
254 case IPMICTL_SEND_COMMAND_SETTIME:
255 {
256 struct ipmi_req_settime req;
258 if (copy_from_user(&req, arg, sizeof(req))) {
259 rv = -EFAULT;
260 break;
261 }
263 rv = handle_send_req(priv->user,
264 &req.req,
265 req.retries,
266 req.retry_time_ms);
267 break;
268 }
270 case IPMICTL_RECEIVE_MSG:
271 case IPMICTL_RECEIVE_MSG_TRUNC:
272 {
273 struct ipmi_recv rsp;
274 int addr_len;
275 struct list_head *entry;
276 struct ipmi_recv_msg *msg;
277 unsigned long flags;
280 rv = 0;
281 if (copy_from_user(&rsp, arg, sizeof(rsp))) {
282 rv = -EFAULT;
283 break;
284 }
286 /* We claim a mutex because we don't want two
287 users getting something from the queue at a time.
288 Since we have to release the spinlock before we can
289 copy the data to the user, it's possible another
290 user will grab something from the queue, too. Then
291 the messages might get out of order if something
292 fails and the message gets put back onto the
293 queue. This mutex prevents that problem. */
294 mutex_lock(&priv->recv_mutex);
296 /* Grab the message off the list. */
297 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
298 if (list_empty(&(priv->recv_msgs))) {
299 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
300 rv = -EAGAIN;
301 goto recv_err;
302 }
303 entry = priv->recv_msgs.next;
304 msg = list_entry(entry, struct ipmi_recv_msg, link);
305 list_del(entry);
306 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
308 addr_len = ipmi_addr_length(msg->addr.addr_type);
309 if (rsp.addr_len < addr_len)
310 {
311 rv = -EINVAL;
312 goto recv_putback_on_err;
313 }
315 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) {
316 rv = -EFAULT;
317 goto recv_putback_on_err;
318 }
319 rsp.addr_len = addr_len;
321 rsp.recv_type = msg->recv_type;
322 rsp.msgid = msg->msgid;
323 rsp.msg.netfn = msg->msg.netfn;
324 rsp.msg.cmd = msg->msg.cmd;
326 if (msg->msg.data_len > 0) {
327 if (rsp.msg.data_len < msg->msg.data_len) {
328 rv = -EMSGSIZE;
329 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) {
330 msg->msg.data_len = rsp.msg.data_len;
331 } else {
332 goto recv_putback_on_err;
333 }
334 }
336 if (copy_to_user(rsp.msg.data,
337 msg->msg.data,
338 msg->msg.data_len))
339 {
340 rv = -EFAULT;
341 goto recv_putback_on_err;
342 }
343 rsp.msg.data_len = msg->msg.data_len;
344 } else {
345 rsp.msg.data_len = 0;
346 }
348 if (copy_to_user(arg, &rsp, sizeof(rsp))) {
349 rv = -EFAULT;
350 goto recv_putback_on_err;
351 }
353 mutex_unlock(&priv->recv_mutex);
354 ipmi_free_recv_msg(msg);
355 break;
357 recv_putback_on_err:
358 /* If we got an error, put the message back onto
359 the head of the queue. */
360 spin_lock_irqsave(&(priv->recv_msg_lock), flags);
361 list_add(entry, &(priv->recv_msgs));
362 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
363 mutex_unlock(&priv->recv_mutex);
364 break;
366 recv_err:
367 mutex_unlock(&priv->recv_mutex);
368 break;
369 }
371 case IPMICTL_REGISTER_FOR_CMD:
372 {
373 struct ipmi_cmdspec val;
375 if (copy_from_user(&val, arg, sizeof(val))) {
376 rv = -EFAULT;
377 break;
378 }
380 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd);
381 break;
382 }
384 case IPMICTL_UNREGISTER_FOR_CMD:
385 {
386 struct ipmi_cmdspec val;
388 if (copy_from_user(&val, arg, sizeof(val))) {
389 rv = -EFAULT;
390 break;
391 }
393 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
394 break;
395 }
397 case IPMICTL_SET_GETS_EVENTS_CMD:
398 {
399 int val;
401 if (copy_from_user(&val, arg, sizeof(val))) {
402 rv = -EFAULT;
403 break;
404 }
406 rv = ipmi_set_gets_events(priv->user, val);
407 break;
408 }
410 /* The next four are legacy, not per-channel. */
411 case IPMICTL_SET_MY_ADDRESS_CMD:
412 {
413 unsigned int val;
415 if (copy_from_user(&val, arg, sizeof(val))) {
416 rv = -EFAULT;
417 break;
418 }
420 rv = ipmi_set_my_address(priv->user, 0, val);
421 break;
422 }
424 case IPMICTL_GET_MY_ADDRESS_CMD:
425 {
426 unsigned int val;
427 unsigned char rval;
429 rv = ipmi_get_my_address(priv->user, 0, &rval);
430 if (rv)
431 break;
433 val = rval;
435 if (copy_to_user(arg, &val, sizeof(val))) {
436 rv = -EFAULT;
437 break;
438 }
439 break;
440 }
442 case IPMICTL_SET_MY_LUN_CMD:
443 {
444 unsigned int val;
446 if (copy_from_user(&val, arg, sizeof(val))) {
447 rv = -EFAULT;
448 break;
449 }
451 rv = ipmi_set_my_LUN(priv->user, 0, val);
452 break;
453 }
455 case IPMICTL_GET_MY_LUN_CMD:
456 {
457 unsigned int val;
458 unsigned char rval;
460 rv = ipmi_get_my_LUN(priv->user, 0, &rval);
461 if (rv)
462 break;
464 val = rval;
466 if (copy_to_user(arg, &val, sizeof(val))) {
467 rv = -EFAULT;
468 break;
469 }
470 break;
471 }
473 case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD:
474 {
475 struct ipmi_channel_lun_address_set val;
477 if (copy_from_user(&val, arg, sizeof(val))) {
478 rv = -EFAULT;
479 break;
480 }
482 return ipmi_set_my_address(priv->user, val.channel, val.value);
483 break;
484 }
486 case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD:
487 {
488 struct ipmi_channel_lun_address_set val;
490 if (copy_from_user(&val, arg, sizeof(val))) {
491 rv = -EFAULT;
492 break;
493 }
495 rv = ipmi_get_my_address(priv->user, val.channel, &val.value);
496 if (rv)
497 break;
499 if (copy_to_user(arg, &val, sizeof(val))) {
500 rv = -EFAULT;
501 break;
502 }
503 break;
504 }
506 case IPMICTL_SET_MY_CHANNEL_LUN_CMD:
507 {
508 struct ipmi_channel_lun_address_set val;
510 if (copy_from_user(&val, arg, sizeof(val))) {
511 rv = -EFAULT;
512 break;
513 }
515 rv = ipmi_set_my_LUN(priv->user, val.channel, val.value);
516 break;
517 }
519 case IPMICTL_GET_MY_CHANNEL_LUN_CMD:
520 {
521 struct ipmi_channel_lun_address_set val;
523 if (copy_from_user(&val, arg, sizeof(val))) {
524 rv = -EFAULT;
525 break;
526 }
528 rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value);
529 if (rv)
530 break;
532 if (copy_to_user(arg, &val, sizeof(val))) {
533 rv = -EFAULT;
534 break;
535 }
536 break;
537 }
539 case IPMICTL_SET_TIMING_PARMS_CMD:
540 {
541 struct ipmi_timing_parms parms;
543 if (copy_from_user(&parms, arg, sizeof(parms))) {
544 rv = -EFAULT;
545 break;
546 }
548 priv->default_retries = parms.retries;
549 priv->default_retry_time_ms = parms.retry_time_ms;
550 rv = 0;
551 break;
552 }
554 case IPMICTL_GET_TIMING_PARMS_CMD:
555 {
556 struct ipmi_timing_parms parms;
558 parms.retries = priv->default_retries;
559 parms.retry_time_ms = priv->default_retry_time_ms;
561 if (copy_to_user(arg, &parms, sizeof(parms))) {
562 rv = -EFAULT;
563 break;
564 }
566 rv = 0;
567 break;
568 }
569 }
571 return rv;
572 }
574 #ifdef CONFIG_COMPAT
576 /*
577 * The following code contains code for supporting 32-bit compatible
578 * ioctls on 64-bit kernels. This allows running 32-bit apps on the
579 * 64-bit kernel
580 */
581 #define COMPAT_IPMICTL_SEND_COMMAND \
582 _IOR(IPMI_IOC_MAGIC, 13, struct compat_ipmi_req)
583 #define COMPAT_IPMICTL_SEND_COMMAND_SETTIME \
584 _IOR(IPMI_IOC_MAGIC, 21, struct compat_ipmi_req_settime)
585 #define COMPAT_IPMICTL_RECEIVE_MSG \
586 _IOWR(IPMI_IOC_MAGIC, 12, struct compat_ipmi_recv)
587 #define COMPAT_IPMICTL_RECEIVE_MSG_TRUNC \
588 _IOWR(IPMI_IOC_MAGIC, 11, struct compat_ipmi_recv)
590 struct compat_ipmi_msg {
591 u8 netfn;
592 u8 cmd;
593 u16 data_len;
594 compat_uptr_t data;
595 };
597 struct compat_ipmi_req {
598 compat_uptr_t addr;
599 compat_uint_t addr_len;
600 compat_long_t msgid;
601 struct compat_ipmi_msg msg;
602 };
604 struct compat_ipmi_recv {
605 compat_int_t recv_type;
606 compat_uptr_t addr;
607 compat_uint_t addr_len;
608 compat_long_t msgid;
609 struct compat_ipmi_msg msg;
610 };
612 struct compat_ipmi_req_settime {
613 struct compat_ipmi_req req;
614 compat_int_t retries;
615 compat_uint_t retry_time_ms;
616 };
618 /*
619 * Define some helper functions for copying IPMI data
620 */
621 static long get_compat_ipmi_msg(struct ipmi_msg *p64,
622 struct compat_ipmi_msg __user *p32)
623 {
624 compat_uptr_t tmp;
626 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
627 __get_user(p64->netfn, &p32->netfn) ||
628 __get_user(p64->cmd, &p32->cmd) ||
629 __get_user(p64->data_len, &p32->data_len) ||
630 __get_user(tmp, &p32->data))
631 return -EFAULT;
632 p64->data = compat_ptr(tmp);
633 return 0;
634 }
636 static long put_compat_ipmi_msg(struct ipmi_msg *p64,
637 struct compat_ipmi_msg __user *p32)
638 {
639 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
640 __put_user(p64->netfn, &p32->netfn) ||
641 __put_user(p64->cmd, &p32->cmd) ||
642 __put_user(p64->data_len, &p32->data_len))
643 return -EFAULT;
644 return 0;
645 }
647 static long get_compat_ipmi_req(struct ipmi_req *p64,
648 struct compat_ipmi_req __user *p32)
649 {
651 compat_uptr_t tmp;
653 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
654 __get_user(tmp, &p32->addr) ||
655 __get_user(p64->addr_len, &p32->addr_len) ||
656 __get_user(p64->msgid, &p32->msgid) ||
657 get_compat_ipmi_msg(&p64->msg, &p32->msg))
658 return -EFAULT;
659 p64->addr = compat_ptr(tmp);
660 return 0;
661 }
663 static long get_compat_ipmi_req_settime(struct ipmi_req_settime *p64,
664 struct compat_ipmi_req_settime __user *p32)
665 {
666 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
667 get_compat_ipmi_req(&p64->req, &p32->req) ||
668 __get_user(p64->retries, &p32->retries) ||
669 __get_user(p64->retry_time_ms, &p32->retry_time_ms))
670 return -EFAULT;
671 return 0;
672 }
674 static long get_compat_ipmi_recv(struct ipmi_recv *p64,
675 struct compat_ipmi_recv __user *p32)
676 {
677 compat_uptr_t tmp;
679 if (!access_ok(VERIFY_READ, p32, sizeof(*p32)) ||
680 __get_user(p64->recv_type, &p32->recv_type) ||
681 __get_user(tmp, &p32->addr) ||
682 __get_user(p64->addr_len, &p32->addr_len) ||
683 __get_user(p64->msgid, &p32->msgid) ||
684 get_compat_ipmi_msg(&p64->msg, &p32->msg))
685 return -EFAULT;
686 p64->addr = compat_ptr(tmp);
687 return 0;
688 }
690 static long put_compat_ipmi_recv(struct ipmi_recv *p64,
691 struct compat_ipmi_recv __user *p32)
692 {
693 if (!access_ok(VERIFY_WRITE, p32, sizeof(*p32)) ||
694 __put_user(p64->recv_type, &p32->recv_type) ||
695 __put_user(p64->addr_len, &p32->addr_len) ||
696 __put_user(p64->msgid, &p32->msgid) ||
697 put_compat_ipmi_msg(&p64->msg, &p32->msg))
698 return -EFAULT;
699 return 0;
700 }
702 /*
703 * Handle compatibility ioctls
704 */
705 static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd,
706 unsigned long arg)
707 {
708 int rc;
709 struct ipmi_file_private *priv = filep->private_data;
711 switch(cmd) {
712 case COMPAT_IPMICTL_SEND_COMMAND:
713 {
714 struct ipmi_req rp;
716 if (get_compat_ipmi_req(&rp, compat_ptr(arg)))
717 return -EFAULT;
719 return handle_send_req(priv->user, &rp,
720 priv->default_retries,
721 priv->default_retry_time_ms);
722 }
723 case COMPAT_IPMICTL_SEND_COMMAND_SETTIME:
724 {
725 struct ipmi_req_settime sp;
727 if (get_compat_ipmi_req_settime(&sp, compat_ptr(arg)))
728 return -EFAULT;
730 return handle_send_req(priv->user, &sp.req,
731 sp.retries, sp.retry_time_ms);
732 }
733 case COMPAT_IPMICTL_RECEIVE_MSG:
734 case COMPAT_IPMICTL_RECEIVE_MSG_TRUNC:
735 {
736 struct ipmi_recv __user *precv64;
737 struct ipmi_recv recv64;
739 if (get_compat_ipmi_recv(&recv64, compat_ptr(arg)))
740 return -EFAULT;
742 precv64 = compat_alloc_user_space(sizeof(recv64));
743 if (copy_to_user(precv64, &recv64, sizeof(recv64)))
744 return -EFAULT;
746 rc = ipmi_ioctl(filep->f_dentry->d_inode, filep,
747 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
748 ? IPMICTL_RECEIVE_MSG
749 : IPMICTL_RECEIVE_MSG_TRUNC),
750 (unsigned long) precv64);
751 if (rc != 0)
752 return rc;
754 if (copy_from_user(&recv64, precv64, sizeof(recv64)))
755 return -EFAULT;
757 if (put_compat_ipmi_recv(&recv64, compat_ptr(arg)))
758 return -EFAULT;
760 return rc;
761 }
762 default:
763 return ipmi_ioctl(filep->f_dentry->d_inode, filep, cmd, arg);
764 }
765 }
766 #endif
768 static const struct file_operations ipmi_fops = {
769 .owner = THIS_MODULE,
770 .ioctl = ipmi_ioctl,
771 #ifdef CONFIG_COMPAT
772 .compat_ioctl = compat_ipmi_ioctl,
773 #endif
774 .open = ipmi_open,
775 .release = ipmi_release,
776 .fasync = ipmi_fasync,
777 .poll = ipmi_poll,
778 };
780 #define DEVICE_NAME "ipmidev"
782 static int ipmi_major = 0;
783 module_param(ipmi_major, int, 0);
784 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device. By"
785 " default, or if you set it to zero, it will choose the next"
786 " available device. Setting it to -1 will disable the"
787 " interface. Other values will set the major device number"
788 " to that value.");
790 /* Keep track of the devices that are registered. */
791 struct ipmi_reg_list {
792 dev_t dev;
793 struct list_head link;
794 };
795 static LIST_HEAD(reg_list);
796 static DEFINE_MUTEX(reg_list_mutex);
798 static struct class *ipmi_class;
800 static void ipmi_new_smi(int if_num, struct device *device)
801 {
802 dev_t dev = MKDEV(ipmi_major, if_num);
803 struct ipmi_reg_list *entry;
805 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
806 if (!entry) {
807 printk(KERN_ERR "ipmi_devintf: Unable to create the"
808 " ipmi class device link\n");
809 return;
810 }
811 entry->dev = dev;
813 mutex_lock(&reg_list_mutex);
814 class_device_create(ipmi_class, NULL, dev, device, "ipmi%d", if_num);
815 list_add(&entry->link, &reg_list);
816 mutex_unlock(&reg_list_mutex);
817 }
819 static void ipmi_smi_gone(int if_num)
820 {
821 dev_t dev = MKDEV(ipmi_major, if_num);
822 struct ipmi_reg_list *entry;
824 mutex_lock(&reg_list_mutex);
825 list_for_each_entry(entry, &reg_list, link) {
826 if (entry->dev == dev) {
827 list_del(&entry->link);
828 kfree(entry);
829 break;
830 }
831 }
832 class_device_destroy(ipmi_class, dev);
833 mutex_unlock(&reg_list_mutex);
834 }
836 static struct ipmi_smi_watcher smi_watcher =
837 {
838 .owner = THIS_MODULE,
839 .new_smi = ipmi_new_smi,
840 .smi_gone = ipmi_smi_gone,
841 };
843 static __init int init_ipmi_devintf(void)
844 {
845 int rv;
847 if (ipmi_major < 0)
848 return -EINVAL;
850 printk(KERN_INFO "ipmi device interface\n");
852 ipmi_class = class_create(THIS_MODULE, "ipmi");
853 if (IS_ERR(ipmi_class)) {
854 printk(KERN_ERR "ipmi: can't register device class\n");
855 return PTR_ERR(ipmi_class);
856 }
858 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
859 if (rv < 0) {
860 class_destroy(ipmi_class);
861 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
862 return rv;
863 }
865 if (ipmi_major == 0) {
866 ipmi_major = rv;
867 }
869 rv = ipmi_smi_watcher_register(&smi_watcher);
870 if (rv) {
871 unregister_chrdev(ipmi_major, DEVICE_NAME);
872 class_destroy(ipmi_class);
873 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
874 return rv;
875 }
877 return 0;
878 }
879 module_init(init_ipmi_devintf);
881 static __exit void cleanup_ipmi(void)
882 {
883 struct ipmi_reg_list *entry, *entry2;
884 mutex_lock(&reg_list_mutex);
885 list_for_each_entry_safe(entry, entry2, &reg_list, link) {
886 list_del(&entry->link);
887 class_device_destroy(ipmi_class, entry->dev);
888 kfree(entry);
889 }
890 mutex_unlock(&reg_list_mutex);
891 class_destroy(ipmi_class);
892 ipmi_smi_watcher_unregister(&smi_watcher);
893 unregister_chrdev(ipmi_major, DEVICE_NAME);
894 }
895 module_exit(cleanup_ipmi);
897 MODULE_LICENSE("GPL");
898 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
899 MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");