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