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