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