arch/sparc64/kernel/ioctl32.c

   1 /* $Id: ioctl32.c,v 1.136 2002/01/14 09:49:52 davem Exp $
   2  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
   3  *
   4  * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
   5  * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
   6  * Copyright (C) 2003  Pavel Machek (pavel@suse.cz)
   7  *
   8  * These routines maintain argument size conversion between 32bit and 64bit
   9  * ioctls.
  10  */
  11
  12 #define INCLUDES
  13 #include "compat_ioctl.c"
  14 #include <linux/ncp_fs.h>
  15 #include <linux/syscalls.h>
  16 #include <asm/fbio.h>
  17 #include <asm/kbio.h>
  18 #include <asm/vuid_event.h>
  19 #include <asm/envctrl.h>
  20 #include <asm/display7seg.h>
  21 #include <asm/openpromio.h>
  22 #include <asm/audioio.h>
  23 #include <asm/watchdog.h>
  24
  25 /* Use this to get at 32-bit user passed pointers.
  26  * See sys_sparc32.c for description about it.
  27  */
  28 #define A(__x) ((void __user *)(unsigned long)(__x))
  29
  30 static __inline__ void *alloc_user_space(long len)
  31 {
  32         struct pt_regs *regs = current_thread_info()->kregs;
  33         unsigned long usp = regs->u_regs[UREG_I6];
  34
  35         if (!(test_thread_flag(TIF_32BIT)))
  36                 usp += STACK_BIAS;
  37
  38         return (void *) (usp - len);
  39 }
  40
  41 #define CODE
  42 #include "compat_ioctl.c"
  43
  44 struct  fbcmap32 {
  45         int             index;          /* first element (0 origin) */
  46         int             count;
  47         u32             red;
  48         u32             green;
  49         u32             blue;
  50 };
  51
  52 #define FBIOPUTCMAP32   _IOW('F', 3, struct fbcmap32)
  53 #define FBIOGETCMAP32   _IOW('F', 4, struct fbcmap32)
  54
  55 static int fbiogetputcmap(unsigned int fd, unsigned int cmd, unsigned long arg)
  56 {
  57         struct fbcmap f;
  58         int ret;
  59         char red[256], green[256], blue[256];
  60         u32 r, g, b;
  61         mm_segment_t old_fs = get_fs();
  62
  63         ret = get_user(f.index, &(((struct fbcmap32 __user *)arg)->index));
  64         ret |= __get_user(f.count, &(((struct fbcmap32 __user *)arg)->count));
  65         ret |= __get_user(r, &(((struct fbcmap32 __user *)arg)->red));
  66         ret |= __get_user(g, &(((struct fbcmap32 __user *)arg)->green));
  67         ret |= __get_user(b, &(((struct fbcmap32 __user *)arg)->blue));
  68         if (ret)
  69                 return -EFAULT;
  70         if ((f.index < 0) || (f.index > 255)) return -EINVAL;
  71         if (f.index + f.count > 256)
  72                 f.count = 256 - f.index;
  73         if (cmd == FBIOPUTCMAP32) {
  74                 ret = copy_from_user (red, A(r), f.count);
  75                 ret |= copy_from_user (green, A(g), f.count);
  76                 ret |= copy_from_user (blue, A(b), f.count);
  77                 if (ret)
  78                         return -EFAULT;
  79         }
  80         f.red = red; f.green = green; f.blue = blue;
  81         set_fs (KERNEL_DS);
  82         ret = sys_ioctl (fd, (cmd == FBIOPUTCMAP32) ? FBIOPUTCMAP_SPARC : FBIOGETCMAP_SPARC, (long)&f);
  83         set_fs (old_fs);
  84         if (!ret && cmd == FBIOGETCMAP32) {
  85                 ret = copy_to_user (A(r), red, f.count);
  86                 ret |= copy_to_user (A(g), green, f.count);
  87                 ret |= copy_to_user (A(b), blue, f.count);
  88         }
  89         return ret ? -EFAULT : 0;
  90 }
  91
  92 struct fbcursor32 {
  93         short set;              /* what to set, choose from the list above */
  94         short enable;           /* cursor on/off */
  95         struct fbcurpos pos;    /* cursor position */
  96         struct fbcurpos hot;    /* cursor hot spot */
  97         struct fbcmap32 cmap;   /* color map info */
  98         struct fbcurpos size;   /* cursor bit map size */
  99         u32     image;          /* cursor image bits */
 100         u32     mask;           /* cursor mask bits */
 101 };
 102
 103 #define FBIOSCURSOR32   _IOW('F', 24, struct fbcursor32)
 104 #define FBIOGCURSOR32   _IOW('F', 25, struct fbcursor32)
 105
 106 static int fbiogscursor(unsigned int fd, unsigned int cmd, unsigned long arg)
 107 {
 108         struct fbcursor f;
 109         int ret;
 110         char red[2], green[2], blue[2];
 111         char image[128], mask[128];
 112         u32 r, g, b;
 113         u32 m, i;
 114         mm_segment_t old_fs = get_fs();
 115
 116         ret = copy_from_user (&f, (struct fbcursor32 __user *) arg,
 117                               2 * sizeof (short) + 2 * sizeof(struct fbcurpos));
 118         ret |= __get_user(f.size.x,
 119                           &(((struct fbcursor32 __user *)arg)->size.x));
 120         ret |= __get_user(f.size.y,
 121                           &(((struct fbcursor32 __user *)arg)->size.y));
 122         ret |= __get_user(f.cmap.index,
 123                           &(((struct fbcursor32 __user *)arg)->cmap.index));
 124         ret |= __get_user(f.cmap.count,
 125                           &(((struct fbcursor32 __user *)arg)->cmap.count));
 126         ret |= __get_user(r, &(((struct fbcursor32 __user *)arg)->cmap.red));
 127         ret |= __get_user(g, &(((struct fbcursor32 __user *)arg)->cmap.green));
 128         ret |= __get_user(b, &(((struct fbcursor32 __user *)arg)->cmap.blue));
 129         ret |= __get_user(m, &(((struct fbcursor32 __user *)arg)->mask));
 130         ret |= __get_user(i, &(((struct fbcursor32 __user *)arg)->image));
 131         if (ret)
 132                 return -EFAULT;
 133         if (f.set & FB_CUR_SETCMAP) {
 134                 if ((uint) f.size.y > 32)
 135                         return -EINVAL;
 136                 ret = copy_from_user (mask, A(m), f.size.y * 4);
 137                 ret |= copy_from_user (image, A(i), f.size.y * 4);
 138                 if (ret)
 139                         return -EFAULT;
 140                 f.image = image; f.mask = mask;
 141         }
 142         if (f.set & FB_CUR_SETCMAP) {
 143                 ret = copy_from_user (red, A(r), 2);
 144                 ret |= copy_from_user (green, A(g), 2);
 145                 ret |= copy_from_user (blue, A(b), 2);
 146                 if (ret)
 147                         return -EFAULT;
 148                 f.cmap.red = red; f.cmap.green = green; f.cmap.blue = blue;
 149         }
 150         set_fs (KERNEL_DS);
 151         ret = sys_ioctl (fd, FBIOSCURSOR, (long)&f);
 152         set_fs (old_fs);
 153         return ret;
 154 }
 155
 156 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
 157 /* This really belongs in include/linux/drm.h -DaveM */
 158 #include "../../../drivers/char/drm/drm.h"
 159
 160 typedef struct drm32_version {
 161         int    version_major;     /* Major version                          */
 162         int    version_minor;     /* Minor version                          */
 163         int    version_patchlevel;/* Patch level                            */
 164         int    name_len;          /* Length of name buffer                  */
 165         u32    name;              /* Name of driver                         */
 166         int    date_len;          /* Length of date buffer                  */
 167         u32    date;              /* User-space buffer to hold date         */
 168         int    desc_len;          /* Length of desc buffer                  */
 169         u32    desc;              /* User-space buffer to hold desc         */
 170 } drm32_version_t;
 171 #define DRM32_IOCTL_VERSION    DRM_IOWR(0x00, drm32_version_t)
 172
 173 static int drm32_version(unsigned int fd, unsigned int cmd, unsigned long arg)
 174 {
 175         drm32_version_t __user *uversion = (drm32_version_t __user *)arg;
 176         char __user *name_ptr, *date_ptr, *desc_ptr;
 177         u32 tmp1, tmp2, tmp3;
 178         drm_version_t kversion;
 179         mm_segment_t old_fs;
 180         int ret;
 181
 182         memset(&kversion, 0, sizeof(kversion));
 183         if (get_user(kversion.name_len, &uversion->name_len) ||
 184             get_user(kversion.date_len, &uversion->date_len) ||
 185             get_user(kversion.desc_len, &uversion->desc_len) ||
 186             get_user(tmp1, &uversion->name) ||
 187             get_user(tmp2, &uversion->date) ||
 188             get_user(tmp3, &uversion->desc))
 189                 return -EFAULT;
 190
 191         name_ptr = A(tmp1);
 192         date_ptr = A(tmp2);
 193         desc_ptr = A(tmp3);
 194
 195         ret = -ENOMEM;
 196         if (kversion.name_len && name_ptr) {
 197                 kversion.name = kmalloc(kversion.name_len, GFP_KERNEL);
 198                 if (!kversion.name)
 199                         goto out;
 200         }
 201         if (kversion.date_len && date_ptr) {
 202                 kversion.date = kmalloc(kversion.date_len, GFP_KERNEL);
 203                 if (!kversion.date)
 204                         goto out;
 205         }
 206         if (kversion.desc_len && desc_ptr) {
 207                 kversion.desc = kmalloc(kversion.desc_len, GFP_KERNEL);
 208                 if (!kversion.desc)
 209                         goto out;
 210         }
 211
 212         old_fs = get_fs();
 213         set_fs(KERNEL_DS);
 214         ret = sys_ioctl (fd, DRM_IOCTL_VERSION, (unsigned long)&kversion);
 215         set_fs(old_fs);
 216
 217         if (!ret) {
 218                 if ((kversion.name &&
 219                      copy_to_user(name_ptr, kversion.name, kversion.name_len)) ||
 220                     (kversion.date &&
 221                      copy_to_user(date_ptr, kversion.date, kversion.date_len)) ||
 222                     (kversion.desc &&
 223                      copy_to_user(desc_ptr, kversion.desc, kversion.desc_len)))
 224                         ret = -EFAULT;
 225                 if (put_user(kversion.version_major, &uversion->version_major) ||
 226                     put_user(kversion.version_minor, &uversion->version_minor) ||
 227                     put_user(kversion.version_patchlevel, &uversion->version_patchlevel) ||
 228                     put_user(kversion.name_len, &uversion->name_len) ||
 229                     put_user(kversion.date_len, &uversion->date_len) ||
 230                     put_user(kversion.desc_len, &uversion->desc_len))
 231                         ret = -EFAULT;
 232         }
 233
 234 out:
 235         if (kversion.name)
 236                 kfree(kversion.name);
 237         if (kversion.date)
 238                 kfree(kversion.date);
 239         if (kversion.desc)
 240                 kfree(kversion.desc);
 241         return ret;
 242 }
 243
 244 typedef struct drm32_unique {
 245         int     unique_len;       /* Length of unique                       */
 246         u32     unique;           /* Unique name for driver instantiation   */
 247 } drm32_unique_t;
 248 #define DRM32_IOCTL_GET_UNIQUE DRM_IOWR(0x01, drm32_unique_t)
 249 #define DRM32_IOCTL_SET_UNIQUE DRM_IOW( 0x10, drm32_unique_t)
 250
 251 static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg)
 252 {
 253         drm32_unique_t __user *uarg = (drm32_unique_t __user *)arg;
 254         drm_unique_t karg;
 255         mm_segment_t old_fs;
 256         char __user *uptr;
 257         u32 tmp;
 258         int ret;
 259
 260         if (get_user(karg.unique_len, &uarg->unique_len))
 261                 return -EFAULT;
 262         karg.unique = NULL;
 263
 264         if (get_user(tmp, &uarg->unique))
 265                 return -EFAULT;
 266
 267         uptr = A(tmp);
 268
 269         if (uptr) {
 270                 karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);
 271                 if (!karg.unique)
 272                         return -ENOMEM;
 273                 if (cmd == DRM32_IOCTL_SET_UNIQUE &&
 274                     copy_from_user(karg.unique, uptr, karg.unique_len)) {
 275                         kfree(karg.unique);
 276                         return -EFAULT;
 277                 }
 278         }
 279
 280         old_fs = get_fs();
 281         set_fs(KERNEL_DS);
 282         if (cmd == DRM32_IOCTL_GET_UNIQUE)
 283                 ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);
 284         else
 285                 ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);
 286         set_fs(old_fs);
 287
 288         if (!ret) {
 289                 if (cmd == DRM32_IOCTL_GET_UNIQUE &&
 290                     uptr != NULL &&
 291                     copy_to_user(uptr, karg.unique, karg.unique_len))
 292                         ret = -EFAULT;
 293                 if (put_user(karg.unique_len, &uarg->unique_len))
 294                         ret = -EFAULT;
 295         }
 296
 297         if (karg.unique != NULL)
 298                 kfree(karg.unique);
 299
 300         return ret;
 301 }
 302
 303 typedef struct drm32_map {
 304         u32             offset;  /* Requested physical address (0 for SAREA)*/
 305         u32             size;    /* Requested physical size (bytes)         */
 306         drm_map_type_t  type;    /* Type of memory to map                   */
 307         drm_map_flags_t flags;   /* Flags                                   */
 308         u32             handle;  /* User-space: "Handle" to pass to mmap    */
 309                                  /* Kernel-space: kernel-virtual address    */
 310         int             mtrr;    /* MTRR slot used                          */
 311                                  /* Private data                            */
 312 } drm32_map_t;
 313 #define DRM32_IOCTL_ADD_MAP    DRM_IOWR(0x15, drm32_map_t)
 314
 315 static int drm32_addmap(unsigned int fd, unsigned int cmd, unsigned long arg)
 316 {
 317         drm32_map_t __user *uarg = (drm32_map_t __user *) arg;
 318         drm_map_t karg;
 319         mm_segment_t old_fs;
 320         u32 tmp;
 321         int ret;
 322
 323         ret  = get_user(karg.offset, &uarg->offset);
 324         ret |= get_user(karg.size, &uarg->size);
 325         ret |= get_user(karg.type, &uarg->type);
 326         ret |= get_user(karg.flags, &uarg->flags);
 327         ret |= get_user(tmp, &uarg->handle);
 328         ret |= get_user(karg.mtrr, &uarg->mtrr);
 329         if (ret)
 330                 return -EFAULT;
 331
 332         karg.handle = (void *) (unsigned long) tmp;
 333
 334         old_fs = get_fs();
 335         set_fs(KERNEL_DS);
 336         ret = sys_ioctl(fd, DRM_IOCTL_ADD_MAP, (unsigned long) &karg);
 337         set_fs(old_fs);
 338
 339         if (!ret) {
 340                 ret  = put_user(karg.offset, &uarg->offset);
 341                 ret |= put_user(karg.size, &uarg->size);
 342                 ret |= put_user(karg.type, &uarg->type);
 343                 ret |= put_user(karg.flags, &uarg->flags);
 344                 tmp = (u32) (long)karg.handle;
 345                 ret |= put_user(tmp, &uarg->handle);
 346                 ret |= put_user(karg.mtrr, &uarg->mtrr);
 347                 if (ret)
 348                         ret = -EFAULT;
 349         }
 350
 351         return ret;
 352 }
 353
 354 typedef struct drm32_buf_info {
 355         int            count;   /* Entries in list                           */
 356         u32            list;    /* (drm_buf_desc_t *) */
 357 } drm32_buf_info_t;
 358 #define DRM32_IOCTL_INFO_BUFS  DRM_IOWR(0x18, drm32_buf_info_t)
 359
 360 static int drm32_info_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 361 {
 362         drm32_buf_info_t __user *uarg = (drm32_buf_info_t __user *)arg;
 363         drm_buf_desc_t __user *ulist;
 364         drm_buf_info_t karg;
 365         mm_segment_t old_fs;
 366         int orig_count, ret;
 367         u32 tmp;
 368
 369         if (get_user(karg.count, &uarg->count) ||
 370             get_user(tmp, &uarg->list))
 371                 return -EFAULT;
 372
 373         ulist = A(tmp);
 374
 375         orig_count = karg.count;
 376
 377         karg.list = kmalloc(karg.count * sizeof(drm_buf_desc_t), GFP_KERNEL);
 378         if (!karg.list)
 379                 return -EFAULT;
 380
 381         old_fs = get_fs();
 382         set_fs(KERNEL_DS);
 383         ret = sys_ioctl(fd, DRM_IOCTL_INFO_BUFS, (unsigned long) &karg);
 384         set_fs(old_fs);
 385
 386         if (!ret) {
 387                 if (karg.count <= orig_count &&
 388                     (copy_to_user(ulist, karg.list,
 389                                   karg.count * sizeof(drm_buf_desc_t))))
 390                         ret = -EFAULT;
 391                 if (put_user(karg.count, &uarg->count))
 392                         ret = -EFAULT;
 393         }
 394
 395         kfree(karg.list);
 396
 397         return ret;
 398 }
 399
 400 typedef struct drm32_buf_free {
 401         int            count;
 402         u32            list;    /* (int *) */
 403 } drm32_buf_free_t;
 404 #define DRM32_IOCTL_FREE_BUFS  DRM_IOW( 0x1a, drm32_buf_free_t)
 405
 406 static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 407 {
 408         drm32_buf_free_t __user *uarg = (drm32_buf_free_t __user *)arg;
 409         drm_buf_free_t karg;
 410         mm_segment_t old_fs;
 411         int __user *ulist;
 412         int ret;
 413         u32 tmp;
 414
 415         if (get_user(karg.count, &uarg->count) ||
 416             get_user(tmp, &uarg->list))
 417                 return -EFAULT;
 418
 419         ulist = A(tmp);
 420
 421         karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);
 422         if (!karg.list)
 423                 return -ENOMEM;
 424
 425         ret = -EFAULT;
 426         if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))
 427                 goto out;
 428
 429         old_fs = get_fs();
 430         set_fs(KERNEL_DS);
 431         ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);
 432         set_fs(old_fs);
 433
 434 out:
 435         kfree(karg.list);
 436
 437         return ret;
 438 }
 439
 440 typedef struct drm32_buf_pub {
 441         int               idx;         /* Index into master buflist          */
 442         int               total;       /* Buffer size                        */
 443         int               used;        /* Amount of buffer in use (for DMA)  */
 444         u32               address;     /* Address of buffer (void *)         */
 445 } drm32_buf_pub_t;
 446
 447 typedef struct drm32_buf_map {
 448         int           count;    /* Length of buflist                        */
 449         u32           virtual;  /* Mmaped area in user-virtual (void *)     */
 450         u32           list;     /* Buffer information (drm_buf_pub_t *)     */
 451 } drm32_buf_map_t;
 452 #define DRM32_IOCTL_MAP_BUFS   DRM_IOWR(0x19, drm32_buf_map_t)
 453
 454 static int drm32_map_bufs(unsigned int fd, unsigned int cmd, unsigned long arg)
 455 {
 456         drm32_buf_map_t __user *uarg = (drm32_buf_map_t __user *)arg;
 457         drm32_buf_pub_t __user *ulist;
 458         drm_buf_map_t karg;
 459         mm_segment_t old_fs;
 460         int orig_count, ret, i;
 461         u32 tmp1, tmp2;
 462
 463         if (get_user(karg.count, &uarg->count) ||
 464             get_user(tmp1, &uarg->virtual) ||
 465             get_user(tmp2, &uarg->list))
 466                 return -EFAULT;
 467
 468         karg.virtual = (void *) (unsigned long) tmp1;
 469         ulist = A(tmp2);
 470
 471         orig_count = karg.count;
 472
 473         karg.list = kmalloc(karg.count * sizeof(drm_buf_pub_t), GFP_KERNEL);
 474         if (!karg.list)
 475                 return -ENOMEM;
 476
 477         ret = -EFAULT;
 478         for (i = 0; i < karg.count; i++) {
 479                 if (get_user(karg.list[i].idx, &ulist[i].idx) ||
 480                     get_user(karg.list[i].total, &ulist[i].total) ||
 481                     get_user(karg.list[i].used, &ulist[i].used) ||
 482                     get_user(tmp1, &ulist[i].address))
 483                         goto out;
 484
 485                 karg.list[i].address = (void *) (unsigned long) tmp1;
 486         }
 487
 488         old_fs = get_fs();
 489         set_fs(KERNEL_DS);
 490         ret = sys_ioctl(fd, DRM_IOCTL_MAP_BUFS, (unsigned long) &karg);
 491         set_fs(old_fs);
 492
 493         if (!ret) {
 494                 for (i = 0; i < orig_count; i++) {
 495                         tmp1 = (u32) (long) karg.list[i].address;
 496                         if (put_user(karg.list[i].idx, &ulist[i].idx) ||
 497                             put_user(karg.list[i].total, &ulist[i].total) ||
 498                             put_user(karg.list[i].used, &ulist[i].used) ||
 499                             put_user(tmp1, &ulist[i].address)) {
 500                                 ret = -EFAULT;
 501                                 goto out;
 502                         }
 503                 }
 504                 if (put_user(karg.count, &uarg->count))
 505                         ret = -EFAULT;
 506         }
 507
 508 out:
 509         kfree(karg.list);
 510         return ret;
 511 }
 512
 513 typedef struct drm32_dma {
 514                                 /* Indices here refer to the offset into
 515                                    buflist in drm_buf_get_t.  */
 516         int             context;          /* Context handle                 */
 517         int             send_count;       /* Number of buffers to send      */
 518         u32             send_indices;     /* List of handles to buffers (int *) */
 519         u32             send_sizes;       /* Lengths of data to send (int *) */
 520         drm_dma_flags_t flags;            /* Flags                          */
 521         int             request_count;    /* Number of buffers requested    */
 522         int             request_size;     /* Desired size for buffers       */
 523         u32             request_indices;  /* Buffer information (int *)     */
 524         u32             request_sizes;    /* (int *) */
 525         int             granted_count;    /* Number of buffers granted      */
 526 } drm32_dma_t;
 527 #define DRM32_IOCTL_DMA      DRM_IOWR(0x29, drm32_dma_t)
 528
 529 /* RED PEN      The DRM layer blindly dereferences the send/request
 530  *              index/size arrays even though they are userland
 531  *              pointers.  -DaveM
 532  */
 533 static int drm32_dma(unsigned int fd, unsigned int cmd, unsigned long arg)
 534 {
 535         drm32_dma_t __user *uarg = (drm32_dma_t __user *) arg;
 536         int __user *u_si, *u_ss, *u_ri, *u_rs;
 537         drm_dma_t karg;
 538         mm_segment_t old_fs;
 539         int ret;
 540         u32 tmp1, tmp2, tmp3, tmp4;
 541
 542         karg.send_indices = karg.send_sizes = NULL;
 543         karg.request_indices = karg.request_sizes = NULL;
 544
 545         if (get_user(karg.context, &uarg->context) ||
 546             get_user(karg.send_count, &uarg->send_count) ||
 547             get_user(tmp1, &uarg->send_indices) ||
 548             get_user(tmp2, &uarg->send_sizes) ||
 549             get_user(karg.flags, &uarg->flags) ||
 550             get_user(karg.request_count, &uarg->request_count) ||
 551             get_user(karg.request_size, &uarg->request_size) ||
 552             get_user(tmp3, &uarg->request_indices) ||
 553             get_user(tmp4, &uarg->request_sizes) ||
 554             get_user(karg.granted_count, &uarg->granted_count))
 555                 return -EFAULT;
 556
 557         u_si = A(tmp1);
 558         u_ss = A(tmp2);
 559         u_ri = A(tmp3);
 560         u_rs = A(tmp4);
 561
 562         if (karg.send_count) {
 563                 karg.send_indices = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
 564                 karg.send_sizes = kmalloc(karg.send_count * sizeof(int), GFP_KERNEL);
 565
 566                 ret = -ENOMEM;
 567                 if (!karg.send_indices || !karg.send_sizes)
 568                         goto out;
 569
 570                 ret = -EFAULT;
 571                 if (copy_from_user(karg.send_indices, u_si,
 572                                    (karg.send_count * sizeof(int))) ||
 573                     copy_from_user(karg.send_sizes, u_ss,
 574                                    (karg.send_count * sizeof(int))))
 575                         goto out;
 576         }
 577
 578         if (karg.request_count) {
 579                 karg.request_indices = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
 580                 karg.request_sizes = kmalloc(karg.request_count * sizeof(int), GFP_KERNEL);
 581
 582                 ret = -ENOMEM;
 583                 if (!karg.request_indices || !karg.request_sizes)
 584                         goto out;
 585
 586                 ret = -EFAULT;
 587                 if (copy_from_user(karg.request_indices, u_ri,
 588                                    (karg.request_count * sizeof(int))) ||
 589                     copy_from_user(karg.request_sizes, u_rs,
 590                                    (karg.request_count * sizeof(int))))
 591                         goto out;
 592         }
 593
 594         old_fs = get_fs();
 595         set_fs(KERNEL_DS);
 596         ret = sys_ioctl(fd, DRM_IOCTL_DMA, (unsigned long) &karg);
 597         set_fs(old_fs);
 598
 599         if (!ret) {
 600                 if (put_user(karg.context, &uarg->context) ||
 601                     put_user(karg.send_count, &uarg->send_count) ||
 602                     put_user(karg.flags, &uarg->flags) ||
 603                     put_user(karg.request_count, &uarg->request_count) ||
 604                     put_user(karg.request_size, &uarg->request_size) ||
 605                     put_user(karg.granted_count, &uarg->granted_count))
 606                         ret = -EFAULT;
 607
 608                 if (karg.send_count) {
 609                         if (copy_to_user(u_si, karg.send_indices,
 610                                          (karg.send_count * sizeof(int))) ||
 611                             copy_to_user(u_ss, karg.send_sizes,
 612                                          (karg.send_count * sizeof(int))))
 613                                 ret = -EFAULT;
 614                 }
 615                 if (karg.request_count) {
 616                         if (copy_to_user(u_ri, karg.request_indices,
 617                                          (karg.request_count * sizeof(int))) ||
 618                             copy_to_user(u_rs, karg.request_sizes,
 619                                          (karg.request_count * sizeof(int))))
 620                                 ret = -EFAULT;
 621                 }
 622         }
 623
 624 out:
 625         if (karg.send_indices)
 626                 kfree(karg.send_indices);
 627         if (karg.send_sizes)
 628                 kfree(karg.send_sizes);
 629         if (karg.request_indices)
 630                 kfree(karg.request_indices);
 631         if (karg.request_sizes)
 632                 kfree(karg.request_sizes);
 633
 634         return ret;
 635 }
 636
 637 typedef struct drm32_ctx_res {
 638         int             count;
 639         u32             contexts; /* (drm_ctx_t *) */
 640 } drm32_ctx_res_t;
 641 #define DRM32_IOCTL_RES_CTX    DRM_IOWR(0x26, drm32_ctx_res_t)
 642
 643 static int drm32_res_ctx(unsigned int fd, unsigned int cmd, unsigned long arg)
 644 {
 645         drm32_ctx_res_t __user *uarg = (drm32_ctx_res_t __user *) arg;
 646         drm_ctx_t __user *ulist;
 647         drm_ctx_res_t karg;
 648         mm_segment_t old_fs;
 649         int orig_count, ret;
 650         u32 tmp;
 651
 652         karg.contexts = NULL;
 653         if (get_user(karg.count, &uarg->count) ||
 654             get_user(tmp, &uarg->contexts))
 655                 return -EFAULT;
 656
 657         ulist = A(tmp);
 658
 659         orig_count = karg.count;
 660         if (karg.count && ulist) {
 661                 karg.contexts = kmalloc((karg.count * sizeof(drm_ctx_t)), GFP_KERNEL);
 662                 if (!karg.contexts)
 663                         return -ENOMEM;
 664                 if (copy_from_user(karg.contexts, ulist,
 665                                    (karg.count * sizeof(drm_ctx_t)))) {
 666                         kfree(karg.contexts);
 667                         return -EFAULT;
 668                 }
 669         }
 670
 671         old_fs = get_fs();
 672         set_fs(KERNEL_DS);
 673         ret = sys_ioctl(fd, DRM_IOCTL_RES_CTX, (unsigned long) &karg);
 674         set_fs(old_fs);
 675
 676         if (!ret) {
 677                 if (orig_count) {
 678                         if (copy_to_user(ulist, karg.contexts,
 679                                          (orig_count * sizeof(drm_ctx_t))))
 680                                 ret = -EFAULT;
 681                 }
 682                 if (put_user(karg.count, &uarg->count))
 683                         ret = -EFAULT;
 684         }
 685
 686         if (karg.contexts)
 687                 kfree(karg.contexts);
 688
 689         return ret;
 690 }
 691
 692 #endif
 693
 694 typedef int (* ioctl32_handler_t)(unsigned int, unsigned int, unsigned long, struct file *);
 695
 696 #define COMPATIBLE_IOCTL(cmd)           HANDLE_IOCTL((cmd),sys_ioctl)
 697 #define HANDLE_IOCTL(cmd,handler)       { (cmd), (ioctl32_handler_t)(handler), NULL },
 698 #define IOCTL_TABLE_START \
 699         struct ioctl_trans ioctl_start[] = {
 700 #define IOCTL_TABLE_END \
 701         };
 702
 703 IOCTL_TABLE_START
 704 #include <linux/compat_ioctl.h>
 705 #define DECLARES
 706 #include "compat_ioctl.c"
 707 COMPATIBLE_IOCTL(TCSBRKP)
 708 COMPATIBLE_IOCTL(TIOCSTART)
 709 COMPATIBLE_IOCTL(TIOCSTOP)
 710 COMPATIBLE_IOCTL(TIOCSLTC)
 711 COMPATIBLE_IOCTL(FBIOGTYPE)
 712 COMPATIBLE_IOCTL(FBIOSATTR)
 713 COMPATIBLE_IOCTL(FBIOGATTR)
 714 COMPATIBLE_IOCTL(FBIOSVIDEO)
 715 COMPATIBLE_IOCTL(FBIOGVIDEO)
 716 COMPATIBLE_IOCTL(FBIOGCURSOR32)  /* This is not implemented yet. Later it should be converted... */
 717 COMPATIBLE_IOCTL(FBIOSCURPOS)
 718 COMPATIBLE_IOCTL(FBIOGCURPOS)
 719 COMPATIBLE_IOCTL(FBIOGCURMAX)
 720 /* Little k */
 721 COMPATIBLE_IOCTL(KIOCTYPE)
 722 COMPATIBLE_IOCTL(KIOCLAYOUT)
 723 COMPATIBLE_IOCTL(KIOCGTRANS)
 724 COMPATIBLE_IOCTL(KIOCTRANS)
 725 COMPATIBLE_IOCTL(KIOCCMD)
 726 COMPATIBLE_IOCTL(KIOCSDIRECT)
 727 COMPATIBLE_IOCTL(KIOCSLED)
 728 COMPATIBLE_IOCTL(KIOCGLED)
 729 COMPATIBLE_IOCTL(KIOCSRATE)
 730 COMPATIBLE_IOCTL(KIOCGRATE)
 731 COMPATIBLE_IOCTL(VUIDSFORMAT)
 732 COMPATIBLE_IOCTL(VUIDGFORMAT)
 733 /* Little v, the video4linux ioctls */
 734 COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
 735 COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
 736 COMPATIBLE_IOCTL(ENVCTRL_RD_WARNING_TEMPERATURE)
 737 COMPATIBLE_IOCTL(ENVCTRL_RD_SHUTDOWN_TEMPERATURE)
 738 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_TEMPERATURE)
 739 COMPATIBLE_IOCTL(ENVCTRL_RD_FAN_STATUS)
 740 COMPATIBLE_IOCTL(ENVCTRL_RD_VOLTAGE_STATUS)
 741 COMPATIBLE_IOCTL(ENVCTRL_RD_SCSI_TEMPERATURE)
 742 COMPATIBLE_IOCTL(ENVCTRL_RD_ETHERNET_TEMPERATURE)
 743 COMPATIBLE_IOCTL(ENVCTRL_RD_MTHRBD_TEMPERATURE)
 744 COMPATIBLE_IOCTL(ENVCTRL_RD_CPU_VOLTAGE)
 745 COMPATIBLE_IOCTL(ENVCTRL_RD_GLOBALADDRESS)
 746 /* COMPATIBLE_IOCTL(D7SIOCRD) same value as ENVCTRL_RD_VOLTAGE_STATUS */
 747 COMPATIBLE_IOCTL(D7SIOCWR)
 748 COMPATIBLE_IOCTL(D7SIOCTM)
 749 /* OPENPROMIO, SunOS/Solaris only, the NetBSD one's have
 750  * embedded pointers in the arg which we'd need to clean up...
 751  */
 752 COMPATIBLE_IOCTL(OPROMGETOPT)
 753 COMPATIBLE_IOCTL(OPROMSETOPT)
 754 COMPATIBLE_IOCTL(OPROMNXTOPT)
 755 COMPATIBLE_IOCTL(OPROMSETOPT2)
 756 COMPATIBLE_IOCTL(OPROMNEXT)
 757 COMPATIBLE_IOCTL(OPROMCHILD)
 758 COMPATIBLE_IOCTL(OPROMGETPROP)
 759 COMPATIBLE_IOCTL(OPROMNXTPROP)
 760 COMPATIBLE_IOCTL(OPROMU2P)
 761 COMPATIBLE_IOCTL(OPROMGETCONS)
 762 COMPATIBLE_IOCTL(OPROMGETFBNAME)
 763 COMPATIBLE_IOCTL(OPROMGETBOOTARGS)
 764 COMPATIBLE_IOCTL(OPROMSETCUR)
 765 COMPATIBLE_IOCTL(OPROMPCI2NODE)
 766 COMPATIBLE_IOCTL(OPROMPATH2NODE)
 767 /* Big L */
 768 COMPATIBLE_IOCTL(LOOP_SET_STATUS64)
 769 COMPATIBLE_IOCTL(LOOP_GET_STATUS64)
 770 /* Big A */
 771 COMPATIBLE_IOCTL(AUDIO_GETINFO)
 772 COMPATIBLE_IOCTL(AUDIO_SETINFO)
 773 COMPATIBLE_IOCTL(AUDIO_DRAIN)
 774 COMPATIBLE_IOCTL(AUDIO_GETDEV)
 775 COMPATIBLE_IOCTL(AUDIO_GETDEV_SUNOS)
 776 COMPATIBLE_IOCTL(AUDIO_FLUSH)
 777 COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
 778 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
 779 COMPATIBLE_IOCTL(DRM_IOCTL_GET_MAGIC)
 780 COMPATIBLE_IOCTL(DRM_IOCTL_IRQ_BUSID)
 781 COMPATIBLE_IOCTL(DRM_IOCTL_AUTH_MAGIC)
 782 COMPATIBLE_IOCTL(DRM_IOCTL_BLOCK)
 783 COMPATIBLE_IOCTL(DRM_IOCTL_UNBLOCK)
 784 COMPATIBLE_IOCTL(DRM_IOCTL_CONTROL)
 785 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_BUFS)
 786 COMPATIBLE_IOCTL(DRM_IOCTL_MARK_BUFS)
 787 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_CTX)
 788 COMPATIBLE_IOCTL(DRM_IOCTL_RM_CTX)
 789 COMPATIBLE_IOCTL(DRM_IOCTL_MOD_CTX)
 790 COMPATIBLE_IOCTL(DRM_IOCTL_GET_CTX)
 791 COMPATIBLE_IOCTL(DRM_IOCTL_SWITCH_CTX)
 792 COMPATIBLE_IOCTL(DRM_IOCTL_NEW_CTX)
 793 COMPATIBLE_IOCTL(DRM_IOCTL_ADD_DRAW)
 794 COMPATIBLE_IOCTL(DRM_IOCTL_RM_DRAW)
 795 COMPATIBLE_IOCTL(DRM_IOCTL_LOCK)
 796 COMPATIBLE_IOCTL(DRM_IOCTL_UNLOCK)
 797 COMPATIBLE_IOCTL(DRM_IOCTL_FINISH)
 798 #endif /* DRM */
 799 COMPATIBLE_IOCTL(WIOCSTART)
 800 COMPATIBLE_IOCTL(WIOCSTOP)
 801 COMPATIBLE_IOCTL(WIOCGSTAT)
 802 /* And these ioctls need translation */
 803 /* Note SIOCRTMSG is no longer, so this is safe and * the user would have seen just an -EINVAL anyways. */
 804 HANDLE_IOCTL(FBIOPUTCMAP32, fbiogetputcmap)
 805 HANDLE_IOCTL(FBIOGETCMAP32, fbiogetputcmap)
 806 HANDLE_IOCTL(FBIOSCURSOR32, fbiogscursor)
 807 #if defined(CONFIG_DRM) || defined(CONFIG_DRM_MODULE)
 808 HANDLE_IOCTL(DRM32_IOCTL_VERSION, drm32_version)
 809 HANDLE_IOCTL(DRM32_IOCTL_GET_UNIQUE, drm32_getsetunique)
 810 HANDLE_IOCTL(DRM32_IOCTL_SET_UNIQUE, drm32_getsetunique)
 811 HANDLE_IOCTL(DRM32_IOCTL_ADD_MAP, drm32_addmap)
 812 HANDLE_IOCTL(DRM32_IOCTL_INFO_BUFS, drm32_info_bufs)
 813 HANDLE_IOCTL(DRM32_IOCTL_FREE_BUFS, drm32_free_bufs)
 814 HANDLE_IOCTL(DRM32_IOCTL_MAP_BUFS, drm32_map_bufs)
 815 HANDLE_IOCTL(DRM32_IOCTL_DMA, drm32_dma)
 816 HANDLE_IOCTL(DRM32_IOCTL_RES_CTX, drm32_res_ctx)
 817 #endif /* DRM */
 818 #if 0
 819 HANDLE_IOCTL(RTC32_IRQP_READ, do_rtc_ioctl)
 820 HANDLE_IOCTL(RTC32_IRQP_SET, do_rtc_ioctl)
 821 HANDLE_IOCTL(RTC32_EPOCH_READ, do_rtc_ioctl)
 822 HANDLE_IOCTL(RTC32_EPOCH_SET, do_rtc_ioctl)
 823 #endif
 824 /* take care of sizeof(sizeof()) breakage */
 825 IOCTL_TABLE_END
 826
 827 int ioctl_table_size = ARRAY_SIZE(ioctl_start);