/drivers/staging/comedi/comedi_compat32.c

  1/*
  2    comedi/comedi_compat32.c
  3    32-bit ioctl compatibility for 64-bit comedi kernel module.
  4
  5    Author: Ian Abbott, MEV Ltd. <abbotti@mev.co.uk>
  6    Copyright (C) 2007 MEV Ltd. <http://www.mev.co.uk/>
  7
  8    COMEDI - Linux Control and Measurement Device Interface
  9    Copyright (C) 1997-2007 David A. Schleef <ds@schleef.org>
 10
 11    This program is free software; you can redistribute it and/or modify
 12    it under the terms of the GNU General Public License as published by
 13    the Free Software Foundation; either version 2 of the License, or
 14    (at your option) any later version.
 15
 16    This program is distributed in the hope that it will be useful,
 17    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 19    GNU General Public License for more details.
 20
 21    You should have received a copy of the GNU General Public License
 22    along with this program; if not, write to the Free Software
 23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 24
 25*/
 26
 27#define __NO_VERSION__
 28#include <linux/uaccess.h>
 29#include "comedi.h"
 30#include "comedi_compat32.h"
 31
 32#ifdef CONFIG_COMPAT
 33
 34#define COMEDI32_CHANINFO _IOR(CIO, 3, struct comedi32_chaninfo_struct)
 35#define COMEDI32_RANGEINFO _IOR(CIO, 8, struct comedi32_rangeinfo_struct)
 36/* N.B. COMEDI32_CMD and COMEDI_CMD ought to use _IOWR, not _IOR.
 37 * It's too late to change it now, but it only affects the command number. */
 38#define COMEDI32_CMD _IOR(CIO, 9, struct comedi32_cmd_struct)
 39/* N.B. COMEDI32_CMDTEST and COMEDI_CMDTEST ought to use _IOWR, not _IOR.
 40 * It's too late to change it now, but it only affects the command number. */
 41#define COMEDI32_CMDTEST _IOR(CIO, 10, struct comedi32_cmd_struct)
 42#define COMEDI32_INSNLIST _IOR(CIO, 11, struct comedi32_insnlist_struct)
 43#define COMEDI32_INSN _IOR(CIO, 12, struct comedi32_insn_struct)
 44
 45struct comedi32_chaninfo_struct {
 46	unsigned int subdev;
 47	compat_uptr_t maxdata_list;	/* 32-bit 'unsigned int *' */
 48	compat_uptr_t flaglist;	/* 32-bit 'unsigned int *' */
 49	compat_uptr_t rangelist;	/* 32-bit 'unsigned int *' */
 50	unsigned int unused[4];
 51};
 52
 53struct comedi32_rangeinfo_struct {
 54	unsigned int range_type;
 55	compat_uptr_t range_ptr;	/* 32-bit 'void *' */
 56};
 57
 58struct comedi32_cmd_struct {
 59	unsigned int subdev;
 60	unsigned int flags;
 61	unsigned int start_src;
 62	unsigned int start_arg;
 63	unsigned int scan_begin_src;
 64	unsigned int scan_begin_arg;
 65	unsigned int convert_src;
 66	unsigned int convert_arg;
 67	unsigned int scan_end_src;
 68	unsigned int scan_end_arg;
 69	unsigned int stop_src;
 70	unsigned int stop_arg;
 71	compat_uptr_t chanlist;	/* 32-bit 'unsigned int *' */
 72	unsigned int chanlist_len;
 73	compat_uptr_t data;	/* 32-bit 'short *' */
 74	unsigned int data_len;
 75};
 76
 77struct comedi32_insn_struct {
 78	unsigned int insn;
 79	unsigned int n;
 80	compat_uptr_t data;	/* 32-bit 'unsigned int *' */
 81	unsigned int subdev;
 82	unsigned int chanspec;
 83	unsigned int unused[3];
 84};
 85
 86struct comedi32_insnlist_struct {
 87	unsigned int n_insns;
 88	compat_uptr_t insns;	/* 32-bit 'struct comedi_insn *' */
 89};
 90
 91/* Handle translated ioctl. */
 92static int translated_ioctl(struct file *file, unsigned int cmd,
 93			    unsigned long arg)
 94{
 95	if (!file->f_op)
 96		return -ENOTTY;
 97
 98	if (file->f_op->unlocked_ioctl)
 99		return file->f_op->unlocked_ioctl(file, cmd, arg);
100
101	return -ENOTTY;
102}
103
104/* Handle 32-bit COMEDI_CHANINFO ioctl. */
105static int compat_chaninfo(struct file *file, unsigned long arg)
106{
107	struct comedi_chaninfo __user *chaninfo;
108	struct comedi32_chaninfo_struct __user *chaninfo32;
109	int err;
110	union {
111		unsigned int uint;
112		compat_uptr_t uptr;
113	} temp;
114
115	chaninfo32 = compat_ptr(arg);
116	chaninfo = compat_alloc_user_space(sizeof(*chaninfo));
117
118	/* Copy chaninfo structure.  Ignore unused members. */
119	if (!access_ok(VERIFY_READ, chaninfo32, sizeof(*chaninfo32))
120	    || !access_ok(VERIFY_WRITE, chaninfo, sizeof(*chaninfo))) {
121		return -EFAULT;
122	}
123	err = 0;
124	err |= __get_user(temp.uint, &chaninfo32->subdev);
125	err |= __put_user(temp.uint, &chaninfo->subdev);
126	err |= __get_user(temp.uptr, &chaninfo32->maxdata_list);
127	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->maxdata_list);
128	err |= __get_user(temp.uptr, &chaninfo32->flaglist);
129	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->flaglist);
130	err |= __get_user(temp.uptr, &chaninfo32->rangelist);
131	err |= __put_user(compat_ptr(temp.uptr), &chaninfo->rangelist);
132	if (err)
133		return -EFAULT;
134
135	return translated_ioctl(file, COMEDI_CHANINFO, (unsigned long)chaninfo);
136}
137
138/* Handle 32-bit COMEDI_RANGEINFO ioctl. */
139static int compat_rangeinfo(struct file *file, unsigned long arg)
140{
141	struct comedi_rangeinfo __user *rangeinfo;
142	struct comedi32_rangeinfo_struct __user *rangeinfo32;
143	int err;
144	union {
145		unsigned int uint;
146		compat_uptr_t uptr;
147	} temp;
148
149	rangeinfo32 = compat_ptr(arg);
150	rangeinfo = compat_alloc_user_space(sizeof(*rangeinfo));
151
152	/* Copy rangeinfo structure. */
153	if (!access_ok(VERIFY_READ, rangeinfo32, sizeof(*rangeinfo32))
154	    || !access_ok(VERIFY_WRITE, rangeinfo, sizeof(*rangeinfo))) {
155		return -EFAULT;
156	}
157	err = 0;
158	err |= __get_user(temp.uint, &rangeinfo32->range_type);
159	err |= __put_user(temp.uint, &rangeinfo->range_type);
160	err |= __get_user(temp.uptr, &rangeinfo32->range_ptr);
161	err |= __put_user(compat_ptr(temp.uptr), &rangeinfo->range_ptr);
162	if (err)
163		return -EFAULT;
164
165	return translated_ioctl(file, COMEDI_RANGEINFO,
166				(unsigned long)rangeinfo);
167}
168
169/* Copy 32-bit cmd structure to native cmd structure. */
170static int get_compat_cmd(struct comedi_cmd __user *cmd,
171			  struct comedi32_cmd_struct __user *cmd32)
172{
173	int err;
174	union {
175		unsigned int uint;
176		compat_uptr_t uptr;
177	} temp;
178
179	/* Copy cmd structure. */
180	if (!access_ok(VERIFY_READ, cmd32, sizeof(*cmd32))
181	    || !access_ok(VERIFY_WRITE, cmd, sizeof(*cmd))) {
182		return -EFAULT;
183	}
184	err = 0;
185	err |= __get_user(temp.uint, &cmd32->subdev);
186	err |= __put_user(temp.uint, &cmd->subdev);
187	err |= __get_user(temp.uint, &cmd32->flags);
188	err |= __put_user(temp.uint, &cmd->flags);
189	err |= __get_user(temp.uint, &cmd32->start_src);
190	err |= __put_user(temp.uint, &cmd->start_src);
191	err |= __get_user(temp.uint, &cmd32->start_arg);
192	err |= __put_user(temp.uint, &cmd->start_arg);
193	err |= __get_user(temp.uint, &cmd32->scan_begin_src);
194	err |= __put_user(temp.uint, &cmd->scan_begin_src);
195	err |= __get_user(temp.uint, &cmd32->scan_begin_arg);
196	err |= __put_user(temp.uint, &cmd->scan_begin_arg);
197	err |= __get_user(temp.uint, &cmd32->convert_src);
198	err |= __put_user(temp.uint, &cmd->convert_src);
199	err |= __get_user(temp.uint, &cmd32->convert_arg);
200	err |= __put_user(temp.uint, &cmd->convert_arg);
201	err |= __get_user(temp.uint, &cmd32->scan_end_src);
202	err |= __put_user(temp.uint, &cmd->scan_end_src);
203	err |= __get_user(temp.uint, &cmd32->scan_end_arg);
204	err |= __put_user(temp.uint, &cmd->scan_end_arg);
205	err |= __get_user(temp.uint, &cmd32->stop_src);
206	err |= __put_user(temp.uint, &cmd->stop_src);
207	err |= __get_user(temp.uint, &cmd32->stop_arg);
208	err |= __put_user(temp.uint, &cmd->stop_arg);
209	err |= __get_user(temp.uptr, &cmd32->chanlist);
210	err |= __put_user(compat_ptr(temp.uptr), &cmd->chanlist);
211	err |= __get_user(temp.uint, &cmd32->chanlist_len);
212	err |= __put_user(temp.uint, &cmd->chanlist_len);
213	err |= __get_user(temp.uptr, &cmd32->data);
214	err |= __put_user(compat_ptr(temp.uptr), &cmd->data);
215	err |= __get_user(temp.uint, &cmd32->data_len);
216	err |= __put_user(temp.uint, &cmd->data_len);
217	return err ? -EFAULT : 0;
218}
219
220/* Copy native cmd structure to 32-bit cmd structure. */
221static int put_compat_cmd(struct comedi32_cmd_struct __user *cmd32,
222			  struct comedi_cmd __user *cmd)
223{
224	int err;
225	unsigned int temp;
226
227	/* Copy back most of cmd structure. */
228	/* Assume the pointer values are already valid. */
229	/* (Could use ptr_to_compat() to set them, but that wasn't implemented
230	 * until kernel version 2.6.11.) */
231	if (!access_ok(VERIFY_READ, cmd, sizeof(*cmd))
232	    || !access_ok(VERIFY_WRITE, cmd32, sizeof(*cmd32))) {
233		return -EFAULT;
234	}
235	err = 0;
236	err |= __get_user(temp, &cmd->subdev);
237	err |= __put_user(temp, &cmd32->subdev);
238	err |= __get_user(temp, &cmd->flags);
239	err |= __put_user(temp, &cmd32->flags);
240	err |= __get_user(temp, &cmd->start_src);
241	err |= __put_user(temp, &cmd32->start_src);
242	err |= __get_user(temp, &cmd->start_arg);
243	err |= __put_user(temp, &cmd32->start_arg);
244	err |= __get_user(temp, &cmd->scan_begin_src);
245	err |= __put_user(temp, &cmd32->scan_begin_src);
246	err |= __get_user(temp, &cmd->scan_begin_arg);
247	err |= __put_user(temp, &cmd32->scan_begin_arg);
248	err |= __get_user(temp, &cmd->convert_src);
249	err |= __put_user(temp, &cmd32->convert_src);
250	err |= __get_user(temp, &cmd->convert_arg);
251	err |= __put_user(temp, &cmd32->convert_arg);
252	err |= __get_user(temp, &cmd->scan_end_src);
253	err |= __put_user(temp, &cmd32->scan_end_src);
254	err |= __get_user(temp, &cmd->scan_end_arg);
255	err |= __put_user(temp, &cmd32->scan_end_arg);
256	err |= __get_user(temp, &cmd->stop_src);
257	err |= __put_user(temp, &cmd32->stop_src);
258	err |= __get_user(temp, &cmd->stop_arg);
259	err |= __put_user(temp, &cmd32->stop_arg);
260	/* Assume chanlist pointer is unchanged. */
261	err |= __get_user(temp, &cmd->chanlist_len);
262	err |= __put_user(temp, &cmd32->chanlist_len);
263	/* Assume data pointer is unchanged. */
264	err |= __get_user(temp, &cmd->data_len);
265	err |= __put_user(temp, &cmd32->data_len);
266	return err ? -EFAULT : 0;
267}
268
269/* Handle 32-bit COMEDI_CMD ioctl. */
270static int compat_cmd(struct file *file, unsigned long arg)
271{
272	struct comedi_cmd __user *cmd;
273	struct comedi32_cmd_struct __user *cmd32;
274	int rc;
275
276	cmd32 = compat_ptr(arg);
277	cmd = compat_alloc_user_space(sizeof(*cmd));
278
279	rc = get_compat_cmd(cmd, cmd32);
280	if (rc)
281		return rc;
282
283	return translated_ioctl(file, COMEDI_CMD, (unsigned long)cmd);
284}
285
286/* Handle 32-bit COMEDI_CMDTEST ioctl. */
287static int compat_cmdtest(struct file *file, unsigned long arg)
288{
289	struct comedi_cmd __user *cmd;
290	struct comedi32_cmd_struct __user *cmd32;
291	int rc, err;
292
293	cmd32 = compat_ptr(arg);
294	cmd = compat_alloc_user_space(sizeof(*cmd));
295
296	rc = get_compat_cmd(cmd, cmd32);
297	if (rc)
298		return rc;
299
300	rc = translated_ioctl(file, COMEDI_CMDTEST, (unsigned long)cmd);
301	if (rc < 0)
302		return rc;
303
304	err = put_compat_cmd(cmd32, cmd);
305	if (err)
306		rc = err;
307
308	return rc;
309}
310
311/* Copy 32-bit insn structure to native insn structure. */
312static int get_compat_insn(struct comedi_insn __user *insn,
313			   struct comedi32_insn_struct __user *insn32)
314{
315	int err;
316	union {
317		unsigned int uint;
318		compat_uptr_t uptr;
319	} temp;
320
321	/* Copy insn structure.  Ignore the unused members. */
322	err = 0;
323	if (!access_ok(VERIFY_READ, insn32, sizeof(*insn32))
324	    || !access_ok(VERIFY_WRITE, insn, sizeof(*insn)))
325		return -EFAULT;
326
327	err |= __get_user(temp.uint, &insn32->insn);
328	err |= __put_user(temp.uint, &insn->insn);
329	err |= __get_user(temp.uint, &insn32->n);
330	err |= __put_user(temp.uint, &insn->n);
331	err |= __get_user(temp.uptr, &insn32->data);
332	err |= __put_user(compat_ptr(temp.uptr), &insn->data);
333	err |= __get_user(temp.uint, &insn32->subdev);
334	err |= __put_user(temp.uint, &insn->subdev);
335	err |= __get_user(temp.uint, &insn32->chanspec);
336	err |= __put_user(temp.uint, &insn->chanspec);
337	return err ? -EFAULT : 0;
338}
339
340/* Handle 32-bit COMEDI_INSNLIST ioctl. */
341static int compat_insnlist(struct file *file, unsigned long arg)
342{
343	struct combined_insnlist {
344		struct comedi_insnlist insnlist;
345		struct comedi_insn insn[1];
346	} __user *s;
347	struct comedi32_insnlist_struct __user *insnlist32;
348	struct comedi32_insn_struct __user *insn32;
349	compat_uptr_t uptr;
350	unsigned int n_insns, n;
351	int err, rc;
352
353	insnlist32 = compat_ptr(arg);
354
355	/* Get 32-bit insnlist structure.  */
356	if (!access_ok(VERIFY_READ, insnlist32, sizeof(*insnlist32)))
357		return -EFAULT;
358
359	err = 0;
360	err |= __get_user(n_insns, &insnlist32->n_insns);
361	err |= __get_user(uptr, &insnlist32->insns);
362	insn32 = compat_ptr(uptr);
363	if (err)
364		return -EFAULT;
365
366	/* Allocate user memory to copy insnlist and insns into. */
367	s = compat_alloc_user_space(offsetof(struct combined_insnlist,
368					     insn[n_insns]));
369
370	/* Set native insnlist structure. */
371	if (!access_ok(VERIFY_WRITE, &s->insnlist, sizeof(s->insnlist)))
372		return -EFAULT;
373
374	err |= __put_user(n_insns, &s->insnlist.n_insns);
375	err |= __put_user(&s->insn[0], &s->insnlist.insns);
376	if (err)
377		return -EFAULT;
378
379	/* Copy insn structures. */
380	for (n = 0; n < n_insns; n++) {
381		rc = get_compat_insn(&s->insn[n], &insn32[n]);
382		if (rc)
383			return rc;
384	}
385
386	return translated_ioctl(file, COMEDI_INSNLIST,
387				(unsigned long)&s->insnlist);
388}
389
390/* Handle 32-bit COMEDI_INSN ioctl. */
391static int compat_insn(struct file *file, unsigned long arg)
392{
393	struct comedi_insn __user *insn;
394	struct comedi32_insn_struct __user *insn32;
395	int rc;
396
397	insn32 = compat_ptr(arg);
398	insn = compat_alloc_user_space(sizeof(*insn));
399
400	rc = get_compat_insn(insn, insn32);
401	if (rc)
402		return rc;
403
404	return translated_ioctl(file, COMEDI_INSN, (unsigned long)insn);
405}
406
407/* Process untranslated ioctl. */
408/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
409static inline int raw_ioctl(struct file *file, unsigned int cmd,
410			    unsigned long arg)
411{
412	int rc;
413
414	switch (cmd) {
415	case COMEDI_DEVCONFIG:
416	case COMEDI_DEVINFO:
417	case COMEDI_SUBDINFO:
418	case COMEDI_BUFCONFIG:
419	case COMEDI_BUFINFO:
420		/* Just need to translate the pointer argument. */
421		arg = (unsigned long)compat_ptr(arg);
422		rc = translated_ioctl(file, cmd, arg);
423		break;
424	case COMEDI_LOCK:
425	case COMEDI_UNLOCK:
426	case COMEDI_CANCEL:
427	case COMEDI_POLL:
428		/* No translation needed. */
429		rc = translated_ioctl(file, cmd, arg);
430		break;
431	case COMEDI32_CHANINFO:
432		rc = compat_chaninfo(file, arg);
433		break;
434	case COMEDI32_RANGEINFO:
435		rc = compat_rangeinfo(file, arg);
436		break;
437	case COMEDI32_CMD:
438		rc = compat_cmd(file, arg);
439		break;
440	case COMEDI32_CMDTEST:
441		rc = compat_cmdtest(file, arg);
442		break;
443	case COMEDI32_INSNLIST:
444		rc = compat_insnlist(file, arg);
445		break;
446	case COMEDI32_INSN:
447		rc = compat_insn(file, arg);
448		break;
449	default:
450		rc = -ENOIOCTLCMD;
451		break;
452	}
453	return rc;
454}
455
456/* compat_ioctl file operation. */
457/* Returns -ENOIOCTLCMD for unrecognised ioctl codes. */
458long comedi_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
459{
460	return raw_ioctl(file, cmd, arg);
461}
462
463#endif /* CONFIG_COMPAT */