1 /* 2 * \file drm_ioc32.c 3 * 4 * 32-bit ioctl compatibility routines for the DRM. 5 * 6 * \author Paul Mackerras <paulus@samba.org> 7 * 8 * Copyright (C) Paul Mackerras 2005. 9 * All Rights Reserved. 10 * 11 * Permission is hereby granted, free of charge, to any person obtaining a 12 * copy of this software and associated documentation files (the "Software"), 13 * to deal in the Software without restriction, including without limitation 14 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 15 * and/or sell copies of the Software, and to permit persons to whom the 16 * Software is furnished to do so, subject to the following conditions: 17 * 18 * The above copyright notice and this permission notice (including the next 19 * paragraph) shall be included in all copies or substantial portions of the 20 * Software. 21 * 22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 25 * THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 26 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 27 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 28 * IN THE SOFTWARE. 29 */ 30 #include <linux/compat.h> 31 #include <linux/ratelimit.h> 32 #include <linux/export.h> 33 34 #include <drm/drm_agpsupport.h> 35 #include <drm/drm_file.h> 36 #include <drm/drm_print.h> 37 38 #include "drm_crtc_internal.h" 39 #include "drm_internal.h" 40 #include "drm_legacy.h" 41 42 #define DRM_IOCTL_VERSION32 DRM_IOWR(0x00, drm_version32_t) 43 #define DRM_IOCTL_GET_UNIQUE32 DRM_IOWR(0x01, drm_unique32_t) 44 #define DRM_IOCTL_GET_MAP32 DRM_IOWR(0x04, drm_map32_t) 45 #define DRM_IOCTL_GET_CLIENT32 DRM_IOWR(0x05, drm_client32_t) 46 #define DRM_IOCTL_GET_STATS32 DRM_IOR( 0x06, drm_stats32_t) 47 48 #define DRM_IOCTL_SET_UNIQUE32 DRM_IOW( 0x10, drm_unique32_t) 49 #define DRM_IOCTL_ADD_MAP32 DRM_IOWR(0x15, drm_map32_t) 50 #define DRM_IOCTL_ADD_BUFS32 DRM_IOWR(0x16, drm_buf_desc32_t) 51 #define DRM_IOCTL_MARK_BUFS32 DRM_IOW( 0x17, drm_buf_desc32_t) 52 #define DRM_IOCTL_INFO_BUFS32 DRM_IOWR(0x18, drm_buf_info32_t) 53 #define DRM_IOCTL_MAP_BUFS32 DRM_IOWR(0x19, drm_buf_map32_t) 54 #define DRM_IOCTL_FREE_BUFS32 DRM_IOW( 0x1a, drm_buf_free32_t) 55 56 #define DRM_IOCTL_RM_MAP32 DRM_IOW( 0x1b, drm_map32_t) 57 58 #define DRM_IOCTL_SET_SAREA_CTX32 DRM_IOW( 0x1c, drm_ctx_priv_map32_t) 59 #define DRM_IOCTL_GET_SAREA_CTX32 DRM_IOWR(0x1d, drm_ctx_priv_map32_t) 60 61 #define DRM_IOCTL_RES_CTX32 DRM_IOWR(0x26, drm_ctx_res32_t) 62 #define DRM_IOCTL_DMA32 DRM_IOWR(0x29, drm_dma32_t) 63 64 #define DRM_IOCTL_AGP_ENABLE32 DRM_IOW( 0x32, drm_agp_mode32_t) 65 #define DRM_IOCTL_AGP_INFO32 DRM_IOR( 0x33, drm_agp_info32_t) 66 #define DRM_IOCTL_AGP_ALLOC32 DRM_IOWR(0x34, drm_agp_buffer32_t) 67 #define DRM_IOCTL_AGP_FREE32 DRM_IOW( 0x35, drm_agp_buffer32_t) 68 #define DRM_IOCTL_AGP_BIND32 DRM_IOW( 0x36, drm_agp_binding32_t) 69 #define DRM_IOCTL_AGP_UNBIND32 DRM_IOW( 0x37, drm_agp_binding32_t) 70 71 #define DRM_IOCTL_SG_ALLOC32 DRM_IOW( 0x38, drm_scatter_gather32_t) 72 #define DRM_IOCTL_SG_FREE32 DRM_IOW( 0x39, drm_scatter_gather32_t) 73 74 #define DRM_IOCTL_UPDATE_DRAW32 DRM_IOW( 0x3f, drm_update_draw32_t) 75 76 #define DRM_IOCTL_WAIT_VBLANK32 DRM_IOWR(0x3a, drm_wait_vblank32_t) 77 78 #define DRM_IOCTL_MODE_ADDFB232 DRM_IOWR(0xb8, drm_mode_fb_cmd232_t) 79 80 typedef struct drm_version_32 { 81 int version_major; /* Major version */ 82 int version_minor; /* Minor version */ 83 int version_patchlevel; /* Patch level */ 84 u32 name_len; /* Length of name buffer */ 85 u32 name; /* Name of driver */ 86 u32 date_len; /* Length of date buffer */ 87 u32 date; /* User-space buffer to hold date */ 88 u32 desc_len; /* Length of desc buffer */ 89 u32 desc; /* User-space buffer to hold desc */ 90 } drm_version32_t; 91 92 static int compat_drm_version(struct file *file, unsigned int cmd, 93 unsigned long arg) 94 { 95 drm_version32_t v32; 96 struct drm_version v; 97 int err; 98 99 if (copy_from_user(&v32, (void __user *)arg, sizeof(v32))) 100 return -EFAULT; 101 102 v = (struct drm_version) { 103 .name_len = v32.name_len, 104 .name = compat_ptr(v32.name), 105 .date_len = v32.date_len, 106 .date = compat_ptr(v32.date), 107 .desc_len = v32.desc_len, 108 .desc = compat_ptr(v32.desc), 109 }; 110 err = drm_ioctl_kernel(file, drm_version, &v, 111 DRM_RENDER_ALLOW); 112 if (err) 113 return err; 114 115 v32.version_major = v.version_major; 116 v32.version_minor = v.version_minor; 117 v32.version_patchlevel = v.version_patchlevel; 118 v32.name_len = v.name_len; 119 v32.date_len = v.date_len; 120 v32.desc_len = v.desc_len; 121 if (copy_to_user((void __user *)arg, &v32, sizeof(v32))) 122 return -EFAULT; 123 return 0; 124 } 125 126 typedef struct drm_unique32 { 127 u32 unique_len; /* Length of unique */ 128 u32 unique; /* Unique name for driver instantiation */ 129 } drm_unique32_t; 130 131 static int compat_drm_getunique(struct file *file, unsigned int cmd, 132 unsigned long arg) 133 { 134 drm_unique32_t uq32; 135 struct drm_unique uq; 136 int err; 137 138 if (copy_from_user(&uq32, (void __user *)arg, sizeof(uq32))) 139 return -EFAULT; 140 uq = (struct drm_unique){ 141 .unique_len = uq32.unique_len, 142 .unique = compat_ptr(uq32.unique), 143 }; 144 145 err = drm_ioctl_kernel(file, drm_getunique, &uq, 0); 146 if (err) 147 return err; 148 149 uq32.unique_len = uq.unique_len; 150 if (copy_to_user((void __user *)arg, &uq32, sizeof(uq32))) 151 return -EFAULT; 152 return 0; 153 } 154 155 static int compat_drm_setunique(struct file *file, unsigned int cmd, 156 unsigned long arg) 157 { 158 /* it's dead */ 159 return -EINVAL; 160 } 161 162 #if IS_ENABLED(CONFIG_DRM_LEGACY) 163 typedef struct drm_map32 { 164 u32 offset; /* Requested physical address (0 for SAREA) */ 165 u32 size; /* Requested physical size (bytes) */ 166 enum drm_map_type type; /* Type of memory to map */ 167 enum drm_map_flags flags; /* Flags */ 168 u32 handle; /* User-space: "Handle" to pass to mmap() */ 169 int mtrr; /* MTRR slot used */ 170 } drm_map32_t; 171 172 static int compat_drm_getmap(struct file *file, unsigned int cmd, 173 unsigned long arg) 174 { 175 drm_map32_t __user *argp = (void __user *)arg; 176 drm_map32_t m32; 177 struct drm_map map; 178 int err; 179 180 if (copy_from_user(&m32, argp, sizeof(m32))) 181 return -EFAULT; 182 183 map.offset = m32.offset; 184 err = drm_ioctl_kernel(file, drm_legacy_getmap_ioctl, &map, 0); 185 if (err) 186 return err; 187 188 m32.offset = map.offset; 189 m32.size = map.size; 190 m32.type = map.type; 191 m32.flags = map.flags; 192 m32.handle = ptr_to_compat((void __user *)map.handle); 193 m32.mtrr = map.mtrr; 194 if (copy_to_user(argp, &m32, sizeof(m32))) 195 return -EFAULT; 196 return 0; 197 198 } 199 200 static int compat_drm_addmap(struct file *file, unsigned int cmd, 201 unsigned long arg) 202 { 203 drm_map32_t __user *argp = (void __user *)arg; 204 drm_map32_t m32; 205 struct drm_map map; 206 int err; 207 208 if (copy_from_user(&m32, argp, sizeof(m32))) 209 return -EFAULT; 210 211 map.offset = m32.offset; 212 map.size = m32.size; 213 map.type = m32.type; 214 map.flags = m32.flags; 215 216 err = drm_ioctl_kernel(file, drm_legacy_addmap_ioctl, &map, 217 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 218 if (err) 219 return err; 220 221 m32.offset = map.offset; 222 m32.mtrr = map.mtrr; 223 m32.handle = ptr_to_compat((void __user *)map.handle); 224 if (map.handle != compat_ptr(m32.handle)) 225 pr_err_ratelimited("compat_drm_addmap truncated handle %p for type %d offset %x\n", 226 map.handle, m32.type, m32.offset); 227 228 if (copy_to_user(argp, &m32, sizeof(m32))) 229 return -EFAULT; 230 231 return 0; 232 } 233 234 static int compat_drm_rmmap(struct file *file, unsigned int cmd, 235 unsigned long arg) 236 { 237 drm_map32_t __user *argp = (void __user *)arg; 238 struct drm_map map; 239 u32 handle; 240 241 if (get_user(handle, &argp->handle)) 242 return -EFAULT; 243 map.handle = compat_ptr(handle); 244 return drm_ioctl_kernel(file, drm_legacy_rmmap_ioctl, &map, DRM_AUTH); 245 } 246 #endif 247 248 typedef struct drm_client32 { 249 int idx; /* Which client desired? */ 250 int auth; /* Is client authenticated? */ 251 u32 pid; /* Process ID */ 252 u32 uid; /* User ID */ 253 u32 magic; /* Magic */ 254 u32 iocs; /* Ioctl count */ 255 } drm_client32_t; 256 257 static int compat_drm_getclient(struct file *file, unsigned int cmd, 258 unsigned long arg) 259 { 260 drm_client32_t c32; 261 drm_client32_t __user *argp = (void __user *)arg; 262 struct drm_client client; 263 int err; 264 265 if (copy_from_user(&c32, argp, sizeof(c32))) 266 return -EFAULT; 267 268 client.idx = c32.idx; 269 270 err = drm_ioctl_kernel(file, drm_getclient, &client, 0); 271 if (err) 272 return err; 273 274 c32.idx = client.idx; 275 c32.auth = client.auth; 276 c32.pid = client.pid; 277 c32.uid = client.uid; 278 c32.magic = client.magic; 279 c32.iocs = client.iocs; 280 281 if (copy_to_user(argp, &c32, sizeof(c32))) 282 return -EFAULT; 283 return 0; 284 } 285 286 typedef struct drm_stats32 { 287 u32 count; 288 struct { 289 u32 value; 290 enum drm_stat_type type; 291 } data[15]; 292 } drm_stats32_t; 293 294 static int compat_drm_getstats(struct file *file, unsigned int cmd, 295 unsigned long arg) 296 { 297 drm_stats32_t __user *argp = (void __user *)arg; 298 int err; 299 300 err = drm_ioctl_kernel(file, drm_noop, NULL, 0); 301 if (err) 302 return err; 303 304 if (clear_user(argp, sizeof(drm_stats32_t))) 305 return -EFAULT; 306 return 0; 307 } 308 309 #if IS_ENABLED(CONFIG_DRM_LEGACY) 310 typedef struct drm_buf_desc32 { 311 int count; /* Number of buffers of this size */ 312 int size; /* Size in bytes */ 313 int low_mark; /* Low water mark */ 314 int high_mark; /* High water mark */ 315 int flags; 316 u32 agp_start; /* Start address in the AGP aperture */ 317 } drm_buf_desc32_t; 318 319 static int compat_drm_addbufs(struct file *file, unsigned int cmd, 320 unsigned long arg) 321 { 322 drm_buf_desc32_t __user *argp = (void __user *)arg; 323 drm_buf_desc32_t desc32; 324 struct drm_buf_desc desc; 325 int err; 326 327 if (copy_from_user(&desc32, argp, sizeof(drm_buf_desc32_t))) 328 return -EFAULT; 329 330 desc = (struct drm_buf_desc){ 331 desc32.count, desc32.size, desc32.low_mark, desc32.high_mark, 332 desc32.flags, desc32.agp_start 333 }; 334 335 err = drm_ioctl_kernel(file, drm_legacy_addbufs, &desc, 336 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 337 if (err) 338 return err; 339 340 desc32 = (drm_buf_desc32_t){ 341 desc.count, desc.size, desc.low_mark, desc.high_mark, 342 desc.flags, desc.agp_start 343 }; 344 if (copy_to_user(argp, &desc32, sizeof(drm_buf_desc32_t))) 345 return -EFAULT; 346 347 return 0; 348 } 349 350 static int compat_drm_markbufs(struct file *file, unsigned int cmd, 351 unsigned long arg) 352 { 353 drm_buf_desc32_t b32; 354 drm_buf_desc32_t __user *argp = (void __user *)arg; 355 struct drm_buf_desc buf; 356 357 if (copy_from_user(&b32, argp, sizeof(b32))) 358 return -EFAULT; 359 360 buf.size = b32.size; 361 buf.low_mark = b32.low_mark; 362 buf.high_mark = b32.high_mark; 363 364 return drm_ioctl_kernel(file, drm_legacy_markbufs, &buf, 365 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 366 } 367 368 typedef struct drm_buf_info32 { 369 int count; /**< Entries in list */ 370 u32 list; 371 } drm_buf_info32_t; 372 373 static int copy_one_buf32(void *data, int count, struct drm_buf_entry *from) 374 { 375 drm_buf_info32_t *request = data; 376 drm_buf_desc32_t __user *to = compat_ptr(request->list); 377 drm_buf_desc32_t v = {.count = from->buf_count, 378 .size = from->buf_size, 379 .low_mark = from->low_mark, 380 .high_mark = from->high_mark}; 381 382 if (copy_to_user(to + count, &v, offsetof(drm_buf_desc32_t, flags))) 383 return -EFAULT; 384 return 0; 385 } 386 387 static int drm_legacy_infobufs32(struct drm_device *dev, void *data, 388 struct drm_file *file_priv) 389 { 390 drm_buf_info32_t *request = data; 391 392 return __drm_legacy_infobufs(dev, data, &request->count, copy_one_buf32); 393 } 394 395 static int compat_drm_infobufs(struct file *file, unsigned int cmd, 396 unsigned long arg) 397 { 398 drm_buf_info32_t req32; 399 drm_buf_info32_t __user *argp = (void __user *)arg; 400 int err; 401 402 if (copy_from_user(&req32, argp, sizeof(req32))) 403 return -EFAULT; 404 405 if (req32.count < 0) 406 req32.count = 0; 407 408 err = drm_ioctl_kernel(file, drm_legacy_infobufs32, &req32, DRM_AUTH); 409 if (err) 410 return err; 411 412 if (put_user(req32.count, &argp->count)) 413 return -EFAULT; 414 415 return 0; 416 } 417 418 typedef struct drm_buf_pub32 { 419 int idx; /**< Index into the master buffer list */ 420 int total; /**< Buffer size */ 421 int used; /**< Amount of buffer in use (for DMA) */ 422 u32 address; /**< Address of buffer */ 423 } drm_buf_pub32_t; 424 425 typedef struct drm_buf_map32 { 426 int count; /**< Length of the buffer list */ 427 u32 virtual; /**< Mmap'd area in user-virtual */ 428 u32 list; /**< Buffer information */ 429 } drm_buf_map32_t; 430 431 static int map_one_buf32(void *data, int idx, unsigned long virtual, 432 struct drm_buf *buf) 433 { 434 drm_buf_map32_t *request = data; 435 drm_buf_pub32_t __user *to = compat_ptr(request->list) + idx; 436 drm_buf_pub32_t v; 437 438 v.idx = buf->idx; 439 v.total = buf->total; 440 v.used = 0; 441 v.address = virtual + buf->offset; 442 if (copy_to_user(to, &v, sizeof(v))) 443 return -EFAULT; 444 return 0; 445 } 446 447 static int drm_legacy_mapbufs32(struct drm_device *dev, void *data, 448 struct drm_file *file_priv) 449 { 450 drm_buf_map32_t *request = data; 451 void __user *v; 452 int err = __drm_legacy_mapbufs(dev, data, &request->count, 453 &v, map_one_buf32, 454 file_priv); 455 request->virtual = ptr_to_compat(v); 456 return err; 457 } 458 459 static int compat_drm_mapbufs(struct file *file, unsigned int cmd, 460 unsigned long arg) 461 { 462 drm_buf_map32_t __user *argp = (void __user *)arg; 463 drm_buf_map32_t req32; 464 int err; 465 466 if (copy_from_user(&req32, argp, sizeof(req32))) 467 return -EFAULT; 468 if (req32.count < 0) 469 return -EINVAL; 470 471 err = drm_ioctl_kernel(file, drm_legacy_mapbufs32, &req32, DRM_AUTH); 472 if (err) 473 return err; 474 475 if (put_user(req32.count, &argp->count) 476 || put_user(req32.virtual, &argp->virtual)) 477 return -EFAULT; 478 479 return 0; 480 } 481 482 typedef struct drm_buf_free32 { 483 int count; 484 u32 list; 485 } drm_buf_free32_t; 486 487 static int compat_drm_freebufs(struct file *file, unsigned int cmd, 488 unsigned long arg) 489 { 490 drm_buf_free32_t req32; 491 struct drm_buf_free request; 492 drm_buf_free32_t __user *argp = (void __user *)arg; 493 494 if (copy_from_user(&req32, argp, sizeof(req32))) 495 return -EFAULT; 496 497 request.count = req32.count; 498 request.list = compat_ptr(req32.list); 499 return drm_ioctl_kernel(file, drm_legacy_freebufs, &request, DRM_AUTH); 500 } 501 502 typedef struct drm_ctx_priv_map32 { 503 unsigned int ctx_id; /**< Context requesting private mapping */ 504 u32 handle; /**< Handle of map */ 505 } drm_ctx_priv_map32_t; 506 507 static int compat_drm_setsareactx(struct file *file, unsigned int cmd, 508 unsigned long arg) 509 { 510 drm_ctx_priv_map32_t req32; 511 struct drm_ctx_priv_map request; 512 drm_ctx_priv_map32_t __user *argp = (void __user *)arg; 513 514 if (copy_from_user(&req32, argp, sizeof(req32))) 515 return -EFAULT; 516 517 request.ctx_id = req32.ctx_id; 518 request.handle = compat_ptr(req32.handle); 519 return drm_ioctl_kernel(file, drm_legacy_setsareactx, &request, 520 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 521 } 522 523 static int compat_drm_getsareactx(struct file *file, unsigned int cmd, 524 unsigned long arg) 525 { 526 struct drm_ctx_priv_map req; 527 drm_ctx_priv_map32_t req32; 528 drm_ctx_priv_map32_t __user *argp = (void __user *)arg; 529 int err; 530 531 if (copy_from_user(&req32, argp, sizeof(req32))) 532 return -EFAULT; 533 534 req.ctx_id = req32.ctx_id; 535 err = drm_ioctl_kernel(file, drm_legacy_getsareactx, &req, DRM_AUTH); 536 if (err) 537 return err; 538 539 req32.handle = ptr_to_compat((void __user *)req.handle); 540 if (copy_to_user(argp, &req32, sizeof(req32))) 541 return -EFAULT; 542 543 return 0; 544 } 545 546 typedef struct drm_ctx_res32 { 547 int count; 548 u32 contexts; 549 } drm_ctx_res32_t; 550 551 static int compat_drm_resctx(struct file *file, unsigned int cmd, 552 unsigned long arg) 553 { 554 drm_ctx_res32_t __user *argp = (void __user *)arg; 555 drm_ctx_res32_t res32; 556 struct drm_ctx_res res; 557 int err; 558 559 if (copy_from_user(&res32, argp, sizeof(res32))) 560 return -EFAULT; 561 562 res.count = res32.count; 563 res.contexts = compat_ptr(res32.contexts); 564 err = drm_ioctl_kernel(file, drm_legacy_resctx, &res, DRM_AUTH); 565 if (err) 566 return err; 567 568 res32.count = res.count; 569 if (copy_to_user(argp, &res32, sizeof(res32))) 570 return -EFAULT; 571 572 return 0; 573 } 574 575 typedef struct drm_dma32 { 576 int context; /**< Context handle */ 577 int send_count; /**< Number of buffers to send */ 578 u32 send_indices; /**< List of handles to buffers */ 579 u32 send_sizes; /**< Lengths of data to send */ 580 enum drm_dma_flags flags; /**< Flags */ 581 int request_count; /**< Number of buffers requested */ 582 int request_size; /**< Desired size for buffers */ 583 u32 request_indices; /**< Buffer information */ 584 u32 request_sizes; 585 int granted_count; /**< Number of buffers granted */ 586 } drm_dma32_t; 587 588 static int compat_drm_dma(struct file *file, unsigned int cmd, 589 unsigned long arg) 590 { 591 drm_dma32_t d32; 592 drm_dma32_t __user *argp = (void __user *)arg; 593 struct drm_dma d; 594 int err; 595 596 if (copy_from_user(&d32, argp, sizeof(d32))) 597 return -EFAULT; 598 599 d.context = d32.context; 600 d.send_count = d32.send_count; 601 d.send_indices = compat_ptr(d32.send_indices); 602 d.send_sizes = compat_ptr(d32.send_sizes); 603 d.flags = d32.flags; 604 d.request_count = d32.request_count; 605 d.request_indices = compat_ptr(d32.request_indices); 606 d.request_sizes = compat_ptr(d32.request_sizes); 607 err = drm_ioctl_kernel(file, drm_legacy_dma_ioctl, &d, DRM_AUTH); 608 if (err) 609 return err; 610 611 if (put_user(d.request_size, &argp->request_size) 612 || put_user(d.granted_count, &argp->granted_count)) 613 return -EFAULT; 614 615 return 0; 616 } 617 #endif 618 619 #if IS_ENABLED(CONFIG_AGP) 620 typedef struct drm_agp_mode32 { 621 u32 mode; /**< AGP mode */ 622 } drm_agp_mode32_t; 623 624 static int compat_drm_agp_enable(struct file *file, unsigned int cmd, 625 unsigned long arg) 626 { 627 drm_agp_mode32_t __user *argp = (void __user *)arg; 628 struct drm_agp_mode mode; 629 630 if (get_user(mode.mode, &argp->mode)) 631 return -EFAULT; 632 633 return drm_ioctl_kernel(file, drm_agp_enable_ioctl, &mode, 634 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 635 } 636 637 typedef struct drm_agp_info32 { 638 int agp_version_major; 639 int agp_version_minor; 640 u32 mode; 641 u32 aperture_base; /* physical address */ 642 u32 aperture_size; /* bytes */ 643 u32 memory_allowed; /* bytes */ 644 u32 memory_used; 645 646 /* PCI information */ 647 unsigned short id_vendor; 648 unsigned short id_device; 649 } drm_agp_info32_t; 650 651 static int compat_drm_agp_info(struct file *file, unsigned int cmd, 652 unsigned long arg) 653 { 654 drm_agp_info32_t __user *argp = (void __user *)arg; 655 drm_agp_info32_t i32; 656 struct drm_agp_info info; 657 int err; 658 659 err = drm_ioctl_kernel(file, drm_agp_info_ioctl, &info, DRM_AUTH); 660 if (err) 661 return err; 662 663 i32.agp_version_major = info.agp_version_major; 664 i32.agp_version_minor = info.agp_version_minor; 665 i32.mode = info.mode; 666 i32.aperture_base = info.aperture_base; 667 i32.aperture_size = info.aperture_size; 668 i32.memory_allowed = info.memory_allowed; 669 i32.memory_used = info.memory_used; 670 i32.id_vendor = info.id_vendor; 671 i32.id_device = info.id_device; 672 if (copy_to_user(argp, &i32, sizeof(i32))) 673 return -EFAULT; 674 675 return 0; 676 } 677 678 typedef struct drm_agp_buffer32 { 679 u32 size; /**< In bytes -- will round to page boundary */ 680 u32 handle; /**< Used for binding / unbinding */ 681 u32 type; /**< Type of memory to allocate */ 682 u32 physical; /**< Physical used by i810 */ 683 } drm_agp_buffer32_t; 684 685 static int compat_drm_agp_alloc(struct file *file, unsigned int cmd, 686 unsigned long arg) 687 { 688 drm_agp_buffer32_t __user *argp = (void __user *)arg; 689 drm_agp_buffer32_t req32; 690 struct drm_agp_buffer request; 691 int err; 692 693 if (copy_from_user(&req32, argp, sizeof(req32))) 694 return -EFAULT; 695 696 request.size = req32.size; 697 request.type = req32.type; 698 err = drm_ioctl_kernel(file, drm_agp_alloc_ioctl, &request, 699 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 700 if (err) 701 return err; 702 703 req32.handle = request.handle; 704 req32.physical = request.physical; 705 if (copy_to_user(argp, &req32, sizeof(req32))) { 706 drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, 707 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 708 return -EFAULT; 709 } 710 711 return 0; 712 } 713 714 static int compat_drm_agp_free(struct file *file, unsigned int cmd, 715 unsigned long arg) 716 { 717 drm_agp_buffer32_t __user *argp = (void __user *)arg; 718 struct drm_agp_buffer request; 719 720 if (get_user(request.handle, &argp->handle)) 721 return -EFAULT; 722 723 return drm_ioctl_kernel(file, drm_agp_free_ioctl, &request, 724 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 725 } 726 727 typedef struct drm_agp_binding32 { 728 u32 handle; /**< From drm_agp_buffer */ 729 u32 offset; /**< In bytes -- will round to page boundary */ 730 } drm_agp_binding32_t; 731 732 static int compat_drm_agp_bind(struct file *file, unsigned int cmd, 733 unsigned long arg) 734 { 735 drm_agp_binding32_t __user *argp = (void __user *)arg; 736 drm_agp_binding32_t req32; 737 struct drm_agp_binding request; 738 739 if (copy_from_user(&req32, argp, sizeof(req32))) 740 return -EFAULT; 741 742 request.handle = req32.handle; 743 request.offset = req32.offset; 744 return drm_ioctl_kernel(file, drm_agp_bind_ioctl, &request, 745 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 746 } 747 748 static int compat_drm_agp_unbind(struct file *file, unsigned int cmd, 749 unsigned long arg) 750 { 751 drm_agp_binding32_t __user *argp = (void __user *)arg; 752 struct drm_agp_binding request; 753 754 if (get_user(request.handle, &argp->handle)) 755 return -EFAULT; 756 757 return drm_ioctl_kernel(file, drm_agp_unbind_ioctl, &request, 758 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 759 } 760 #endif /* CONFIG_AGP */ 761 762 #if IS_ENABLED(CONFIG_DRM_LEGACY) 763 typedef struct drm_scatter_gather32 { 764 u32 size; /**< In bytes -- will round to page boundary */ 765 u32 handle; /**< Used for mapping / unmapping */ 766 } drm_scatter_gather32_t; 767 768 static int compat_drm_sg_alloc(struct file *file, unsigned int cmd, 769 unsigned long arg) 770 { 771 drm_scatter_gather32_t __user *argp = (void __user *)arg; 772 struct drm_scatter_gather request; 773 int err; 774 775 if (get_user(request.size, &argp->size)) 776 return -EFAULT; 777 778 err = drm_ioctl_kernel(file, drm_legacy_sg_alloc, &request, 779 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 780 if (err) 781 return err; 782 783 /* XXX not sure about the handle conversion here... */ 784 if (put_user(request.handle >> PAGE_SHIFT, &argp->handle)) 785 return -EFAULT; 786 787 return 0; 788 } 789 790 static int compat_drm_sg_free(struct file *file, unsigned int cmd, 791 unsigned long arg) 792 { 793 drm_scatter_gather32_t __user *argp = (void __user *)arg; 794 struct drm_scatter_gather request; 795 unsigned long x; 796 797 if (get_user(x, &argp->handle)) 798 return -EFAULT; 799 request.handle = x << PAGE_SHIFT; 800 return drm_ioctl_kernel(file, drm_legacy_sg_free, &request, 801 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 802 } 803 #endif 804 #if defined(CONFIG_X86) 805 typedef struct drm_update_draw32 { 806 drm_drawable_t handle; 807 unsigned int type; 808 unsigned int num; 809 /* 64-bit version has a 32-bit pad here */ 810 u64 data; /**< Pointer */ 811 } __attribute__((packed)) drm_update_draw32_t; 812 813 static int compat_drm_update_draw(struct file *file, unsigned int cmd, 814 unsigned long arg) 815 { 816 drm_update_draw32_t update32; 817 818 if (copy_from_user(&update32, (void __user *)arg, sizeof(update32))) 819 return -EFAULT; 820 821 return drm_ioctl_kernel(file, drm_noop, NULL, 822 DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY); 823 } 824 #endif 825 826 struct drm_wait_vblank_request32 { 827 enum drm_vblank_seq_type type; 828 unsigned int sequence; 829 u32 signal; 830 }; 831 832 struct drm_wait_vblank_reply32 { 833 enum drm_vblank_seq_type type; 834 unsigned int sequence; 835 s32 tval_sec; 836 s32 tval_usec; 837 }; 838 839 typedef union drm_wait_vblank32 { 840 struct drm_wait_vblank_request32 request; 841 struct drm_wait_vblank_reply32 reply; 842 } drm_wait_vblank32_t; 843 844 static int compat_drm_wait_vblank(struct file *file, unsigned int cmd, 845 unsigned long arg) 846 { 847 drm_wait_vblank32_t __user *argp = (void __user *)arg; 848 drm_wait_vblank32_t req32; 849 union drm_wait_vblank req; 850 int err; 851 852 if (copy_from_user(&req32, argp, sizeof(req32))) 853 return -EFAULT; 854 855 req.request.type = req32.request.type; 856 req.request.sequence = req32.request.sequence; 857 req.request.signal = req32.request.signal; 858 err = drm_ioctl_kernel(file, drm_wait_vblank_ioctl, &req, DRM_UNLOCKED); 859 if (err) 860 return err; 861 862 req32.reply.type = req.reply.type; 863 req32.reply.sequence = req.reply.sequence; 864 req32.reply.tval_sec = req.reply.tval_sec; 865 req32.reply.tval_usec = req.reply.tval_usec; 866 if (copy_to_user(argp, &req32, sizeof(req32))) 867 return -EFAULT; 868 869 return 0; 870 } 871 872 #if defined(CONFIG_X86) 873 typedef struct drm_mode_fb_cmd232 { 874 u32 fb_id; 875 u32 width; 876 u32 height; 877 u32 pixel_format; 878 u32 flags; 879 u32 handles[4]; 880 u32 pitches[4]; 881 u32 offsets[4]; 882 u64 modifier[4]; 883 } __attribute__((packed)) drm_mode_fb_cmd232_t; 884 885 static int compat_drm_mode_addfb2(struct file *file, unsigned int cmd, 886 unsigned long arg) 887 { 888 struct drm_mode_fb_cmd232 __user *argp = (void __user *)arg; 889 struct drm_mode_fb_cmd2 req64; 890 int err; 891 892 if (copy_from_user(&req64, argp, 893 offsetof(drm_mode_fb_cmd232_t, modifier))) 894 return -EFAULT; 895 896 if (copy_from_user(&req64.modifier, &argp->modifier, 897 sizeof(req64.modifier))) 898 return -EFAULT; 899 900 err = drm_ioctl_kernel(file, drm_mode_addfb2, &req64, 0); 901 if (err) 902 return err; 903 904 if (put_user(req64.fb_id, &argp->fb_id)) 905 return -EFAULT; 906 907 return 0; 908 } 909 #endif 910 911 static struct { 912 drm_ioctl_compat_t *fn; 913 char *name; 914 } drm_compat_ioctls[] = { 915 #define DRM_IOCTL32_DEF(n, f) [DRM_IOCTL_NR(n##32)] = {.fn = f, .name = #n} 916 DRM_IOCTL32_DEF(DRM_IOCTL_VERSION, compat_drm_version), 917 DRM_IOCTL32_DEF(DRM_IOCTL_GET_UNIQUE, compat_drm_getunique), 918 #if IS_ENABLED(CONFIG_DRM_LEGACY) 919 DRM_IOCTL32_DEF(DRM_IOCTL_GET_MAP, compat_drm_getmap), 920 #endif 921 DRM_IOCTL32_DEF(DRM_IOCTL_GET_CLIENT, compat_drm_getclient), 922 DRM_IOCTL32_DEF(DRM_IOCTL_GET_STATS, compat_drm_getstats), 923 DRM_IOCTL32_DEF(DRM_IOCTL_SET_UNIQUE, compat_drm_setunique), 924 #if IS_ENABLED(CONFIG_DRM_LEGACY) 925 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_MAP, compat_drm_addmap), 926 DRM_IOCTL32_DEF(DRM_IOCTL_ADD_BUFS, compat_drm_addbufs), 927 DRM_IOCTL32_DEF(DRM_IOCTL_MARK_BUFS, compat_drm_markbufs), 928 DRM_IOCTL32_DEF(DRM_IOCTL_INFO_BUFS, compat_drm_infobufs), 929 DRM_IOCTL32_DEF(DRM_IOCTL_MAP_BUFS, compat_drm_mapbufs), 930 DRM_IOCTL32_DEF(DRM_IOCTL_FREE_BUFS, compat_drm_freebufs), 931 DRM_IOCTL32_DEF(DRM_IOCTL_RM_MAP, compat_drm_rmmap), 932 DRM_IOCTL32_DEF(DRM_IOCTL_SET_SAREA_CTX, compat_drm_setsareactx), 933 DRM_IOCTL32_DEF(DRM_IOCTL_GET_SAREA_CTX, compat_drm_getsareactx), 934 DRM_IOCTL32_DEF(DRM_IOCTL_RES_CTX, compat_drm_resctx), 935 DRM_IOCTL32_DEF(DRM_IOCTL_DMA, compat_drm_dma), 936 #endif 937 #if IS_ENABLED(CONFIG_AGP) 938 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ENABLE, compat_drm_agp_enable), 939 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_INFO, compat_drm_agp_info), 940 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_ALLOC, compat_drm_agp_alloc), 941 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_FREE, compat_drm_agp_free), 942 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_BIND, compat_drm_agp_bind), 943 DRM_IOCTL32_DEF(DRM_IOCTL_AGP_UNBIND, compat_drm_agp_unbind), 944 #endif 945 #if IS_ENABLED(CONFIG_DRM_LEGACY) 946 DRM_IOCTL32_DEF(DRM_IOCTL_SG_ALLOC, compat_drm_sg_alloc), 947 DRM_IOCTL32_DEF(DRM_IOCTL_SG_FREE, compat_drm_sg_free), 948 #endif 949 #if defined(CONFIG_X86) || defined(CONFIG_IA64) 950 DRM_IOCTL32_DEF(DRM_IOCTL_UPDATE_DRAW, compat_drm_update_draw), 951 #endif 952 DRM_IOCTL32_DEF(DRM_IOCTL_WAIT_VBLANK, compat_drm_wait_vblank), 953 #if defined(CONFIG_X86) || defined(CONFIG_IA64) 954 DRM_IOCTL32_DEF(DRM_IOCTL_MODE_ADDFB2, compat_drm_mode_addfb2), 955 #endif 956 }; 957 958 /** 959 * drm_compat_ioctl - 32bit IOCTL compatibility handler for DRM drivers 960 * @filp: file this ioctl is called on 961 * @cmd: ioctl cmd number 962 * @arg: user argument 963 * 964 * Compatibility handler for 32 bit userspace running on 64 kernels. All actual 965 * IOCTL handling is forwarded to drm_ioctl(), while marshalling structures as 966 * appropriate. Note that this only handles DRM core IOCTLs, if the driver has 967 * botched IOCTL itself, it must handle those by wrapping this function. 968 * 969 * Returns: 970 * Zero on success, negative error code on failure. 971 */ 972 long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 973 { 974 unsigned int nr = DRM_IOCTL_NR(cmd); 975 struct drm_file *file_priv = filp->private_data; 976 drm_ioctl_compat_t *fn; 977 int ret; 978 979 /* Assume that ioctls without an explicit compat routine will just 980 * work. This may not always be a good assumption, but it's better 981 * than always failing. 982 */ 983 if (nr >= ARRAY_SIZE(drm_compat_ioctls)) 984 return drm_ioctl(filp, cmd, arg); 985 986 fn = drm_compat_ioctls[nr].fn; 987 if (!fn) 988 return drm_ioctl(filp, cmd, arg); 989 990 DRM_DEBUG("comm=\"%s\", pid=%d, dev=0x%lx, auth=%d, %s\n", 991 current->comm, task_pid_nr(current), 992 (long)old_encode_dev(file_priv->minor->kdev->devt), 993 file_priv->authenticated, 994 drm_compat_ioctls[nr].name); 995 ret = (*fn)(filp, cmd, arg); 996 if (ret) 997 DRM_DEBUG("ret = %d\n", ret); 998 return ret; 999 } 1000 EXPORT_SYMBOL(drm_compat_ioctl); 1001