blob: 65545de3dbf4ded375e55467fcaf5a8360000dfd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/module.h>
35#include <linux/moduleparam.h>
36#include <linux/errno.h>
37#include <asm/system.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include <linux/poll.h>
Alexey Dobriyana99bbaf2009-10-04 16:11:37 +040039#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include <linux/spinlock.h>
41#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/ipmi.h>
Corey Minyardd6dfd132006-03-31 02:30:41 -080043#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/init.h>
Corey Minyard37e09152005-05-20 08:56:23 +020045#include <linux/device.h>
Andrew Morton6a94f922005-06-23 22:01:45 -070046#include <linux/compat.h>
Jonathan Corbetecc38982008-05-15 10:46:49 -060047#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Linus Torvalds1da177e2005-04-16 15:20:36 -070049struct 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;
Corey Minyardd6dfd132006-03-31 02:30:41 -080057 struct mutex recv_mutex;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 int default_retries;
59 unsigned int default_retry_time_ms;
60};
61
62static 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
82static 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
Corey Minyard50c812b2006-03-26 01:37:21 -080092 if (!list_empty(&(priv->recv_msgs)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 mask |= (POLLIN | POLLRDNORM);
94
95 spin_unlock_irqrestore(&priv->recv_msg_lock, flags);
96
97 return mask;
98}
99
100static int ipmi_fasync(int fd, struct file *file, int on)
101{
102 struct ipmi_file_private *priv = file->private_data;
103 int result;
104
Jonathan Corbet70b028b2008-06-23 17:00:14 -0600105 lock_kernel(); /* could race against open() otherwise */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 result = fasync_helper(fd, file, on, &priv->fasync_queue);
Jonathan Corbet70b028b2008-06-23 17:00:14 -0600107 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109 return (result);
110}
111
112static struct ipmi_user_hndl ipmi_hndlrs =
113{
114 .ipmi_recv_hndl = file_receive_handler,
115};
116
117static 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
Jonathan Corbetecc38982008-05-15 10:46:49 -0600128 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 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);
Jonathan Corbetecc38982008-05-15 10:46:49 -0600137 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 }
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;
Corey Minyardd6dfd132006-03-31 02:30:41 -0800146 mutex_init(&priv->recv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
148 /* Use the low-level defaults. */
149 priv->default_retries = -1;
150 priv->default_retry_time_ms = 0;
151
Jonathan Corbetecc38982008-05-15 10:46:49 -0600152out:
153 unlock_kernel();
154 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155}
156
157static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 /* FIXME - free the messages in the list. */
167 kfree(priv);
168
169 return 0;
170}
171
172static 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
231static 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
Corey Minyardd6dfd132006-03-31 02:30:41 -0800290 /* We claim a mutex because we don't want two
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 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
Corey Minyardd6dfd132006-03-31 02:30:41 -0800297 queue. This mutex prevents that problem. */
298 mutex_lock(&priv->recv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
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
Corey Minyardd6dfd132006-03-31 02:30:41 -0800357 mutex_unlock(&priv->recv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 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);
Corey Minyardd6dfd132006-03-31 02:30:41 -0800367 mutex_unlock(&priv->recv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 break;
369
370 recv_err:
Corey Minyardd6dfd132006-03-31 02:30:41 -0800371 mutex_unlock(&priv->recv_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 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
Corey Minyardc69c3122006-09-30 23:27:56 -0700384 rv = ipmi_register_for_cmd(priv->user, val.netfn, val.cmd,
385 IPMI_CHAN_ALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 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
Corey Minyardc69c3122006-09-30 23:27:56 -0700398 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 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
Corey Minyardc14979b2005-09-06 15:18:38 -0700444 /* The next four are legacy, not per-channel. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 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
Corey Minyardc14979b2005-09-06 15:18:38 -0700454 rv = ipmi_set_my_address(priv->user, 0, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 break;
456 }
457
458 case IPMICTL_GET_MY_ADDRESS_CMD:
459 {
Corey Minyardc14979b2005-09-06 15:18:38 -0700460 unsigned int val;
461 unsigned char rval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462
Corey Minyardc14979b2005-09-06 15:18:38 -0700463 rv = ipmi_get_my_address(priv->user, 0, &rval);
464 if (rv)
465 break;
466
467 val = rval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 if (copy_to_user(arg, &val, sizeof(val))) {
470 rv = -EFAULT;
471 break;
472 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 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
Corey Minyardc14979b2005-09-06 15:18:38 -0700485 rv = ipmi_set_my_LUN(priv->user, 0, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 break;
487 }
488
489 case IPMICTL_GET_MY_LUN_CMD:
490 {
Corey Minyardc14979b2005-09-06 15:18:38 -0700491 unsigned int val;
492 unsigned char rval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
Corey Minyardc14979b2005-09-06 15:18:38 -0700494 rv = ipmi_get_my_LUN(priv->user, 0, &rval);
495 if (rv)
496 break;
497
498 val = rval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
500 if (copy_to_user(arg, &val, sizeof(val))) {
501 rv = -EFAULT;
502 break;
503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 break;
505 }
Corey Minyardc14979b2005-09-06 15:18:38 -0700506
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 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 }
Corey Minyardb9675132006-12-06 20:41:02 -0800603
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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 }
629
630 return rv;
631}
632
Andrew Morton6a94f922005-06-23 22:01:45 -0700633#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
649struct compat_ipmi_msg {
650 u8 netfn;
651 u8 cmd;
652 u16 data_len;
653 compat_uptr_t data;
654};
655
656struct 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
663struct 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
671struct 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 */
680static 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
695static 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
706static 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
722static 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
733static 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
749static 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 */
764static 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 {
viro@ZenIV.linux.org.uk18fb9442005-09-09 20:14:05 +0100795 struct ipmi_recv __user *precv64;
796 struct ipmi_recv recv64;
Andrew Morton6a94f922005-06-23 22:01:45 -0700797
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
Josef Sipek78088412006-12-08 02:37:12 -0800805 rc = ipmi_ioctl(filep->f_path.dentry->d_inode, filep,
Andrew Morton6a94f922005-06-23 22:01:45 -0700806 ((cmd == COMPAT_IPMICTL_RECEIVE_MSG)
807 ? IPMICTL_RECEIVE_MSG
808 : IPMICTL_RECEIVE_MSG_TRUNC),
viro@ZenIV.linux.org.uk18fb9442005-09-09 20:14:05 +0100809 (unsigned long) precv64);
Andrew Morton6a94f922005-06-23 22:01:45 -0700810 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:
Josef Sipek78088412006-12-08 02:37:12 -0800822 return ipmi_ioctl(filep->f_path.dentry->d_inode, filep, cmd, arg);
Andrew Morton6a94f922005-06-23 22:01:45 -0700823 }
824}
825#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
Arjan van de Ven62322d22006-07-03 00:24:21 -0700827static const struct file_operations ipmi_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 .owner = THIS_MODULE,
829 .ioctl = ipmi_ioctl,
Andrew Morton6a94f922005-06-23 22:01:45 -0700830#ifdef CONFIG_COMPAT
831 .compat_ioctl = compat_ipmi_ioctl,
832#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 .open = ipmi_open,
834 .release = ipmi_release,
835 .fasync = ipmi_fasync,
836 .poll = ipmi_poll,
837};
838
839#define DEVICE_NAME "ipmidev"
840
Randy Dunlap0c8204b2006-12-10 02:19:06 -0800841static int ipmi_major;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842module_param(ipmi_major, int, 0);
843MODULE_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
Corey Minyard50c812b2006-03-26 01:37:21 -0800849/* Keep track of the devices that are registered. */
850struct ipmi_reg_list {
851 dev_t dev;
852 struct list_head link;
853};
854static LIST_HEAD(reg_list);
855static DEFINE_MUTEX(reg_list_mutex);
856
Andrew Mortoneb51b652005-05-05 15:06:38 -0700857static struct class *ipmi_class;
Corey Minyard37e09152005-05-20 08:56:23 +0200858
Corey Minyard50c812b2006-03-26 01:37:21 -0800859static void ipmi_new_smi(int if_num, struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860{
Corey Minyard37e09152005-05-20 08:56:23 +0200861 dev_t dev = MKDEV(ipmi_major, if_num);
Corey Minyard50c812b2006-03-26 01:37:21 -0800862 struct ipmi_reg_list *entry;
Corey Minyard37e09152005-05-20 08:56:23 +0200863
Corey Minyard50c812b2006-03-26 01:37:21 -0800864 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);
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -0700873 device_create(ipmi_class, device, dev, NULL, "ipmi%d", if_num);
Corey Minyard50c812b2006-03-26 01:37:21 -0800874 list_add(&entry->link, &reg_list);
875 mutex_unlock(&reg_list_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876}
877
878static void ipmi_smi_gone(int if_num)
879{
Corey Minyard50c812b2006-03-26 01:37:21 -0800880 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 }
tonyj@suse.de07c015e2007-08-07 22:28:44 -0700891 device_destroy(ipmi_class, dev);
Corey Minyard50c812b2006-03-26 01:37:21 -0800892 mutex_unlock(&reg_list_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893}
894
895static 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
902static __init int init_ipmi_devintf(void)
903{
904 int rv;
905
906 if (ipmi_major < 0)
907 return -EINVAL;
908
Corey Minyard1fdd75b2005-09-06 15:18:42 -0700909 printk(KERN_INFO "ipmi device interface\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910
Andrew Mortoneb51b652005-05-05 15:06:38 -0700911 ipmi_class = class_create(THIS_MODULE, "ipmi");
Corey Minyard37e09152005-05-20 08:56:23 +0200912 if (IS_ERR(ipmi_class)) {
913 printk(KERN_ERR "ipmi: can't register device class\n");
914 return PTR_ERR(ipmi_class);
915 }
916
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 rv = register_chrdev(ipmi_major, DEVICE_NAME, &ipmi_fops);
918 if (rv < 0) {
Andrew Mortoneb51b652005-05-05 15:06:38 -0700919 class_destroy(ipmi_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 rv = ipmi_smi_watcher_register(&smi_watcher);
929 if (rv) {
930 unregister_chrdev(ipmi_major, DEVICE_NAME);
Andrew Mortoneb51b652005-05-05 15:06:38 -0700931 class_destroy(ipmi_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 printk(KERN_WARNING "ipmi: can't register smi watcher\n");
933 return rv;
934 }
935
936 return 0;
937}
938module_init(init_ipmi_devintf);
939
940static __exit void cleanup_ipmi(void)
941{
Corey Minyard50c812b2006-03-26 01:37:21 -0800942 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);
tonyj@suse.de07c015e2007-08-07 22:28:44 -0700946 device_destroy(ipmi_class, entry->dev);
Corey Minyard50c812b2006-03-26 01:37:21 -0800947 kfree(entry);
948 }
949 mutex_unlock(&reg_list_mutex);
Andrew Mortoneb51b652005-05-05 15:06:38 -0700950 class_destroy(ipmi_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 ipmi_smi_watcher_unregister(&smi_watcher);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 unregister_chrdev(ipmi_major, DEVICE_NAME);
953}
954module_exit(cleanup_ipmi);
955
956MODULE_LICENSE("GPL");
Corey Minyard1fdd75b2005-09-06 15:18:42 -0700957MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
958MODULE_DESCRIPTION("Linux device interface for the IPMI message handler.");
Scott James Remnant6c891612008-10-29 14:01:18 -0700959MODULE_ALIAS("platform:ipmi_si");