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 */ 33 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> 48 49 struct ipmi_file_private 50 { 51 ipmi_user_t user; 52 spinlock_t recv_msg_lock; 53 struct list_head recv_msgs; 54 struct file *file; 55 struct fasync_struct *fasync_queue; 56 wait_queue_head_t wait; 57 struct mutex recv_mutex; 58 int default_retries; 59 unsigned int default_retry_time_ms; 60 }; 61 62 static void file_receive_handler(struct ipmi_recv_msg *msg, 63 void *handler_data) 64 { 65 struct ipmi_file_private *priv = handler_data; 66 int was_empty; 67 unsigned long flags; 68 69 spin_lock_irqsave(&(priv->recv_msg_lock), flags); 70 71 was_empty = list_empty(&(priv->recv_msgs)); 72 list_add_tail(&(msg->link), &(priv->recv_msgs)); 73 74 if (was_empty) { 75 wake_up_interruptible(&priv->wait); 76 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN); 77 } 78 79 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags); 80 } 81 82 static unsigned int ipmi_poll(struct file *file, poll_table *wait) 83 { 84 struct ipmi_file_private *priv = file->private_data; 85 unsigned int mask = 0; 86 unsigned long flags; 87 88 poll_wait(file, &priv->wait, wait); 89 90 spin_lock_irqsave(&priv->recv_msg_lock, flags); 91 92 if (!list_empty(&(priv->recv_msgs))) 93 mask |= (POLLIN | POLLRDNORM); 94 95 spin_unlock_irqrestore(&priv->recv_msg_lock, flags); 96 97 return mask; 98 } 99 100 static int ipmi_fasync(int fd, struct file *file, int on) 101 { 102 struct ipmi_file_private *priv = file->private_data; 103 int result; 104 105 result = fasync_helper(fd, file, on, &priv->fasync_queue); 106 107 return (result); 108 } 109 110 static struct ipmi_user_hndl ipmi_hndlrs = 111 { 112 .ipmi_recv_hndl = file_receive_handler, 113 }; 114 115 static int ipmi_open(struct inode *inode, struct file *file) 116 { 117 int if_num = iminor(inode); 118 int rv; 119 struct ipmi_file_private *priv; 120 121 122 priv = kmalloc(sizeof(*priv), GFP_KERNEL); 123 if (!priv) 124 return -ENOMEM; 125 126 priv->file = file; 127 128 rv = ipmi_create_user(if_num, 129 &ipmi_hndlrs, 130 priv, 131 &(priv->user)); 132 if (rv) { 133 kfree(priv); 134 return rv; 135 } 136 137 file->private_data = priv; 138 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); 144 145 /* Use the low-level defaults. */ 146 priv->default_retries = -1; 147 priv->default_retry_time_ms = 0; 148 149 return 0; 150 } 151 152 static int ipmi_release(struct inode *inode, struct file *file) 153 { 154 struct ipmi_file_private *priv = file->private_data; 155 int rv; 156 157 rv = ipmi_destroy_user(priv->user); 158 if (rv) 159 return rv; 160 161 ipmi_fasync (-1, file, 0); 162 163 /* FIXME - free the messages in the list. */ 164 kfree(priv); 165 166 return 0; 167 } 168 169 static int handle_send_req(ipmi_user_t user, 170 struct ipmi_req *req, 171 int retries, 172 unsigned int retry_time_ms) 173 { 174 int rv; 175 struct ipmi_addr addr; 176 struct kernel_ipmi_msg msg; 177 178 if (req->addr_len > sizeof(struct ipmi_addr)) 179 return -EINVAL; 180 181 if (copy_from_user(&addr, req->addr, req->addr_len)) 182 return -EFAULT; 183 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); 188 if (!msg.data) 189 return -ENOMEM; 190 191 /* From here out we cannot return, we must jump to "out" for 192 error exits to free msgdata. */ 193 194 rv = ipmi_validate_addr(&addr, req->addr_len); 195 if (rv) 196 goto out; 197 198 if (req->msg.data != NULL) { 199 if (req->msg.data_len > IPMI_MAX_MSG_LENGTH) { 200 rv = -EMSGSIZE; 201 goto out; 202 } 203 204 if (copy_from_user(msg.data, 205 req->msg.data, 206 req->msg.data_len)) 207 { 208 rv = -EFAULT; 209 goto out; 210 } 211 } else { 212 msg.data_len = 0; 213 } 214 215 rv = ipmi_request_settime(user, 216 &addr, 217 req->msgid, 218 &msg, 219 NULL, 220 0, 221 retries, 222 retry_time_ms); 223 out: 224 kfree(msg.data); 225 return rv; 226 } 227 228 static int ipmi_ioctl(struct inode *inode, 229 struct file *file, 230 unsigned int cmd, 231 unsigned long data) 232 { 233 int rv = -EINVAL; 234 struct ipmi_file_private *priv = file->private_data; 235 void __user *arg = (void __user *)data; 236 237 switch (cmd) 238 { 239 case IPMICTL_SEND_COMMAND: 240 { 241 struct ipmi_req req; 242 243 if (copy_from_user(&req, arg, sizeof(req))) { 244 rv = -EFAULT; 245 break; 246 } 247 248 rv = handle_send_req(priv->user, 249 &req, 250 priv->default_retries, 251 priv->default_retry_time_ms); 252 break; 253 } 254 255 case IPMICTL_SEND_COMMAND_SETTIME: 256 { 257 struct ipmi_req_settime req; 258 259 if (copy_from_user(&req, arg, sizeof(req))) { 260 rv = -EFAULT; 261 break; 262 } 263 264 rv = handle_send_req(priv->user, 265 &req.req, 266 req.retries, 267 req.retry_time_ms); 268 break; 269 } 270 271 case IPMICTL_RECEIVE_MSG: 272 case IPMICTL_RECEIVE_MSG_TRUNC: 273 { 274 struct ipmi_recv rsp; 275 int addr_len; 276 struct list_head *entry; 277 struct ipmi_recv_msg *msg; 278 unsigned long flags; 279 280 281 rv = 0; 282 if (copy_from_user(&rsp, arg, sizeof(rsp))) { 283 rv = -EFAULT; 284 break; 285 } 286 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); 296 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); 301 rv = -EAGAIN; 302 goto recv_err; 303 } 304 entry = priv->recv_msgs.next; 305 msg = list_entry(entry, struct ipmi_recv_msg, link); 306 list_del(entry); 307 spin_unlock_irqrestore(&(priv->recv_msg_lock), flags); 308 309 addr_len = ipmi_addr_length(msg->addr.addr_type); 310 if (rsp.addr_len < addr_len) 311 { 312 rv = -EINVAL; 313 goto recv_putback_on_err; 314 } 315 316 if (copy_to_user(rsp.addr, &(msg->addr), addr_len)) { 317 rv = -EFAULT; 318 goto recv_putback_on_err; 319 } 320 rsp.addr_len = addr_len; 321 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; 326 327 if (msg->msg.data_len > 0) { 328 if (rsp.msg.data_len < msg->msg.data_len) { 329 rv = -EMSGSIZE; 330 if (cmd == IPMICTL_RECEIVE_MSG_TRUNC) { 331 msg->msg.data_len = rsp.msg.data_len; 332 } else { 333 goto recv_putback_on_err; 334 } 335 } 336 337 if (copy_to_user(rsp.msg.data, 338 msg->msg.data, 339 msg->msg.data_len)) 340 { 341 rv = -EFAULT; 342 goto recv_putback_on_err; 343 } 344 rsp.msg.data_len = msg->msg.data_len; 345 } else { 346 rsp.msg.data_len = 0; 347 } 348 349 if (copy_to_user(arg, &rsp, sizeof(rsp))) { 350 rv = -EFAULT; 351 goto recv_putback_on_err; 352 } 353 354 mutex_unlock(&priv->recv_mutex); 355 ipmi_free_recv_msg(msg); 356 break; 357 358 recv_putback_on_err: 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); 365 break; 366 367 recv_err: 368 mutex_unlock(&priv->recv_mutex); 369 break; 370 } 371 372 case IPMICTL_REGISTER_FOR_CMD: 373 { 374 struct ipmi_cmdspec val; 375 376 if (copy_from_user(&val, arg, sizeof(val))) { 377 rv = -EFAULT; 378 break; 379 } 380 381 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd); 382 break; 383 } 384 385 case IPMICTL_UNREGISTER_FOR_CMD: 386 { 387 struct ipmi_cmdspec val; 388 389 if (copy_from_user(&val, arg, sizeof(val))) { 390 rv = -EFAULT; 391 break; 392 } 393 394 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd); 395 break; 396 } 397 398 case IPMICTL_SET_GETS_EVENTS_CMD: 399 { 400 int val; 401 402 if (copy_from_user(&val, arg, sizeof(val))) { 403 rv = -EFAULT; 404 break; 405 } 406 407 rv = ipmi_set_gets_events(priv->user, val); 408 break; 409 } 410 411 /* The next four are legacy, not per-channel. */ 412 case IPMICTL_SET_MY_ADDRESS_CMD: 413 { 414 unsigned int val; 415 416 if (copy_from_user(&val, arg, sizeof(val))) { 417 rv = -EFAULT; 418 break; 419 } 420 421 rv = ipmi_set_my_address(priv->user, 0, val); 422 break; 423 } 424 425 case IPMICTL_GET_MY_ADDRESS_CMD: 426 { 427 unsigned int val; 428 unsigned char rval; 429 430 rv = ipmi_get_my_address(priv->user, 0, &rval); 431 if (rv) 432 break; 433 434 val = rval; 435 436 if (copy_to_user(arg, &val, sizeof(val))) { 437 rv = -EFAULT; 438 break; 439 } 440 break; 441 } 442 443 case IPMICTL_SET_MY_LUN_CMD: 444 { 445 unsigned int val; 446 447 if (copy_from_user(&val, arg, sizeof(val))) { 448 rv = -EFAULT; 449 break; 450 } 451 452 rv = ipmi_set_my_LUN(priv->user, 0, val); 453 break; 454 } 455 456 case IPMICTL_GET_MY_LUN_CMD: 457 { 458 unsigned int val; 459 unsigned char rval; 460 461 rv = ipmi_get_my_LUN(priv->user, 0, &rval); 462 if (rv) 463 break; 464 465 val = rval; 466 467 if (copy_to_user(arg, &val, sizeof(val))) { 468 rv = -EFAULT; 469 break; 470 } 471 break; 472 } 473 474 case IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD: 475 { 476 struct ipmi_channel_lun_address_set val; 477 478 if (copy_from_user(&val, arg, sizeof(val))) { 479 rv = -EFAULT; 480 break; 481 } 482 483 return ipmi_set_my_address(priv->user, val.channel, val.value); 484 break; 485 } 486 487 case IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD: 488 { 489 struct ipmi_channel_lun_address_set val; 490 491 if (copy_from_user(&val, arg, sizeof(val))) { 492 rv = -EFAULT; 493 break; 494 } 495 496 rv = ipmi_get_my_address(priv->user, val.channel, &val.value); 497 if (rv) 498 break; 499 500 if (copy_to_user(arg, &val, sizeof(val))) { 501 rv = -EFAULT; 502 break; 503 } 504 break; 505 } 506 507 case IPMICTL_SET_MY_CHANNEL_LUN_CMD: 508 { 509 struct ipmi_channel_lun_address_set val; 510 511 if (copy_from_user(&val, arg, sizeof(val))) { 512 rv = -EFAULT; 513 break; 514 } 515 516 rv = ipmi_set_my_LUN(priv->user, val.channel, val.value); 517 break; 518 } 519 520 case IPMICTL_GET_MY_CHANNEL_LUN_CMD: 521 { 522 struct ipmi_channel_lun_address_set val; 523 524 if (copy_from_user(&val, arg, sizeof(val))) { 525 rv = -EFAULT; 526 break; 527 } 528 529 rv = ipmi_get_my_LUN(priv->user, val.channel, &val.value); 530 if (rv) 531 break; 532 533 if (copy_to_user(arg, &val, sizeof(val))) { 534 rv = -EFAULT; 535 break; 536 } 537 break; 538 } 539 540 case IPMICTL_SET_TIMING_PARMS_CMD: 541 { 542 struct ipmi_timing_parms parms; 543 544 if (copy_from_user(&parms, arg, sizeof(parms))) { 545 rv = -EFAULT; 546 break; 547 } 548 549 priv->default_retries = parms.retries; 550 priv->default_retry_time_ms = parms.retry_time_ms; 551 rv = 0; 552 break; 553 } 554 555 case IPMICTL_GET_TIMING_PARMS_CMD: 556 { 557 struct ipmi_timing_parms parms; 558 559 parms.retries = priv->default_retries; 560 parms.retry_time_ms = priv->default_retry_time_ms; 561 562 if (copy_to_user(arg, &parms, sizeof(parms))) { 563 rv = -EFAULT; 564 break; 565 } 566 567 rv = 0; 568 break; 569 } 570 } 571 572 return rv; 573 } 574 575 #ifdef CONFIG_COMPAT 576 577 /* 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 580 * 64-bit kernel 581 */ 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) 590 591 struct compat_ipmi_msg { 592 u8 netfn; 593 u8 cmd; 594 u16 data_len; 595 compat_uptr_t data; 596 }; 597 598 struct compat_ipmi_req { 599 compat_uptr_t addr; 600 compat_uint_t addr_len; 601 compat_long_t msgid; 602 struct compat_ipmi_msg msg; 603 }; 604 605 struct compat_ipmi_recv { 606 compat_int_t recv_type; 607 compat_uptr_t addr; 608 compat_uint_t addr_len; 609 compat_long_t msgid; 610 struct compat_ipmi_msg msg; 611 }; 612 613 struct compat_ipmi_req_settime { 614 struct compat_ipmi_req req; 615 compat_int_t retries; 616 compat_uint_t retry_time_ms; 617 }; 618 619 /* 620 * Define some helper functions for copying IPMI data 621 */ 622 static long get_compat_ipmi_msg(struct ipmi_msg *p64, 623 struct compat_ipmi_msg __user *p32) 624 { 625 compat_uptr_t tmp; 626 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)) 632 return -EFAULT; 633 p64->data = compat_ptr(tmp); 634 return 0; 635 } 636 637 static long put_compat_ipmi_msg(struct ipmi_msg *p64, 638 struct compat_ipmi_msg __user *p32) 639 { 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)) 644 return -EFAULT; 645 return 0; 646 } 647 648 static long get_compat_ipmi_req(struct ipmi_req *p64, 649 struct compat_ipmi_req __user *p32) 650 { 651 652 compat_uptr_t tmp; 653 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)) 659 return -EFAULT; 660 p64->addr = compat_ptr(tmp); 661 return 0; 662 } 663 664 static long get_compat_ipmi_req_settime(struct ipmi_req_settime *p64, 665 struct compat_ipmi_req_settime __user *p32) 666 { 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)) 671 return -EFAULT; 672 return 0; 673 } 674 675 static long get_compat_ipmi_recv(struct ipmi_recv *p64, 676 struct compat_ipmi_recv __user *p32) 677 { 678 compat_uptr_t tmp; 679 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)) 686 return -EFAULT; 687 p64->addr = compat_ptr(tmp); 688 return 0; 689 } 690 691 static long put_compat_ipmi_recv(struct ipmi_recv *p64, 692 struct compat_ipmi_recv __user *p32) 693 { 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)) 699 return -EFAULT; 700 return 0; 701 } 702 703 /* 704 * Handle compatibility ioctls 705 */ 706 static long compat_ipmi_ioctl(struct file *filep, unsigned int cmd, 707 unsigned long arg) 708 { 709 int rc; 710 struct ipmi_file_private *priv = filep->private_data; 711 712 switch(cmd) { 713 case COMPAT_IPMICTL_SEND_COMMAND: 714 { 715 struct ipmi_req rp; 716 717 if (get_compat_ipmi_req(&rp, compat_ptr(arg))) 718 return -EFAULT; 719 720 return handle_send_req(priv->user, &rp, 721 priv->default_retries, 722 priv->default_retry_time_ms); 723 } 724 case COMPAT_IPMICTL_SEND_COMMAND_SETTIME: 725 { 726 struct ipmi_req_settime sp; 727 728 if (get_compat_ipmi_req_settime(&sp, compat_ptr(arg))) 729 return -EFAULT; 730 731 return handle_send_req(priv->user, &sp.req, 732 sp.retries, sp.retry_time_ms); 733 } 734 case COMPAT_IPMICTL_RECEIVE_MSG: 735 case COMPAT_IPMICTL_RECEIVE_MSG_TRUNC: 736 { 737 struct ipmi_recv __user *precv64; 738 struct ipmi_recv recv64; 739 740 if (get_compat_ipmi_recv(&recv64, compat_ptr(arg))) 741 return -EFAULT; 742 743 precv64 = compat_alloc_user_space(sizeof(recv64)); 744 if (copy_to_user(precv64, &recv64, sizeof(recv64))) 745 return -EFAULT; 746 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); 752 if (rc != 0) 753 return rc; 754 755 if (copy_from_user(&recv64, precv64, sizeof(recv64))) 756 return -EFAULT; 757 758 if (put_compat_ipmi_recv(&recv64, compat_ptr(arg))) 759 return -EFAULT; 760 761 return rc; 762 } 763 default: 764 return ipmi_ioctl(filep->f_dentry->d_inode, filep, cmd, arg); 765 } 766 } 767 #endif 768 769 static struct file_operations ipmi_fops = { 770 .owner = THIS_MODULE, 771 .ioctl = ipmi_ioctl, 772 #ifdef CONFIG_COMPAT 773 .compat_ioctl = compat_ipmi_ioctl, 774 #endif 775 .open = ipmi_open, 776 .release = ipmi_release, 777 .fasync = ipmi_fasync, 778 .poll = ipmi_poll, 779 }; 780 781 #define DEVICE_NAME "ipmidev" 782 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" 789 " to that value."); 790 791 /* Keep track of the devices that are registered. */ 792 struct ipmi_reg_list { 793 dev_t dev; 794 struct list_head link; 795 }; 796 static LIST_HEAD(reg_list); 797 static DEFINE_MUTEX(reg_list_mutex); 798 799 static struct class *ipmi_class; 800 801 static void ipmi_new_smi(int if_num, struct device *device) 802 { 803 dev_t dev = MKDEV(ipmi_major, if_num); 804 struct ipmi_reg_list *entry; 805 806 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 807 if (!entry) { 808 printk(KERN_ERR "ipmi_devintf: Unable to create the" 809 " ipmi class device link\n"); 810 return; 811 } 812 entry->dev = dev; 813 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); 818 } 819 820 static void ipmi_smi_gone(int if_num) 821 { 822 dev_t dev = MKDEV(ipmi_major, if_num); 823 struct ipmi_reg_list *entry; 824 825 mutex_lock(®_list_mutex); 826 list_for_each_entry(entry, ®_list, link) { 827 if (entry->dev == dev) { 828 list_del(&entry->link); 829 kfree(entry); 830 break; 831 } 832 } 833 class_device_destroy(ipmi_class, dev); 834 mutex_unlock(®_list_mutex); 835 } 836 837 static struct ipmi_smi_watcher smi_watcher = 838 { 839 .owner = THIS_MODULE, 840 .new_smi = ipmi_new_smi, 841 .smi_gone = ipmi_smi_gone, 842 }; 843 844 static __init int init_ipmi_devintf(void) 845 { 846 int rv; 847 848 if (ipmi_major < 0) 849 return -EINVAL; 850 851 printk(KERN_INFO "ipmi device interface\n"); 852 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); 857 } 858 859 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops); 860 if (rv < 0) { 861 class_destroy(ipmi_class); 862 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major); 863 return rv; 864 } 865 866 if (ipmi_major == 0) { 867 ipmi_major = rv; 868 } 869 870 rv = ipmi_smi_watcher_register(&smi_watcher); 871 if (rv) { 872 unregister_chrdev(ipmi_major, DEVICE_NAME); 873 class_destroy(ipmi_class); 874 printk(KERN_WARNING "ipmi: can't register smi watcher\n"); 875 return rv; 876 } 877 878 return 0; 879 } 880 module_init(init_ipmi_devintf); 881 882 static __exit void cleanup_ipmi(void) 883 { 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); 889 kfree(entry); 890 } 891 mutex_unlock(®_list_mutex); 892 class_destroy(ipmi_class); 893 ipmi_smi_watcher_unregister(&smi_watcher); 894 unregister_chrdev(ipmi_major, DEVICE_NAME); 895 } 896 module_exit(cleanup_ipmi); 897 898 MODULE_LICENSE("GPL"); 899 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 900 MODULE_DESCRIPTION("Linux device interface for the IPMI message handler."); 901