1 /* 2 * ioctl32.c: Conversion between 32bit and 64bit native ioctls. 3 * Separated from fs stuff by Arnd Bergmann <arnd@arndb.de> 4 * 5 * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com) 6 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be) 7 * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs 8 * Copyright (C) 2003 Pavel Machek (pavel@ucw.cz) 9 * Copyright (C) 2005 Philippe De Muyter (phdm@macqel.be) 10 * Copyright (C) 2008 Hans Verkuil <hverkuil@xs4all.nl> 11 * 12 * These routines maintain argument size conversion between 32bit and 64bit 13 * ioctls. 14 */ 15 16 #include <linux/compat.h> 17 #include <linux/module.h> 18 #include <linux/videodev2.h> 19 #include <linux/v4l2-subdev.h> 20 #include <media/v4l2-dev.h> 21 #include <media/v4l2-ioctl.h> 22 23 static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 24 { 25 long ret = -ENOIOCTLCMD; 26 27 if (file->f_op->unlocked_ioctl) 28 ret = file->f_op->unlocked_ioctl(file, cmd, arg); 29 30 return ret; 31 } 32 33 34 struct v4l2_clip32 { 35 struct v4l2_rect c; 36 compat_caddr_t next; 37 }; 38 39 struct v4l2_window32 { 40 struct v4l2_rect w; 41 __u32 field; /* enum v4l2_field */ 42 __u32 chromakey; 43 compat_caddr_t clips; /* actually struct v4l2_clip32 * */ 44 __u32 clipcount; 45 compat_caddr_t bitmap; 46 }; 47 48 static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) 49 { 50 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) || 51 copy_from_user(&kp->w, &up->w, sizeof(up->w)) || 52 get_user(kp->field, &up->field) || 53 get_user(kp->chromakey, &up->chromakey) || 54 get_user(kp->clipcount, &up->clipcount)) 55 return -EFAULT; 56 if (kp->clipcount > 2048) 57 return -EINVAL; 58 if (kp->clipcount) { 59 struct v4l2_clip32 __user *uclips; 60 struct v4l2_clip __user *kclips; 61 int n = kp->clipcount; 62 compat_caddr_t p; 63 64 if (get_user(p, &up->clips)) 65 return -EFAULT; 66 uclips = compat_ptr(p); 67 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip)); 68 kp->clips = kclips; 69 while (--n >= 0) { 70 if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c))) 71 return -EFAULT; 72 if (put_user(n ? kclips + 1 : NULL, &kclips->next)) 73 return -EFAULT; 74 uclips += 1; 75 kclips += 1; 76 } 77 } else 78 kp->clips = NULL; 79 return 0; 80 } 81 82 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) 83 { 84 if (copy_to_user(&up->w, &kp->w, sizeof(kp->w)) || 85 put_user(kp->field, &up->field) || 86 put_user(kp->chromakey, &up->chromakey) || 87 put_user(kp->clipcount, &up->clipcount)) 88 return -EFAULT; 89 return 0; 90 } 91 92 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) 93 { 94 if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format))) 95 return -EFAULT; 96 return 0; 97 } 98 99 static inline int get_v4l2_pix_format_mplane(struct v4l2_pix_format_mplane *kp, 100 struct v4l2_pix_format_mplane __user *up) 101 { 102 if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format_mplane))) 103 return -EFAULT; 104 return 0; 105 } 106 107 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) 108 { 109 if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format))) 110 return -EFAULT; 111 return 0; 112 } 113 114 static inline int put_v4l2_pix_format_mplane(struct v4l2_pix_format_mplane *kp, 115 struct v4l2_pix_format_mplane __user *up) 116 { 117 if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format_mplane))) 118 return -EFAULT; 119 return 0; 120 } 121 122 static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) 123 { 124 if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format))) 125 return -EFAULT; 126 return 0; 127 } 128 129 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) 130 { 131 if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format))) 132 return -EFAULT; 133 return 0; 134 } 135 136 static inline int get_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up) 137 { 138 if (copy_from_user(kp, up, sizeof(struct v4l2_sliced_vbi_format))) 139 return -EFAULT; 140 return 0; 141 } 142 143 static inline int put_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up) 144 { 145 if (copy_to_user(up, kp, sizeof(struct v4l2_sliced_vbi_format))) 146 return -EFAULT; 147 return 0; 148 } 149 150 static inline int get_v4l2_sdr_format(struct v4l2_sdr_format *kp, struct v4l2_sdr_format __user *up) 151 { 152 if (copy_from_user(kp, up, sizeof(struct v4l2_sdr_format))) 153 return -EFAULT; 154 return 0; 155 } 156 157 static inline int put_v4l2_sdr_format(struct v4l2_sdr_format *kp, struct v4l2_sdr_format __user *up) 158 { 159 if (copy_to_user(up, kp, sizeof(struct v4l2_sdr_format))) 160 return -EFAULT; 161 return 0; 162 } 163 164 struct v4l2_format32 { 165 __u32 type; /* enum v4l2_buf_type */ 166 union { 167 struct v4l2_pix_format pix; 168 struct v4l2_pix_format_mplane pix_mp; 169 struct v4l2_window32 win; 170 struct v4l2_vbi_format vbi; 171 struct v4l2_sliced_vbi_format sliced; 172 struct v4l2_sdr_format sdr; 173 __u8 raw_data[200]; /* user-defined */ 174 } fmt; 175 }; 176 177 /** 178 * struct v4l2_create_buffers32 - VIDIOC_CREATE_BUFS32 argument 179 * @index: on return, index of the first created buffer 180 * @count: entry: number of requested buffers, 181 * return: number of created buffers 182 * @memory: buffer memory type 183 * @format: frame format, for which buffers are requested 184 * @reserved: future extensions 185 */ 186 struct v4l2_create_buffers32 { 187 __u32 index; 188 __u32 count; 189 __u32 memory; /* enum v4l2_memory */ 190 struct v4l2_format32 format; 191 __u32 reserved[8]; 192 }; 193 194 static int __get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) 195 { 196 if (get_user(kp->type, &up->type)) 197 return -EFAULT; 198 199 switch (kp->type) { 200 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 201 case V4L2_BUF_TYPE_VIDEO_OUTPUT: 202 return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); 203 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 204 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 205 return get_v4l2_pix_format_mplane(&kp->fmt.pix_mp, 206 &up->fmt.pix_mp); 207 case V4L2_BUF_TYPE_VIDEO_OVERLAY: 208 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: 209 return get_v4l2_window32(&kp->fmt.win, &up->fmt.win); 210 case V4L2_BUF_TYPE_VBI_CAPTURE: 211 case V4L2_BUF_TYPE_VBI_OUTPUT: 212 return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); 213 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: 214 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: 215 return get_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced); 216 case V4L2_BUF_TYPE_SDR_CAPTURE: 217 case V4L2_BUF_TYPE_SDR_OUTPUT: 218 return get_v4l2_sdr_format(&kp->fmt.sdr, &up->fmt.sdr); 219 default: 220 pr_info("compat_ioctl32: unexpected VIDIOC_FMT type %d\n", 221 kp->type); 222 return -EINVAL; 223 } 224 } 225 226 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) 227 { 228 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32))) 229 return -EFAULT; 230 return __get_v4l2_format32(kp, up); 231 } 232 233 static int get_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_buffers32 __user *up) 234 { 235 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_create_buffers32)) || 236 copy_from_user(kp, up, offsetof(struct v4l2_create_buffers32, format))) 237 return -EFAULT; 238 return __get_v4l2_format32(&kp->format, &up->format); 239 } 240 241 static int __put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) 242 { 243 if (put_user(kp->type, &up->type)) 244 return -EFAULT; 245 246 switch (kp->type) { 247 case V4L2_BUF_TYPE_VIDEO_CAPTURE: 248 case V4L2_BUF_TYPE_VIDEO_OUTPUT: 249 return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); 250 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: 251 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE: 252 return put_v4l2_pix_format_mplane(&kp->fmt.pix_mp, 253 &up->fmt.pix_mp); 254 case V4L2_BUF_TYPE_VIDEO_OVERLAY: 255 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: 256 return put_v4l2_window32(&kp->fmt.win, &up->fmt.win); 257 case V4L2_BUF_TYPE_VBI_CAPTURE: 258 case V4L2_BUF_TYPE_VBI_OUTPUT: 259 return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); 260 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: 261 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: 262 return put_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced); 263 case V4L2_BUF_TYPE_SDR_CAPTURE: 264 case V4L2_BUF_TYPE_SDR_OUTPUT: 265 return put_v4l2_sdr_format(&kp->fmt.sdr, &up->fmt.sdr); 266 default: 267 pr_info("compat_ioctl32: unexpected VIDIOC_FMT type %d\n", 268 kp->type); 269 return -EINVAL; 270 } 271 } 272 273 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) 274 { 275 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32))) 276 return -EFAULT; 277 return __put_v4l2_format32(kp, up); 278 } 279 280 static int put_v4l2_create32(struct v4l2_create_buffers *kp, struct v4l2_create_buffers32 __user *up) 281 { 282 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_create_buffers32)) || 283 copy_to_user(up, kp, offsetof(struct v4l2_create_buffers32, format)) || 284 copy_to_user(up->reserved, kp->reserved, sizeof(kp->reserved))) 285 return -EFAULT; 286 return __put_v4l2_format32(&kp->format, &up->format); 287 } 288 289 struct v4l2_standard32 { 290 __u32 index; 291 compat_u64 id; 292 __u8 name[24]; 293 struct v4l2_fract frameperiod; /* Frames, not fields */ 294 __u32 framelines; 295 __u32 reserved[4]; 296 }; 297 298 static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) 299 { 300 /* other fields are not set by the user, nor used by the driver */ 301 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard32)) || 302 get_user(kp->index, &up->index)) 303 return -EFAULT; 304 return 0; 305 } 306 307 static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) 308 { 309 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard32)) || 310 put_user(kp->index, &up->index) || 311 put_user(kp->id, &up->id) || 312 copy_to_user(up->name, kp->name, 24) || 313 copy_to_user(&up->frameperiod, &kp->frameperiod, sizeof(kp->frameperiod)) || 314 put_user(kp->framelines, &up->framelines) || 315 copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32))) 316 return -EFAULT; 317 return 0; 318 } 319 320 struct v4l2_plane32 { 321 __u32 bytesused; 322 __u32 length; 323 union { 324 __u32 mem_offset; 325 compat_long_t userptr; 326 __s32 fd; 327 } m; 328 __u32 data_offset; 329 __u32 reserved[11]; 330 }; 331 332 struct v4l2_buffer32 { 333 __u32 index; 334 __u32 type; /* enum v4l2_buf_type */ 335 __u32 bytesused; 336 __u32 flags; 337 __u32 field; /* enum v4l2_field */ 338 struct compat_timeval timestamp; 339 struct v4l2_timecode timecode; 340 __u32 sequence; 341 342 /* memory location */ 343 __u32 memory; /* enum v4l2_memory */ 344 union { 345 __u32 offset; 346 compat_long_t userptr; 347 compat_caddr_t planes; 348 __s32 fd; 349 } m; 350 __u32 length; 351 __u32 reserved2; 352 __u32 reserved; 353 }; 354 355 static int get_v4l2_plane32(struct v4l2_plane __user *up, struct v4l2_plane32 __user *up32, 356 enum v4l2_memory memory) 357 { 358 void __user *up_pln; 359 compat_long_t p; 360 361 if (copy_in_user(up, up32, 2 * sizeof(__u32)) || 362 copy_in_user(&up->data_offset, &up32->data_offset, 363 sizeof(__u32))) 364 return -EFAULT; 365 366 if (memory == V4L2_MEMORY_USERPTR) { 367 if (get_user(p, &up32->m.userptr)) 368 return -EFAULT; 369 up_pln = compat_ptr(p); 370 if (put_user((unsigned long)up_pln, &up->m.userptr)) 371 return -EFAULT; 372 } else if (memory == V4L2_MEMORY_DMABUF) { 373 if (copy_in_user(&up->m.fd, &up32->m.fd, sizeof(int))) 374 return -EFAULT; 375 } else { 376 if (copy_in_user(&up->m.mem_offset, &up32->m.mem_offset, 377 sizeof(__u32))) 378 return -EFAULT; 379 } 380 381 return 0; 382 } 383 384 static int put_v4l2_plane32(struct v4l2_plane __user *up, struct v4l2_plane32 __user *up32, 385 enum v4l2_memory memory) 386 { 387 if (copy_in_user(up32, up, 2 * sizeof(__u32)) || 388 copy_in_user(&up32->data_offset, &up->data_offset, 389 sizeof(__u32))) 390 return -EFAULT; 391 392 /* For MMAP, driver might've set up the offset, so copy it back. 393 * USERPTR stays the same (was userspace-provided), so no copying. */ 394 if (memory == V4L2_MEMORY_MMAP) 395 if (copy_in_user(&up32->m.mem_offset, &up->m.mem_offset, 396 sizeof(__u32))) 397 return -EFAULT; 398 /* For DMABUF, driver might've set up the fd, so copy it back. */ 399 if (memory == V4L2_MEMORY_DMABUF) 400 if (copy_in_user(&up32->m.fd, &up->m.fd, 401 sizeof(int))) 402 return -EFAULT; 403 404 return 0; 405 } 406 407 static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) 408 { 409 struct v4l2_plane32 __user *uplane32; 410 struct v4l2_plane __user *uplane; 411 compat_caddr_t p; 412 int ret; 413 414 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_buffer32)) || 415 get_user(kp->index, &up->index) || 416 get_user(kp->type, &up->type) || 417 get_user(kp->flags, &up->flags) || 418 get_user(kp->memory, &up->memory) || 419 get_user(kp->length, &up->length)) 420 return -EFAULT; 421 422 if (V4L2_TYPE_IS_OUTPUT(kp->type)) 423 if (get_user(kp->bytesused, &up->bytesused) || 424 get_user(kp->field, &up->field) || 425 get_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) || 426 get_user(kp->timestamp.tv_usec, 427 &up->timestamp.tv_usec)) 428 return -EFAULT; 429 430 if (V4L2_TYPE_IS_MULTIPLANAR(kp->type)) { 431 unsigned int num_planes; 432 433 if (kp->length == 0) { 434 kp->m.planes = NULL; 435 /* num_planes == 0 is legal, e.g. when userspace doesn't 436 * need planes array on DQBUF*/ 437 return 0; 438 } else if (kp->length > VIDEO_MAX_PLANES) { 439 return -EINVAL; 440 } 441 442 if (get_user(p, &up->m.planes)) 443 return -EFAULT; 444 445 uplane32 = compat_ptr(p); 446 if (!access_ok(VERIFY_READ, uplane32, 447 kp->length * sizeof(struct v4l2_plane32))) 448 return -EFAULT; 449 450 /* We don't really care if userspace decides to kill itself 451 * by passing a very big num_planes value */ 452 uplane = compat_alloc_user_space(kp->length * 453 sizeof(struct v4l2_plane)); 454 kp->m.planes = (__force struct v4l2_plane *)uplane; 455 456 for (num_planes = 0; num_planes < kp->length; num_planes++) { 457 ret = get_v4l2_plane32(uplane, uplane32, kp->memory); 458 if (ret) 459 return ret; 460 ++uplane; 461 ++uplane32; 462 } 463 } else { 464 switch (kp->memory) { 465 case V4L2_MEMORY_MMAP: 466 if (get_user(kp->m.offset, &up->m.offset)) 467 return -EFAULT; 468 break; 469 case V4L2_MEMORY_USERPTR: 470 { 471 compat_long_t tmp; 472 473 if (get_user(tmp, &up->m.userptr)) 474 return -EFAULT; 475 476 kp->m.userptr = (unsigned long)compat_ptr(tmp); 477 } 478 break; 479 case V4L2_MEMORY_OVERLAY: 480 if (get_user(kp->m.offset, &up->m.offset)) 481 return -EFAULT; 482 break; 483 case V4L2_MEMORY_DMABUF: 484 if (get_user(kp->m.fd, &up->m.fd)) 485 return -EFAULT; 486 break; 487 } 488 } 489 490 return 0; 491 } 492 493 static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) 494 { 495 struct v4l2_plane32 __user *uplane32; 496 struct v4l2_plane __user *uplane; 497 compat_caddr_t p; 498 int num_planes; 499 int ret; 500 501 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) || 502 put_user(kp->index, &up->index) || 503 put_user(kp->type, &up->type) || 504 put_user(kp->flags, &up->flags) || 505 put_user(kp->memory, &up->memory)) 506 return -EFAULT; 507 508 if (put_user(kp->bytesused, &up->bytesused) || 509 put_user(kp->field, &up->field) || 510 put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) || 511 put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) || 512 copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) || 513 put_user(kp->sequence, &up->sequence) || 514 put_user(kp->reserved2, &up->reserved2) || 515 put_user(kp->reserved, &up->reserved) || 516 put_user(kp->length, &up->length)) 517 return -EFAULT; 518 519 if (V4L2_TYPE_IS_MULTIPLANAR(kp->type)) { 520 num_planes = kp->length; 521 if (num_planes == 0) 522 return 0; 523 524 uplane = (__force struct v4l2_plane __user *)kp->m.planes; 525 if (get_user(p, &up->m.planes)) 526 return -EFAULT; 527 uplane32 = compat_ptr(p); 528 529 while (--num_planes >= 0) { 530 ret = put_v4l2_plane32(uplane, uplane32, kp->memory); 531 if (ret) 532 return ret; 533 ++uplane; 534 ++uplane32; 535 } 536 } else { 537 switch (kp->memory) { 538 case V4L2_MEMORY_MMAP: 539 if (put_user(kp->m.offset, &up->m.offset)) 540 return -EFAULT; 541 break; 542 case V4L2_MEMORY_USERPTR: 543 if (put_user(kp->m.userptr, &up->m.userptr)) 544 return -EFAULT; 545 break; 546 case V4L2_MEMORY_OVERLAY: 547 if (put_user(kp->m.offset, &up->m.offset)) 548 return -EFAULT; 549 break; 550 case V4L2_MEMORY_DMABUF: 551 if (put_user(kp->m.fd, &up->m.fd)) 552 return -EFAULT; 553 break; 554 } 555 } 556 557 return 0; 558 } 559 560 struct v4l2_framebuffer32 { 561 __u32 capability; 562 __u32 flags; 563 compat_caddr_t base; 564 struct { 565 __u32 width; 566 __u32 height; 567 __u32 pixelformat; 568 __u32 field; 569 __u32 bytesperline; 570 __u32 sizeimage; 571 __u32 colorspace; 572 __u32 priv; 573 } fmt; 574 }; 575 576 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) 577 { 578 u32 tmp; 579 580 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_framebuffer32)) || 581 get_user(tmp, &up->base) || 582 get_user(kp->capability, &up->capability) || 583 get_user(kp->flags, &up->flags) || 584 copy_from_user(&kp->fmt, &up->fmt, sizeof(up->fmt))) 585 return -EFAULT; 586 kp->base = (__force void *)compat_ptr(tmp); 587 return 0; 588 } 589 590 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) 591 { 592 u32 tmp = (u32)((unsigned long)kp->base); 593 594 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_framebuffer32)) || 595 put_user(tmp, &up->base) || 596 put_user(kp->capability, &up->capability) || 597 put_user(kp->flags, &up->flags) || 598 copy_to_user(&up->fmt, &kp->fmt, sizeof(up->fmt))) 599 return -EFAULT; 600 return 0; 601 } 602 603 struct v4l2_input32 { 604 __u32 index; /* Which input */ 605 __u8 name[32]; /* Label */ 606 __u32 type; /* Type of input */ 607 __u32 audioset; /* Associated audios (bitfield) */ 608 __u32 tuner; /* Associated tuner */ 609 compat_u64 std; 610 __u32 status; 611 __u32 reserved[4]; 612 }; 613 614 /* The 64-bit v4l2_input struct has extra padding at the end of the struct. 615 Otherwise it is identical to the 32-bit version. */ 616 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up) 617 { 618 if (copy_from_user(kp, up, sizeof(struct v4l2_input32))) 619 return -EFAULT; 620 return 0; 621 } 622 623 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up) 624 { 625 if (copy_to_user(up, kp, sizeof(struct v4l2_input32))) 626 return -EFAULT; 627 return 0; 628 } 629 630 struct v4l2_ext_controls32 { 631 __u32 which; 632 __u32 count; 633 __u32 error_idx; 634 __u32 reserved[2]; 635 compat_caddr_t controls; /* actually struct v4l2_ext_control32 * */ 636 }; 637 638 struct v4l2_ext_control32 { 639 __u32 id; 640 __u32 size; 641 __u32 reserved2[1]; 642 union { 643 __s32 value; 644 __s64 value64; 645 compat_caddr_t string; /* actually char * */ 646 }; 647 } __attribute__ ((packed)); 648 649 /* The following function really belong in v4l2-common, but that causes 650 a circular dependency between modules. We need to think about this, but 651 for now this will do. */ 652 653 /* Return non-zero if this control is a pointer type. Currently only 654 type STRING is a pointer type. */ 655 static inline int ctrl_is_pointer(u32 id) 656 { 657 switch (id) { 658 case V4L2_CID_RDS_TX_PS_NAME: 659 case V4L2_CID_RDS_TX_RADIO_TEXT: 660 return 1; 661 default: 662 return 0; 663 } 664 } 665 666 static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up) 667 { 668 struct v4l2_ext_control32 __user *ucontrols; 669 struct v4l2_ext_control __user *kcontrols; 670 unsigned int n; 671 compat_caddr_t p; 672 673 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_ext_controls32)) || 674 get_user(kp->which, &up->which) || 675 get_user(kp->count, &up->count) || 676 get_user(kp->error_idx, &up->error_idx) || 677 copy_from_user(kp->reserved, up->reserved, 678 sizeof(kp->reserved))) 679 return -EFAULT; 680 if (kp->count == 0) { 681 kp->controls = NULL; 682 return 0; 683 } else if (kp->count > V4L2_CID_MAX_CTRLS) { 684 return -EINVAL; 685 } 686 if (get_user(p, &up->controls)) 687 return -EFAULT; 688 ucontrols = compat_ptr(p); 689 if (!access_ok(VERIFY_READ, ucontrols, 690 kp->count * sizeof(struct v4l2_ext_control32))) 691 return -EFAULT; 692 kcontrols = compat_alloc_user_space(kp->count * 693 sizeof(struct v4l2_ext_control)); 694 kp->controls = (__force struct v4l2_ext_control *)kcontrols; 695 for (n = 0; n < kp->count; n++) { 696 u32 id; 697 698 if (copy_in_user(kcontrols, ucontrols, sizeof(*ucontrols))) 699 return -EFAULT; 700 if (get_user(id, &kcontrols->id)) 701 return -EFAULT; 702 if (ctrl_is_pointer(id)) { 703 void __user *s; 704 705 if (get_user(p, &ucontrols->string)) 706 return -EFAULT; 707 s = compat_ptr(p); 708 if (put_user(s, &kcontrols->string)) 709 return -EFAULT; 710 } 711 ucontrols++; 712 kcontrols++; 713 } 714 return 0; 715 } 716 717 static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up) 718 { 719 struct v4l2_ext_control32 __user *ucontrols; 720 struct v4l2_ext_control __user *kcontrols = 721 (__force struct v4l2_ext_control __user *)kp->controls; 722 int n = kp->count; 723 compat_caddr_t p; 724 725 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_ext_controls32)) || 726 put_user(kp->which, &up->which) || 727 put_user(kp->count, &up->count) || 728 put_user(kp->error_idx, &up->error_idx) || 729 copy_to_user(up->reserved, kp->reserved, sizeof(up->reserved))) 730 return -EFAULT; 731 if (!kp->count) 732 return 0; 733 734 if (get_user(p, &up->controls)) 735 return -EFAULT; 736 ucontrols = compat_ptr(p); 737 if (!access_ok(VERIFY_WRITE, ucontrols, 738 n * sizeof(struct v4l2_ext_control32))) 739 return -EFAULT; 740 741 while (--n >= 0) { 742 unsigned size = sizeof(*ucontrols); 743 u32 id; 744 745 if (get_user(id, &kcontrols->id)) 746 return -EFAULT; 747 /* Do not modify the pointer when copying a pointer control. 748 The contents of the pointer was changed, not the pointer 749 itself. */ 750 if (ctrl_is_pointer(id)) 751 size -= sizeof(ucontrols->value64); 752 if (copy_in_user(ucontrols, kcontrols, size)) 753 return -EFAULT; 754 ucontrols++; 755 kcontrols++; 756 } 757 return 0; 758 } 759 760 struct v4l2_event32 { 761 __u32 type; 762 union { 763 compat_s64 value64; 764 __u8 data[64]; 765 } u; 766 __u32 pending; 767 __u32 sequence; 768 struct compat_timespec timestamp; 769 __u32 id; 770 __u32 reserved[8]; 771 }; 772 773 static int put_v4l2_event32(struct v4l2_event *kp, struct v4l2_event32 __user *up) 774 { 775 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_event32)) || 776 put_user(kp->type, &up->type) || 777 copy_to_user(&up->u, &kp->u, sizeof(kp->u)) || 778 put_user(kp->pending, &up->pending) || 779 put_user(kp->sequence, &up->sequence) || 780 compat_put_timespec(&kp->timestamp, &up->timestamp) || 781 put_user(kp->id, &up->id) || 782 copy_to_user(up->reserved, kp->reserved, 8 * sizeof(__u32))) 783 return -EFAULT; 784 return 0; 785 } 786 787 struct v4l2_edid32 { 788 __u32 pad; 789 __u32 start_block; 790 __u32 blocks; 791 __u32 reserved[5]; 792 compat_caddr_t edid; 793 }; 794 795 static int get_v4l2_edid32(struct v4l2_edid *kp, struct v4l2_edid32 __user *up) 796 { 797 u32 tmp; 798 799 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_edid32)) || 800 get_user(kp->pad, &up->pad) || 801 get_user(kp->start_block, &up->start_block) || 802 get_user(kp->blocks, &up->blocks) || 803 get_user(tmp, &up->edid) || 804 copy_from_user(kp->reserved, up->reserved, sizeof(kp->reserved))) 805 return -EFAULT; 806 kp->edid = (__force u8 *)compat_ptr(tmp); 807 return 0; 808 } 809 810 static int put_v4l2_edid32(struct v4l2_edid *kp, struct v4l2_edid32 __user *up) 811 { 812 u32 tmp = (u32)((unsigned long)kp->edid); 813 814 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_edid32)) || 815 put_user(kp->pad, &up->pad) || 816 put_user(kp->start_block, &up->start_block) || 817 put_user(kp->blocks, &up->blocks) || 818 put_user(tmp, &up->edid) || 819 copy_to_user(up->reserved, kp->reserved, sizeof(up->reserved))) 820 return -EFAULT; 821 return 0; 822 } 823 824 825 #define VIDIOC_G_FMT32 _IOWR('V', 4, struct v4l2_format32) 826 #define VIDIOC_S_FMT32 _IOWR('V', 5, struct v4l2_format32) 827 #define VIDIOC_QUERYBUF32 _IOWR('V', 9, struct v4l2_buffer32) 828 #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32) 829 #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32) 830 #define VIDIOC_QBUF32 _IOWR('V', 15, struct v4l2_buffer32) 831 #define VIDIOC_DQBUF32 _IOWR('V', 17, struct v4l2_buffer32) 832 #define VIDIOC_ENUMSTD32 _IOWR('V', 25, struct v4l2_standard32) 833 #define VIDIOC_ENUMINPUT32 _IOWR('V', 26, struct v4l2_input32) 834 #define VIDIOC_G_EDID32 _IOWR('V', 40, struct v4l2_edid32) 835 #define VIDIOC_S_EDID32 _IOWR('V', 41, struct v4l2_edid32) 836 #define VIDIOC_TRY_FMT32 _IOWR('V', 64, struct v4l2_format32) 837 #define VIDIOC_G_EXT_CTRLS32 _IOWR('V', 71, struct v4l2_ext_controls32) 838 #define VIDIOC_S_EXT_CTRLS32 _IOWR('V', 72, struct v4l2_ext_controls32) 839 #define VIDIOC_TRY_EXT_CTRLS32 _IOWR('V', 73, struct v4l2_ext_controls32) 840 #define VIDIOC_DQEVENT32 _IOR ('V', 89, struct v4l2_event32) 841 #define VIDIOC_CREATE_BUFS32 _IOWR('V', 92, struct v4l2_create_buffers32) 842 #define VIDIOC_PREPARE_BUF32 _IOWR('V', 93, struct v4l2_buffer32) 843 844 #define VIDIOC_OVERLAY32 _IOW ('V', 14, s32) 845 #define VIDIOC_STREAMON32 _IOW ('V', 18, s32) 846 #define VIDIOC_STREAMOFF32 _IOW ('V', 19, s32) 847 #define VIDIOC_G_INPUT32 _IOR ('V', 38, s32) 848 #define VIDIOC_S_INPUT32 _IOWR('V', 39, s32) 849 #define VIDIOC_G_OUTPUT32 _IOR ('V', 46, s32) 850 #define VIDIOC_S_OUTPUT32 _IOWR('V', 47, s32) 851 852 static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 853 { 854 union { 855 struct v4l2_format v2f; 856 struct v4l2_buffer v2b; 857 struct v4l2_framebuffer v2fb; 858 struct v4l2_input v2i; 859 struct v4l2_standard v2s; 860 struct v4l2_ext_controls v2ecs; 861 struct v4l2_event v2ev; 862 struct v4l2_create_buffers v2crt; 863 struct v4l2_edid v2edid; 864 unsigned long vx; 865 int vi; 866 } karg; 867 void __user *up = compat_ptr(arg); 868 int compatible_arg = 1; 869 long err = 0; 870 871 /* First, convert the command. */ 872 switch (cmd) { 873 case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break; 874 case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break; 875 case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break; 876 case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break; 877 case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break; 878 case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break; 879 case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break; 880 case VIDIOC_ENUMSTD32: cmd = VIDIOC_ENUMSTD; break; 881 case VIDIOC_ENUMINPUT32: cmd = VIDIOC_ENUMINPUT; break; 882 case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break; 883 case VIDIOC_G_EXT_CTRLS32: cmd = VIDIOC_G_EXT_CTRLS; break; 884 case VIDIOC_S_EXT_CTRLS32: cmd = VIDIOC_S_EXT_CTRLS; break; 885 case VIDIOC_TRY_EXT_CTRLS32: cmd = VIDIOC_TRY_EXT_CTRLS; break; 886 case VIDIOC_DQEVENT32: cmd = VIDIOC_DQEVENT; break; 887 case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break; 888 case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break; 889 case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break; 890 case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break; 891 case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break; 892 case VIDIOC_G_OUTPUT32: cmd = VIDIOC_G_OUTPUT; break; 893 case VIDIOC_S_OUTPUT32: cmd = VIDIOC_S_OUTPUT; break; 894 case VIDIOC_CREATE_BUFS32: cmd = VIDIOC_CREATE_BUFS; break; 895 case VIDIOC_PREPARE_BUF32: cmd = VIDIOC_PREPARE_BUF; break; 896 case VIDIOC_G_EDID32: cmd = VIDIOC_G_EDID; break; 897 case VIDIOC_S_EDID32: cmd = VIDIOC_S_EDID; break; 898 } 899 900 switch (cmd) { 901 case VIDIOC_OVERLAY: 902 case VIDIOC_STREAMON: 903 case VIDIOC_STREAMOFF: 904 case VIDIOC_S_INPUT: 905 case VIDIOC_S_OUTPUT: 906 err = get_user(karg.vi, (s32 __user *)up); 907 compatible_arg = 0; 908 break; 909 910 case VIDIOC_G_INPUT: 911 case VIDIOC_G_OUTPUT: 912 compatible_arg = 0; 913 break; 914 915 case VIDIOC_G_EDID: 916 case VIDIOC_S_EDID: 917 err = get_v4l2_edid32(&karg.v2edid, up); 918 compatible_arg = 0; 919 break; 920 921 case VIDIOC_G_FMT: 922 case VIDIOC_S_FMT: 923 case VIDIOC_TRY_FMT: 924 err = get_v4l2_format32(&karg.v2f, up); 925 compatible_arg = 0; 926 break; 927 928 case VIDIOC_CREATE_BUFS: 929 err = get_v4l2_create32(&karg.v2crt, up); 930 compatible_arg = 0; 931 break; 932 933 case VIDIOC_PREPARE_BUF: 934 case VIDIOC_QUERYBUF: 935 case VIDIOC_QBUF: 936 case VIDIOC_DQBUF: 937 err = get_v4l2_buffer32(&karg.v2b, up); 938 compatible_arg = 0; 939 break; 940 941 case VIDIOC_S_FBUF: 942 err = get_v4l2_framebuffer32(&karg.v2fb, up); 943 compatible_arg = 0; 944 break; 945 946 case VIDIOC_G_FBUF: 947 compatible_arg = 0; 948 break; 949 950 case VIDIOC_ENUMSTD: 951 err = get_v4l2_standard32(&karg.v2s, up); 952 compatible_arg = 0; 953 break; 954 955 case VIDIOC_ENUMINPUT: 956 err = get_v4l2_input32(&karg.v2i, up); 957 compatible_arg = 0; 958 break; 959 960 case VIDIOC_G_EXT_CTRLS: 961 case VIDIOC_S_EXT_CTRLS: 962 case VIDIOC_TRY_EXT_CTRLS: 963 err = get_v4l2_ext_controls32(&karg.v2ecs, up); 964 compatible_arg = 0; 965 break; 966 case VIDIOC_DQEVENT: 967 compatible_arg = 0; 968 break; 969 } 970 if (err) 971 return err; 972 973 if (compatible_arg) 974 err = native_ioctl(file, cmd, (unsigned long)up); 975 else { 976 mm_segment_t old_fs = get_fs(); 977 978 set_fs(KERNEL_DS); 979 err = native_ioctl(file, cmd, (unsigned long)&karg); 980 set_fs(old_fs); 981 } 982 983 /* Special case: even after an error we need to put the 984 results back for these ioctls since the error_idx will 985 contain information on which control failed. */ 986 switch (cmd) { 987 case VIDIOC_G_EXT_CTRLS: 988 case VIDIOC_S_EXT_CTRLS: 989 case VIDIOC_TRY_EXT_CTRLS: 990 if (put_v4l2_ext_controls32(&karg.v2ecs, up)) 991 err = -EFAULT; 992 break; 993 } 994 if (err) 995 return err; 996 997 switch (cmd) { 998 case VIDIOC_S_INPUT: 999 case VIDIOC_S_OUTPUT: 1000 case VIDIOC_G_INPUT: 1001 case VIDIOC_G_OUTPUT: 1002 err = put_user(((s32)karg.vi), (s32 __user *)up); 1003 break; 1004 1005 case VIDIOC_G_FBUF: 1006 err = put_v4l2_framebuffer32(&karg.v2fb, up); 1007 break; 1008 1009 case VIDIOC_DQEVENT: 1010 err = put_v4l2_event32(&karg.v2ev, up); 1011 break; 1012 1013 case VIDIOC_G_EDID: 1014 case VIDIOC_S_EDID: 1015 err = put_v4l2_edid32(&karg.v2edid, up); 1016 break; 1017 1018 case VIDIOC_G_FMT: 1019 case VIDIOC_S_FMT: 1020 case VIDIOC_TRY_FMT: 1021 err = put_v4l2_format32(&karg.v2f, up); 1022 break; 1023 1024 case VIDIOC_CREATE_BUFS: 1025 err = put_v4l2_create32(&karg.v2crt, up); 1026 break; 1027 1028 case VIDIOC_QUERYBUF: 1029 case VIDIOC_QBUF: 1030 case VIDIOC_DQBUF: 1031 err = put_v4l2_buffer32(&karg.v2b, up); 1032 break; 1033 1034 case VIDIOC_ENUMSTD: 1035 err = put_v4l2_standard32(&karg.v2s, up); 1036 break; 1037 1038 case VIDIOC_ENUMINPUT: 1039 err = put_v4l2_input32(&karg.v2i, up); 1040 break; 1041 } 1042 return err; 1043 } 1044 1045 long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) 1046 { 1047 struct video_device *vdev = video_devdata(file); 1048 long ret = -ENOIOCTLCMD; 1049 1050 if (!file->f_op->unlocked_ioctl) 1051 return ret; 1052 1053 if (_IOC_TYPE(cmd) == 'V' && _IOC_NR(cmd) < BASE_VIDIOC_PRIVATE) 1054 ret = do_video_ioctl(file, cmd, arg); 1055 else if (vdev->fops->compat_ioctl32) 1056 ret = vdev->fops->compat_ioctl32(file, cmd, arg); 1057 1058 if (ret == -ENOIOCTLCMD) 1059 pr_debug("compat_ioctl32: unknown ioctl '%c', dir=%d, #%d (0x%08x)\n", 1060 _IOC_TYPE(cmd), _IOC_DIR(cmd), _IOC_NR(cmd), cmd); 1061 return ret; 1062 } 1063 EXPORT_SYMBOL_GPL(v4l2_compat_ioctl32); 1064