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