drivers/char/ipmi/ipmi_devintf.c

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