1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#define __NO_VERSION__
28#include "comedi.h"
29#include <linux/smp_lock.h>
30#include <asm/uaccess.h>
31
32#include "comedi_compat32.h"
33
34#ifdef CONFIG_COMPAT
35
36#ifndef HAVE_COMPAT_IOCTL
37#include <linux/ioctl32.h>
38#endif
39
40#define COMEDI32_CHANINFO _IOR(CIO, 3, struct comedi32_chaninfo_struct)
41#define COMEDI32_RANGEINFO _IOR(CIO, 8, struct comedi32_rangeinfo_struct)
42
43
44#define COMEDI32_CMD _IOR(CIO, 9, struct comedi32_cmd_struct)
45
46
47#define COMEDI32_CMDTEST _IOR(CIO, 10, struct comedi32_cmd_struct)
48#define COMEDI32_INSNLIST _IOR(CIO, 11, struct comedi32_insnlist_struct)
49#define COMEDI32_INSN _IOR(CIO, 12, struct comedi32_insn_struct)
50
51struct comedi32_chaninfo_struct {
52 unsigned int subdev;
53 compat_uptr_t maxdata_list;
54 compat_uptr_t flaglist;
55 compat_uptr_t rangelist;
56 unsigned int unused[4];
57};
58
59struct comedi32_rangeinfo_struct {
60 unsigned int range_type;
61 compat_uptr_t range_ptr;
62};
63
64struct comedi32_cmd_struct {
65 unsigned int subdev;
66 unsigned int flags;
67 unsigned int start_src;
68 unsigned int start_arg;
69 unsigned int scan_begin_src;
70 unsigned int scan_begin_arg;
71 unsigned int convert_src;
72 unsigned int convert_arg;
73 unsigned int scan_end_src;
74 unsigned int scan_end_arg;
75 unsigned int stop_src;
76 unsigned int stop_arg;
77 compat_uptr_t chanlist;
78 unsigned int chanlist_len;
79 compat_uptr_t data;
80 unsigned int data_len;
81};
82
83struct comedi32_insn_struct {
84 unsigned int insn;
85 unsigned int n;
86 compat_uptr_t data;
87 unsigned int subdev;
88 unsigned int chanspec;
89 unsigned int unused[3];
90};
91
92struct comedi32_insnlist_struct {
93 unsigned int n_insns;
94 compat_uptr_t insns;
95};
96
97
98static int translated_ioctl(struct file *file, unsigned int cmd,
99 unsigned long arg)
100{
101 if (!file->f_op)
102 return -ENOTTY;
103
104#ifdef HAVE_UNLOCKED_IOCTL
105 if (file->f_op->unlocked_ioctl) {
106 int rc = (int)(*file->f_op->unlocked_ioctl) (file, cmd, arg);
107 if (rc == -ENOIOCTLCMD)
108 rc = -ENOTTY;
109 return rc;
110 }
111#endif
112 if (file->f_op->ioctl) {
113 int rc;
114 lock_kernel();
115 rc = (*file->f_op->ioctl) (file->f_dentry->d_inode,
116 file, cmd, arg);
117 unlock_kernel();
118 return rc;
119 }
120 return -ENOTTY;
121}
122
123
124static int compat_chaninfo(struct file *file, unsigned long arg)
125{
126 struct comedi_chaninfo __user *chaninfo;
127 struct comedi32_chaninfo_struct __user *chaninfo32;
128 int err;
129 union {
130 unsigned int uint;
131 compat_uptr_t uptr;
132 } temp;
133
134 chaninfo32 = compat_ptr(arg);
135 chaninfo = compat_alloc_user_space(sizeof(*chaninfo));
136
137
138 if (!access_ok(VERIFY_READ, chaninfo32, sizeof(*chaninfo32))
139 || !access_ok(VERIFY_WRITE, chaninfo, sizeof(*chaninfo))) {
140 return -EFAULT;
141 }
142 err = 0;
143 err |= __get_user(temp.uint, &chaninfo32->subdev);
144 err |= __put_user(temp.uint, &chaninfo->subdev);
145 err |= __get_user(temp.uptr, &chaninfo32->maxdata_list);
146 err |= __put_user(compat_ptr(temp.uptr), &chaninfo->maxdata_list);
147 err |= __get_user(temp.uptr, &chaninfo32->flaglist);
148 err |= __put_user(compat_ptr(temp.uptr), &chaninfo->flaglist);
149 err |= __get_user(temp.uptr, &chaninfo32->rangelist);
150 err |= __put_user(compat_ptr(temp.uptr), &chaninfo->rangelist);
151 if (err)
152 return -EFAULT;
153
154 return translated_ioctl(file, COMEDI_CHANINFO, (unsigned long)chaninfo);
155}
156
157
158static int compat_rangeinfo(struct file *file, unsigned long arg)
159{
160 struct comedi_rangeinfo __user *rangeinfo;
161 struct comedi32_rangeinfo_struct __user *rangeinfo32;
162 int err;
163 union {
164 unsigned int uint;
165 compat_uptr_t uptr;
166 } temp;
167
168 rangeinfo32 = compat_ptr(arg);
169 rangeinfo = compat_alloc_user_space(sizeof(*rangeinfo));
170
171
172 if (!access_ok(VERIFY_READ, rangeinfo32, sizeof(*rangeinfo32))
173 || !access_ok(VERIFY_WRITE, rangeinfo, sizeof(*rangeinfo))) {
174 return -EFAULT;
175 }
176 err = 0;
177 err |= __get_user(temp.uint, &rangeinfo32->range_type);
178 err |= __put_user(temp.uint, &rangeinfo->range_type);
179 err |= __get_user(temp.uptr, &rangeinfo32->range_ptr);
180 err |= __put_user(compat_ptr(temp.uptr), &rangeinfo->range_ptr);
181 if (err)
182 return -EFAULT;
183
184 return translated_ioctl(file, COMEDI_RANGEINFO,
185 (unsigned long)rangeinfo);
186}
187
188
189static int get_compat_cmd(struct comedi_cmd __user * cmd,
190 struct comedi32_cmd_struct __user * cmd32)
191{
192 int err;
193 union {
194 unsigned int uint;
195 compat_uptr_t uptr;
196 } temp;
197
198
199 if (!access_ok(VERIFY_READ, cmd32, sizeof(*cmd32))
200 || !access_ok(VERIFY_WRITE, cmd, sizeof(*cmd))) {
201 return -EFAULT;
202 }
203 err = 0;
204 err |= __get_user(temp.uint, &cmd32->subdev);
205 err |= __put_user(temp.uint, &cmd->subdev);
206 err |= __get_user(temp.uint, &cmd32->flags);
207 err |= __put_user(temp.uint, &cmd->flags);
208 err |= __get_user(temp.uint, &cmd32->start_src);
209 err |= __put_user(temp.uint, &cmd->start_src);
210 err |= __get_user(temp.uint, &cmd32->start_arg);
211 err |= __put_user(temp.uint, &cmd->start_arg);
212 err |= __get_user(temp.uint, &cmd32->scan_begin_src);
213 err |= __put_user(temp.uint, &cmd->scan_begin_src);
214 err |= __get_user(temp.uint, &cmd32->scan_begin_arg);
215 err |= __put_user(temp.uint, &cmd->scan_begin_arg);
216 err |= __get_user(temp.uint, &cmd32->convert_src);
217 err |= __put_user(temp.uint, &cmd->convert_src);
218 err |= __get_user(temp.uint, &cmd32->convert_arg);
219 err |= __put_user(temp.uint, &cmd->convert_arg);
220 err |= __get_user(temp.uint, &cmd32->scan_end_src);
221 err |= __put_user(temp.uint, &cmd->scan_end_src);
222 err |= __get_user(temp.uint, &cmd32->scan_end_arg);
223 err |= __put_user(temp.uint, &cmd->scan_end_arg);
224 err |= __get_user(temp.uint, &cmd32->stop_src);
225 err |= __put_user(temp.uint, &cmd->stop_src);
226 err |= __get_user(temp.uint, &cmd32->stop_arg);
227 err |= __put_user(temp.uint, &cmd->stop_arg);
228 err |= __get_user(temp.uptr, &cmd32->chanlist);
229 err |= __put_user(compat_ptr(temp.uptr), &cmd->chanlist);
230 err |= __get_user(temp.uint, &cmd32->chanlist_len);
231 err |= __put_user(temp.uint, &cmd->chanlist_len);
232 err |= __get_user(temp.uptr, &cmd32->data);
233 err |= __put_user(compat_ptr(temp.uptr), &cmd->data);
234 err |= __get_user(temp.uint, &cmd32->data_len);
235 err |= __put_user(temp.uint, &cmd->data_len);
236 return err ? -EFAULT : 0;
237}
238
239
240static int put_compat_cmd(struct comedi32_cmd_struct __user * cmd32,
241 struct comedi_cmd __user * cmd)
242{
243 int err;
244 unsigned int temp;
245
246
247
248
249
250 if (!access_ok(VERIFY_READ, cmd, sizeof(*cmd))
251 || !access_ok(VERIFY_WRITE, cmd32, sizeof(*cmd32))) {
252 return -EFAULT;
253 }
254 err = 0;
255 err |= __get_user(temp, &cmd->subdev);
256 err |= __put_user(temp, &cmd32->subdev);
257 err |= __get_user(temp, &cmd->flags);
258 err |= __put_user(temp, &cmd32->flags);
259 err |= __get_user(temp, &cmd->start_src);
260 err |= __put_user(temp, &cmd32->start_src);
261 err |= __get_user(temp, &cmd->start_arg);
262 err |= __put_user(temp, &cmd32->start_arg);
263 err |= __get_user(temp, &cmd->scan_begin_src);
264 err |= __put_user(temp, &cmd32->scan_begin_src);
265 err |= __get_user(temp, &cmd->scan_begin_arg);
266 err |= __put_user(temp, &cmd32->scan_begin_arg);
267 err |= __get_user(temp, &cmd->convert_src);
268 err |= __put_user(temp, &cmd32->convert_src);
269 err |= __get_user(temp, &cmd->convert_arg);
270 err |= __put_user(temp, &cmd32->convert_arg);
271 err |= __get_user(temp, &cmd->scan_end_src);
272 err |= __put_user(temp, &cmd32->scan_end_src);
273 err |= __get_user(temp, &cmd->scan_end_arg);
274 err |= __put_user(temp, &cmd32->scan_end_arg);
275 err |= __get_user(temp, &cmd->stop_src);
276 err |= __put_user(temp, &cmd32->stop_src);
277 err |= __get_user(temp, &cmd->stop_arg);
278 err |= __put_user(temp, &cmd32->stop_arg);
279
280 err |= __get_user(temp, &cmd->chanlist_len);
281 err |= __put_user(temp, &cmd32->chanlist_len);
282
283 err |= __get_user(temp, &cmd->data_len);
284 err |= __put_user(temp, &cmd32->data_len);
285 return err ? -EFAULT : 0;
286}
287
288
289static int compat_cmd(struct file *file, unsigned long arg)
290{
291 struct comedi_cmd __user *cmd;
292 struct comedi32_cmd_struct __user *cmd32;
293 int rc;
294
295 cmd32 = compat_ptr(arg);
296 cmd = compat_alloc_user_space(sizeof(*cmd));
297
298 rc = get_compat_cmd(cmd, cmd32);
299 if (rc)
300 return rc;
301
302 return translated_ioctl(file, COMEDI_CMD, (unsigned long)cmd);
303}
304
305
306static int compat_cmdtest(struct file *file, unsigned long arg)
307{
308 struct comedi_cmd __user *cmd;
309 struct comedi32_cmd_struct __user *cmd32;
310 int rc, err;
311
312 cmd32 = compat_ptr(arg);
313 cmd = compat_alloc_user_space(sizeof(*cmd));
314
315 rc = get_compat_cmd(cmd, cmd32);
316 if (rc)
317 return rc;
318
319 rc = translated_ioctl(file, COMEDI_CMDTEST, (unsigned long)cmd);
320 if (rc < 0)
321 return rc;
322
323 err = put_compat_cmd(cmd32, cmd);
324 if (err)
325 rc = err;
326
327 return rc;
328}
329
330
331static int get_compat_insn(struct comedi_insn __user * insn,
332 struct comedi32_insn_struct __user * insn32)
333{
334 int err;
335 union {
336 unsigned int uint;
337 compat_uptr_t uptr;
338 } temp;
339
340
341 err = 0;
342 if (!access_ok(VERIFY_READ, insn32, sizeof(*insn32))
343 || !access_ok(VERIFY_WRITE, insn, sizeof(*insn)))
344 return -EFAULT;
345
346 err |= __get_user(temp.uint, &insn32->insn);
347 err |= __put_user(temp.uint, &insn->insn);
348 err |= __get_user(temp.uint, &insn32->n);
349 err |= __put_user(temp.uint, &insn->n);
350 err |= __get_user(temp.uptr, &insn32->data);
351 err |= __put_user(compat_ptr(temp.uptr), &insn->data);
352 err |= __get_user(temp.uint, &insn32->subdev);
353 err |= __put_user(temp.uint, &insn->subdev);
354 err |= __get_user(temp.uint, &insn32->chanspec);
355 err |= __put_user(temp.uint, &insn->chanspec);
356 return err ? -EFAULT : 0;
357}
358
359
360static int compat_insnlist(struct file *file, unsigned long arg)
361{
362 struct combined_insnlist {
363 struct comedi_insnlist insnlist;
364 struct comedi_insn insn[1];
365 } __user *s;
366 struct comedi32_insnlist_struct __user *insnlist32;
367 struct comedi32_insn_struct __user *insn32;
368 compat_uptr_t uptr;
369 unsigned int n_insns, n;
370 int err, rc;
371
372 insnlist32 = compat_ptr(arg);
373
374
375 if (!access_ok(VERIFY_READ, insnlist32, sizeof(*insnlist32))) {
376 return -EFAULT;
377 }
378 err = 0;
379 err |= __get_user(n_insns, &insnlist32->n_insns);
380 err |= __get_user(uptr, &insnlist32->insns);
381 insn32 = compat_ptr(uptr);
382 if (err)
383 return -EFAULT;
384
385
386 s = compat_alloc_user_space(offsetof(struct combined_insnlist,
387 insn[n_insns]));
388
389
390 if (!access_ok(VERIFY_WRITE, &s->insnlist, sizeof(s->insnlist))) {
391 return -EFAULT;
392 }
393 err |= __put_user(n_insns, &s->insnlist.n_insns);
394 err |= __put_user(&s->insn[0], &s->insnlist.insns);
395 if (err)
396 return -EFAULT;
397
398
399 for (n = 0; n < n_insns; n++) {
400 rc = get_compat_insn(&s->insn[n], &insn32[n]);
401 if (rc)
402 return rc;
403 }
404
405 return translated_ioctl(file, COMEDI_INSNLIST,
406 (unsigned long)&s->insnlist);
407}
408
409
410static int compat_insn(struct file *file, unsigned long arg)
411{
412 struct comedi_insn __user *insn;
413 struct comedi32_insn_struct __user *insn32;
414 int rc;
415
416 insn32 = compat_ptr(arg);
417 insn = compat_alloc_user_space(sizeof(*insn));
418
419 rc = get_compat_insn(insn, insn32);
420 if (rc)
421 return rc;
422
423 return translated_ioctl(file, COMEDI_INSN, (unsigned long)insn);
424}
425
426
427
428static inline int raw_ioctl(struct file *file, unsigned int cmd,
429 unsigned long arg)
430{
431 int rc;
432
433 switch (cmd) {
434 case COMEDI_DEVCONFIG:
435 case COMEDI_DEVINFO:
436 case COMEDI_SUBDINFO:
437 case COMEDI_BUFCONFIG:
438 case COMEDI_BUFINFO:
439
440 arg = (unsigned long)compat_ptr(arg);
441 rc = translated_ioctl(file, cmd, arg);
442 break;
443 case COMEDI_LOCK:
444 case COMEDI_UNLOCK:
445 case COMEDI_CANCEL:
446 case COMEDI_POLL:
447
448 rc = translated_ioctl(file, cmd, arg);
449 break;
450 case COMEDI32_CHANINFO:
451 rc = compat_chaninfo(file, arg);
452 break;
453 case COMEDI32_RANGEINFO:
454 rc = compat_rangeinfo(file, arg);
455 break;
456 case COMEDI32_CMD:
457 rc = compat_cmd(file, arg);
458 break;
459 case COMEDI32_CMDTEST:
460 rc = compat_cmdtest(file, arg);
461 break;
462 case COMEDI32_INSNLIST:
463 rc = compat_insnlist(file, arg);
464 break;
465 case COMEDI32_INSN:
466 rc = compat_insn(file, arg);
467 break;
468 default:
469 rc = -ENOIOCTLCMD;
470 break;
471 }
472 return rc;
473}
474
475#ifdef HAVE_COMPAT_IOCTL
476
477
478
479long comedi_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
480{
481 return raw_ioctl(file, cmd, arg);
482}
483
484#else
485
486
487
488
489
490
491
492
493
494
495
496
497static int mapped_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg,
498 struct file *file)
499{
500 int rc;
501
502
503 if (imajor(file->f_dentry->d_inode) != COMEDI_MAJOR)
504 return -ENOTTY;
505
506 rc = raw_ioctl(file, cmd, arg);
507
508 if (rc == -ENOIOCTLCMD)
509 rc = -ENOTTY;
510
511 return rc;
512}
513
514struct ioctl32_map {
515 unsigned int cmd;
516 int (*handler) (unsigned int, unsigned int, unsigned long,
517 struct file *);
518 int registered;
519};
520
521static struct ioctl32_map comedi_ioctl32_map[] = {
522 {COMEDI_DEVCONFIG, mapped_ioctl, 0},
523 {COMEDI_DEVINFO, mapped_ioctl, 0},
524 {COMEDI_SUBDINFO, mapped_ioctl, 0},
525 {COMEDI_BUFCONFIG, mapped_ioctl, 0},
526 {COMEDI_BUFINFO, mapped_ioctl, 0},
527 {COMEDI_LOCK, mapped_ioctl, 0},
528 {COMEDI_UNLOCK, mapped_ioctl, 0},
529 {COMEDI_CANCEL, mapped_ioctl, 0},
530 {COMEDI_POLL, mapped_ioctl, 0},
531 {COMEDI32_CHANINFO, mapped_ioctl, 0},
532 {COMEDI32_RANGEINFO, mapped_ioctl, 0},
533 {COMEDI32_CMD, mapped_ioctl, 0},
534 {COMEDI32_CMDTEST, mapped_ioctl, 0},
535 {COMEDI32_INSNLIST, mapped_ioctl, 0},
536 {COMEDI32_INSN, mapped_ioctl, 0},
537};
538
539#define NUM_IOCTL32_MAPS ARRAY_SIZE(comedi_ioctl32_map)
540
541
542void comedi_register_ioctl32(void)
543{
544 int n, rc;
545
546 for (n = 0; n < NUM_IOCTL32_MAPS; n++) {
547 rc = register_ioctl32_conversion(comedi_ioctl32_map[n].cmd,
548 comedi_ioctl32_map[n].handler);
549 if (rc) {
550 printk(KERN_WARNING
551 "comedi: failed to register 32-bit "
552 "compatible ioctl handler for 0x%X - "
553 "expect bad things to happen!\n",
554 comedi_ioctl32_map[n].cmd);
555 }
556 comedi_ioctl32_map[n].registered = !rc;
557 }
558}
559
560
561void comedi_unregister_ioctl32(void)
562{
563 int n, rc;
564
565 for (n = 0; n < NUM_IOCTL32_MAPS; n++) {
566 if (comedi_ioctl32_map[n].registered) {
567 rc = unregister_ioctl32_conversion(comedi_ioctl32_map
568 [n].cmd,
569 comedi_ioctl32_map
570 [n].handler);
571 if (rc) {
572 printk(KERN_ERR
573 "comedi: failed to unregister 32-bit "
574 "compatible ioctl handler for 0x%X - "
575 "expect kernel Oops!\n",
576 comedi_ioctl32_map[n].cmd);
577 } else {
578 comedi_ioctl32_map[n].registered = 0;
579 }
580 }
581 }
582}
583
584#endif
585
586#endif
587