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