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