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/config.h>
  35 #include <linux/module.h>
  36 #include <linux/moduleparam.h>
  37 #include <linux/errno.h>
  38 #include <asm/system.h>
  39 #include <linux/sched.h>
  40 #include <linux/poll.h>
  41 #include <linux/spinlock.h>
  42 #include <linux/slab.h>
  43 #include <linux/devfs_fs_kernel.h>
  44 #include <linux/ipmi.h>
  45 #include <asm/semaphore.h>
  46 #include <linux/init.h>
  47 #include <linux/device.h>
  48
  49 #define IPMI_DEVINTF_VERSION "v33"
  50
  51 struct ipmi_file_private
  52 {
  53         ipmi_user_t          user;
  54         spinlock_t           recv_msg_lock;
  55         struct list_head     recv_msgs;
  56         struct file          *file;
  57         struct fasync_struct *fasync_queue;
  58         wait_queue_head_t    wait;
  59         struct semaphore     recv_sem;
  60         int                  default_retries;
  61         unsigned int         default_retry_time_ms;
  62 };
  63
  64 static void file_receive_handler(struct ipmi_recv_msg *msg,
  65                                  void                 *handler_data)
  66 {
  67         struct ipmi_file_private *priv = handler_data;
  68         int                      was_empty;
  69         unsigned long            flags;
  70
  71         spin_lock_irqsave(&(priv->recv_msg_lock), flags);
  72
  73         was_empty = list_empty(&(priv->recv_msgs));
  74         list_add_tail(&(msg->link), &(priv->recv_msgs));
  75
  76         if (was_empty) {
  77                 wake_up_interruptible(&priv->wait);
  78                 kill_fasync(&priv->fasync_queue, SIGIO, POLL_IN);
  79         }
  80
  81         spin_unlock_irqrestore(&(priv->recv_msg_lock), flags);
  82 }
  83
  84 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
  85 {
  86         struct ipmi_file_private *priv = file->private_data;
  87         unsigned int             mask = 0;
  88         unsigned long            flags;
  89
  90         poll_wait(file, &priv->wait, wait);
  91
  92         spin_lock_irqsave(&priv->recv_msg_lock, flags);
  93
  94         if (! list_empty(&(priv->recv_msgs)))
  95                 mask |= (POLLIN | POLLRDNORM);
  96
  97         spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
  98
  99         return mask;
 100 }
 101
 102 static int ipmi_fasync(int fd, struct file *file, int on)
 103 {
 104         struct ipmi_file_private *priv = file->private_data;
 105         int                      result;
 106
 107         result = fasync_helper(fd, file, on, &priv->fasync_queue);
 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         priv->file = file;
 129
 130         rv = ipmi_create_user(if_num,
 131                               &ipmi_hndlrs,
 132                               priv,
 133                               &(priv->user));
 134         if (rv) {
 135                 kfree(priv);
 136                 return rv;
 137         }
 138
 139         file->private_data = priv;
 140
 141         spin_lock_init(&(priv->recv_msg_lock));
 142         INIT_LIST_HEAD(&(priv->recv_msgs));
 143         init_waitqueue_head(&priv->wait);
 144         priv->fasync_queue = NULL;
 145         sema_init(&(priv->recv_sem), 1);
 146
 147         /* Use the low-level defaults. */
 148         priv->default_retries = -1;
 149         priv->default_retry_time_ms = 0;
 150
 151         return 0;
 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 semaphore 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 semaphore prevents that problem. */
 297                 down(&(priv->recv_sem));
 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                 up(&(priv->recv_sem));
 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                 up(&(priv->recv_sem));
 367                 break;
 368
 369         recv_err:
 370                 up(&(priv->recv_sem));
 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                 break;
 385         }
 386
 387         case IPMICTL_UNREGISTER_FOR_CMD:
 388         {
 389                 struct ipmi_cmdspec   val;
 390
 391                 if (copy_from_user(&val, arg, sizeof(val))) {
 392                         rv = -EFAULT;
 393                         break;
 394                 }
 395
 396                 rv = ipmi_unregister_for_cmd(priv->user, val.netfn, val.cmd);
 397                 break;
 398         }
 399
 400         case IPMICTL_SET_GETS_EVENTS_CMD:
 401         {
 402                 int val;
 403
 404                 if (copy_from_user(&val, arg, sizeof(val))) {
 405                         rv = -EFAULT;
 406                         break;
 407                 }
 408
 409                 rv = ipmi_set_gets_events(priv->user, val);
 410                 break;
 411         }
 412
 413         case IPMICTL_SET_MY_ADDRESS_CMD:
 414         {
 415                 unsigned int val;
 416
 417                 if (copy_from_user(&val, arg, sizeof(val))) {
 418                         rv = -EFAULT;
 419                         break;
 420                 }
 421
 422                 ipmi_set_my_address(priv->user, val);
 423                 rv = 0;
 424                 break;
 425         }
 426
 427         case IPMICTL_GET_MY_ADDRESS_CMD:
 428         {
 429                 unsigned int val;
 430
 431                 val = ipmi_get_my_address(priv->user);
 432
 433                 if (copy_to_user(arg, &val, sizeof(val))) {
 434                         rv = -EFAULT;
 435                         break;
 436                 }
 437                 rv = 0;
 438                 break;
 439         }
 440
 441         case IPMICTL_SET_MY_LUN_CMD:
 442         {
 443                 unsigned int val;
 444
 445                 if (copy_from_user(&val, arg, sizeof(val))) {
 446                         rv = -EFAULT;
 447                         break;
 448                 }
 449
 450                 ipmi_set_my_LUN(priv->user, val);
 451                 rv = 0;
 452                 break;
 453         }
 454
 455         case IPMICTL_GET_MY_LUN_CMD:
 456         {
 457                 unsigned int val;
 458
 459                 val = ipmi_get_my_LUN(priv->user);
 460
 461                 if (copy_to_user(arg, &val, sizeof(val))) {
 462                         rv = -EFAULT;
 463                         break;
 464                 }
 465                 rv = 0;
 466                 break;
 467         }
 468         case IPMICTL_SET_TIMING_PARMS_CMD:
 469         {
 470                 struct ipmi_timing_parms parms;
 471
 472                 if (copy_from_user(&parms, arg, sizeof(parms))) {
 473                         rv = -EFAULT;
 474                         break;
 475                 }
 476
 477                 priv->default_retries = parms.retries;
 478                 priv->default_retry_time_ms = parms.retry_time_ms;
 479                 rv = 0;
 480                 break;
 481         }
 482
 483         case IPMICTL_GET_TIMING_PARMS_CMD:
 484         {
 485                 struct ipmi_timing_parms parms;
 486
 487                 parms.retries = priv->default_retries;
 488                 parms.retry_time_ms = priv->default_retry_time_ms;
 489
 490                 if (copy_to_user(arg, &parms, sizeof(parms))) {
 491                         rv = -EFAULT;
 492                         break;
 493                 }
 494
 495                 rv = 0;
 496                 break;
 497         }
 498         }
 499
 500         return rv;
 501 }
 502
 503
 504 static struct file_operations ipmi_fops = {
 505         .owner          = THIS_MODULE,
 506         .ioctl          = ipmi_ioctl,
 507         .open           = ipmi_open,
 508         .release        = ipmi_release,
 509         .fasync         = ipmi_fasync,
 510         .poll           = ipmi_poll,
 511 };
 512
 513 #define DEVICE_NAME     "ipmidev"
 514
 515 static int ipmi_major = 0;
 516 module_param(ipmi_major, int, 0);
 517 MODULE_PARM_DESC(ipmi_major, "Sets the major number of the IPMI device.  By"
 518                  " default, or if you set it to zero, it will choose the next"
 519                  " available device.  Setting it to -1 will disable the"
 520                  " interface.  Other values will set the major device number"
 521                  " to that value.");
 522
 523 static struct class *ipmi_class;
 524
 525 static void ipmi_new_smi(int if_num)
 526 {
 527         dev_t dev = MKDEV(ipmi_major, if_num);
 528
 529         devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
 530                       "ipmidev/%d", if_num);
 531
 532         class_device_create(ipmi_class, dev, NULL, "ipmi%d", if_num);
 533 }
 534
 535 static void ipmi_smi_gone(int if_num)
 536 {
 537         class_device_destroy(ipmi_class, MKDEV(ipmi_major, if_num));
 538         devfs_remove("ipmidev/%d", if_num);
 539 }
 540
 541 static struct ipmi_smi_watcher smi_watcher =
 542 {
 543         .owner    = THIS_MODULE,
 544         .new_smi  = ipmi_new_smi,
 545         .smi_gone = ipmi_smi_gone,
 546 };
 547
 548 static __init int init_ipmi_devintf(void)
 549 {
 550         int rv;
 551
 552         if (ipmi_major < 0)
 553                 return -EINVAL;
 554
 555         printk(KERN_INFO "ipmi device interface version "
 556                IPMI_DEVINTF_VERSION "\n");
 557
 558         ipmi_class = class_create(THIS_MODULE, "ipmi");
 559         if (IS_ERR(ipmi_class)) {
 560                 printk(KERN_ERR "ipmi: can't register device class\n");
 561                 return PTR_ERR(ipmi_class);
 562         }
 563
 564         rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
 565         if (rv < 0) {
 566                 class_destroy(ipmi_class);
 567                 printk(KERN_ERR "ipmi: can't get major %d\n", ipmi_major);
 568                 return rv;
 569         }
 570
 571         if (ipmi_major == 0) {
 572                 ipmi_major = rv;
 573         }
 574
 575         devfs_mk_dir(DEVICE_NAME);
 576
 577         rv = ipmi_smi_watcher_register(&smi_watcher);
 578         if (rv) {
 579                 unregister_chrdev(ipmi_major, DEVICE_NAME);
 580                 class_destroy(ipmi_class);
 581                 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
 582                 return rv;
 583         }
 584
 585         return 0;
 586 }
 587 module_init(init_ipmi_devintf);
 588
 589 static __exit void cleanup_ipmi(void)
 590 {
 591         class_destroy(ipmi_class);
 592         ipmi_smi_watcher_unregister(&smi_watcher);
 593         devfs_remove(DEVICE_NAME);
 594         unregister_chrdev(ipmi_major, DEVICE_NAME);
 595 }
 596 module_exit(cleanup_ipmi);
 597
 598 MODULE_LICENSE("GPL");