1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 1994-1995 Søren Schmidt
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 #include <sys/param.h>
31 #include <sys/capsicum.h>
32 #include <sys/cdio.h>
33 #include <sys/consio.h>
34 #include <sys/disk.h>
35 #include <sys/dvdio.h>
36 #include <sys/fcntl.h>
37 #include <sys/filio.h>
38 #include <sys/jail.h>
39 #include <sys/kbio.h>
40 #include <sys/kcov.h>
41 #include <sys/kernel.h>
42 #include <sys/linker_set.h>
43 #include <sys/lock.h>
44 #include <sys/malloc.h>
45 #include <sys/mman.h>
46 #include <sys/proc.h>
47 #include <sys/sbuf.h>
48 #include <sys/sockio.h>
49 #include <sys/soundcard.h>
50 #include <sys/sysctl.h>
51 #include <sys/sysproto.h>
52 #include <sys/sx.h>
53 #include <sys/tty.h>
54
55 #include <net/if.h>
56 #include <net/if_var.h>
57 #include <net/if_dl.h>
58 #include <net/if_types.h>
59
60 #include <dev/evdev/input.h>
61 #include <dev/usb/usb_ioctl.h>
62
63 #ifdef COMPAT_LINUX32
64 #include <machine/../linux32/linux.h>
65 #include <machine/../linux32/linux32_proto.h>
66 #else
67 #include <machine/../linux/linux.h>
68 #include <machine/../linux/linux_proto.h>
69 #endif
70
71 #include <compat/linux/linux_common.h>
72 #include <compat/linux/linux_ioctl.h>
73 #include <compat/linux/linux_mib.h>
74 #include <compat/linux/linux_socket.h>
75 #include <compat/linux/linux_time.h>
76 #include <compat/linux/linux_util.h>
77
78 #include <contrib/v4l/videodev.h>
79 #include <compat/linux/linux_videodev_compat.h>
80
81 #include <contrib/v4l/videodev2.h>
82 #include <compat/linux/linux_videodev2_compat.h>
83
84 #include <cam/scsi/scsi_sg.h>
85
86 CTASSERT(LINUX_IFNAMSIZ == IFNAMSIZ);
87
88 #define DEFINE_LINUX_IOCTL_SET(shortname, SHORTNAME) \
89 static linux_ioctl_function_t linux_ioctl_ ## shortname; \
90 static struct linux_ioctl_handler shortname ## _handler = { \
91 .func = linux_ioctl_ ## shortname, \
92 .low = LINUX_IOCTL_ ## SHORTNAME ## _MIN, \
93 .high = LINUX_IOCTL_ ## SHORTNAME ## _MAX, \
94 }; \
95 DATA_SET(linux_ioctl_handler_set, shortname ## _handler)
96
97 DEFINE_LINUX_IOCTL_SET(cdrom, CDROM);
98 DEFINE_LINUX_IOCTL_SET(vfat, VFAT);
99 DEFINE_LINUX_IOCTL_SET(console, CONSOLE);
100 DEFINE_LINUX_IOCTL_SET(hdio, HDIO);
101 DEFINE_LINUX_IOCTL_SET(disk, DISK);
102 DEFINE_LINUX_IOCTL_SET(socket, SOCKET);
103 DEFINE_LINUX_IOCTL_SET(sound, SOUND);
104 DEFINE_LINUX_IOCTL_SET(termio, TERMIO);
105 DEFINE_LINUX_IOCTL_SET(private, PRIVATE);
106 DEFINE_LINUX_IOCTL_SET(drm, DRM);
107 DEFINE_LINUX_IOCTL_SET(sg, SG);
108 DEFINE_LINUX_IOCTL_SET(v4l, VIDEO);
109 DEFINE_LINUX_IOCTL_SET(v4l2, VIDEO2);
110 DEFINE_LINUX_IOCTL_SET(fbsd_usb, FBSD_LUSB);
111 DEFINE_LINUX_IOCTL_SET(evdev, EVDEV);
112 DEFINE_LINUX_IOCTL_SET(kcov, KCOV);
113
114 #undef DEFINE_LINUX_IOCTL_SET
115
116 static int linux_ioctl_special(struct thread *, struct linux_ioctl_args *);
117
118 /*
119 * Keep sorted by low.
120 */
121 static struct linux_ioctl_handler linux_ioctls[] = {
122 { .func = linux_ioctl_termio, .low = LINUX_IOCTL_TERMIO_MIN,
123 .high = LINUX_IOCTL_TERMIO_MAX },
124 };
125
126 #ifdef __i386__
127 static TAILQ_HEAD(, linux_ioctl_handler_element) linux_ioctl_handlers =
128 TAILQ_HEAD_INITIALIZER(linux_ioctl_handlers);
129 static struct sx linux_ioctl_sx;
130 SX_SYSINIT(linux_ioctl, &linux_ioctl_sx, "Linux ioctl handlers");
131 #else
132 extern TAILQ_HEAD(, linux_ioctl_handler_element) linux_ioctl_handlers;
133 extern struct sx linux_ioctl_sx;
134 #endif
135 #ifdef COMPAT_LINUX32
136 static TAILQ_HEAD(, linux_ioctl_handler_element) linux32_ioctl_handlers =
137 TAILQ_HEAD_INITIALIZER(linux32_ioctl_handlers);
138 #endif
139
140 /*
141 * hdio related ioctls for VMWare support
142 */
143
144 struct linux_hd_geometry {
145 u_int8_t heads;
146 u_int8_t sectors;
147 u_int16_t cylinders;
148 u_int32_t start;
149 };
150
151 struct linux_hd_big_geometry {
152 u_int8_t heads;
153 u_int8_t sectors;
154 u_int32_t cylinders;
155 u_int32_t start;
156 };
157
158 static int
linux_ioctl_hdio(struct thread * td,struct linux_ioctl_args * args)159 linux_ioctl_hdio(struct thread *td, struct linux_ioctl_args *args)
160 {
161 struct file *fp;
162 int error;
163 u_int sectorsize, fwcylinders, fwheads, fwsectors;
164 off_t mediasize, bytespercyl;
165
166 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
167 if (error != 0)
168 return (error);
169 switch (args->cmd & 0xffff) {
170 case LINUX_HDIO_GET_GEO:
171 case LINUX_HDIO_GET_GEO_BIG:
172 error = fo_ioctl(fp, DIOCGMEDIASIZE,
173 (caddr_t)&mediasize, td->td_ucred, td);
174 if (!error)
175 error = fo_ioctl(fp, DIOCGSECTORSIZE,
176 (caddr_t)§orsize, td->td_ucred, td);
177 if (!error)
178 error = fo_ioctl(fp, DIOCGFWHEADS,
179 (caddr_t)&fwheads, td->td_ucred, td);
180 if (!error)
181 error = fo_ioctl(fp, DIOCGFWSECTORS,
182 (caddr_t)&fwsectors, td->td_ucred, td);
183 /*
184 * XXX: DIOCGFIRSTOFFSET is not yet implemented, so
185 * so pretend that GEOM always says 0. This is NOT VALID
186 * for slices or partitions, only the per-disk raw devices.
187 */
188
189 fdrop(fp, td);
190 if (error)
191 return (error);
192 /*
193 * 1. Calculate the number of bytes in a cylinder,
194 * given the firmware's notion of heads and sectors
195 * per cylinder.
196 * 2. Calculate the number of cylinders, given the total
197 * size of the media.
198 * All internal calculations should have 64-bit precision.
199 */
200 bytespercyl = (off_t) sectorsize * fwheads * fwsectors;
201 fwcylinders = mediasize / bytespercyl;
202
203 if ((args->cmd & 0xffff) == LINUX_HDIO_GET_GEO) {
204 struct linux_hd_geometry hdg;
205
206 hdg.cylinders = fwcylinders;
207 hdg.heads = fwheads;
208 hdg.sectors = fwsectors;
209 hdg.start = 0;
210 error = copyout(&hdg, (void *)args->arg, sizeof(hdg));
211 } else if ((args->cmd & 0xffff) == LINUX_HDIO_GET_GEO_BIG) {
212 struct linux_hd_big_geometry hdbg;
213
214 memset(&hdbg, 0, sizeof(hdbg));
215 hdbg.cylinders = fwcylinders;
216 hdbg.heads = fwheads;
217 hdbg.sectors = fwsectors;
218 hdbg.start = 0;
219 error = copyout(&hdbg, (void *)args->arg, sizeof(hdbg));
220 }
221 return (error);
222 break;
223 default:
224 /* XXX */
225 linux_msg(td,
226 "%s fd=%d, cmd=0x%x ('%c',%d) is not implemented",
227 __func__, args->fd, args->cmd,
228 (int)(args->cmd & 0xff00) >> 8,
229 (int)(args->cmd & 0xff));
230 break;
231 }
232 fdrop(fp, td);
233 return (ENOIOCTL);
234 }
235
236 static int
linux_ioctl_disk(struct thread * td,struct linux_ioctl_args * args)237 linux_ioctl_disk(struct thread *td, struct linux_ioctl_args *args)
238 {
239 struct file *fp;
240 int error;
241 u_int sectorsize, psectorsize;
242 uint64_t blksize64;
243 off_t mediasize, stripesize;
244
245 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
246 if (error != 0)
247 return (error);
248 switch (args->cmd & 0xffff) {
249 case LINUX_BLKGETSIZE:
250 error = fo_ioctl(fp, DIOCGSECTORSIZE,
251 (caddr_t)§orsize, td->td_ucred, td);
252 if (!error)
253 error = fo_ioctl(fp, DIOCGMEDIASIZE,
254 (caddr_t)&mediasize, td->td_ucred, td);
255 fdrop(fp, td);
256 if (error)
257 return (error);
258 sectorsize = mediasize / sectorsize;
259 /*
260 * XXX: How do we know we return the right size of integer ?
261 */
262 return (copyout(§orsize, (void *)args->arg,
263 sizeof(sectorsize)));
264 break;
265 case LINUX_BLKGETSIZE64:
266 error = fo_ioctl(fp, DIOCGMEDIASIZE,
267 (caddr_t)&mediasize, td->td_ucred, td);
268 fdrop(fp, td);
269 if (error)
270 return (error);
271 blksize64 = mediasize;;
272 return (copyout(&blksize64, (void *)args->arg,
273 sizeof(blksize64)));
274 case LINUX_BLKSSZGET:
275 error = fo_ioctl(fp, DIOCGSECTORSIZE,
276 (caddr_t)§orsize, td->td_ucred, td);
277 fdrop(fp, td);
278 if (error)
279 return (error);
280 return (copyout(§orsize, (void *)args->arg,
281 sizeof(sectorsize)));
282 break;
283 case LINUX_BLKPBSZGET:
284 error = fo_ioctl(fp, DIOCGSTRIPESIZE,
285 (caddr_t)&stripesize, td->td_ucred, td);
286 if (error != 0) {
287 fdrop(fp, td);
288 return (error);
289 }
290 if (stripesize > 0 && stripesize <= 4096) {
291 psectorsize = stripesize;
292 } else {
293 error = fo_ioctl(fp, DIOCGSECTORSIZE,
294 (caddr_t)§orsize, td->td_ucred, td);
295 if (error != 0) {
296 fdrop(fp, td);
297 return (error);
298 }
299 psectorsize = sectorsize;
300 }
301 fdrop(fp, td);
302 return (copyout(&psectorsize, (void *)args->arg,
303 sizeof(psectorsize)));
304 }
305 fdrop(fp, td);
306 return (ENOIOCTL);
307 }
308
309 /*
310 * termio related ioctls
311 */
312
313 struct linux_termio {
314 unsigned short c_iflag;
315 unsigned short c_oflag;
316 unsigned short c_cflag;
317 unsigned short c_lflag;
318 unsigned char c_line;
319 unsigned char c_cc[LINUX_NCC];
320 };
321
322 struct linux_termios {
323 unsigned int c_iflag;
324 unsigned int c_oflag;
325 unsigned int c_cflag;
326 unsigned int c_lflag;
327 unsigned char c_line;
328 unsigned char c_cc[LINUX_NCCS];
329 };
330
331 struct linux_winsize {
332 unsigned short ws_row, ws_col;
333 unsigned short ws_xpixel, ws_ypixel;
334 };
335
336 struct speedtab {
337 int sp_speed; /* Speed. */
338 int sp_code; /* Code. */
339 };
340
341 static struct speedtab sptab[] = {
342 { B0, LINUX_B0 }, { B50, LINUX_B50 },
343 { B75, LINUX_B75 }, { B110, LINUX_B110 },
344 { B134, LINUX_B134 }, { B150, LINUX_B150 },
345 { B200, LINUX_B200 }, { B300, LINUX_B300 },
346 { B600, LINUX_B600 }, { B1200, LINUX_B1200 },
347 { B1800, LINUX_B1800 }, { B2400, LINUX_B2400 },
348 { B4800, LINUX_B4800 }, { B9600, LINUX_B9600 },
349 { B19200, LINUX_B19200 }, { B38400, LINUX_B38400 },
350 { B57600, LINUX_B57600 }, { B115200, LINUX_B115200 },
351 {-1, -1 }
352 };
353
354 struct linux_serial_struct {
355 int type;
356 int line;
357 int port;
358 int irq;
359 int flags;
360 int xmit_fifo_size;
361 int custom_divisor;
362 int baud_base;
363 unsigned short close_delay;
364 char reserved_char[2];
365 int hub6;
366 unsigned short closing_wait;
367 unsigned short closing_wait2;
368 int reserved[4];
369 };
370
371 static int
linux_to_bsd_speed(int code,struct speedtab * table)372 linux_to_bsd_speed(int code, struct speedtab *table)
373 {
374 for ( ; table->sp_code != -1; table++)
375 if (table->sp_code == code)
376 return (table->sp_speed);
377 return (-1);
378 }
379
380 static int
bsd_to_linux_speed(int speed,struct speedtab * table)381 bsd_to_linux_speed(int speed, struct speedtab *table)
382 {
383 for ( ; table->sp_speed != -1; table++)
384 if (table->sp_speed == speed)
385 return (table->sp_code);
386 return (-1);
387 }
388
389 static void
bsd_to_linux_termios(struct termios * bios,struct linux_termios * lios)390 bsd_to_linux_termios(struct termios *bios, struct linux_termios *lios)
391 {
392 int i;
393
394 lios->c_iflag = 0;
395 if (bios->c_iflag & IGNBRK)
396 lios->c_iflag |= LINUX_IGNBRK;
397 if (bios->c_iflag & BRKINT)
398 lios->c_iflag |= LINUX_BRKINT;
399 if (bios->c_iflag & IGNPAR)
400 lios->c_iflag |= LINUX_IGNPAR;
401 if (bios->c_iflag & PARMRK)
402 lios->c_iflag |= LINUX_PARMRK;
403 if (bios->c_iflag & INPCK)
404 lios->c_iflag |= LINUX_INPCK;
405 if (bios->c_iflag & ISTRIP)
406 lios->c_iflag |= LINUX_ISTRIP;
407 if (bios->c_iflag & INLCR)
408 lios->c_iflag |= LINUX_INLCR;
409 if (bios->c_iflag & IGNCR)
410 lios->c_iflag |= LINUX_IGNCR;
411 if (bios->c_iflag & ICRNL)
412 lios->c_iflag |= LINUX_ICRNL;
413 if (bios->c_iflag & IXON)
414 lios->c_iflag |= LINUX_IXON;
415 if (bios->c_iflag & IXANY)
416 lios->c_iflag |= LINUX_IXANY;
417 if (bios->c_iflag & IXOFF)
418 lios->c_iflag |= LINUX_IXOFF;
419 if (bios->c_iflag & IMAXBEL)
420 lios->c_iflag |= LINUX_IMAXBEL;
421
422 lios->c_oflag = 0;
423 if (bios->c_oflag & OPOST)
424 lios->c_oflag |= LINUX_OPOST;
425 if (bios->c_oflag & ONLCR)
426 lios->c_oflag |= LINUX_ONLCR;
427 if (bios->c_oflag & TAB3)
428 lios->c_oflag |= LINUX_XTABS;
429
430 lios->c_cflag = bsd_to_linux_speed(bios->c_ispeed, sptab);
431 lios->c_cflag |= (bios->c_cflag & CSIZE) >> 4;
432 if (bios->c_cflag & CSTOPB)
433 lios->c_cflag |= LINUX_CSTOPB;
434 if (bios->c_cflag & CREAD)
435 lios->c_cflag |= LINUX_CREAD;
436 if (bios->c_cflag & PARENB)
437 lios->c_cflag |= LINUX_PARENB;
438 if (bios->c_cflag & PARODD)
439 lios->c_cflag |= LINUX_PARODD;
440 if (bios->c_cflag & HUPCL)
441 lios->c_cflag |= LINUX_HUPCL;
442 if (bios->c_cflag & CLOCAL)
443 lios->c_cflag |= LINUX_CLOCAL;
444 if (bios->c_cflag & CRTSCTS)
445 lios->c_cflag |= LINUX_CRTSCTS;
446
447 lios->c_lflag = 0;
448 if (bios->c_lflag & ISIG)
449 lios->c_lflag |= LINUX_ISIG;
450 if (bios->c_lflag & ICANON)
451 lios->c_lflag |= LINUX_ICANON;
452 if (bios->c_lflag & ECHO)
453 lios->c_lflag |= LINUX_ECHO;
454 if (bios->c_lflag & ECHOE)
455 lios->c_lflag |= LINUX_ECHOE;
456 if (bios->c_lflag & ECHOK)
457 lios->c_lflag |= LINUX_ECHOK;
458 if (bios->c_lflag & ECHONL)
459 lios->c_lflag |= LINUX_ECHONL;
460 if (bios->c_lflag & NOFLSH)
461 lios->c_lflag |= LINUX_NOFLSH;
462 if (bios->c_lflag & TOSTOP)
463 lios->c_lflag |= LINUX_TOSTOP;
464 if (bios->c_lflag & ECHOCTL)
465 lios->c_lflag |= LINUX_ECHOCTL;
466 if (bios->c_lflag & ECHOPRT)
467 lios->c_lflag |= LINUX_ECHOPRT;
468 if (bios->c_lflag & ECHOKE)
469 lios->c_lflag |= LINUX_ECHOKE;
470 if (bios->c_lflag & FLUSHO)
471 lios->c_lflag |= LINUX_FLUSHO;
472 if (bios->c_lflag & PENDIN)
473 lios->c_lflag |= LINUX_PENDIN;
474 if (bios->c_lflag & IEXTEN)
475 lios->c_lflag |= LINUX_IEXTEN;
476
477 for (i=0; i<LINUX_NCCS; i++)
478 lios->c_cc[i] = LINUX_POSIX_VDISABLE;
479 lios->c_cc[LINUX_VINTR] = bios->c_cc[VINTR];
480 lios->c_cc[LINUX_VQUIT] = bios->c_cc[VQUIT];
481 lios->c_cc[LINUX_VERASE] = bios->c_cc[VERASE];
482 lios->c_cc[LINUX_VKILL] = bios->c_cc[VKILL];
483 lios->c_cc[LINUX_VEOF] = bios->c_cc[VEOF];
484 lios->c_cc[LINUX_VEOL] = bios->c_cc[VEOL];
485 lios->c_cc[LINUX_VMIN] = bios->c_cc[VMIN];
486 lios->c_cc[LINUX_VTIME] = bios->c_cc[VTIME];
487 lios->c_cc[LINUX_VEOL2] = bios->c_cc[VEOL2];
488 lios->c_cc[LINUX_VSUSP] = bios->c_cc[VSUSP];
489 lios->c_cc[LINUX_VSTART] = bios->c_cc[VSTART];
490 lios->c_cc[LINUX_VSTOP] = bios->c_cc[VSTOP];
491 lios->c_cc[LINUX_VREPRINT] = bios->c_cc[VREPRINT];
492 lios->c_cc[LINUX_VDISCARD] = bios->c_cc[VDISCARD];
493 lios->c_cc[LINUX_VWERASE] = bios->c_cc[VWERASE];
494 lios->c_cc[LINUX_VLNEXT] = bios->c_cc[VLNEXT];
495 if (linux_preserve_vstatus)
496 lios->c_cc[LINUX_VSTATUS] = bios->c_cc[VSTATUS];
497
498 for (i=0; i<LINUX_NCCS; i++) {
499 if (i != LINUX_VMIN && i != LINUX_VTIME &&
500 lios->c_cc[i] == _POSIX_VDISABLE)
501 lios->c_cc[i] = LINUX_POSIX_VDISABLE;
502 }
503 lios->c_line = 0;
504 }
505
506 static void
linux_to_bsd_termios(struct linux_termios * lios,struct termios * bios)507 linux_to_bsd_termios(struct linux_termios *lios, struct termios *bios)
508 {
509 int i;
510
511 bios->c_iflag = 0;
512 if (lios->c_iflag & LINUX_IGNBRK)
513 bios->c_iflag |= IGNBRK;
514 if (lios->c_iflag & LINUX_BRKINT)
515 bios->c_iflag |= BRKINT;
516 if (lios->c_iflag & LINUX_IGNPAR)
517 bios->c_iflag |= IGNPAR;
518 if (lios->c_iflag & LINUX_PARMRK)
519 bios->c_iflag |= PARMRK;
520 if (lios->c_iflag & LINUX_INPCK)
521 bios->c_iflag |= INPCK;
522 if (lios->c_iflag & LINUX_ISTRIP)
523 bios->c_iflag |= ISTRIP;
524 if (lios->c_iflag & LINUX_INLCR)
525 bios->c_iflag |= INLCR;
526 if (lios->c_iflag & LINUX_IGNCR)
527 bios->c_iflag |= IGNCR;
528 if (lios->c_iflag & LINUX_ICRNL)
529 bios->c_iflag |= ICRNL;
530 if (lios->c_iflag & LINUX_IXON)
531 bios->c_iflag |= IXON;
532 if (lios->c_iflag & LINUX_IXANY)
533 bios->c_iflag |= IXANY;
534 if (lios->c_iflag & LINUX_IXOFF)
535 bios->c_iflag |= IXOFF;
536 if (lios->c_iflag & LINUX_IMAXBEL)
537 bios->c_iflag |= IMAXBEL;
538
539 bios->c_oflag = 0;
540 if (lios->c_oflag & LINUX_OPOST)
541 bios->c_oflag |= OPOST;
542 if (lios->c_oflag & LINUX_ONLCR)
543 bios->c_oflag |= ONLCR;
544 if (lios->c_oflag & LINUX_XTABS)
545 bios->c_oflag |= TAB3;
546
547 bios->c_cflag = (lios->c_cflag & LINUX_CSIZE) << 4;
548 if (lios->c_cflag & LINUX_CSTOPB)
549 bios->c_cflag |= CSTOPB;
550 if (lios->c_cflag & LINUX_CREAD)
551 bios->c_cflag |= CREAD;
552 if (lios->c_cflag & LINUX_PARENB)
553 bios->c_cflag |= PARENB;
554 if (lios->c_cflag & LINUX_PARODD)
555 bios->c_cflag |= PARODD;
556 if (lios->c_cflag & LINUX_HUPCL)
557 bios->c_cflag |= HUPCL;
558 if (lios->c_cflag & LINUX_CLOCAL)
559 bios->c_cflag |= CLOCAL;
560 if (lios->c_cflag & LINUX_CRTSCTS)
561 bios->c_cflag |= CRTSCTS;
562
563 bios->c_lflag = 0;
564 if (lios->c_lflag & LINUX_ISIG)
565 bios->c_lflag |= ISIG;
566 if (lios->c_lflag & LINUX_ICANON)
567 bios->c_lflag |= ICANON;
568 if (lios->c_lflag & LINUX_ECHO)
569 bios->c_lflag |= ECHO;
570 if (lios->c_lflag & LINUX_ECHOE)
571 bios->c_lflag |= ECHOE;
572 if (lios->c_lflag & LINUX_ECHOK)
573 bios->c_lflag |= ECHOK;
574 if (lios->c_lflag & LINUX_ECHONL)
575 bios->c_lflag |= ECHONL;
576 if (lios->c_lflag & LINUX_NOFLSH)
577 bios->c_lflag |= NOFLSH;
578 if (lios->c_lflag & LINUX_TOSTOP)
579 bios->c_lflag |= TOSTOP;
580 if (lios->c_lflag & LINUX_ECHOCTL)
581 bios->c_lflag |= ECHOCTL;
582 if (lios->c_lflag & LINUX_ECHOPRT)
583 bios->c_lflag |= ECHOPRT;
584 if (lios->c_lflag & LINUX_ECHOKE)
585 bios->c_lflag |= ECHOKE;
586 if (lios->c_lflag & LINUX_FLUSHO)
587 bios->c_lflag |= FLUSHO;
588 if (lios->c_lflag & LINUX_PENDIN)
589 bios->c_lflag |= PENDIN;
590 if (lios->c_lflag & LINUX_IEXTEN)
591 bios->c_lflag |= IEXTEN;
592
593 for (i=0; i<NCCS; i++)
594 bios->c_cc[i] = _POSIX_VDISABLE;
595 bios->c_cc[VINTR] = lios->c_cc[LINUX_VINTR];
596 bios->c_cc[VQUIT] = lios->c_cc[LINUX_VQUIT];
597 bios->c_cc[VERASE] = lios->c_cc[LINUX_VERASE];
598 bios->c_cc[VKILL] = lios->c_cc[LINUX_VKILL];
599 bios->c_cc[VEOF] = lios->c_cc[LINUX_VEOF];
600 bios->c_cc[VEOL] = lios->c_cc[LINUX_VEOL];
601 bios->c_cc[VMIN] = lios->c_cc[LINUX_VMIN];
602 bios->c_cc[VTIME] = lios->c_cc[LINUX_VTIME];
603 bios->c_cc[VEOL2] = lios->c_cc[LINUX_VEOL2];
604 bios->c_cc[VSUSP] = lios->c_cc[LINUX_VSUSP];
605 bios->c_cc[VSTART] = lios->c_cc[LINUX_VSTART];
606 bios->c_cc[VSTOP] = lios->c_cc[LINUX_VSTOP];
607 bios->c_cc[VREPRINT] = lios->c_cc[LINUX_VREPRINT];
608 bios->c_cc[VDISCARD] = lios->c_cc[LINUX_VDISCARD];
609 bios->c_cc[VWERASE] = lios->c_cc[LINUX_VWERASE];
610 bios->c_cc[VLNEXT] = lios->c_cc[LINUX_VLNEXT];
611 if (linux_preserve_vstatus)
612 bios->c_cc[VSTATUS] = lios->c_cc[LINUX_VSTATUS];
613
614 for (i=0; i<NCCS; i++) {
615 if (i != VMIN && i != VTIME &&
616 bios->c_cc[i] == LINUX_POSIX_VDISABLE)
617 bios->c_cc[i] = _POSIX_VDISABLE;
618 }
619
620 bios->c_ispeed = bios->c_ospeed =
621 linux_to_bsd_speed(lios->c_cflag & LINUX_CBAUD, sptab);
622 }
623
624 static void
bsd_to_linux_termio(struct termios * bios,struct linux_termio * lio)625 bsd_to_linux_termio(struct termios *bios, struct linux_termio *lio)
626 {
627 struct linux_termios lios;
628
629 memset(lio, 0, sizeof(*lio));
630 bsd_to_linux_termios(bios, &lios);
631 lio->c_iflag = lios.c_iflag;
632 lio->c_oflag = lios.c_oflag;
633 lio->c_cflag = lios.c_cflag;
634 lio->c_lflag = lios.c_lflag;
635 lio->c_line = lios.c_line;
636 memcpy(lio->c_cc, lios.c_cc, LINUX_NCC);
637 }
638
639 static void
linux_to_bsd_termio(struct linux_termio * lio,struct termios * bios)640 linux_to_bsd_termio(struct linux_termio *lio, struct termios *bios)
641 {
642 struct linux_termios lios;
643 int i;
644
645 lios.c_iflag = lio->c_iflag;
646 lios.c_oflag = lio->c_oflag;
647 lios.c_cflag = lio->c_cflag;
648 lios.c_lflag = lio->c_lflag;
649 for (i=LINUX_NCC; i<LINUX_NCCS; i++)
650 lios.c_cc[i] = LINUX_POSIX_VDISABLE;
651 memcpy(lios.c_cc, lio->c_cc, LINUX_NCC);
652 linux_to_bsd_termios(&lios, bios);
653 }
654
655 static int
linux_ioctl_termio(struct thread * td,struct linux_ioctl_args * args)656 linux_ioctl_termio(struct thread *td, struct linux_ioctl_args *args)
657 {
658 struct termios bios;
659 struct linux_termios lios;
660 struct linux_termio lio;
661 struct file *fp;
662 int error;
663
664 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
665 if (error != 0)
666 return (error);
667
668 switch (args->cmd & 0xffff) {
669 case LINUX_TCGETS:
670 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td->td_ucred,
671 td);
672 if (error)
673 break;
674 bsd_to_linux_termios(&bios, &lios);
675 error = copyout(&lios, (void *)args->arg, sizeof(lios));
676 break;
677
678 case LINUX_TCSETS:
679 error = copyin((void *)args->arg, &lios, sizeof(lios));
680 if (error)
681 break;
682 linux_to_bsd_termios(&lios, &bios);
683 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td->td_ucred,
684 td));
685 break;
686
687 case LINUX_TCSETSW:
688 error = copyin((void *)args->arg, &lios, sizeof(lios));
689 if (error)
690 break;
691 linux_to_bsd_termios(&lios, &bios);
692 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td->td_ucred,
693 td));
694 break;
695
696 case LINUX_TCSETSF:
697 error = copyin((void *)args->arg, &lios, sizeof(lios));
698 if (error)
699 break;
700 linux_to_bsd_termios(&lios, &bios);
701 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td->td_ucred,
702 td));
703 break;
704
705 case LINUX_TCGETA:
706 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td->td_ucred,
707 td);
708 if (error)
709 break;
710 bsd_to_linux_termio(&bios, &lio);
711 error = (copyout(&lio, (void *)args->arg, sizeof(lio)));
712 break;
713
714 case LINUX_TCSETA:
715 error = copyin((void *)args->arg, &lio, sizeof(lio));
716 if (error)
717 break;
718 linux_to_bsd_termio(&lio, &bios);
719 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td->td_ucred,
720 td));
721 break;
722
723 case LINUX_TCSETAW:
724 error = copyin((void *)args->arg, &lio, sizeof(lio));
725 if (error)
726 break;
727 linux_to_bsd_termio(&lio, &bios);
728 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td->td_ucred,
729 td));
730 break;
731
732 case LINUX_TCSETAF:
733 error = copyin((void *)args->arg, &lio, sizeof(lio));
734 if (error)
735 break;
736 linux_to_bsd_termio(&lio, &bios);
737 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td->td_ucred,
738 td));
739 break;
740
741 case LINUX_TCSBRK:
742 if (args->arg != 0) {
743 error = (fo_ioctl(fp, TIOCDRAIN, (caddr_t)&bios, td->td_ucred,
744 td));
745 } else {
746 linux_msg(td, "ioctl TCSBRK arg 0 not implemented");
747 error = ENOIOCTL;
748 }
749 break;
750
751 case LINUX_TCXONC: {
752 switch (args->arg) {
753 case LINUX_TCOOFF:
754 args->cmd = TIOCSTOP;
755 break;
756 case LINUX_TCOON:
757 args->cmd = TIOCSTART;
758 break;
759 case LINUX_TCIOFF:
760 case LINUX_TCION: {
761 int c;
762 struct write_args wr;
763 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios,
764 td->td_ucred, td);
765 if (error)
766 break;
767 fdrop(fp, td);
768 c = (args->arg == LINUX_TCIOFF) ? VSTOP : VSTART;
769 c = bios.c_cc[c];
770 if (c != _POSIX_VDISABLE) {
771 wr.fd = args->fd;
772 wr.buf = &c;
773 wr.nbyte = sizeof(c);
774 return (sys_write(td, &wr));
775 } else
776 return (0);
777 }
778 default:
779 fdrop(fp, td);
780 return (EINVAL);
781 }
782 args->arg = 0;
783 error = (sys_ioctl(td, (struct ioctl_args *)args));
784 break;
785 }
786
787 case LINUX_TCFLSH: {
788 int val;
789 switch (args->arg) {
790 case LINUX_TCIFLUSH:
791 val = FREAD;
792 break;
793 case LINUX_TCOFLUSH:
794 val = FWRITE;
795 break;
796 case LINUX_TCIOFLUSH:
797 val = FREAD | FWRITE;
798 break;
799 default:
800 fdrop(fp, td);
801 return (EINVAL);
802 }
803 error = (fo_ioctl(fp,TIOCFLUSH,(caddr_t)&val,td->td_ucred,td));
804 break;
805 }
806
807 case LINUX_TIOCEXCL:
808 args->cmd = TIOCEXCL;
809 error = (sys_ioctl(td, (struct ioctl_args *)args));
810 break;
811
812 case LINUX_TIOCNXCL:
813 args->cmd = TIOCNXCL;
814 error = (sys_ioctl(td, (struct ioctl_args *)args));
815 break;
816
817 case LINUX_TIOCSCTTY:
818 args->cmd = TIOCSCTTY;
819 error = (sys_ioctl(td, (struct ioctl_args *)args));
820 break;
821
822 case LINUX_TIOCGPGRP:
823 args->cmd = TIOCGPGRP;
824 error = (sys_ioctl(td, (struct ioctl_args *)args));
825 break;
826
827 case LINUX_TIOCSPGRP:
828 args->cmd = TIOCSPGRP;
829 error = (sys_ioctl(td, (struct ioctl_args *)args));
830 break;
831
832 /* LINUX_TIOCOUTQ */
833 /* LINUX_TIOCSTI */
834
835 case LINUX_TIOCGWINSZ:
836 args->cmd = TIOCGWINSZ;
837 error = (sys_ioctl(td, (struct ioctl_args *)args));
838 break;
839
840 case LINUX_TIOCSWINSZ:
841 args->cmd = TIOCSWINSZ;
842 error = (sys_ioctl(td, (struct ioctl_args *)args));
843 break;
844
845 case LINUX_TIOCMGET:
846 args->cmd = TIOCMGET;
847 error = (sys_ioctl(td, (struct ioctl_args *)args));
848 break;
849
850 case LINUX_TIOCMBIS:
851 args->cmd = TIOCMBIS;
852 error = (sys_ioctl(td, (struct ioctl_args *)args));
853 break;
854
855 case LINUX_TIOCMBIC:
856 args->cmd = TIOCMBIC;
857 error = (sys_ioctl(td, (struct ioctl_args *)args));
858 break;
859
860 case LINUX_TIOCMSET:
861 args->cmd = TIOCMSET;
862 error = (sys_ioctl(td, (struct ioctl_args *)args));
863 break;
864
865 /* TIOCGSOFTCAR */
866 /* TIOCSSOFTCAR */
867
868 case LINUX_FIONREAD: /* LINUX_TIOCINQ */
869 args->cmd = FIONREAD;
870 error = (sys_ioctl(td, (struct ioctl_args *)args));
871 break;
872
873 /* LINUX_TIOCLINUX */
874
875 case LINUX_TIOCCONS:
876 args->cmd = TIOCCONS;
877 error = (sys_ioctl(td, (struct ioctl_args *)args));
878 break;
879
880 case LINUX_TIOCGSERIAL: {
881 struct linux_serial_struct lss;
882
883 bzero(&lss, sizeof(lss));
884 lss.type = LINUX_PORT_16550A;
885 lss.flags = 0;
886 lss.close_delay = 0;
887 error = copyout(&lss, (void *)args->arg, sizeof(lss));
888 break;
889 }
890
891 case LINUX_TIOCSSERIAL: {
892 struct linux_serial_struct lss;
893 error = copyin((void *)args->arg, &lss, sizeof(lss));
894 if (error)
895 break;
896 /* XXX - It really helps to have an implementation that
897 * does nothing. NOT!
898 */
899 error = 0;
900 break;
901 }
902
903 case LINUX_TIOCPKT:
904 args->cmd = TIOCPKT;
905 error = (sys_ioctl(td, (struct ioctl_args *)args));
906 break;
907
908 case LINUX_FIONBIO:
909 args->cmd = FIONBIO;
910 error = (sys_ioctl(td, (struct ioctl_args *)args));
911 break;
912
913 case LINUX_TIOCNOTTY:
914 args->cmd = TIOCNOTTY;
915 error = (sys_ioctl(td, (struct ioctl_args *)args));
916 break;
917
918 case LINUX_TIOCSETD: {
919 int line;
920 switch (args->arg) {
921 case LINUX_N_TTY:
922 line = TTYDISC;
923 break;
924 case LINUX_N_SLIP:
925 line = SLIPDISC;
926 break;
927 case LINUX_N_PPP:
928 line = PPPDISC;
929 break;
930 default:
931 fdrop(fp, td);
932 return (EINVAL);
933 }
934 error = (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td->td_ucred,
935 td));
936 break;
937 }
938
939 case LINUX_TIOCGETD: {
940 int linux_line;
941 int bsd_line = TTYDISC;
942 error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line,
943 td->td_ucred, td);
944 if (error)
945 break;
946 switch (bsd_line) {
947 case TTYDISC:
948 linux_line = LINUX_N_TTY;
949 break;
950 case SLIPDISC:
951 linux_line = LINUX_N_SLIP;
952 break;
953 case PPPDISC:
954 linux_line = LINUX_N_PPP;
955 break;
956 default:
957 fdrop(fp, td);
958 return (EINVAL);
959 }
960 error = (copyout(&linux_line, (void *)args->arg, sizeof(int)));
961 break;
962 }
963
964 /* LINUX_TCSBRKP */
965 /* LINUX_TIOCTTYGSTRUCT */
966
967 case LINUX_FIONCLEX:
968 args->cmd = FIONCLEX;
969 error = (sys_ioctl(td, (struct ioctl_args *)args));
970 break;
971
972 case LINUX_FIOCLEX:
973 args->cmd = FIOCLEX;
974 error = (sys_ioctl(td, (struct ioctl_args *)args));
975 break;
976
977 case LINUX_FIOASYNC:
978 args->cmd = FIOASYNC;
979 error = (sys_ioctl(td, (struct ioctl_args *)args));
980 break;
981
982 /* LINUX_TIOCSERCONFIG */
983 /* LINUX_TIOCSERGWILD */
984 /* LINUX_TIOCSERSWILD */
985 /* LINUX_TIOCGLCKTRMIOS */
986 /* LINUX_TIOCSLCKTRMIOS */
987
988 case LINUX_TIOCSBRK:
989 args->cmd = TIOCSBRK;
990 error = (sys_ioctl(td, (struct ioctl_args *)args));
991 break;
992
993 case LINUX_TIOCCBRK:
994 args->cmd = TIOCCBRK;
995 error = (sys_ioctl(td, (struct ioctl_args *)args));
996 break;
997 case LINUX_TIOCGPTN: {
998 int nb;
999
1000 error = fo_ioctl(fp, TIOCGPTN, (caddr_t)&nb, td->td_ucred, td);
1001 if (!error)
1002 error = copyout(&nb, (void *)args->arg,
1003 sizeof(int));
1004 break;
1005 }
1006 case LINUX_TIOCGPTPEER:
1007 linux_msg(td, "unsupported ioctl TIOCGPTPEER");
1008 error = ENOIOCTL;
1009 break;
1010 case LINUX_TIOCSPTLCK:
1011 /*
1012 * Our unlockpt() does nothing. Check that fd refers
1013 * to a pseudo-terminal master device.
1014 */
1015 args->cmd = TIOCPTMASTER;
1016 error = (sys_ioctl(td, (struct ioctl_args *)args));
1017 break;
1018 default:
1019 error = ENOIOCTL;
1020 break;
1021 }
1022
1023 fdrop(fp, td);
1024 return (error);
1025 }
1026
1027 /*
1028 * CDROM related ioctls
1029 */
1030
1031 struct linux_cdrom_msf
1032 {
1033 u_char cdmsf_min0;
1034 u_char cdmsf_sec0;
1035 u_char cdmsf_frame0;
1036 u_char cdmsf_min1;
1037 u_char cdmsf_sec1;
1038 u_char cdmsf_frame1;
1039 };
1040
1041 struct linux_cdrom_tochdr
1042 {
1043 u_char cdth_trk0;
1044 u_char cdth_trk1;
1045 };
1046
1047 union linux_cdrom_addr
1048 {
1049 struct {
1050 u_char minute;
1051 u_char second;
1052 u_char frame;
1053 } msf;
1054 int lba;
1055 };
1056
1057 struct linux_cdrom_tocentry
1058 {
1059 u_char cdte_track;
1060 u_char cdte_adr:4;
1061 u_char cdte_ctrl:4;
1062 u_char cdte_format;
1063 union linux_cdrom_addr cdte_addr;
1064 u_char cdte_datamode;
1065 };
1066
1067 struct linux_cdrom_subchnl
1068 {
1069 u_char cdsc_format;
1070 u_char cdsc_audiostatus;
1071 u_char cdsc_adr:4;
1072 u_char cdsc_ctrl:4;
1073 u_char cdsc_trk;
1074 u_char cdsc_ind;
1075 union linux_cdrom_addr cdsc_absaddr;
1076 union linux_cdrom_addr cdsc_reladdr;
1077 };
1078
1079 struct l_cdrom_read_audio {
1080 union linux_cdrom_addr addr;
1081 u_char addr_format;
1082 l_int nframes;
1083 u_char *buf;
1084 };
1085
1086 struct l_dvd_layer {
1087 u_char book_version:4;
1088 u_char book_type:4;
1089 u_char min_rate:4;
1090 u_char disc_size:4;
1091 u_char layer_type:4;
1092 u_char track_path:1;
1093 u_char nlayers:2;
1094 u_char track_density:4;
1095 u_char linear_density:4;
1096 u_char bca:1;
1097 u_int32_t start_sector;
1098 u_int32_t end_sector;
1099 u_int32_t end_sector_l0;
1100 };
1101
1102 struct l_dvd_physical {
1103 u_char type;
1104 u_char layer_num;
1105 struct l_dvd_layer layer[4];
1106 };
1107
1108 struct l_dvd_copyright {
1109 u_char type;
1110 u_char layer_num;
1111 u_char cpst;
1112 u_char rmi;
1113 };
1114
1115 struct l_dvd_disckey {
1116 u_char type;
1117 l_uint agid:2;
1118 u_char value[2048];
1119 };
1120
1121 struct l_dvd_bca {
1122 u_char type;
1123 l_int len;
1124 u_char value[188];
1125 };
1126
1127 struct l_dvd_manufact {
1128 u_char type;
1129 u_char layer_num;
1130 l_int len;
1131 u_char value[2048];
1132 };
1133
1134 typedef union {
1135 u_char type;
1136 struct l_dvd_physical physical;
1137 struct l_dvd_copyright copyright;
1138 struct l_dvd_disckey disckey;
1139 struct l_dvd_bca bca;
1140 struct l_dvd_manufact manufact;
1141 } l_dvd_struct;
1142
1143 typedef u_char l_dvd_key[5];
1144 typedef u_char l_dvd_challenge[10];
1145
1146 struct l_dvd_lu_send_agid {
1147 u_char type;
1148 l_uint agid:2;
1149 };
1150
1151 struct l_dvd_host_send_challenge {
1152 u_char type;
1153 l_uint agid:2;
1154 l_dvd_challenge chal;
1155 };
1156
1157 struct l_dvd_send_key {
1158 u_char type;
1159 l_uint agid:2;
1160 l_dvd_key key;
1161 };
1162
1163 struct l_dvd_lu_send_challenge {
1164 u_char type;
1165 l_uint agid:2;
1166 l_dvd_challenge chal;
1167 };
1168
1169 struct l_dvd_lu_send_title_key {
1170 u_char type;
1171 l_uint agid:2;
1172 l_dvd_key title_key;
1173 l_int lba;
1174 l_uint cpm:1;
1175 l_uint cp_sec:1;
1176 l_uint cgms:2;
1177 };
1178
1179 struct l_dvd_lu_send_asf {
1180 u_char type;
1181 l_uint agid:2;
1182 l_uint asf:1;
1183 };
1184
1185 struct l_dvd_host_send_rpcstate {
1186 u_char type;
1187 u_char pdrc;
1188 };
1189
1190 struct l_dvd_lu_send_rpcstate {
1191 u_char type:2;
1192 u_char vra:3;
1193 u_char ucca:3;
1194 u_char region_mask;
1195 u_char rpc_scheme;
1196 };
1197
1198 typedef union {
1199 u_char type;
1200 struct l_dvd_lu_send_agid lsa;
1201 struct l_dvd_host_send_challenge hsc;
1202 struct l_dvd_send_key lsk;
1203 struct l_dvd_lu_send_challenge lsc;
1204 struct l_dvd_send_key hsk;
1205 struct l_dvd_lu_send_title_key lstk;
1206 struct l_dvd_lu_send_asf lsasf;
1207 struct l_dvd_host_send_rpcstate hrpcs;
1208 struct l_dvd_lu_send_rpcstate lrpcs;
1209 } l_dvd_authinfo;
1210
1211 static void
bsd_to_linux_msf_lba(u_char af,union msf_lba * bp,union linux_cdrom_addr * lp)1212 bsd_to_linux_msf_lba(u_char af, union msf_lba *bp, union linux_cdrom_addr *lp)
1213 {
1214 if (af == CD_LBA_FORMAT)
1215 lp->lba = bp->lba;
1216 else {
1217 lp->msf.minute = bp->msf.minute;
1218 lp->msf.second = bp->msf.second;
1219 lp->msf.frame = bp->msf.frame;
1220 }
1221 }
1222
1223 static void
set_linux_cdrom_addr(union linux_cdrom_addr * addr,int format,int lba)1224 set_linux_cdrom_addr(union linux_cdrom_addr *addr, int format, int lba)
1225 {
1226 if (format == LINUX_CDROM_MSF) {
1227 addr->msf.frame = lba % 75;
1228 lba /= 75;
1229 lba += 2;
1230 addr->msf.second = lba % 60;
1231 addr->msf.minute = lba / 60;
1232 } else
1233 addr->lba = lba;
1234 }
1235
1236 static int
linux_to_bsd_dvd_struct(l_dvd_struct * lp,struct dvd_struct * bp)1237 linux_to_bsd_dvd_struct(l_dvd_struct *lp, struct dvd_struct *bp)
1238 {
1239 bp->format = lp->type;
1240 switch (bp->format) {
1241 case DVD_STRUCT_PHYSICAL:
1242 if (bp->layer_num >= 4)
1243 return (EINVAL);
1244 bp->layer_num = lp->physical.layer_num;
1245 break;
1246 case DVD_STRUCT_COPYRIGHT:
1247 bp->layer_num = lp->copyright.layer_num;
1248 break;
1249 case DVD_STRUCT_DISCKEY:
1250 bp->agid = lp->disckey.agid;
1251 break;
1252 case DVD_STRUCT_BCA:
1253 case DVD_STRUCT_MANUFACT:
1254 break;
1255 default:
1256 return (EINVAL);
1257 }
1258 return (0);
1259 }
1260
1261 static int
bsd_to_linux_dvd_struct(struct dvd_struct * bp,l_dvd_struct * lp)1262 bsd_to_linux_dvd_struct(struct dvd_struct *bp, l_dvd_struct *lp)
1263 {
1264 switch (bp->format) {
1265 case DVD_STRUCT_PHYSICAL: {
1266 struct dvd_layer *blp = (struct dvd_layer *)bp->data;
1267 struct l_dvd_layer *llp = &lp->physical.layer[bp->layer_num];
1268 memset(llp, 0, sizeof(*llp));
1269 llp->book_version = blp->book_version;
1270 llp->book_type = blp->book_type;
1271 llp->min_rate = blp->max_rate;
1272 llp->disc_size = blp->disc_size;
1273 llp->layer_type = blp->layer_type;
1274 llp->track_path = blp->track_path;
1275 llp->nlayers = blp->nlayers;
1276 llp->track_density = blp->track_density;
1277 llp->linear_density = blp->linear_density;
1278 llp->bca = blp->bca;
1279 llp->start_sector = blp->start_sector;
1280 llp->end_sector = blp->end_sector;
1281 llp->end_sector_l0 = blp->end_sector_l0;
1282 break;
1283 }
1284 case DVD_STRUCT_COPYRIGHT:
1285 lp->copyright.cpst = bp->cpst;
1286 lp->copyright.rmi = bp->rmi;
1287 break;
1288 case DVD_STRUCT_DISCKEY:
1289 memcpy(lp->disckey.value, bp->data, sizeof(lp->disckey.value));
1290 break;
1291 case DVD_STRUCT_BCA:
1292 lp->bca.len = bp->length;
1293 memcpy(lp->bca.value, bp->data, sizeof(lp->bca.value));
1294 break;
1295 case DVD_STRUCT_MANUFACT:
1296 lp->manufact.len = bp->length;
1297 memcpy(lp->manufact.value, bp->data,
1298 sizeof(lp->manufact.value));
1299 /* lp->manufact.layer_num is unused in Linux (redhat 7.0). */
1300 break;
1301 default:
1302 return (EINVAL);
1303 }
1304 return (0);
1305 }
1306
1307 static int
linux_to_bsd_dvd_authinfo(l_dvd_authinfo * lp,int * bcode,struct dvd_authinfo * bp)1308 linux_to_bsd_dvd_authinfo(l_dvd_authinfo *lp, int *bcode,
1309 struct dvd_authinfo *bp)
1310 {
1311 switch (lp->type) {
1312 case LINUX_DVD_LU_SEND_AGID:
1313 *bcode = DVDIOCREPORTKEY;
1314 bp->format = DVD_REPORT_AGID;
1315 bp->agid = lp->lsa.agid;
1316 break;
1317 case LINUX_DVD_HOST_SEND_CHALLENGE:
1318 *bcode = DVDIOCSENDKEY;
1319 bp->format = DVD_SEND_CHALLENGE;
1320 bp->agid = lp->hsc.agid;
1321 memcpy(bp->keychal, lp->hsc.chal, 10);
1322 break;
1323 case LINUX_DVD_LU_SEND_KEY1:
1324 *bcode = DVDIOCREPORTKEY;
1325 bp->format = DVD_REPORT_KEY1;
1326 bp->agid = lp->lsk.agid;
1327 break;
1328 case LINUX_DVD_LU_SEND_CHALLENGE:
1329 *bcode = DVDIOCREPORTKEY;
1330 bp->format = DVD_REPORT_CHALLENGE;
1331 bp->agid = lp->lsc.agid;
1332 break;
1333 case LINUX_DVD_HOST_SEND_KEY2:
1334 *bcode = DVDIOCSENDKEY;
1335 bp->format = DVD_SEND_KEY2;
1336 bp->agid = lp->hsk.agid;
1337 memcpy(bp->keychal, lp->hsk.key, 5);
1338 break;
1339 case LINUX_DVD_LU_SEND_TITLE_KEY:
1340 *bcode = DVDIOCREPORTKEY;
1341 bp->format = DVD_REPORT_TITLE_KEY;
1342 bp->agid = lp->lstk.agid;
1343 bp->lba = lp->lstk.lba;
1344 break;
1345 case LINUX_DVD_LU_SEND_ASF:
1346 *bcode = DVDIOCREPORTKEY;
1347 bp->format = DVD_REPORT_ASF;
1348 bp->agid = lp->lsasf.agid;
1349 break;
1350 case LINUX_DVD_INVALIDATE_AGID:
1351 *bcode = DVDIOCREPORTKEY;
1352 bp->format = DVD_INVALIDATE_AGID;
1353 bp->agid = lp->lsa.agid;
1354 break;
1355 case LINUX_DVD_LU_SEND_RPC_STATE:
1356 *bcode = DVDIOCREPORTKEY;
1357 bp->format = DVD_REPORT_RPC;
1358 break;
1359 case LINUX_DVD_HOST_SEND_RPC_STATE:
1360 *bcode = DVDIOCSENDKEY;
1361 bp->format = DVD_SEND_RPC;
1362 bp->region = lp->hrpcs.pdrc;
1363 break;
1364 default:
1365 return (EINVAL);
1366 }
1367 return (0);
1368 }
1369
1370 static int
bsd_to_linux_dvd_authinfo(struct dvd_authinfo * bp,l_dvd_authinfo * lp)1371 bsd_to_linux_dvd_authinfo(struct dvd_authinfo *bp, l_dvd_authinfo *lp)
1372 {
1373 switch (lp->type) {
1374 case LINUX_DVD_LU_SEND_AGID:
1375 lp->lsa.agid = bp->agid;
1376 break;
1377 case LINUX_DVD_HOST_SEND_CHALLENGE:
1378 lp->type = LINUX_DVD_LU_SEND_KEY1;
1379 break;
1380 case LINUX_DVD_LU_SEND_KEY1:
1381 memcpy(lp->lsk.key, bp->keychal, sizeof(lp->lsk.key));
1382 break;
1383 case LINUX_DVD_LU_SEND_CHALLENGE:
1384 memcpy(lp->lsc.chal, bp->keychal, sizeof(lp->lsc.chal));
1385 break;
1386 case LINUX_DVD_HOST_SEND_KEY2:
1387 lp->type = LINUX_DVD_AUTH_ESTABLISHED;
1388 break;
1389 case LINUX_DVD_LU_SEND_TITLE_KEY:
1390 memcpy(lp->lstk.title_key, bp->keychal,
1391 sizeof(lp->lstk.title_key));
1392 lp->lstk.cpm = bp->cpm;
1393 lp->lstk.cp_sec = bp->cp_sec;
1394 lp->lstk.cgms = bp->cgms;
1395 break;
1396 case LINUX_DVD_LU_SEND_ASF:
1397 lp->lsasf.asf = bp->asf;
1398 break;
1399 case LINUX_DVD_INVALIDATE_AGID:
1400 break;
1401 case LINUX_DVD_LU_SEND_RPC_STATE:
1402 lp->lrpcs.type = bp->reg_type;
1403 lp->lrpcs.vra = bp->vend_rsts;
1404 lp->lrpcs.ucca = bp->user_rsts;
1405 lp->lrpcs.region_mask = bp->region;
1406 lp->lrpcs.rpc_scheme = bp->rpc_scheme;
1407 break;
1408 case LINUX_DVD_HOST_SEND_RPC_STATE:
1409 break;
1410 default:
1411 return (EINVAL);
1412 }
1413 return (0);
1414 }
1415
1416 static int
linux_ioctl_cdrom(struct thread * td,struct linux_ioctl_args * args)1417 linux_ioctl_cdrom(struct thread *td, struct linux_ioctl_args *args)
1418 {
1419 struct file *fp;
1420 int error;
1421
1422 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
1423 if (error != 0)
1424 return (error);
1425 switch (args->cmd & 0xffff) {
1426 case LINUX_CDROMPAUSE:
1427 args->cmd = CDIOCPAUSE;
1428 error = (sys_ioctl(td, (struct ioctl_args *)args));
1429 break;
1430
1431 case LINUX_CDROMRESUME:
1432 args->cmd = CDIOCRESUME;
1433 error = (sys_ioctl(td, (struct ioctl_args *)args));
1434 break;
1435
1436 case LINUX_CDROMPLAYMSF:
1437 args->cmd = CDIOCPLAYMSF;
1438 error = (sys_ioctl(td, (struct ioctl_args *)args));
1439 break;
1440
1441 case LINUX_CDROMPLAYTRKIND:
1442 args->cmd = CDIOCPLAYTRACKS;
1443 error = (sys_ioctl(td, (struct ioctl_args *)args));
1444 break;
1445
1446 case LINUX_CDROMREADTOCHDR: {
1447 struct ioc_toc_header th;
1448 struct linux_cdrom_tochdr lth;
1449 error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th,
1450 td->td_ucred, td);
1451 if (!error) {
1452 lth.cdth_trk0 = th.starting_track;
1453 lth.cdth_trk1 = th.ending_track;
1454 copyout(<h, (void *)args->arg, sizeof(lth));
1455 }
1456 break;
1457 }
1458
1459 case LINUX_CDROMREADTOCENTRY: {
1460 struct linux_cdrom_tocentry lte;
1461 struct ioc_read_toc_single_entry irtse;
1462
1463 error = copyin((void *)args->arg, <e, sizeof(lte));
1464 if (error)
1465 break;
1466 irtse.address_format = lte.cdte_format;
1467 irtse.track = lte.cdte_track;
1468 error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse,
1469 td->td_ucred, td);
1470 if (!error) {
1471 lte.cdte_ctrl = irtse.entry.control;
1472 lte.cdte_adr = irtse.entry.addr_type;
1473 bsd_to_linux_msf_lba(irtse.address_format,
1474 &irtse.entry.addr, <e.cdte_addr);
1475 error = copyout(<e, (void *)args->arg, sizeof(lte));
1476 }
1477 break;
1478 }
1479
1480 case LINUX_CDROMSTOP:
1481 args->cmd = CDIOCSTOP;
1482 error = (sys_ioctl(td, (struct ioctl_args *)args));
1483 break;
1484
1485 case LINUX_CDROMSTART:
1486 args->cmd = CDIOCSTART;
1487 error = (sys_ioctl(td, (struct ioctl_args *)args));
1488 break;
1489
1490 case LINUX_CDROMEJECT:
1491 args->cmd = CDIOCEJECT;
1492 error = (sys_ioctl(td, (struct ioctl_args *)args));
1493 break;
1494
1495 /* LINUX_CDROMVOLCTRL */
1496
1497 case LINUX_CDROMSUBCHNL: {
1498 struct linux_cdrom_subchnl sc;
1499 struct ioc_read_subchannel bsdsc;
1500 struct cd_sub_channel_info bsdinfo;
1501
1502 error = copyin((void *)args->arg, &sc, sizeof(sc));
1503 if (error)
1504 break;
1505
1506 /*
1507 * Invoke the native ioctl and bounce the returned data through
1508 * the userspace buffer. This works because the Linux structure
1509 * is the same size as our structures for the subchannel header
1510 * and position data.
1511 */
1512 bsdsc.address_format = CD_LBA_FORMAT;
1513 bsdsc.data_format = CD_CURRENT_POSITION;
1514 bsdsc.track = 0;
1515 bsdsc.data_len = sizeof(sc);
1516 bsdsc.data = (void *)args->arg;
1517 error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc,
1518 td->td_ucred, td);
1519 if (error)
1520 break;
1521 error = copyin((void *)args->arg, &bsdinfo, sizeof(bsdinfo));
1522 if (error)
1523 break;
1524 sc.cdsc_audiostatus = bsdinfo.header.audio_status;
1525 sc.cdsc_adr = bsdinfo.what.position.addr_type;
1526 sc.cdsc_ctrl = bsdinfo.what.position.control;
1527 sc.cdsc_trk = bsdinfo.what.position.track_number;
1528 sc.cdsc_ind = bsdinfo.what.position.index_number;
1529 set_linux_cdrom_addr(&sc.cdsc_absaddr, sc.cdsc_format,
1530 bsdinfo.what.position.absaddr.lba);
1531 set_linux_cdrom_addr(&sc.cdsc_reladdr, sc.cdsc_format,
1532 bsdinfo.what.position.reladdr.lba);
1533 error = copyout(&sc, (void *)args->arg, sizeof(sc));
1534 break;
1535 }
1536
1537 /* LINUX_CDROMREADMODE2 */
1538 /* LINUX_CDROMREADMODE1 */
1539 /* LINUX_CDROMREADAUDIO */
1540 /* LINUX_CDROMEJECT_SW */
1541 /* LINUX_CDROMMULTISESSION */
1542 /* LINUX_CDROM_GET_UPC */
1543
1544 case LINUX_CDROMRESET:
1545 args->cmd = CDIOCRESET;
1546 error = (sys_ioctl(td, (struct ioctl_args *)args));
1547 break;
1548
1549 /* LINUX_CDROMVOLREAD */
1550 /* LINUX_CDROMREADRAW */
1551 /* LINUX_CDROMREADCOOKED */
1552 /* LINUX_CDROMSEEK */
1553 /* LINUX_CDROMPLAYBLK */
1554 /* LINUX_CDROMREADALL */
1555 /* LINUX_CDROMCLOSETRAY */
1556 /* LINUX_CDROMLOADFROMSLOT */
1557 /* LINUX_CDROMGETSPINDOWN */
1558 /* LINUX_CDROMSETSPINDOWN */
1559 /* LINUX_CDROM_SET_OPTIONS */
1560 /* LINUX_CDROM_CLEAR_OPTIONS */
1561 /* LINUX_CDROM_SELECT_SPEED */
1562 /* LINUX_CDROM_SELECT_DISC */
1563 /* LINUX_CDROM_MEDIA_CHANGED */
1564 /* LINUX_CDROM_DRIVE_STATUS */
1565 /* LINUX_CDROM_DISC_STATUS */
1566 /* LINUX_CDROM_CHANGER_NSLOTS */
1567 /* LINUX_CDROM_LOCKDOOR */
1568 /* LINUX_CDROM_DEBUG */
1569 /* LINUX_CDROM_GET_CAPABILITY */
1570 /* LINUX_CDROMAUDIOBUFSIZ */
1571
1572 case LINUX_DVD_READ_STRUCT: {
1573 l_dvd_struct *lds;
1574 struct dvd_struct *bds;
1575
1576 lds = malloc(sizeof(*lds), M_LINUX, M_WAITOK);
1577 bds = malloc(sizeof(*bds), M_LINUX, M_WAITOK);
1578 error = copyin((void *)args->arg, lds, sizeof(*lds));
1579 if (error)
1580 goto out;
1581 error = linux_to_bsd_dvd_struct(lds, bds);
1582 if (error)
1583 goto out;
1584 error = fo_ioctl(fp, DVDIOCREADSTRUCTURE, (caddr_t)bds,
1585 td->td_ucred, td);
1586 if (error)
1587 goto out;
1588 error = bsd_to_linux_dvd_struct(bds, lds);
1589 if (error)
1590 goto out;
1591 error = copyout(lds, (void *)args->arg, sizeof(*lds));
1592 out:
1593 free(bds, M_LINUX);
1594 free(lds, M_LINUX);
1595 break;
1596 }
1597
1598 /* LINUX_DVD_WRITE_STRUCT */
1599
1600 case LINUX_DVD_AUTH: {
1601 l_dvd_authinfo lda;
1602 struct dvd_authinfo bda;
1603 int bcode;
1604
1605 error = copyin((void *)args->arg, &lda, sizeof(lda));
1606 if (error)
1607 break;
1608 error = linux_to_bsd_dvd_authinfo(&lda, &bcode, &bda);
1609 if (error)
1610 break;
1611 error = fo_ioctl(fp, bcode, (caddr_t)&bda, td->td_ucred,
1612 td);
1613 if (error) {
1614 if (lda.type == LINUX_DVD_HOST_SEND_KEY2) {
1615 lda.type = LINUX_DVD_AUTH_FAILURE;
1616 copyout(&lda, (void *)args->arg, sizeof(lda));
1617 }
1618 break;
1619 }
1620 error = bsd_to_linux_dvd_authinfo(&bda, &lda);
1621 if (error)
1622 break;
1623 error = copyout(&lda, (void *)args->arg, sizeof(lda));
1624 break;
1625 }
1626
1627 case LINUX_SCSI_GET_BUS_NUMBER:
1628 {
1629 struct sg_scsi_id id;
1630
1631 error = fo_ioctl(fp, SG_GET_SCSI_ID, (caddr_t)&id,
1632 td->td_ucred, td);
1633 if (error)
1634 break;
1635 error = copyout(&id.channel, (void *)args->arg, sizeof(int));
1636 break;
1637 }
1638
1639 case LINUX_SCSI_GET_IDLUN:
1640 {
1641 struct sg_scsi_id id;
1642 struct scsi_idlun idl;
1643
1644 error = fo_ioctl(fp, SG_GET_SCSI_ID, (caddr_t)&id,
1645 td->td_ucred, td);
1646 if (error)
1647 break;
1648 idl.dev_id = (id.scsi_id & 0xff) + ((id.lun & 0xff) << 8) +
1649 ((id.channel & 0xff) << 16) + ((id.host_no & 0xff) << 24);
1650 idl.host_unique_id = id.host_no;
1651 error = copyout(&idl, (void *)args->arg, sizeof(idl));
1652 break;
1653 }
1654
1655 /* LINUX_CDROM_SEND_PACKET */
1656 /* LINUX_CDROM_NEXT_WRITABLE */
1657 /* LINUX_CDROM_LAST_WRITTEN */
1658
1659 default:
1660 error = ENOIOCTL;
1661 break;
1662 }
1663
1664 fdrop(fp, td);
1665 return (error);
1666 }
1667
1668 static int
linux_ioctl_vfat(struct thread * td,struct linux_ioctl_args * args)1669 linux_ioctl_vfat(struct thread *td, struct linux_ioctl_args *args)
1670 {
1671
1672 return (ENOTTY);
1673 }
1674
1675 /*
1676 * Sound related ioctls
1677 */
1678
1679 struct linux_old_mixer_info {
1680 char id[16];
1681 char name[32];
1682 };
1683
1684 static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT };
1685
1686 #define SETDIR(c) (((c) & ~IOC_DIRMASK) | dirbits[args->cmd >> 30])
1687
1688 static int
linux_ioctl_sound(struct thread * td,struct linux_ioctl_args * args)1689 linux_ioctl_sound(struct thread *td, struct linux_ioctl_args *args)
1690 {
1691
1692 switch (args->cmd & 0xffff) {
1693 case LINUX_SOUND_MIXER_WRITE_VOLUME:
1694 args->cmd = SETDIR(SOUND_MIXER_WRITE_VOLUME);
1695 return (sys_ioctl(td, (struct ioctl_args *)args));
1696
1697 case LINUX_SOUND_MIXER_WRITE_BASS:
1698 args->cmd = SETDIR(SOUND_MIXER_WRITE_BASS);
1699 return (sys_ioctl(td, (struct ioctl_args *)args));
1700
1701 case LINUX_SOUND_MIXER_WRITE_TREBLE:
1702 args->cmd = SETDIR(SOUND_MIXER_WRITE_TREBLE);
1703 return (sys_ioctl(td, (struct ioctl_args *)args));
1704
1705 case LINUX_SOUND_MIXER_WRITE_SYNTH:
1706 args->cmd = SETDIR(SOUND_MIXER_WRITE_SYNTH);
1707 return (sys_ioctl(td, (struct ioctl_args *)args));
1708
1709 case LINUX_SOUND_MIXER_WRITE_PCM:
1710 args->cmd = SETDIR(SOUND_MIXER_WRITE_PCM);
1711 return (sys_ioctl(td, (struct ioctl_args *)args));
1712
1713 case LINUX_SOUND_MIXER_WRITE_SPEAKER:
1714 args->cmd = SETDIR(SOUND_MIXER_WRITE_SPEAKER);
1715 return (sys_ioctl(td, (struct ioctl_args *)args));
1716
1717 case LINUX_SOUND_MIXER_WRITE_LINE:
1718 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE);
1719 return (sys_ioctl(td, (struct ioctl_args *)args));
1720
1721 case LINUX_SOUND_MIXER_WRITE_MIC:
1722 args->cmd = SETDIR(SOUND_MIXER_WRITE_MIC);
1723 return (sys_ioctl(td, (struct ioctl_args *)args));
1724
1725 case LINUX_SOUND_MIXER_WRITE_CD:
1726 args->cmd = SETDIR(SOUND_MIXER_WRITE_CD);
1727 return (sys_ioctl(td, (struct ioctl_args *)args));
1728
1729 case LINUX_SOUND_MIXER_WRITE_IMIX:
1730 args->cmd = SETDIR(SOUND_MIXER_WRITE_IMIX);
1731 return (sys_ioctl(td, (struct ioctl_args *)args));
1732
1733 case LINUX_SOUND_MIXER_WRITE_ALTPCM:
1734 args->cmd = SETDIR(SOUND_MIXER_WRITE_ALTPCM);
1735 return (sys_ioctl(td, (struct ioctl_args *)args));
1736
1737 case LINUX_SOUND_MIXER_WRITE_RECLEV:
1738 args->cmd = SETDIR(SOUND_MIXER_WRITE_RECLEV);
1739 return (sys_ioctl(td, (struct ioctl_args *)args));
1740
1741 case LINUX_SOUND_MIXER_WRITE_IGAIN:
1742 args->cmd = SETDIR(SOUND_MIXER_WRITE_IGAIN);
1743 return (sys_ioctl(td, (struct ioctl_args *)args));
1744
1745 case LINUX_SOUND_MIXER_WRITE_OGAIN:
1746 args->cmd = SETDIR(SOUND_MIXER_WRITE_OGAIN);
1747 return (sys_ioctl(td, (struct ioctl_args *)args));
1748
1749 case LINUX_SOUND_MIXER_WRITE_LINE1:
1750 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE1);
1751 return (sys_ioctl(td, (struct ioctl_args *)args));
1752
1753 case LINUX_SOUND_MIXER_WRITE_LINE2:
1754 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE2);
1755 return (sys_ioctl(td, (struct ioctl_args *)args));
1756
1757 case LINUX_SOUND_MIXER_WRITE_LINE3:
1758 args->cmd = SETDIR(SOUND_MIXER_WRITE_LINE3);
1759 return (sys_ioctl(td, (struct ioctl_args *)args));
1760
1761 case LINUX_SOUND_MIXER_WRITE_MONITOR:
1762 args->cmd = SETDIR(SOUND_MIXER_WRITE_MONITOR);
1763 return (sys_ioctl(td, (struct ioctl_args *)args));
1764
1765 case LINUX_SOUND_MIXER_INFO: {
1766 /* Key on encoded length */
1767 switch ((args->cmd >> 16) & 0x1fff) {
1768 case 0x005c: { /* SOUND_MIXER_INFO */
1769 args->cmd = SOUND_MIXER_INFO;
1770 return (sys_ioctl(td, (struct ioctl_args *)args));
1771 }
1772 case 0x0030: { /* SOUND_OLD_MIXER_INFO */
1773 struct linux_old_mixer_info info;
1774 bzero(&info, sizeof(info));
1775 strncpy(info.id, "OSS", sizeof(info.id) - 1);
1776 strncpy(info.name, "FreeBSD OSS Mixer", sizeof(info.name) - 1);
1777 copyout(&info, (void *)args->arg, sizeof(info));
1778 return (0);
1779 }
1780 default:
1781 return (ENOIOCTL);
1782 }
1783 break;
1784 }
1785
1786 case LINUX_OSS_GETVERSION: {
1787 int version = linux_get_oss_version(td);
1788 return (copyout(&version, (void *)args->arg, sizeof(int)));
1789 }
1790
1791 case LINUX_SOUND_MIXER_READ_STEREODEVS:
1792 args->cmd = SOUND_MIXER_READ_STEREODEVS;
1793 return (sys_ioctl(td, (struct ioctl_args *)args));
1794
1795 case LINUX_SOUND_MIXER_READ_CAPS:
1796 args->cmd = SOUND_MIXER_READ_CAPS;
1797 return (sys_ioctl(td, (struct ioctl_args *)args));
1798
1799 case LINUX_SOUND_MIXER_READ_RECMASK:
1800 args->cmd = SOUND_MIXER_READ_RECMASK;
1801 return (sys_ioctl(td, (struct ioctl_args *)args));
1802
1803 case LINUX_SOUND_MIXER_READ_DEVMASK:
1804 args->cmd = SOUND_MIXER_READ_DEVMASK;
1805 return (sys_ioctl(td, (struct ioctl_args *)args));
1806
1807 case LINUX_SOUND_MIXER_WRITE_RECSRC:
1808 args->cmd = SETDIR(SOUND_MIXER_WRITE_RECSRC);
1809 return (sys_ioctl(td, (struct ioctl_args *)args));
1810
1811 case LINUX_SNDCTL_DSP_RESET:
1812 args->cmd = SNDCTL_DSP_RESET;
1813 return (sys_ioctl(td, (struct ioctl_args *)args));
1814
1815 case LINUX_SNDCTL_DSP_SYNC:
1816 args->cmd = SNDCTL_DSP_SYNC;
1817 return (sys_ioctl(td, (struct ioctl_args *)args));
1818
1819 case LINUX_SNDCTL_DSP_SPEED:
1820 args->cmd = SNDCTL_DSP_SPEED;
1821 return (sys_ioctl(td, (struct ioctl_args *)args));
1822
1823 case LINUX_SNDCTL_DSP_STEREO:
1824 args->cmd = SNDCTL_DSP_STEREO;
1825 return (sys_ioctl(td, (struct ioctl_args *)args));
1826
1827 case LINUX_SNDCTL_DSP_GETBLKSIZE: /* LINUX_SNDCTL_DSP_SETBLKSIZE */
1828 args->cmd = SNDCTL_DSP_GETBLKSIZE;
1829 return (sys_ioctl(td, (struct ioctl_args *)args));
1830
1831 case LINUX_SNDCTL_DSP_SETFMT:
1832 args->cmd = SNDCTL_DSP_SETFMT;
1833 return (sys_ioctl(td, (struct ioctl_args *)args));
1834
1835 case LINUX_SOUND_PCM_WRITE_CHANNELS:
1836 args->cmd = SOUND_PCM_WRITE_CHANNELS;
1837 return (sys_ioctl(td, (struct ioctl_args *)args));
1838
1839 case LINUX_SOUND_PCM_WRITE_FILTER:
1840 args->cmd = SOUND_PCM_WRITE_FILTER;
1841 return (sys_ioctl(td, (struct ioctl_args *)args));
1842
1843 case LINUX_SNDCTL_DSP_POST:
1844 args->cmd = SNDCTL_DSP_POST;
1845 return (sys_ioctl(td, (struct ioctl_args *)args));
1846
1847 case LINUX_SNDCTL_DSP_SUBDIVIDE:
1848 args->cmd = SNDCTL_DSP_SUBDIVIDE;
1849 return (sys_ioctl(td, (struct ioctl_args *)args));
1850
1851 case LINUX_SNDCTL_DSP_SETFRAGMENT:
1852 args->cmd = SNDCTL_DSP_SETFRAGMENT;
1853 return (sys_ioctl(td, (struct ioctl_args *)args));
1854
1855 case LINUX_SNDCTL_DSP_GETFMTS:
1856 args->cmd = SNDCTL_DSP_GETFMTS;
1857 return (sys_ioctl(td, (struct ioctl_args *)args));
1858
1859 case LINUX_SNDCTL_DSP_GETOSPACE:
1860 args->cmd = SNDCTL_DSP_GETOSPACE;
1861 return (sys_ioctl(td, (struct ioctl_args *)args));
1862
1863 case LINUX_SNDCTL_DSP_GETISPACE:
1864 args->cmd = SNDCTL_DSP_GETISPACE;
1865 return (sys_ioctl(td, (struct ioctl_args *)args));
1866
1867 case LINUX_SNDCTL_DSP_NONBLOCK:
1868 args->cmd = SNDCTL_DSP_NONBLOCK;
1869 return (sys_ioctl(td, (struct ioctl_args *)args));
1870
1871 case LINUX_SNDCTL_DSP_GETCAPS:
1872 args->cmd = SNDCTL_DSP_GETCAPS;
1873 return (sys_ioctl(td, (struct ioctl_args *)args));
1874
1875 case LINUX_SNDCTL_DSP_SETTRIGGER: /* LINUX_SNDCTL_GETTRIGGER */
1876 args->cmd = SNDCTL_DSP_SETTRIGGER;
1877 return (sys_ioctl(td, (struct ioctl_args *)args));
1878
1879 case LINUX_SNDCTL_DSP_GETIPTR:
1880 args->cmd = SNDCTL_DSP_GETIPTR;
1881 return (sys_ioctl(td, (struct ioctl_args *)args));
1882
1883 case LINUX_SNDCTL_DSP_GETOPTR:
1884 args->cmd = SNDCTL_DSP_GETOPTR;
1885 return (sys_ioctl(td, (struct ioctl_args *)args));
1886
1887 case LINUX_SNDCTL_DSP_SETDUPLEX:
1888 args->cmd = SNDCTL_DSP_SETDUPLEX;
1889 return (sys_ioctl(td, (struct ioctl_args *)args));
1890
1891 case LINUX_SNDCTL_DSP_GETODELAY:
1892 args->cmd = SNDCTL_DSP_GETODELAY;
1893 return (sys_ioctl(td, (struct ioctl_args *)args));
1894
1895 case LINUX_SNDCTL_SEQ_RESET:
1896 args->cmd = SNDCTL_SEQ_RESET;
1897 return (sys_ioctl(td, (struct ioctl_args *)args));
1898
1899 case LINUX_SNDCTL_SEQ_SYNC:
1900 args->cmd = SNDCTL_SEQ_SYNC;
1901 return (sys_ioctl(td, (struct ioctl_args *)args));
1902
1903 case LINUX_SNDCTL_SYNTH_INFO:
1904 args->cmd = SNDCTL_SYNTH_INFO;
1905 return (sys_ioctl(td, (struct ioctl_args *)args));
1906
1907 case LINUX_SNDCTL_SEQ_CTRLRATE:
1908 args->cmd = SNDCTL_SEQ_CTRLRATE;
1909 return (sys_ioctl(td, (struct ioctl_args *)args));
1910
1911 case LINUX_SNDCTL_SEQ_GETOUTCOUNT:
1912 args->cmd = SNDCTL_SEQ_GETOUTCOUNT;
1913 return (sys_ioctl(td, (struct ioctl_args *)args));
1914
1915 case LINUX_SNDCTL_SEQ_GETINCOUNT:
1916 args->cmd = SNDCTL_SEQ_GETINCOUNT;
1917 return (sys_ioctl(td, (struct ioctl_args *)args));
1918
1919 case LINUX_SNDCTL_SEQ_PERCMODE:
1920 args->cmd = SNDCTL_SEQ_PERCMODE;
1921 return (sys_ioctl(td, (struct ioctl_args *)args));
1922
1923 case LINUX_SNDCTL_FM_LOAD_INSTR:
1924 args->cmd = SNDCTL_FM_LOAD_INSTR;
1925 return (sys_ioctl(td, (struct ioctl_args *)args));
1926
1927 case LINUX_SNDCTL_SEQ_TESTMIDI:
1928 args->cmd = SNDCTL_SEQ_TESTMIDI;
1929 return (sys_ioctl(td, (struct ioctl_args *)args));
1930
1931 case LINUX_SNDCTL_SEQ_RESETSAMPLES:
1932 args->cmd = SNDCTL_SEQ_RESETSAMPLES;
1933 return (sys_ioctl(td, (struct ioctl_args *)args));
1934
1935 case LINUX_SNDCTL_SEQ_NRSYNTHS:
1936 args->cmd = SNDCTL_SEQ_NRSYNTHS;
1937 return (sys_ioctl(td, (struct ioctl_args *)args));
1938
1939 case LINUX_SNDCTL_SEQ_NRMIDIS:
1940 args->cmd = SNDCTL_SEQ_NRMIDIS;
1941 return (sys_ioctl(td, (struct ioctl_args *)args));
1942
1943 case LINUX_SNDCTL_MIDI_INFO:
1944 args->cmd = SNDCTL_MIDI_INFO;
1945 return (sys_ioctl(td, (struct ioctl_args *)args));
1946
1947 case LINUX_SNDCTL_SEQ_TRESHOLD:
1948 args->cmd = SNDCTL_SEQ_TRESHOLD;
1949 return (sys_ioctl(td, (struct ioctl_args *)args));
1950
1951 case LINUX_SNDCTL_SYNTH_MEMAVL:
1952 args->cmd = SNDCTL_SYNTH_MEMAVL;
1953 return (sys_ioctl(td, (struct ioctl_args *)args));
1954 }
1955
1956 return (ENOIOCTL);
1957 }
1958
1959 /*
1960 * Console related ioctls
1961 */
1962
1963 static int
linux_ioctl_console(struct thread * td,struct linux_ioctl_args * args)1964 linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args)
1965 {
1966 struct file *fp;
1967 int error;
1968
1969 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
1970 if (error != 0)
1971 return (error);
1972 switch (args->cmd & 0xffff) {
1973 case LINUX_KIOCSOUND:
1974 args->cmd = KIOCSOUND;
1975 error = (sys_ioctl(td, (struct ioctl_args *)args));
1976 break;
1977
1978 case LINUX_KDMKTONE:
1979 args->cmd = KDMKTONE;
1980 error = (sys_ioctl(td, (struct ioctl_args *)args));
1981 break;
1982
1983 case LINUX_KDGETLED:
1984 args->cmd = KDGETLED;
1985 error = (sys_ioctl(td, (struct ioctl_args *)args));
1986 break;
1987
1988 case LINUX_KDSETLED:
1989 args->cmd = KDSETLED;
1990 error = (sys_ioctl(td, (struct ioctl_args *)args));
1991 break;
1992
1993 case LINUX_KDSETMODE:
1994 args->cmd = KDSETMODE;
1995 error = (sys_ioctl(td, (struct ioctl_args *)args));
1996 break;
1997
1998 case LINUX_KDGETMODE:
1999 args->cmd = KDGETMODE;
2000 error = (sys_ioctl(td, (struct ioctl_args *)args));
2001 break;
2002
2003 case LINUX_KDGKBMODE:
2004 args->cmd = KDGKBMODE;
2005 error = (sys_ioctl(td, (struct ioctl_args *)args));
2006 break;
2007
2008 case LINUX_KDSKBMODE: {
2009 int kbdmode;
2010 switch (args->arg) {
2011 case LINUX_KBD_RAW:
2012 kbdmode = K_RAW;
2013 break;
2014 case LINUX_KBD_XLATE:
2015 kbdmode = K_XLATE;
2016 break;
2017 case LINUX_KBD_MEDIUMRAW:
2018 kbdmode = K_RAW;
2019 break;
2020 default:
2021 fdrop(fp, td);
2022 return (EINVAL);
2023 }
2024 error = (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode,
2025 td->td_ucred, td));
2026 break;
2027 }
2028
2029 case LINUX_VT_OPENQRY:
2030 args->cmd = VT_OPENQRY;
2031 error = (sys_ioctl(td, (struct ioctl_args *)args));
2032 break;
2033
2034 case LINUX_VT_GETMODE:
2035 args->cmd = VT_GETMODE;
2036 error = (sys_ioctl(td, (struct ioctl_args *)args));
2037 break;
2038
2039 case LINUX_VT_SETMODE: {
2040 struct vt_mode mode;
2041 if ((error = copyin((void *)args->arg, &mode, sizeof(mode))))
2042 break;
2043 if (LINUX_SIG_VALID(mode.relsig))
2044 mode.relsig = linux_to_bsd_signal(mode.relsig);
2045 else
2046 mode.relsig = 0;
2047 if (LINUX_SIG_VALID(mode.acqsig))
2048 mode.acqsig = linux_to_bsd_signal(mode.acqsig);
2049 else
2050 mode.acqsig = 0;
2051 /* XXX. Linux ignores frsig and set it to 0. */
2052 mode.frsig = 0;
2053 if ((error = copyout(&mode, (void *)args->arg, sizeof(mode))))
2054 break;
2055 args->cmd = VT_SETMODE;
2056 error = (sys_ioctl(td, (struct ioctl_args *)args));
2057 break;
2058 }
2059
2060 case LINUX_VT_GETSTATE:
2061 args->cmd = VT_GETACTIVE;
2062 error = (sys_ioctl(td, (struct ioctl_args *)args));
2063 break;
2064
2065 case LINUX_VT_RELDISP:
2066 args->cmd = VT_RELDISP;
2067 error = (sys_ioctl(td, (struct ioctl_args *)args));
2068 break;
2069
2070 case LINUX_VT_ACTIVATE:
2071 args->cmd = VT_ACTIVATE;
2072 error = (sys_ioctl(td, (struct ioctl_args *)args));
2073 break;
2074
2075 case LINUX_VT_WAITACTIVE:
2076 args->cmd = VT_WAITACTIVE;
2077 error = (sys_ioctl(td, (struct ioctl_args *)args));
2078 break;
2079
2080 default:
2081 error = ENOIOCTL;
2082 break;
2083 }
2084
2085 fdrop(fp, td);
2086 return (error);
2087 }
2088
2089 /*
2090 * Implement the SIOCGIFNAME ioctl
2091 */
2092
2093 static int
linux_ioctl_ifname(struct thread * td,struct l_ifreq * uifr)2094 linux_ioctl_ifname(struct thread *td, struct l_ifreq *uifr)
2095 {
2096 struct l_ifreq ifr;
2097 int error, ret;
2098
2099 error = copyin(uifr, &ifr, sizeof(ifr));
2100 if (error != 0)
2101 return (error);
2102 ret = ifname_bsd_to_linux_idx(ifr.ifr_ifindex, ifr.ifr_name,
2103 LINUX_IFNAMSIZ);
2104 if (ret > 0)
2105 return (copyout(&ifr, uifr, sizeof(ifr)));
2106 else
2107 return (ENODEV);
2108 }
2109
2110 /*
2111 * Implement the SIOCGIFCONF ioctl
2112 */
2113
2114 static int
linux_ifconf(struct thread * td,struct ifconf * uifc)2115 linux_ifconf(struct thread *td, struct ifconf *uifc)
2116 {
2117 struct epoch_tracker et;
2118 #ifdef COMPAT_LINUX32
2119 struct l_ifconf ifc;
2120 #else
2121 struct ifconf ifc;
2122 #endif
2123 struct l_ifreq ifr;
2124 struct ifnet *ifp;
2125 struct ifaddr *ifa;
2126 struct sbuf *sb;
2127 int error, full = 0, valid_len, max_len;
2128
2129 error = copyin(uifc, &ifc, sizeof(ifc));
2130 if (error != 0)
2131 return (error);
2132
2133 max_len = maxphys - 1;
2134
2135 CURVNET_SET(TD_TO_VNET(td));
2136 /* handle the 'request buffer size' case */
2137 if ((l_uintptr_t)ifc.ifc_buf == PTROUT(NULL)) {
2138 ifc.ifc_len = 0;
2139 NET_EPOCH_ENTER(et);
2140 CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2141 CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2142 struct sockaddr *sa = ifa->ifa_addr;
2143 if (sa->sa_family == AF_INET)
2144 ifc.ifc_len += sizeof(ifr);
2145 }
2146 }
2147 NET_EPOCH_EXIT(et);
2148 error = copyout(&ifc, uifc, sizeof(ifc));
2149 CURVNET_RESTORE();
2150 return (error);
2151 }
2152
2153 if (ifc.ifc_len <= 0) {
2154 CURVNET_RESTORE();
2155 return (EINVAL);
2156 }
2157
2158 again:
2159 if (ifc.ifc_len <= max_len) {
2160 max_len = ifc.ifc_len;
2161 full = 1;
2162 }
2163 sb = sbuf_new(NULL, NULL, max_len + 1, SBUF_FIXEDLEN);
2164 max_len = 0;
2165 valid_len = 0;
2166
2167 /* Return all AF_INET addresses of all interfaces */
2168 NET_EPOCH_ENTER(et);
2169 CK_STAILQ_FOREACH(ifp, &V_ifnet, if_link) {
2170 int addrs = 0;
2171
2172 bzero(&ifr, sizeof(ifr));
2173 ifname_bsd_to_linux_ifp(ifp, ifr.ifr_name,
2174 sizeof(ifr.ifr_name));
2175
2176 /* Walk the address list */
2177 CK_STAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) {
2178 struct sockaddr *sa = ifa->ifa_addr;
2179
2180 if (sa->sa_family == AF_INET) {
2181 ifr.ifr_addr.sa_family = LINUX_AF_INET;
2182 memcpy(ifr.ifr_addr.sa_data, sa->sa_data,
2183 sizeof(ifr.ifr_addr.sa_data));
2184 sbuf_bcat(sb, &ifr, sizeof(ifr));
2185 max_len += sizeof(ifr);
2186 addrs++;
2187 }
2188
2189 if (sbuf_error(sb) == 0)
2190 valid_len = sbuf_len(sb);
2191 }
2192 if (addrs == 0) {
2193 bzero((caddr_t)&ifr.ifr_addr, sizeof(ifr.ifr_addr));
2194 sbuf_bcat(sb, &ifr, sizeof(ifr));
2195 max_len += sizeof(ifr);
2196
2197 if (sbuf_error(sb) == 0)
2198 valid_len = sbuf_len(sb);
2199 }
2200 }
2201 NET_EPOCH_EXIT(et);
2202
2203 if (valid_len != max_len && !full) {
2204 sbuf_delete(sb);
2205 goto again;
2206 }
2207
2208 ifc.ifc_len = valid_len;
2209 sbuf_finish(sb);
2210 error = copyout(sbuf_data(sb), PTRIN(ifc.ifc_buf), ifc.ifc_len);
2211 if (error == 0)
2212 error = copyout(&ifc, uifc, sizeof(ifc));
2213 sbuf_delete(sb);
2214 CURVNET_RESTORE();
2215
2216 return (error);
2217 }
2218
2219 static int
linux_gifflags(struct thread * td,struct ifnet * ifp,struct l_ifreq * ifr)2220 linux_gifflags(struct thread *td, struct ifnet *ifp, struct l_ifreq *ifr)
2221 {
2222 l_short flags;
2223
2224 linux_ifflags(ifp, &flags);
2225
2226 return (copyout(&flags, &ifr->ifr_flags, sizeof(flags)));
2227 }
2228
2229 static int
linux_gifhwaddr(struct ifnet * ifp,struct l_ifreq * ifr)2230 linux_gifhwaddr(struct ifnet *ifp, struct l_ifreq *ifr)
2231 {
2232 struct l_sockaddr lsa;
2233
2234 if (linux_ifhwaddr(ifp, &lsa) != 0)
2235 return (ENOENT);
2236
2237 return (copyout(&lsa, &ifr->ifr_hwaddr, sizeof(lsa)));
2238 }
2239
2240 /*
2241 * If we fault in bsd_to_linux_ifreq() then we will fault when we call
2242 * the native ioctl(). Thus, we don't really need to check the return
2243 * value of this function.
2244 */
2245 static int
bsd_to_linux_ifreq(struct ifreq * arg)2246 bsd_to_linux_ifreq(struct ifreq *arg)
2247 {
2248 struct ifreq ifr;
2249 size_t ifr_len = sizeof(struct ifreq);
2250 int error;
2251
2252 if ((error = copyin(arg, &ifr, ifr_len)))
2253 return (error);
2254
2255 *(u_short *)&ifr.ifr_addr = ifr.ifr_addr.sa_family;
2256
2257 error = copyout(&ifr, arg, ifr_len);
2258
2259 return (error);
2260 }
2261
2262 /*
2263 * Socket related ioctls
2264 */
2265
2266 static int
linux_ioctl_socket(struct thread * td,struct linux_ioctl_args * args)2267 linux_ioctl_socket(struct thread *td, struct linux_ioctl_args *args)
2268 {
2269 char lifname[LINUX_IFNAMSIZ], ifname[IFNAMSIZ];
2270 struct ifnet *ifp;
2271 struct file *fp;
2272 int error, type;
2273
2274 ifp = NULL;
2275 error = 0;
2276
2277 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
2278 if (error != 0)
2279 return (error);
2280 type = fp->f_type;
2281 fdrop(fp, td);
2282 if (type != DTYPE_SOCKET) {
2283 /* not a socket - probably a tap / vmnet device */
2284 switch (args->cmd) {
2285 case LINUX_SIOCGIFADDR:
2286 case LINUX_SIOCSIFADDR:
2287 case LINUX_SIOCGIFFLAGS:
2288 return (linux_ioctl_special(td, args));
2289 default:
2290 return (ENOIOCTL);
2291 }
2292 }
2293
2294 switch (args->cmd & 0xffff) {
2295 case LINUX_FIOGETOWN:
2296 case LINUX_FIOSETOWN:
2297 case LINUX_SIOCADDMULTI:
2298 case LINUX_SIOCATMARK:
2299 case LINUX_SIOCDELMULTI:
2300 case LINUX_SIOCGIFNAME:
2301 case LINUX_SIOCGIFCONF:
2302 case LINUX_SIOCGPGRP:
2303 case LINUX_SIOCSPGRP:
2304 case LINUX_SIOCGIFCOUNT:
2305 /* these ioctls don't take an interface name */
2306 break;
2307
2308 case LINUX_SIOCGIFFLAGS:
2309 case LINUX_SIOCGIFADDR:
2310 case LINUX_SIOCSIFADDR:
2311 case LINUX_SIOCGIFDSTADDR:
2312 case LINUX_SIOCGIFBRDADDR:
2313 case LINUX_SIOCGIFNETMASK:
2314 case LINUX_SIOCSIFNETMASK:
2315 case LINUX_SIOCGIFMTU:
2316 case LINUX_SIOCSIFMTU:
2317 case LINUX_SIOCSIFNAME:
2318 case LINUX_SIOCGIFHWADDR:
2319 case LINUX_SIOCSIFHWADDR:
2320 case LINUX_SIOCDEVPRIVATE:
2321 case LINUX_SIOCDEVPRIVATE+1:
2322 case LINUX_SIOCGIFINDEX:
2323 /* copy in the interface name and translate it. */
2324 error = copyin((void *)args->arg, lifname, LINUX_IFNAMSIZ);
2325 if (error != 0)
2326 return (error);
2327 memset(ifname, 0, sizeof(ifname));
2328 ifp = ifname_linux_to_bsd(td, lifname, ifname);
2329 if (ifp == NULL)
2330 return (EINVAL);
2331 /*
2332 * We need to copy it back out in case we pass the
2333 * request on to our native ioctl(), which will expect
2334 * the ifreq to be in user space and have the correct
2335 * interface name.
2336 */
2337 error = copyout(ifname, (void *)args->arg, IFNAMSIZ);
2338 if (error != 0)
2339 return (error);
2340 break;
2341
2342 default:
2343 return (ENOIOCTL);
2344 }
2345
2346 switch (args->cmd & 0xffff) {
2347 case LINUX_FIOSETOWN:
2348 args->cmd = FIOSETOWN;
2349 error = sys_ioctl(td, (struct ioctl_args *)args);
2350 break;
2351
2352 case LINUX_SIOCSPGRP:
2353 args->cmd = SIOCSPGRP;
2354 error = sys_ioctl(td, (struct ioctl_args *)args);
2355 break;
2356
2357 case LINUX_FIOGETOWN:
2358 args->cmd = FIOGETOWN;
2359 error = sys_ioctl(td, (struct ioctl_args *)args);
2360 break;
2361
2362 case LINUX_SIOCGPGRP:
2363 args->cmd = SIOCGPGRP;
2364 error = sys_ioctl(td, (struct ioctl_args *)args);
2365 break;
2366
2367 case LINUX_SIOCATMARK:
2368 args->cmd = SIOCATMARK;
2369 error = sys_ioctl(td, (struct ioctl_args *)args);
2370 break;
2371
2372 /* LINUX_SIOCGSTAMP */
2373
2374 case LINUX_SIOCGIFNAME:
2375 error = linux_ioctl_ifname(td, (struct l_ifreq *)args->arg);
2376 break;
2377
2378 case LINUX_SIOCGIFCONF:
2379 error = linux_ifconf(td, (struct ifconf *)args->arg);
2380 break;
2381
2382 case LINUX_SIOCGIFFLAGS:
2383 args->cmd = SIOCGIFFLAGS;
2384 error = linux_gifflags(td, ifp, (struct l_ifreq *)args->arg);
2385 break;
2386
2387 case LINUX_SIOCGIFADDR:
2388 args->cmd = SIOCGIFADDR;
2389 error = sys_ioctl(td, (struct ioctl_args *)args);
2390 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2391 break;
2392
2393 case LINUX_SIOCSIFADDR:
2394 /* XXX probably doesn't work, included for completeness */
2395 args->cmd = SIOCSIFADDR;
2396 error = sys_ioctl(td, (struct ioctl_args *)args);
2397 break;
2398
2399 case LINUX_SIOCGIFDSTADDR:
2400 args->cmd = SIOCGIFDSTADDR;
2401 error = sys_ioctl(td, (struct ioctl_args *)args);
2402 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2403 break;
2404
2405 case LINUX_SIOCGIFBRDADDR:
2406 args->cmd = SIOCGIFBRDADDR;
2407 error = sys_ioctl(td, (struct ioctl_args *)args);
2408 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2409 break;
2410
2411 case LINUX_SIOCGIFNETMASK:
2412 args->cmd = SIOCGIFNETMASK;
2413 error = sys_ioctl(td, (struct ioctl_args *)args);
2414 bsd_to_linux_ifreq((struct ifreq *)args->arg);
2415 break;
2416
2417 case LINUX_SIOCSIFNETMASK:
2418 error = ENOIOCTL;
2419 break;
2420
2421 case LINUX_SIOCGIFMTU:
2422 args->cmd = SIOCGIFMTU;
2423 error = sys_ioctl(td, (struct ioctl_args *)args);
2424 break;
2425
2426 case LINUX_SIOCSIFMTU:
2427 args->cmd = SIOCSIFMTU;
2428 error = sys_ioctl(td, (struct ioctl_args *)args);
2429 break;
2430
2431 case LINUX_SIOCSIFNAME:
2432 error = ENOIOCTL;
2433 break;
2434
2435 case LINUX_SIOCGIFHWADDR:
2436 error = linux_gifhwaddr(ifp, (struct l_ifreq *)args->arg);
2437 break;
2438
2439 case LINUX_SIOCSIFHWADDR:
2440 error = ENOIOCTL;
2441 break;
2442
2443 case LINUX_SIOCADDMULTI:
2444 args->cmd = SIOCADDMULTI;
2445 error = sys_ioctl(td, (struct ioctl_args *)args);
2446 break;
2447
2448 case LINUX_SIOCDELMULTI:
2449 args->cmd = SIOCDELMULTI;
2450 error = sys_ioctl(td, (struct ioctl_args *)args);
2451 break;
2452
2453 case LINUX_SIOCGIFINDEX:
2454 args->cmd = SIOCGIFINDEX;
2455 error = sys_ioctl(td, (struct ioctl_args *)args);
2456 break;
2457
2458 case LINUX_SIOCGIFCOUNT:
2459 error = 0;
2460 break;
2461
2462 /*
2463 * XXX This is slightly bogus, but these ioctls are currently
2464 * XXX only used by the aironet (if_an) network driver.
2465 */
2466 case LINUX_SIOCDEVPRIVATE:
2467 args->cmd = SIOCGPRIVATE_0;
2468 error = sys_ioctl(td, (struct ioctl_args *)args);
2469 break;
2470
2471 case LINUX_SIOCDEVPRIVATE+1:
2472 args->cmd = SIOCGPRIVATE_1;
2473 error = sys_ioctl(td, (struct ioctl_args *)args);
2474 break;
2475 }
2476
2477 if (ifp != NULL)
2478 /* restore the original interface name */
2479 copyout(lifname, (void *)args->arg, LINUX_IFNAMSIZ);
2480
2481 return (error);
2482 }
2483
2484 /*
2485 * Device private ioctl handler
2486 */
2487 static int
linux_ioctl_private(struct thread * td,struct linux_ioctl_args * args)2488 linux_ioctl_private(struct thread *td, struct linux_ioctl_args *args)
2489 {
2490 struct file *fp;
2491 int error, type;
2492
2493 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
2494 if (error != 0)
2495 return (error);
2496 type = fp->f_type;
2497 fdrop(fp, td);
2498 if (type == DTYPE_SOCKET)
2499 return (linux_ioctl_socket(td, args));
2500 return (ENOIOCTL);
2501 }
2502
2503 /*
2504 * DRM ioctl handler (sys/dev/drm)
2505 */
2506 static int
linux_ioctl_drm(struct thread * td,struct linux_ioctl_args * args)2507 linux_ioctl_drm(struct thread *td, struct linux_ioctl_args *args)
2508 {
2509 args->cmd = SETDIR(args->cmd);
2510 return (sys_ioctl(td, (struct ioctl_args *)args));
2511 }
2512
2513 #ifdef COMPAT_LINUX32
2514 static int
linux_ioctl_sg_io(struct thread * td,struct linux_ioctl_args * args)2515 linux_ioctl_sg_io(struct thread *td, struct linux_ioctl_args *args)
2516 {
2517 struct sg_io_hdr io;
2518 struct sg_io_hdr32 io32;
2519 struct file *fp;
2520 int error;
2521
2522 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
2523 if (error != 0) {
2524 printf("sg_linux_ioctl: fget returned %d\n", error);
2525 return (error);
2526 }
2527
2528 if ((error = copyin((void *)args->arg, &io32, sizeof(io32))) != 0)
2529 goto out;
2530
2531 CP(io32, io, interface_id);
2532 CP(io32, io, dxfer_direction);
2533 CP(io32, io, cmd_len);
2534 CP(io32, io, mx_sb_len);
2535 CP(io32, io, iovec_count);
2536 CP(io32, io, dxfer_len);
2537 PTRIN_CP(io32, io, dxferp);
2538 PTRIN_CP(io32, io, cmdp);
2539 PTRIN_CP(io32, io, sbp);
2540 CP(io32, io, timeout);
2541 CP(io32, io, flags);
2542 CP(io32, io, pack_id);
2543 PTRIN_CP(io32, io, usr_ptr);
2544 CP(io32, io, status);
2545 CP(io32, io, masked_status);
2546 CP(io32, io, msg_status);
2547 CP(io32, io, sb_len_wr);
2548 CP(io32, io, host_status);
2549 CP(io32, io, driver_status);
2550 CP(io32, io, resid);
2551 CP(io32, io, duration);
2552 CP(io32, io, info);
2553
2554 if ((error = fo_ioctl(fp, SG_IO, (caddr_t)&io, td->td_ucred, td)) != 0)
2555 goto out;
2556
2557 CP(io, io32, interface_id);
2558 CP(io, io32, dxfer_direction);
2559 CP(io, io32, cmd_len);
2560 CP(io, io32, mx_sb_len);
2561 CP(io, io32, iovec_count);
2562 CP(io, io32, dxfer_len);
2563 PTROUT_CP(io, io32, dxferp);
2564 PTROUT_CP(io, io32, cmdp);
2565 PTROUT_CP(io, io32, sbp);
2566 CP(io, io32, timeout);
2567 CP(io, io32, flags);
2568 CP(io, io32, pack_id);
2569 PTROUT_CP(io, io32, usr_ptr);
2570 CP(io, io32, status);
2571 CP(io, io32, masked_status);
2572 CP(io, io32, msg_status);
2573 CP(io, io32, sb_len_wr);
2574 CP(io, io32, host_status);
2575 CP(io, io32, driver_status);
2576 CP(io, io32, resid);
2577 CP(io, io32, duration);
2578 CP(io, io32, info);
2579
2580 error = copyout(&io32, (void *)args->arg, sizeof(io32));
2581
2582 out:
2583 fdrop(fp, td);
2584 return (error);
2585 }
2586 #endif
2587
2588 static int
linux_ioctl_sg(struct thread * td,struct linux_ioctl_args * args)2589 linux_ioctl_sg(struct thread *td, struct linux_ioctl_args *args)
2590 {
2591
2592 switch (args->cmd) {
2593 case LINUX_SG_GET_VERSION_NUM:
2594 args->cmd = SG_GET_VERSION_NUM;
2595 break;
2596 case LINUX_SG_SET_TIMEOUT:
2597 args->cmd = SG_SET_TIMEOUT;
2598 break;
2599 case LINUX_SG_GET_TIMEOUT:
2600 args->cmd = SG_GET_TIMEOUT;
2601 break;
2602 case LINUX_SG_IO:
2603 args->cmd = SG_IO;
2604 #ifdef COMPAT_LINUX32
2605 return (linux_ioctl_sg_io(td, args));
2606 #endif
2607 break;
2608 case LINUX_SG_GET_RESERVED_SIZE:
2609 args->cmd = SG_GET_RESERVED_SIZE;
2610 break;
2611 case LINUX_SG_GET_SCSI_ID:
2612 args->cmd = SG_GET_SCSI_ID;
2613 break;
2614 case LINUX_SG_GET_SG_TABLESIZE:
2615 args->cmd = SG_GET_SG_TABLESIZE;
2616 break;
2617 default:
2618 return (ENODEV);
2619 }
2620 return (sys_ioctl(td, (struct ioctl_args *)args));
2621 }
2622
2623 /*
2624 * Video4Linux (V4L) ioctl handler
2625 */
2626 static int
linux_to_bsd_v4l_tuner(struct l_video_tuner * lvt,struct video_tuner * vt)2627 linux_to_bsd_v4l_tuner(struct l_video_tuner *lvt, struct video_tuner *vt)
2628 {
2629 vt->tuner = lvt->tuner;
2630 strlcpy(vt->name, lvt->name, LINUX_VIDEO_TUNER_NAME_SIZE);
2631 vt->rangelow = lvt->rangelow; /* possible long size conversion */
2632 vt->rangehigh = lvt->rangehigh; /* possible long size conversion */
2633 vt->flags = lvt->flags;
2634 vt->mode = lvt->mode;
2635 vt->signal = lvt->signal;
2636 return (0);
2637 }
2638
2639 static int
bsd_to_linux_v4l_tuner(struct video_tuner * vt,struct l_video_tuner * lvt)2640 bsd_to_linux_v4l_tuner(struct video_tuner *vt, struct l_video_tuner *lvt)
2641 {
2642 lvt->tuner = vt->tuner;
2643 strlcpy(lvt->name, vt->name, LINUX_VIDEO_TUNER_NAME_SIZE);
2644 lvt->rangelow = vt->rangelow; /* possible long size conversion */
2645 lvt->rangehigh = vt->rangehigh; /* possible long size conversion */
2646 lvt->flags = vt->flags;
2647 lvt->mode = vt->mode;
2648 lvt->signal = vt->signal;
2649 return (0);
2650 }
2651
2652 #ifdef COMPAT_LINUX_V4L_CLIPLIST
2653 static int
linux_to_bsd_v4l_clip(struct l_video_clip * lvc,struct video_clip * vc)2654 linux_to_bsd_v4l_clip(struct l_video_clip *lvc, struct video_clip *vc)
2655 {
2656 vc->x = lvc->x;
2657 vc->y = lvc->y;
2658 vc->width = lvc->width;
2659 vc->height = lvc->height;
2660 vc->next = PTRIN(lvc->next); /* possible pointer size conversion */
2661 return (0);
2662 }
2663 #endif
2664
2665 static int
linux_to_bsd_v4l_window(struct l_video_window * lvw,struct video_window * vw)2666 linux_to_bsd_v4l_window(struct l_video_window *lvw, struct video_window *vw)
2667 {
2668 vw->x = lvw->x;
2669 vw->y = lvw->y;
2670 vw->width = lvw->width;
2671 vw->height = lvw->height;
2672 vw->chromakey = lvw->chromakey;
2673 vw->flags = lvw->flags;
2674 vw->clips = PTRIN(lvw->clips); /* possible pointer size conversion */
2675 vw->clipcount = lvw->clipcount;
2676 return (0);
2677 }
2678
2679 static int
bsd_to_linux_v4l_window(struct video_window * vw,struct l_video_window * lvw)2680 bsd_to_linux_v4l_window(struct video_window *vw, struct l_video_window *lvw)
2681 {
2682 memset(lvw, 0, sizeof(*lvw));
2683
2684 lvw->x = vw->x;
2685 lvw->y = vw->y;
2686 lvw->width = vw->width;
2687 lvw->height = vw->height;
2688 lvw->chromakey = vw->chromakey;
2689 lvw->flags = vw->flags;
2690 lvw->clips = PTROUT(vw->clips); /* possible pointer size conversion */
2691 lvw->clipcount = vw->clipcount;
2692 return (0);
2693 }
2694
2695 static int
linux_to_bsd_v4l_buffer(struct l_video_buffer * lvb,struct video_buffer * vb)2696 linux_to_bsd_v4l_buffer(struct l_video_buffer *lvb, struct video_buffer *vb)
2697 {
2698 vb->base = PTRIN(lvb->base); /* possible pointer size conversion */
2699 vb->height = lvb->height;
2700 vb->width = lvb->width;
2701 vb->depth = lvb->depth;
2702 vb->bytesperline = lvb->bytesperline;
2703 return (0);
2704 }
2705
2706 static int
bsd_to_linux_v4l_buffer(struct video_buffer * vb,struct l_video_buffer * lvb)2707 bsd_to_linux_v4l_buffer(struct video_buffer *vb, struct l_video_buffer *lvb)
2708 {
2709 lvb->base = PTROUT(vb->base); /* possible pointer size conversion */
2710 lvb->height = vb->height;
2711 lvb->width = vb->width;
2712 lvb->depth = vb->depth;
2713 lvb->bytesperline = vb->bytesperline;
2714 return (0);
2715 }
2716
2717 static int
linux_to_bsd_v4l_code(struct l_video_code * lvc,struct video_code * vc)2718 linux_to_bsd_v4l_code(struct l_video_code *lvc, struct video_code *vc)
2719 {
2720 strlcpy(vc->loadwhat, lvc->loadwhat, LINUX_VIDEO_CODE_LOADWHAT_SIZE);
2721 vc->datasize = lvc->datasize;
2722 vc->data = PTRIN(lvc->data); /* possible pointer size conversion */
2723 return (0);
2724 }
2725
2726 #ifdef COMPAT_LINUX_V4L_CLIPLIST
2727 static int
linux_v4l_clip_copy(void * lvc,struct video_clip ** ppvc)2728 linux_v4l_clip_copy(void *lvc, struct video_clip **ppvc)
2729 {
2730 int error;
2731 struct video_clip vclip;
2732 struct l_video_clip l_vclip;
2733
2734 error = copyin(lvc, &l_vclip, sizeof(l_vclip));
2735 if (error) return (error);
2736 linux_to_bsd_v4l_clip(&l_vclip, &vclip);
2737 /* XXX: If there can be no concurrency: s/M_NOWAIT/M_WAITOK/ */
2738 if ((*ppvc = malloc(sizeof(**ppvc), M_LINUX, M_NOWAIT)) == NULL)
2739 return (ENOMEM); /* XXX: Linux has no ENOMEM here. */
2740 memcpy(*ppvc, &vclip, sizeof(vclip));
2741 (*ppvc)->next = NULL;
2742 return (0);
2743 }
2744
2745 static int
linux_v4l_cliplist_free(struct video_window * vw)2746 linux_v4l_cliplist_free(struct video_window *vw)
2747 {
2748 struct video_clip **ppvc;
2749 struct video_clip **ppvc_next;
2750
2751 for (ppvc = &(vw->clips); *ppvc != NULL; ppvc = ppvc_next) {
2752 ppvc_next = &((*ppvc)->next);
2753 free(*ppvc, M_LINUX);
2754 }
2755 vw->clips = NULL;
2756
2757 return (0);
2758 }
2759
2760 static int
linux_v4l_cliplist_copy(struct l_video_window * lvw,struct video_window * vw)2761 linux_v4l_cliplist_copy(struct l_video_window *lvw, struct video_window *vw)
2762 {
2763 int error;
2764 int clipcount;
2765 void *plvc;
2766 struct video_clip **ppvc;
2767
2768 /*
2769 * XXX: The cliplist is used to pass in a list of clipping
2770 * rectangles or, if clipcount == VIDEO_CLIP_BITMAP, a
2771 * clipping bitmap. Some Linux apps, however, appear to
2772 * leave cliplist and clips uninitialized. In any case,
2773 * the cliplist is not used by pwc(4), at the time of
2774 * writing, FreeBSD's only V4L driver. When a driver
2775 * that uses the cliplist is developed, this code may
2776 * need re-examiniation.
2777 */
2778 error = 0;
2779 clipcount = vw->clipcount;
2780 if (clipcount == VIDEO_CLIP_BITMAP) {
2781 /*
2782 * In this case, the pointer (clips) is overloaded
2783 * to be a "void *" to a bitmap, therefore there
2784 * is no struct video_clip to copy now.
2785 */
2786 } else if (clipcount > 0 && clipcount <= 16384) {
2787 /*
2788 * Clips points to list of clip rectangles, so
2789 * copy the list.
2790 *
2791 * XXX: Upper limit of 16384 was used here to try to
2792 * avoid cases when clipcount and clips pointer
2793 * are uninitialized and therefore have high random
2794 * values, as is the case in the Linux Skype
2795 * application. The value 16384 was chosen as that
2796 * is what is used in the Linux stradis(4) MPEG
2797 * decoder driver, the only place we found an
2798 * example of cliplist use.
2799 */
2800 plvc = PTRIN(lvw->clips);
2801 vw->clips = NULL;
2802 ppvc = &(vw->clips);
2803 while (clipcount-- > 0) {
2804 if (plvc == NULL) {
2805 error = EFAULT;
2806 break;
2807 } else {
2808 error = linux_v4l_clip_copy(plvc, ppvc);
2809 if (error) {
2810 linux_v4l_cliplist_free(vw);
2811 break;
2812 }
2813 }
2814 ppvc = &((*ppvc)->next);
2815 plvc = PTRIN(((struct l_video_clip *) plvc)->next);
2816 }
2817 } else {
2818 /*
2819 * clipcount == 0 or negative (but not VIDEO_CLIP_BITMAP)
2820 * Force cliplist to null.
2821 */
2822 vw->clipcount = 0;
2823 vw->clips = NULL;
2824 }
2825 return (error);
2826 }
2827 #endif
2828
2829 static int
linux_ioctl_v4l(struct thread * td,struct linux_ioctl_args * args)2830 linux_ioctl_v4l(struct thread *td, struct linux_ioctl_args *args)
2831 {
2832 struct file *fp;
2833 int error;
2834 struct video_tuner vtun;
2835 struct video_window vwin;
2836 struct video_buffer vbuf;
2837 struct video_code vcode;
2838 struct l_video_tuner l_vtun;
2839 struct l_video_window l_vwin;
2840 struct l_video_buffer l_vbuf;
2841 struct l_video_code l_vcode;
2842
2843 switch (args->cmd & 0xffff) {
2844 case LINUX_VIDIOCGCAP: args->cmd = VIDIOCGCAP; break;
2845 case LINUX_VIDIOCGCHAN: args->cmd = VIDIOCGCHAN; break;
2846 case LINUX_VIDIOCSCHAN: args->cmd = VIDIOCSCHAN; break;
2847
2848 case LINUX_VIDIOCGTUNER:
2849 error = fget(td, args->fd,
2850 &cap_ioctl_rights, &fp);
2851 if (error != 0)
2852 return (error);
2853 error = copyin((void *) args->arg, &l_vtun, sizeof(l_vtun));
2854 if (error) {
2855 fdrop(fp, td);
2856 return (error);
2857 }
2858 linux_to_bsd_v4l_tuner(&l_vtun, &vtun);
2859 error = fo_ioctl(fp, VIDIOCGTUNER, &vtun, td->td_ucred, td);
2860 if (!error) {
2861 bsd_to_linux_v4l_tuner(&vtun, &l_vtun);
2862 error = copyout(&l_vtun, (void *) args->arg,
2863 sizeof(l_vtun));
2864 }
2865 fdrop(fp, td);
2866 return (error);
2867
2868 case LINUX_VIDIOCSTUNER:
2869 error = fget(td, args->fd,
2870 &cap_ioctl_rights, &fp);
2871 if (error != 0)
2872 return (error);
2873 error = copyin((void *) args->arg, &l_vtun, sizeof(l_vtun));
2874 if (error) {
2875 fdrop(fp, td);
2876 return (error);
2877 }
2878 linux_to_bsd_v4l_tuner(&l_vtun, &vtun);
2879 error = fo_ioctl(fp, VIDIOCSTUNER, &vtun, td->td_ucred, td);
2880 fdrop(fp, td);
2881 return (error);
2882
2883 case LINUX_VIDIOCGPICT: args->cmd = VIDIOCGPICT; break;
2884 case LINUX_VIDIOCSPICT: args->cmd = VIDIOCSPICT; break;
2885 case LINUX_VIDIOCCAPTURE: args->cmd = VIDIOCCAPTURE; break;
2886
2887 case LINUX_VIDIOCGWIN:
2888 error = fget(td, args->fd,
2889 &cap_ioctl_rights, &fp);
2890 if (error != 0)
2891 return (error);
2892 error = fo_ioctl(fp, VIDIOCGWIN, &vwin, td->td_ucred, td);
2893 if (!error) {
2894 bsd_to_linux_v4l_window(&vwin, &l_vwin);
2895 error = copyout(&l_vwin, (void *) args->arg,
2896 sizeof(l_vwin));
2897 }
2898 fdrop(fp, td);
2899 return (error);
2900
2901 case LINUX_VIDIOCSWIN:
2902 error = fget(td, args->fd,
2903 &cap_ioctl_rights, &fp);
2904 if (error != 0)
2905 return (error);
2906 error = copyin((void *) args->arg, &l_vwin, sizeof(l_vwin));
2907 if (error) {
2908 fdrop(fp, td);
2909 return (error);
2910 }
2911 linux_to_bsd_v4l_window(&l_vwin, &vwin);
2912 #ifdef COMPAT_LINUX_V4L_CLIPLIST
2913 error = linux_v4l_cliplist_copy(&l_vwin, &vwin);
2914 if (error) {
2915 fdrop(fp, td);
2916 return (error);
2917 }
2918 #endif
2919 error = fo_ioctl(fp, VIDIOCSWIN, &vwin, td->td_ucred, td);
2920 fdrop(fp, td);
2921 #ifdef COMPAT_LINUX_V4L_CLIPLIST
2922 linux_v4l_cliplist_free(&vwin);
2923 #endif
2924 return (error);
2925
2926 case LINUX_VIDIOCGFBUF:
2927 error = fget(td, args->fd,
2928 &cap_ioctl_rights, &fp);
2929 if (error != 0)
2930 return (error);
2931 error = fo_ioctl(fp, VIDIOCGFBUF, &vbuf, td->td_ucred, td);
2932 if (!error) {
2933 bsd_to_linux_v4l_buffer(&vbuf, &l_vbuf);
2934 error = copyout(&l_vbuf, (void *) args->arg,
2935 sizeof(l_vbuf));
2936 }
2937 fdrop(fp, td);
2938 return (error);
2939
2940 case LINUX_VIDIOCSFBUF:
2941 error = fget(td, args->fd,
2942 &cap_ioctl_rights, &fp);
2943 if (error != 0)
2944 return (error);
2945 error = copyin((void *) args->arg, &l_vbuf, sizeof(l_vbuf));
2946 if (error) {
2947 fdrop(fp, td);
2948 return (error);
2949 }
2950 linux_to_bsd_v4l_buffer(&l_vbuf, &vbuf);
2951 error = fo_ioctl(fp, VIDIOCSFBUF, &vbuf, td->td_ucred, td);
2952 fdrop(fp, td);
2953 return (error);
2954
2955 case LINUX_VIDIOCKEY: args->cmd = VIDIOCKEY; break;
2956 case LINUX_VIDIOCGFREQ: args->cmd = VIDIOCGFREQ; break;
2957 case LINUX_VIDIOCSFREQ: args->cmd = VIDIOCSFREQ; break;
2958 case LINUX_VIDIOCGAUDIO: args->cmd = VIDIOCGAUDIO; break;
2959 case LINUX_VIDIOCSAUDIO: args->cmd = VIDIOCSAUDIO; break;
2960 case LINUX_VIDIOCSYNC: args->cmd = VIDIOCSYNC; break;
2961 case LINUX_VIDIOCMCAPTURE: args->cmd = VIDIOCMCAPTURE; break;
2962 case LINUX_VIDIOCGMBUF: args->cmd = VIDIOCGMBUF; break;
2963 case LINUX_VIDIOCGUNIT: args->cmd = VIDIOCGUNIT; break;
2964 case LINUX_VIDIOCGCAPTURE: args->cmd = VIDIOCGCAPTURE; break;
2965 case LINUX_VIDIOCSCAPTURE: args->cmd = VIDIOCSCAPTURE; break;
2966 case LINUX_VIDIOCSPLAYMODE: args->cmd = VIDIOCSPLAYMODE; break;
2967 case LINUX_VIDIOCSWRITEMODE: args->cmd = VIDIOCSWRITEMODE; break;
2968 case LINUX_VIDIOCGPLAYINFO: args->cmd = VIDIOCGPLAYINFO; break;
2969
2970 case LINUX_VIDIOCSMICROCODE:
2971 error = fget(td, args->fd,
2972 &cap_ioctl_rights, &fp);
2973 if (error != 0)
2974 return (error);
2975 error = copyin((void *) args->arg, &l_vcode, sizeof(l_vcode));
2976 if (error) {
2977 fdrop(fp, td);
2978 return (error);
2979 }
2980 linux_to_bsd_v4l_code(&l_vcode, &vcode);
2981 error = fo_ioctl(fp, VIDIOCSMICROCODE, &vcode, td->td_ucred, td);
2982 fdrop(fp, td);
2983 return (error);
2984
2985 case LINUX_VIDIOCGVBIFMT: args->cmd = VIDIOCGVBIFMT; break;
2986 case LINUX_VIDIOCSVBIFMT: args->cmd = VIDIOCSVBIFMT; break;
2987 default: return (ENOIOCTL);
2988 }
2989
2990 error = sys_ioctl(td, (struct ioctl_args *)args);
2991 return (error);
2992 }
2993
2994 /*
2995 * Special ioctl handler
2996 */
2997 static int
linux_ioctl_special(struct thread * td,struct linux_ioctl_args * args)2998 linux_ioctl_special(struct thread *td, struct linux_ioctl_args *args)
2999 {
3000 int error;
3001
3002 switch (args->cmd) {
3003 case LINUX_SIOCGIFADDR:
3004 args->cmd = SIOCGIFADDR;
3005 error = sys_ioctl(td, (struct ioctl_args *)args);
3006 break;
3007 case LINUX_SIOCSIFADDR:
3008 args->cmd = SIOCSIFADDR;
3009 error = sys_ioctl(td, (struct ioctl_args *)args);
3010 break;
3011 case LINUX_SIOCGIFFLAGS:
3012 args->cmd = SIOCGIFFLAGS;
3013 error = sys_ioctl(td, (struct ioctl_args *)args);
3014 break;
3015 default:
3016 error = ENOIOCTL;
3017 }
3018
3019 return (error);
3020 }
3021
3022 static int
linux_to_bsd_v4l2_standard(struct l_v4l2_standard * lvstd,struct v4l2_standard * vstd)3023 linux_to_bsd_v4l2_standard(struct l_v4l2_standard *lvstd, struct v4l2_standard *vstd)
3024 {
3025 vstd->index = lvstd->index;
3026 vstd->id = lvstd->id;
3027 CTASSERT(sizeof(vstd->name) == sizeof(lvstd->name));
3028 memcpy(vstd->name, lvstd->name, sizeof(vstd->name));
3029 vstd->frameperiod = lvstd->frameperiod;
3030 vstd->framelines = lvstd->framelines;
3031 CTASSERT(sizeof(vstd->reserved) == sizeof(lvstd->reserved));
3032 memcpy(vstd->reserved, lvstd->reserved, sizeof(vstd->reserved));
3033 return (0);
3034 }
3035
3036 static int
bsd_to_linux_v4l2_standard(struct v4l2_standard * vstd,struct l_v4l2_standard * lvstd)3037 bsd_to_linux_v4l2_standard(struct v4l2_standard *vstd, struct l_v4l2_standard *lvstd)
3038 {
3039 lvstd->index = vstd->index;
3040 lvstd->id = vstd->id;
3041 CTASSERT(sizeof(vstd->name) == sizeof(lvstd->name));
3042 memcpy(lvstd->name, vstd->name, sizeof(lvstd->name));
3043 lvstd->frameperiod = vstd->frameperiod;
3044 lvstd->framelines = vstd->framelines;
3045 CTASSERT(sizeof(vstd->reserved) == sizeof(lvstd->reserved));
3046 memcpy(lvstd->reserved, vstd->reserved, sizeof(lvstd->reserved));
3047 return (0);
3048 }
3049
3050 static int
linux_to_bsd_v4l2_buffer(struct l_v4l2_buffer * lvb,struct v4l2_buffer * vb)3051 linux_to_bsd_v4l2_buffer(struct l_v4l2_buffer *lvb, struct v4l2_buffer *vb)
3052 {
3053 vb->index = lvb->index;
3054 vb->type = lvb->type;
3055 vb->bytesused = lvb->bytesused;
3056 vb->flags = lvb->flags;
3057 vb->field = lvb->field;
3058 vb->timestamp.tv_sec = lvb->timestamp.tv_sec;
3059 vb->timestamp.tv_usec = lvb->timestamp.tv_usec;
3060 memcpy(&vb->timecode, &lvb->timecode, sizeof (lvb->timecode));
3061 vb->sequence = lvb->sequence;
3062 vb->memory = lvb->memory;
3063 if (lvb->memory == V4L2_MEMORY_USERPTR)
3064 /* possible pointer size conversion */
3065 vb->m.userptr = (unsigned long)PTRIN(lvb->m.userptr);
3066 else
3067 vb->m.offset = lvb->m.offset;
3068 vb->length = lvb->length;
3069 vb->input = lvb->input;
3070 vb->reserved = lvb->reserved;
3071 return (0);
3072 }
3073
3074 static int
bsd_to_linux_v4l2_buffer(struct v4l2_buffer * vb,struct l_v4l2_buffer * lvb)3075 bsd_to_linux_v4l2_buffer(struct v4l2_buffer *vb, struct l_v4l2_buffer *lvb)
3076 {
3077 lvb->index = vb->index;
3078 lvb->type = vb->type;
3079 lvb->bytesused = vb->bytesused;
3080 lvb->flags = vb->flags;
3081 lvb->field = vb->field;
3082 lvb->timestamp.tv_sec = vb->timestamp.tv_sec;
3083 lvb->timestamp.tv_usec = vb->timestamp.tv_usec;
3084 memcpy(&lvb->timecode, &vb->timecode, sizeof (vb->timecode));
3085 lvb->sequence = vb->sequence;
3086 lvb->memory = vb->memory;
3087 if (vb->memory == V4L2_MEMORY_USERPTR)
3088 /* possible pointer size conversion */
3089 lvb->m.userptr = PTROUT(vb->m.userptr);
3090 else
3091 lvb->m.offset = vb->m.offset;
3092 lvb->length = vb->length;
3093 lvb->input = vb->input;
3094 lvb->reserved = vb->reserved;
3095 return (0);
3096 }
3097
3098 static int
linux_to_bsd_v4l2_format(struct l_v4l2_format * lvf,struct v4l2_format * vf)3099 linux_to_bsd_v4l2_format(struct l_v4l2_format *lvf, struct v4l2_format *vf)
3100 {
3101 vf->type = lvf->type;
3102 if (lvf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
3103 #ifdef V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
3104 || lvf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
3105 #endif
3106 )
3107 /*
3108 * XXX TODO - needs 32 -> 64 bit conversion:
3109 * (unused by webcams?)
3110 */
3111 return (EINVAL);
3112 memcpy(&vf->fmt, &lvf->fmt, sizeof(vf->fmt));
3113 return (0);
3114 }
3115
3116 static int
bsd_to_linux_v4l2_format(struct v4l2_format * vf,struct l_v4l2_format * lvf)3117 bsd_to_linux_v4l2_format(struct v4l2_format *vf, struct l_v4l2_format *lvf)
3118 {
3119 lvf->type = vf->type;
3120 if (vf->type == V4L2_BUF_TYPE_VIDEO_OVERLAY
3121 #ifdef V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
3122 || vf->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
3123 #endif
3124 )
3125 /*
3126 * XXX TODO - needs 32 -> 64 bit conversion:
3127 * (unused by webcams?)
3128 */
3129 return (EINVAL);
3130 memcpy(&lvf->fmt, &vf->fmt, sizeof(vf->fmt));
3131 return (0);
3132 }
3133 static int
linux_ioctl_v4l2(struct thread * td,struct linux_ioctl_args * args)3134 linux_ioctl_v4l2(struct thread *td, struct linux_ioctl_args *args)
3135 {
3136 struct file *fp;
3137 int error;
3138 struct v4l2_format vformat;
3139 struct l_v4l2_format l_vformat;
3140 struct v4l2_standard vstd;
3141 struct l_v4l2_standard l_vstd;
3142 struct l_v4l2_buffer l_vbuf;
3143 struct v4l2_buffer vbuf;
3144 struct v4l2_input vinp;
3145
3146 switch (args->cmd & 0xffff) {
3147 case LINUX_VIDIOC_RESERVED:
3148 case LINUX_VIDIOC_LOG_STATUS:
3149 if ((args->cmd & IOC_DIRMASK) != LINUX_IOC_VOID)
3150 return (ENOIOCTL);
3151 args->cmd = (args->cmd & 0xffff) | IOC_VOID;
3152 break;
3153
3154 case LINUX_VIDIOC_OVERLAY:
3155 case LINUX_VIDIOC_STREAMON:
3156 case LINUX_VIDIOC_STREAMOFF:
3157 case LINUX_VIDIOC_S_STD:
3158 case LINUX_VIDIOC_S_TUNER:
3159 case LINUX_VIDIOC_S_AUDIO:
3160 case LINUX_VIDIOC_S_AUDOUT:
3161 case LINUX_VIDIOC_S_MODULATOR:
3162 case LINUX_VIDIOC_S_FREQUENCY:
3163 case LINUX_VIDIOC_S_CROP:
3164 case LINUX_VIDIOC_S_JPEGCOMP:
3165 case LINUX_VIDIOC_S_PRIORITY:
3166 case LINUX_VIDIOC_DBG_S_REGISTER:
3167 case LINUX_VIDIOC_S_HW_FREQ_SEEK:
3168 case LINUX_VIDIOC_SUBSCRIBE_EVENT:
3169 case LINUX_VIDIOC_UNSUBSCRIBE_EVENT:
3170 args->cmd = (args->cmd & ~IOC_DIRMASK) | IOC_IN;
3171 break;
3172
3173 case LINUX_VIDIOC_QUERYCAP:
3174 case LINUX_VIDIOC_G_STD:
3175 case LINUX_VIDIOC_G_AUDIO:
3176 case LINUX_VIDIOC_G_INPUT:
3177 case LINUX_VIDIOC_G_OUTPUT:
3178 case LINUX_VIDIOC_G_AUDOUT:
3179 case LINUX_VIDIOC_G_JPEGCOMP:
3180 case LINUX_VIDIOC_QUERYSTD:
3181 case LINUX_VIDIOC_G_PRIORITY:
3182 case LINUX_VIDIOC_QUERY_DV_PRESET:
3183 args->cmd = (args->cmd & ~IOC_DIRMASK) | IOC_OUT;
3184 break;
3185
3186 case LINUX_VIDIOC_ENUM_FMT:
3187 case LINUX_VIDIOC_REQBUFS:
3188 case LINUX_VIDIOC_G_PARM:
3189 case LINUX_VIDIOC_S_PARM:
3190 case LINUX_VIDIOC_G_CTRL:
3191 case LINUX_VIDIOC_S_CTRL:
3192 case LINUX_VIDIOC_G_TUNER:
3193 case LINUX_VIDIOC_QUERYCTRL:
3194 case LINUX_VIDIOC_QUERYMENU:
3195 case LINUX_VIDIOC_S_INPUT:
3196 case LINUX_VIDIOC_S_OUTPUT:
3197 case LINUX_VIDIOC_ENUMOUTPUT:
3198 case LINUX_VIDIOC_G_MODULATOR:
3199 case LINUX_VIDIOC_G_FREQUENCY:
3200 case LINUX_VIDIOC_CROPCAP:
3201 case LINUX_VIDIOC_G_CROP:
3202 case LINUX_VIDIOC_ENUMAUDIO:
3203 case LINUX_VIDIOC_ENUMAUDOUT:
3204 case LINUX_VIDIOC_G_SLICED_VBI_CAP:
3205 #ifdef VIDIOC_ENUM_FRAMESIZES
3206 case LINUX_VIDIOC_ENUM_FRAMESIZES:
3207 case LINUX_VIDIOC_ENUM_FRAMEINTERVALS:
3208 case LINUX_VIDIOC_ENCODER_CMD:
3209 case LINUX_VIDIOC_TRY_ENCODER_CMD:
3210 #endif
3211 case LINUX_VIDIOC_DBG_G_REGISTER:
3212 case LINUX_VIDIOC_DBG_G_CHIP_IDENT:
3213 case LINUX_VIDIOC_ENUM_DV_PRESETS:
3214 case LINUX_VIDIOC_S_DV_PRESET:
3215 case LINUX_VIDIOC_G_DV_PRESET:
3216 case LINUX_VIDIOC_S_DV_TIMINGS:
3217 case LINUX_VIDIOC_G_DV_TIMINGS:
3218 args->cmd = (args->cmd & ~IOC_DIRMASK) | IOC_INOUT;
3219 break;
3220
3221 case LINUX_VIDIOC_G_FMT:
3222 case LINUX_VIDIOC_S_FMT:
3223 case LINUX_VIDIOC_TRY_FMT:
3224 error = copyin((void *)args->arg, &l_vformat, sizeof(l_vformat));
3225 if (error)
3226 return (error);
3227 error = fget(td, args->fd,
3228 &cap_ioctl_rights, &fp);
3229 if (error)
3230 return (error);
3231 if (linux_to_bsd_v4l2_format(&l_vformat, &vformat) != 0)
3232 error = EINVAL;
3233 else if ((args->cmd & 0xffff) == LINUX_VIDIOC_G_FMT)
3234 error = fo_ioctl(fp, VIDIOC_G_FMT, &vformat,
3235 td->td_ucred, td);
3236 else if ((args->cmd & 0xffff) == LINUX_VIDIOC_S_FMT)
3237 error = fo_ioctl(fp, VIDIOC_S_FMT, &vformat,
3238 td->td_ucred, td);
3239 else
3240 error = fo_ioctl(fp, VIDIOC_TRY_FMT, &vformat,
3241 td->td_ucred, td);
3242 bsd_to_linux_v4l2_format(&vformat, &l_vformat);
3243 copyout(&l_vformat, (void *)args->arg, sizeof(l_vformat));
3244 fdrop(fp, td);
3245 return (error);
3246
3247 case LINUX_VIDIOC_ENUMSTD:
3248 error = copyin((void *)args->arg, &l_vstd, sizeof(l_vstd));
3249 if (error)
3250 return (error);
3251 linux_to_bsd_v4l2_standard(&l_vstd, &vstd);
3252 error = fget(td, args->fd,
3253 &cap_ioctl_rights, &fp);
3254 if (error)
3255 return (error);
3256 error = fo_ioctl(fp, VIDIOC_ENUMSTD, (caddr_t)&vstd,
3257 td->td_ucred, td);
3258 if (error) {
3259 fdrop(fp, td);
3260 return (error);
3261 }
3262 bsd_to_linux_v4l2_standard(&vstd, &l_vstd);
3263 error = copyout(&l_vstd, (void *)args->arg, sizeof(l_vstd));
3264 fdrop(fp, td);
3265 return (error);
3266
3267 case LINUX_VIDIOC_ENUMINPUT:
3268 /*
3269 * The Linux struct l_v4l2_input differs only in size,
3270 * it has no padding at the end.
3271 */
3272 error = copyin((void *)args->arg, &vinp,
3273 sizeof(struct l_v4l2_input));
3274 if (error != 0)
3275 return (error);
3276 error = fget(td, args->fd,
3277 &cap_ioctl_rights, &fp);
3278 if (error != 0)
3279 return (error);
3280 error = fo_ioctl(fp, VIDIOC_ENUMINPUT, (caddr_t)&vinp,
3281 td->td_ucred, td);
3282 if (error) {
3283 fdrop(fp, td);
3284 return (error);
3285 }
3286 error = copyout(&vinp, (void *)args->arg,
3287 sizeof(struct l_v4l2_input));
3288 fdrop(fp, td);
3289 return (error);
3290
3291 case LINUX_VIDIOC_QUERYBUF:
3292 case LINUX_VIDIOC_QBUF:
3293 case LINUX_VIDIOC_DQBUF:
3294 error = copyin((void *)args->arg, &l_vbuf, sizeof(l_vbuf));
3295 if (error)
3296 return (error);
3297 error = fget(td, args->fd,
3298 &cap_ioctl_rights, &fp);
3299 if (error)
3300 return (error);
3301 linux_to_bsd_v4l2_buffer(&l_vbuf, &vbuf);
3302 if ((args->cmd & 0xffff) == LINUX_VIDIOC_QUERYBUF)
3303 error = fo_ioctl(fp, VIDIOC_QUERYBUF, &vbuf,
3304 td->td_ucred, td);
3305 else if ((args->cmd & 0xffff) == LINUX_VIDIOC_QBUF)
3306 error = fo_ioctl(fp, VIDIOC_QBUF, &vbuf,
3307 td->td_ucred, td);
3308 else
3309 error = fo_ioctl(fp, VIDIOC_DQBUF, &vbuf,
3310 td->td_ucred, td);
3311 bsd_to_linux_v4l2_buffer(&vbuf, &l_vbuf);
3312 copyout(&l_vbuf, (void *)args->arg, sizeof(l_vbuf));
3313 fdrop(fp, td);
3314 return (error);
3315
3316 /*
3317 * XXX TODO - these need 32 -> 64 bit conversion:
3318 * (are any of them needed for webcams?)
3319 */
3320 case LINUX_VIDIOC_G_FBUF:
3321 case LINUX_VIDIOC_S_FBUF:
3322
3323 case LINUX_VIDIOC_G_EXT_CTRLS:
3324 case LINUX_VIDIOC_S_EXT_CTRLS:
3325 case LINUX_VIDIOC_TRY_EXT_CTRLS:
3326
3327 case LINUX_VIDIOC_DQEVENT:
3328
3329 default: return (ENOIOCTL);
3330 }
3331
3332 error = sys_ioctl(td, (struct ioctl_args *)args);
3333 return (error);
3334 }
3335
3336 /*
3337 * Support for emulators/linux-libusb. This port uses FBSD_LUSB* macros
3338 * instead of USB* ones. This lets us to provide correct values for cmd.
3339 * 0xffffffe0 -- 0xffffffff range seemed to be the least collision-prone.
3340 */
3341 static int
linux_ioctl_fbsd_usb(struct thread * td,struct linux_ioctl_args * args)3342 linux_ioctl_fbsd_usb(struct thread *td, struct linux_ioctl_args *args)
3343 {
3344 int error;
3345
3346 error = 0;
3347 switch (args->cmd) {
3348 case FBSD_LUSB_DEVICEENUMERATE:
3349 args->cmd = USB_DEVICEENUMERATE;
3350 break;
3351 case FBSD_LUSB_DEV_QUIRK_ADD:
3352 args->cmd = USB_DEV_QUIRK_ADD;
3353 break;
3354 case FBSD_LUSB_DEV_QUIRK_GET:
3355 args->cmd = USB_DEV_QUIRK_GET;
3356 break;
3357 case FBSD_LUSB_DEV_QUIRK_REMOVE:
3358 args->cmd = USB_DEV_QUIRK_REMOVE;
3359 break;
3360 case FBSD_LUSB_DO_REQUEST:
3361 args->cmd = USB_DO_REQUEST;
3362 break;
3363 case FBSD_LUSB_FS_CLEAR_STALL_SYNC:
3364 args->cmd = USB_FS_CLEAR_STALL_SYNC;
3365 break;
3366 case FBSD_LUSB_FS_CLOSE:
3367 args->cmd = USB_FS_CLOSE;
3368 break;
3369 case FBSD_LUSB_FS_COMPLETE:
3370 args->cmd = USB_FS_COMPLETE;
3371 break;
3372 case FBSD_LUSB_FS_INIT:
3373 args->cmd = USB_FS_INIT;
3374 break;
3375 case FBSD_LUSB_FS_OPEN:
3376 args->cmd = USB_FS_OPEN;
3377 break;
3378 case FBSD_LUSB_FS_START:
3379 args->cmd = USB_FS_START;
3380 break;
3381 case FBSD_LUSB_FS_STOP:
3382 args->cmd = USB_FS_STOP;
3383 break;
3384 case FBSD_LUSB_FS_UNINIT:
3385 args->cmd = USB_FS_UNINIT;
3386 break;
3387 case FBSD_LUSB_GET_CONFIG:
3388 args->cmd = USB_GET_CONFIG;
3389 break;
3390 case FBSD_LUSB_GET_DEVICEINFO:
3391 args->cmd = USB_GET_DEVICEINFO;
3392 break;
3393 case FBSD_LUSB_GET_DEVICE_DESC:
3394 args->cmd = USB_GET_DEVICE_DESC;
3395 break;
3396 case FBSD_LUSB_GET_FULL_DESC:
3397 args->cmd = USB_GET_FULL_DESC;
3398 break;
3399 case FBSD_LUSB_GET_IFACE_DRIVER:
3400 args->cmd = USB_GET_IFACE_DRIVER;
3401 break;
3402 case FBSD_LUSB_GET_PLUGTIME:
3403 args->cmd = USB_GET_PLUGTIME;
3404 break;
3405 case FBSD_LUSB_GET_POWER_MODE:
3406 args->cmd = USB_GET_POWER_MODE;
3407 break;
3408 case FBSD_LUSB_GET_REPORT_DESC:
3409 args->cmd = USB_GET_REPORT_DESC;
3410 break;
3411 case FBSD_LUSB_GET_REPORT_ID:
3412 args->cmd = USB_GET_REPORT_ID;
3413 break;
3414 case FBSD_LUSB_GET_TEMPLATE:
3415 args->cmd = USB_GET_TEMPLATE;
3416 break;
3417 case FBSD_LUSB_IFACE_DRIVER_ACTIVE:
3418 args->cmd = USB_IFACE_DRIVER_ACTIVE;
3419 break;
3420 case FBSD_LUSB_IFACE_DRIVER_DETACH:
3421 args->cmd = USB_IFACE_DRIVER_DETACH;
3422 break;
3423 case FBSD_LUSB_QUIRK_NAME_GET:
3424 args->cmd = USB_QUIRK_NAME_GET;
3425 break;
3426 case FBSD_LUSB_READ_DIR:
3427 args->cmd = USB_READ_DIR;
3428 break;
3429 case FBSD_LUSB_SET_ALTINTERFACE:
3430 args->cmd = USB_SET_ALTINTERFACE;
3431 break;
3432 case FBSD_LUSB_SET_CONFIG:
3433 args->cmd = USB_SET_CONFIG;
3434 break;
3435 case FBSD_LUSB_SET_IMMED:
3436 args->cmd = USB_SET_IMMED;
3437 break;
3438 case FBSD_LUSB_SET_POWER_MODE:
3439 args->cmd = USB_SET_POWER_MODE;
3440 break;
3441 case FBSD_LUSB_SET_TEMPLATE:
3442 args->cmd = USB_SET_TEMPLATE;
3443 break;
3444 case FBSD_LUSB_FS_OPEN_STREAM:
3445 args->cmd = USB_FS_OPEN_STREAM;
3446 break;
3447 case FBSD_LUSB_GET_DEV_PORT_PATH:
3448 args->cmd = USB_GET_DEV_PORT_PATH;
3449 break;
3450 case FBSD_LUSB_GET_POWER_USAGE:
3451 args->cmd = USB_GET_POWER_USAGE;
3452 break;
3453 case FBSD_LUSB_DEVICESTATS:
3454 args->cmd = USB_DEVICESTATS;
3455 break;
3456 default:
3457 error = ENOIOCTL;
3458 }
3459 if (error != ENOIOCTL)
3460 error = sys_ioctl(td, (struct ioctl_args *)args);
3461 return (error);
3462 }
3463
3464 /*
3465 * Some evdev ioctls must be translated.
3466 * - EVIOCGMTSLOTS is a IOC_READ ioctl on Linux although it has input data
3467 * (must be IOC_INOUT on FreeBSD).
3468 * - On Linux, EVIOCGRAB, EVIOCREVOKE and EVIOCRMFF are defined as _IOW with
3469 * an int argument. You don't pass an int pointer to the ioctl(), however,
3470 * but just the int directly. On FreeBSD, they are defined as _IOWINT for
3471 * this to work.
3472 */
3473 static int
linux_ioctl_evdev(struct thread * td,struct linux_ioctl_args * args)3474 linux_ioctl_evdev(struct thread *td, struct linux_ioctl_args *args)
3475 {
3476 struct file *fp;
3477 clockid_t clock;
3478 int error;
3479
3480 args->cmd = SETDIR(args->cmd);
3481
3482 switch (args->cmd) {
3483 case (EVIOCGRAB & ~IOC_DIRMASK) | IOC_IN:
3484 args->cmd = EVIOCGRAB;
3485 break;
3486 case (EVIOCREVOKE & ~IOC_DIRMASK) | IOC_IN:
3487 args->cmd = EVIOCREVOKE;
3488 break;
3489 case (EVIOCRMFF & ~IOC_DIRMASK) | IOC_IN:
3490 args->cmd = EVIOCRMFF;
3491 break;
3492 case EVIOCSCLOCKID: {
3493 error = copyin(PTRIN(args->arg), &clock, sizeof(clock));
3494 if (error != 0)
3495 return (error);
3496 if (clock & ~(LINUX_IOCTL_EVDEV_CLK))
3497 return (EINVAL);
3498 error = linux_to_native_clockid(&clock, clock);
3499 if (error != 0)
3500 return (error);
3501
3502 error = fget(td, args->fd,
3503 &cap_ioctl_rights, &fp);
3504 if (error != 0)
3505 return (error);
3506
3507 error = fo_ioctl(fp, EVIOCSCLOCKID, &clock, td->td_ucred, td);
3508 fdrop(fp, td);
3509 return (error);
3510 }
3511 default:
3512 break;
3513 }
3514
3515 if (IOCBASECMD(args->cmd) ==
3516 ((EVIOCGMTSLOTS(0) & ~IOC_DIRMASK) | IOC_OUT))
3517 args->cmd = (args->cmd & ~IOC_DIRMASK) | IOC_INOUT;
3518
3519 return (sys_ioctl(td, (struct ioctl_args *)args));
3520 }
3521
3522 static int
linux_ioctl_kcov(struct thread * td,struct linux_ioctl_args * args)3523 linux_ioctl_kcov(struct thread *td, struct linux_ioctl_args *args)
3524 {
3525 int error;
3526
3527 error = 0;
3528 switch (args->cmd & 0xffff) {
3529 case LINUX_KCOV_INIT_TRACE:
3530 args->cmd = KIOSETBUFSIZE;
3531 break;
3532 case LINUX_KCOV_ENABLE:
3533 args->cmd = KIOENABLE;
3534 if (args->arg == 0)
3535 args->arg = KCOV_MODE_TRACE_PC;
3536 else if (args->arg == 1)
3537 args->arg = KCOV_MODE_TRACE_CMP;
3538 else
3539 error = EINVAL;
3540 break;
3541 case LINUX_KCOV_DISABLE:
3542 args->cmd = KIODISABLE;
3543 break;
3544 default:
3545 error = ENOTTY;
3546 break;
3547 }
3548
3549 if (error == 0)
3550 error = sys_ioctl(td, (struct ioctl_args *)args);
3551 return (error);
3552 }
3553
3554 /*
3555 * main ioctl syscall function
3556 */
3557
3558 static int
linux_ioctl_fallback(struct thread * td,struct linux_ioctl_args * args)3559 linux_ioctl_fallback(struct thread *td, struct linux_ioctl_args *args)
3560 {
3561 struct file *fp;
3562 struct linux_ioctl_handler_element *he;
3563 int error, cmd;
3564
3565 error = fget(td, args->fd, &cap_ioctl_rights, &fp);
3566 if (error != 0)
3567 return (error);
3568 if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
3569 fdrop(fp, td);
3570 return (EBADF);
3571 }
3572
3573 /* Iterate over the ioctl handlers */
3574 cmd = args->cmd & 0xffff;
3575 sx_slock(&linux_ioctl_sx);
3576 mtx_lock(&Giant);
3577 #ifdef COMPAT_LINUX32
3578 TAILQ_FOREACH(he, &linux32_ioctl_handlers, list) {
3579 if (cmd >= he->low && cmd <= he->high) {
3580 error = (*he->func)(td, args);
3581 if (error != ENOIOCTL) {
3582 mtx_unlock(&Giant);
3583 sx_sunlock(&linux_ioctl_sx);
3584 fdrop(fp, td);
3585 return (error);
3586 }
3587 }
3588 }
3589 #endif
3590 TAILQ_FOREACH(he, &linux_ioctl_handlers, list) {
3591 if (cmd >= he->low && cmd <= he->high) {
3592 error = (*he->func)(td, args);
3593 if (error != ENOIOCTL) {
3594 mtx_unlock(&Giant);
3595 sx_sunlock(&linux_ioctl_sx);
3596 fdrop(fp, td);
3597 return (error);
3598 }
3599 }
3600 }
3601 mtx_unlock(&Giant);
3602 sx_sunlock(&linux_ioctl_sx);
3603 fdrop(fp, td);
3604
3605 switch (args->cmd & 0xffff) {
3606 case LINUX_BTRFS_IOC_CLONE:
3607 case LINUX_F2FS_IOC_GET_FEATURES:
3608 case LINUX_FS_IOC_FIEMAP:
3609 return (ENOTSUP);
3610
3611 default:
3612 linux_msg(td, "%s fd=%d, cmd=0x%x ('%c',%d) is not implemented",
3613 __func__, args->fd, args->cmd,
3614 (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
3615 break;
3616 }
3617
3618 return (EINVAL);
3619 }
3620
3621 int
linux_ioctl(struct thread * td,struct linux_ioctl_args * args)3622 linux_ioctl(struct thread *td, struct linux_ioctl_args *args)
3623 {
3624 struct linux_ioctl_handler *handler;
3625 int error, cmd, i;
3626
3627 cmd = args->cmd & 0xffff;
3628
3629 /*
3630 * array of ioctls known at compilation time. Elides a lot of work on
3631 * each call compared to the list variant. Everything frequently used
3632 * should be moved here.
3633 *
3634 * Arguably the magic creating the list should create an array instead.
3635 *
3636 * For now just a linear scan.
3637 */
3638 for (i = 0; i < nitems(linux_ioctls); i++) {
3639 handler = &linux_ioctls[i];
3640 if (cmd >= handler->low && cmd <= handler->high) {
3641 error = (*handler->func)(td, args);
3642 if (error != ENOIOCTL) {
3643 return (error);
3644 }
3645 }
3646 }
3647 return (linux_ioctl_fallback(td, args));
3648 }
3649
3650 int
linux_ioctl_register_handler(struct linux_ioctl_handler * h)3651 linux_ioctl_register_handler(struct linux_ioctl_handler *h)
3652 {
3653 struct linux_ioctl_handler_element *he, *cur;
3654
3655 if (h == NULL || h->func == NULL)
3656 return (EINVAL);
3657
3658 /*
3659 * Reuse the element if the handler is already on the list, otherwise
3660 * create a new element.
3661 */
3662 sx_xlock(&linux_ioctl_sx);
3663 TAILQ_FOREACH(he, &linux_ioctl_handlers, list) {
3664 if (he->func == h->func)
3665 break;
3666 }
3667 if (he == NULL) {
3668 he = malloc(sizeof(*he),
3669 M_LINUX, M_WAITOK);
3670 he->func = h->func;
3671 } else
3672 TAILQ_REMOVE(&linux_ioctl_handlers, he, list);
3673
3674 /* Initialize range information. */
3675 he->low = h->low;
3676 he->high = h->high;
3677 he->span = h->high - h->low + 1;
3678
3679 /* Add the element to the list, sorted on span. */
3680 TAILQ_FOREACH(cur, &linux_ioctl_handlers, list) {
3681 if (cur->span > he->span) {
3682 TAILQ_INSERT_BEFORE(cur, he, list);
3683 sx_xunlock(&linux_ioctl_sx);
3684 return (0);
3685 }
3686 }
3687 TAILQ_INSERT_TAIL(&linux_ioctl_handlers, he, list);
3688 sx_xunlock(&linux_ioctl_sx);
3689
3690 return (0);
3691 }
3692
3693 int
linux_ioctl_unregister_handler(struct linux_ioctl_handler * h)3694 linux_ioctl_unregister_handler(struct linux_ioctl_handler *h)
3695 {
3696 struct linux_ioctl_handler_element *he;
3697
3698 if (h == NULL || h->func == NULL)
3699 return (EINVAL);
3700
3701 sx_xlock(&linux_ioctl_sx);
3702 TAILQ_FOREACH(he, &linux_ioctl_handlers, list) {
3703 if (he->func == h->func) {
3704 TAILQ_REMOVE(&linux_ioctl_handlers, he, list);
3705 sx_xunlock(&linux_ioctl_sx);
3706 free(he, M_LINUX);
3707 return (0);
3708 }
3709 }
3710 sx_xunlock(&linux_ioctl_sx);
3711
3712 return (EINVAL);
3713 }
3714
3715 #ifdef COMPAT_LINUX32
3716 int
linux32_ioctl_register_handler(struct linux_ioctl_handler * h)3717 linux32_ioctl_register_handler(struct linux_ioctl_handler *h)
3718 {
3719 struct linux_ioctl_handler_element *he, *cur;
3720
3721 if (h == NULL || h->func == NULL)
3722 return (EINVAL);
3723
3724 /*
3725 * Reuse the element if the handler is already on the list, otherwise
3726 * create a new element.
3727 */
3728 sx_xlock(&linux_ioctl_sx);
3729 TAILQ_FOREACH(he, &linux32_ioctl_handlers, list) {
3730 if (he->func == h->func)
3731 break;
3732 }
3733 if (he == NULL) {
3734 he = malloc(sizeof(*he), M_LINUX, M_WAITOK);
3735 he->func = h->func;
3736 } else
3737 TAILQ_REMOVE(&linux32_ioctl_handlers, he, list);
3738
3739 /* Initialize range information. */
3740 he->low = h->low;
3741 he->high = h->high;
3742 he->span = h->high - h->low + 1;
3743
3744 /* Add the element to the list, sorted on span. */
3745 TAILQ_FOREACH(cur, &linux32_ioctl_handlers, list) {
3746 if (cur->span > he->span) {
3747 TAILQ_INSERT_BEFORE(cur, he, list);
3748 sx_xunlock(&linux_ioctl_sx);
3749 return (0);
3750 }
3751 }
3752 TAILQ_INSERT_TAIL(&linux32_ioctl_handlers, he, list);
3753 sx_xunlock(&linux_ioctl_sx);
3754
3755 return (0);
3756 }
3757
3758 int
linux32_ioctl_unregister_handler(struct linux_ioctl_handler * h)3759 linux32_ioctl_unregister_handler(struct linux_ioctl_handler *h)
3760 {
3761 struct linux_ioctl_handler_element *he;
3762
3763 if (h == NULL || h->func == NULL)
3764 return (EINVAL);
3765
3766 sx_xlock(&linux_ioctl_sx);
3767 TAILQ_FOREACH(he, &linux32_ioctl_handlers, list) {
3768 if (he->func == h->func) {
3769 TAILQ_REMOVE(&linux32_ioctl_handlers, he, list);
3770 sx_xunlock(&linux_ioctl_sx);
3771 free(he, M_LINUX);
3772 return (0);
3773 }
3774 }
3775 sx_xunlock(&linux_ioctl_sx);
3776
3777 return (EINVAL);
3778 }
3779 #endif
3780