Deleted Added
sdiff udiff text old ( 89182 ) new ( 89306 )
full compact
linux_ioctl.c (89182) linux_ioctl.c (89306)
1/*
2 * Copyright (c) 1994-1995 S�ren Schmidt
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
1/*
2 * Copyright (c) 1994-1995 S�ren Schmidt
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: head/sys/compat/linux/linux_ioctl.c 89182 2002-01-10 05:36:36Z marcel $
28 * $FreeBSD: head/sys/compat/linux/linux_ioctl.c 89306 2002-01-13 11:58:06Z alfred $
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/sysproto.h>
34#include <sys/cdio.h>
35#include <sys/dvdio.h>
36#include <sys/consio.h>

--- 63 unchanged lines hidden (view full) ---

100};
101
102static TAILQ_HEAD(, handler_element) handlers =
103 TAILQ_HEAD_INITIALIZER(handlers);
104
105static int
106linux_ioctl_disk(struct thread *td, struct linux_ioctl_args *args)
107{
29 */
30
31#include <sys/param.h>
32#include <sys/systm.h>
33#include <sys/sysproto.h>
34#include <sys/cdio.h>
35#include <sys/dvdio.h>
36#include <sys/consio.h>

--- 63 unchanged lines hidden (view full) ---

100};
101
102static TAILQ_HEAD(, handler_element) handlers =
103 TAILQ_HEAD_INITIALIZER(handlers);
104
105static int
106linux_ioctl_disk(struct thread *td, struct linux_ioctl_args *args)
107{
108 struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd];
108 struct file *fp;
109 int error;
110 struct disklabel dl;
111
109 int error;
110 struct disklabel dl;
111
112 fp = ffind_hold(td, args->fd);
113 if (fp == NULL)
114 return (EBADF);
112 switch (args->cmd & 0xffff) {
113 case LINUX_BLKGETSIZE:
114 error = fo_ioctl(fp, DIOCGDINFO, (caddr_t)&dl, td);
115 switch (args->cmd & 0xffff) {
116 case LINUX_BLKGETSIZE:
117 error = fo_ioctl(fp, DIOCGDINFO, (caddr_t)&dl, td);
118 fdrop(fp, td);
115 if (error)
116 return (error);
117 return (copyout(&(dl.d_secperunit), (caddr_t)args->arg,
118 sizeof(dl.d_secperunit)));
119 if (error)
120 return (error);
121 return (copyout(&(dl.d_secperunit), (caddr_t)args->arg,
122 sizeof(dl.d_secperunit)));
119 break;
120 }
123 }
124 fdrop(fp, td);
121 return (ENOIOCTL);
122}
123
124/*
125 * termio related ioctls
126 */
127
128struct linux_termio {

--- 414 unchanged lines hidden (view full) ---

543}
544
545static int
546linux_ioctl_termio(struct thread *td, struct linux_ioctl_args *args)
547{
548 struct termios bios;
549 struct linux_termios lios;
550 struct linux_termio lio;
125 return (ENOIOCTL);
126}
127
128/*
129 * termio related ioctls
130 */
131
132struct linux_termio {

--- 414 unchanged lines hidden (view full) ---

547}
548
549static int
550linux_ioctl_termio(struct thread *td, struct linux_ioctl_args *args)
551{
552 struct termios bios;
553 struct linux_termios lios;
554 struct linux_termio lio;
551 struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd];
555 struct file *fp;
552 int error;
553
556 int error;
557
558 fp = ffind_hold(td, args->fd);
559 if (fp == NULL)
560 return (EBADF);
554 switch (args->cmd & 0xffff) {
555
556 case LINUX_TCGETS:
557 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
558 if (error)
561 switch (args->cmd & 0xffff) {
562
563 case LINUX_TCGETS:
564 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
565 if (error)
559 return (error);
566 break;
560 bsd_to_linux_termios(&bios, &lios);
567 bsd_to_linux_termios(&bios, &lios);
561 return copyout(&lios, (caddr_t)args->arg, sizeof(lios));
568 error = copyout(&lios, (caddr_t)args->arg, sizeof(lios));
569 break;
562
563 case LINUX_TCSETS:
564 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
565 if (error)
570
571 case LINUX_TCSETS:
572 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
573 if (error)
566 return (error);
574 break;
567 linux_to_bsd_termios(&lios, &bios);
575 linux_to_bsd_termios(&lios, &bios);
568 return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
576 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
577 break;
569
570 case LINUX_TCSETSW:
571 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
572 if (error)
578
579 case LINUX_TCSETSW:
580 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
581 if (error)
573 return (error);
582 break;
574 linux_to_bsd_termios(&lios, &bios);
583 linux_to_bsd_termios(&lios, &bios);
575 return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
584 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
585 break;
576
577 case LINUX_TCSETSF:
578 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
579 if (error)
586
587 case LINUX_TCSETSF:
588 error = copyin((caddr_t)args->arg, &lios, sizeof(lios));
589 if (error)
580 return (error);
590 break;
581 linux_to_bsd_termios(&lios, &bios);
591 linux_to_bsd_termios(&lios, &bios);
582 return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
592 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
593 break;
583
584 case LINUX_TCGETA:
585 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
586 if (error)
594
595 case LINUX_TCGETA:
596 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
597 if (error)
587 return (error);
598 break;
588 bsd_to_linux_termio(&bios, &lio);
599 bsd_to_linux_termio(&bios, &lio);
589 return (copyout(&lio, (caddr_t)args->arg, sizeof(lio)));
600 error = (copyout(&lio, (caddr_t)args->arg, sizeof(lio)));
601 break;
590
591 case LINUX_TCSETA:
592 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
593 if (error)
602
603 case LINUX_TCSETA:
604 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
605 if (error)
594 return (error);
606 break;
595 linux_to_bsd_termio(&lio, &bios);
607 linux_to_bsd_termio(&lio, &bios);
596 return (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
608 error = (fo_ioctl(fp, TIOCSETA, (caddr_t)&bios, td));
609 break;
597
598 case LINUX_TCSETAW:
599 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
600 if (error)
610
611 case LINUX_TCSETAW:
612 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
613 if (error)
601 return (error);
614 break;
602 linux_to_bsd_termio(&lio, &bios);
615 linux_to_bsd_termio(&lio, &bios);
603 return (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
616 error = (fo_ioctl(fp, TIOCSETAW, (caddr_t)&bios, td));
617 break;
604
605 case LINUX_TCSETAF:
606 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
607 if (error)
618
619 case LINUX_TCSETAF:
620 error = copyin((caddr_t)args->arg, &lio, sizeof(lio));
621 if (error)
608 return (error);
622 break;
609 linux_to_bsd_termio(&lio, &bios);
623 linux_to_bsd_termio(&lio, &bios);
610 return (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
624 error = (fo_ioctl(fp, TIOCSETAF, (caddr_t)&bios, td));
625 break;
611
612 /* LINUX_TCSBRK */
613
614 case LINUX_TCXONC: {
615 switch (args->arg) {
616 case LINUX_TCOOFF:
617 args->cmd = TIOCSTOP;
618 break;
619 case LINUX_TCOON:
620 args->cmd = TIOCSTART;
621 break;
622 case LINUX_TCIOFF:
623 case LINUX_TCION: {
624 int c;
625 struct write_args wr;
626 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
627 if (error)
626
627 /* LINUX_TCSBRK */
628
629 case LINUX_TCXONC: {
630 switch (args->arg) {
631 case LINUX_TCOOFF:
632 args->cmd = TIOCSTOP;
633 break;
634 case LINUX_TCOON:
635 args->cmd = TIOCSTART;
636 break;
637 case LINUX_TCIOFF:
638 case LINUX_TCION: {
639 int c;
640 struct write_args wr;
641 error = fo_ioctl(fp, TIOCGETA, (caddr_t)&bios, td);
642 if (error)
628 return (error);
643 break;
644 fdrop(fp, td);
629 c = (args->arg == LINUX_TCIOFF) ? VSTOP : VSTART;
630 c = bios.c_cc[c];
631 if (c != _POSIX_VDISABLE) {
632 wr.fd = args->fd;
633 wr.buf = &c;
634 wr.nbyte = sizeof(c);
635 return (write(td, &wr));
636 } else
637 return (0);
638 }
639 default:
645 c = (args->arg == LINUX_TCIOFF) ? VSTOP : VSTART;
646 c = bios.c_cc[c];
647 if (c != _POSIX_VDISABLE) {
648 wr.fd = args->fd;
649 wr.buf = &c;
650 wr.nbyte = sizeof(c);
651 return (write(td, &wr));
652 } else
653 return (0);
654 }
655 default:
656 fdrop(fp, td);
640 return (EINVAL);
641 }
642 args->arg = 0;
657 return (EINVAL);
658 }
659 args->arg = 0;
643 return (ioctl(td, (struct ioctl_args *)args));
660 error = (ioctl(td, (struct ioctl_args *)args));
661 break;
644 }
645
646 case LINUX_TCFLSH: {
647 args->cmd = TIOCFLUSH;
648 switch (args->arg) {
649 case LINUX_TCIFLUSH:
650 args->arg = FREAD;
651 break;
652 case LINUX_TCOFLUSH:
653 args->arg = FWRITE;
654 break;
655 case LINUX_TCIOFLUSH:
656 args->arg = FREAD | FWRITE;
657 break;
658 default:
662 }
663
664 case LINUX_TCFLSH: {
665 args->cmd = TIOCFLUSH;
666 switch (args->arg) {
667 case LINUX_TCIFLUSH:
668 args->arg = FREAD;
669 break;
670 case LINUX_TCOFLUSH:
671 args->arg = FWRITE;
672 break;
673 case LINUX_TCIOFLUSH:
674 args->arg = FREAD | FWRITE;
675 break;
676 default:
677 fdrop(fp, td);
659 return (EINVAL);
660 }
678 return (EINVAL);
679 }
661 return (ioctl(td, (struct ioctl_args *)args));
680 error = (ioctl(td, (struct ioctl_args *)args));
681 break;
662 }
663
664 case LINUX_TIOCEXCL:
665 args->cmd = TIOCEXCL;
682 }
683
684 case LINUX_TIOCEXCL:
685 args->cmd = TIOCEXCL;
666 return (ioctl(td, (struct ioctl_args *)args));
686 error = (ioctl(td, (struct ioctl_args *)args));
687 break;
667
668 case LINUX_TIOCNXCL:
669 args->cmd = TIOCNXCL;
688
689 case LINUX_TIOCNXCL:
690 args->cmd = TIOCNXCL;
670 return (ioctl(td, (struct ioctl_args *)args));
691 error = (ioctl(td, (struct ioctl_args *)args));
692 break;
671
672 /* LINUX_TIOCSCTTY */
673
674 case LINUX_TIOCGPGRP:
675 args->cmd = TIOCGPGRP;
693
694 /* LINUX_TIOCSCTTY */
695
696 case LINUX_TIOCGPGRP:
697 args->cmd = TIOCGPGRP;
676 return (ioctl(td, (struct ioctl_args *)args));
698 error = (ioctl(td, (struct ioctl_args *)args));
699 break;
677
678 case LINUX_TIOCSPGRP:
679 args->cmd = TIOCSPGRP;
700
701 case LINUX_TIOCSPGRP:
702 args->cmd = TIOCSPGRP;
680 return (ioctl(td, (struct ioctl_args *)args));
703 error = (ioctl(td, (struct ioctl_args *)args));
704 break;
681
682 /* LINUX_TIOCOUTQ */
683 /* LINUX_TIOCSTI */
684
685 case LINUX_TIOCGWINSZ:
686 args->cmd = TIOCGWINSZ;
705
706 /* LINUX_TIOCOUTQ */
707 /* LINUX_TIOCSTI */
708
709 case LINUX_TIOCGWINSZ:
710 args->cmd = TIOCGWINSZ;
687 return (ioctl(td, (struct ioctl_args *)args));
711 error = (ioctl(td, (struct ioctl_args *)args));
712 break;
688
689 case LINUX_TIOCSWINSZ:
690 args->cmd = TIOCSWINSZ;
713
714 case LINUX_TIOCSWINSZ:
715 args->cmd = TIOCSWINSZ;
691 return (ioctl(td, (struct ioctl_args *)args));
716 error = (ioctl(td, (struct ioctl_args *)args));
717 break;
692
693 case LINUX_TIOCMGET:
694 args->cmd = TIOCMGET;
718
719 case LINUX_TIOCMGET:
720 args->cmd = TIOCMGET;
695 return (ioctl(td, (struct ioctl_args *)args));
721 error = (ioctl(td, (struct ioctl_args *)args));
722 break;
696
697 case LINUX_TIOCMBIS:
698 args->cmd = TIOCMBIS;
723
724 case LINUX_TIOCMBIS:
725 args->cmd = TIOCMBIS;
699 return (ioctl(td, (struct ioctl_args *)args));
726 error = (ioctl(td, (struct ioctl_args *)args));
727 break;
700
701 case LINUX_TIOCMBIC:
702 args->cmd = TIOCMBIC;
728
729 case LINUX_TIOCMBIC:
730 args->cmd = TIOCMBIC;
703 return (ioctl(td, (struct ioctl_args *)args));
731 error = (ioctl(td, (struct ioctl_args *)args));
732 break;
704
705 case LINUX_TIOCMSET:
706 args->cmd = TIOCMSET;
733
734 case LINUX_TIOCMSET:
735 args->cmd = TIOCMSET;
707 return (ioctl(td, (struct ioctl_args *)args));
736 error = (ioctl(td, (struct ioctl_args *)args));
737 break;
708
709 /* TIOCGSOFTCAR */
710 /* TIOCSSOFTCAR */
711
712 case LINUX_FIONREAD: /* LINUX_TIOCINQ */
713 args->cmd = FIONREAD;
738
739 /* TIOCGSOFTCAR */
740 /* TIOCSSOFTCAR */
741
742 case LINUX_FIONREAD: /* LINUX_TIOCINQ */
743 args->cmd = FIONREAD;
714 return (ioctl(td, (struct ioctl_args *)args));
744 error = (ioctl(td, (struct ioctl_args *)args));
745 break;
715
716 /* LINUX_TIOCLINUX */
717
718 case LINUX_TIOCCONS:
719 args->cmd = TIOCCONS;
746
747 /* LINUX_TIOCLINUX */
748
749 case LINUX_TIOCCONS:
750 args->cmd = TIOCCONS;
720 return (ioctl(td, (struct ioctl_args *)args));
751 error = (ioctl(td, (struct ioctl_args *)args));
752 break;
721
722 case LINUX_TIOCGSERIAL: {
723 struct linux_serial_struct lss;
724 lss.type = LINUX_PORT_16550A;
725 lss.flags = 0;
726 lss.close_delay = 0;
753
754 case LINUX_TIOCGSERIAL: {
755 struct linux_serial_struct lss;
756 lss.type = LINUX_PORT_16550A;
757 lss.flags = 0;
758 lss.close_delay = 0;
727 return copyout(&lss, (caddr_t)args->arg, sizeof(lss));
759 error = copyout(&lss, (caddr_t)args->arg, sizeof(lss));
760 break;
728 }
729
730 case LINUX_TIOCSSERIAL: {
731 struct linux_serial_struct lss;
732 error = copyin((caddr_t)args->arg, &lss, sizeof(lss));
733 if (error)
761 }
762
763 case LINUX_TIOCSSERIAL: {
764 struct linux_serial_struct lss;
765 error = copyin((caddr_t)args->arg, &lss, sizeof(lss));
766 if (error)
734 return (error);
767 break;
735 /* XXX - It really helps to have an implementation that
736 * does nothing. NOT!
737 */
768 /* XXX - It really helps to have an implementation that
769 * does nothing. NOT!
770 */
738 return (0);
771 error = 0;
772 break;
739 }
740
741 /* LINUX_TIOCPKT */
742
743 case LINUX_FIONBIO:
744 args->cmd = FIONBIO;
773 }
774
775 /* LINUX_TIOCPKT */
776
777 case LINUX_FIONBIO:
778 args->cmd = FIONBIO;
745 return (ioctl(td, (struct ioctl_args *)args));
779 error = (ioctl(td, (struct ioctl_args *)args));
780 break;
746
747 case LINUX_TIOCNOTTY:
748 args->cmd = TIOCNOTTY;
781
782 case LINUX_TIOCNOTTY:
783 args->cmd = TIOCNOTTY;
749 return (ioctl(td, (struct ioctl_args *)args));
784 error = (ioctl(td, (struct ioctl_args *)args));
785 break;
750
751 case LINUX_TIOCSETD: {
752 int line;
753 switch (args->arg) {
754 case LINUX_N_TTY:
755 line = TTYDISC;
756 break;
757 case LINUX_N_SLIP:
758 line = SLIPDISC;
759 break;
760 case LINUX_N_PPP:
761 line = PPPDISC;
762 break;
763 default:
786
787 case LINUX_TIOCSETD: {
788 int line;
789 switch (args->arg) {
790 case LINUX_N_TTY:
791 line = TTYDISC;
792 break;
793 case LINUX_N_SLIP:
794 line = SLIPDISC;
795 break;
796 case LINUX_N_PPP:
797 line = PPPDISC;
798 break;
799 default:
800 fdrop(fp, td);
764 return (EINVAL);
765 }
801 return (EINVAL);
802 }
766 return (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td));
803 error = (fo_ioctl(fp, TIOCSETD, (caddr_t)&line, td));
804 break;
767 }
768
769 case LINUX_TIOCGETD: {
770 int linux_line;
771 int bsd_line = TTYDISC;
772 error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line, td);
773 if (error)
774 return (error);
775 switch (bsd_line) {
776 case TTYDISC:
777 linux_line = LINUX_N_TTY;
778 break;
779 case SLIPDISC:
780 linux_line = LINUX_N_SLIP;
781 break;
782 case PPPDISC:
783 linux_line = LINUX_N_PPP;
784 break;
785 default:
805 }
806
807 case LINUX_TIOCGETD: {
808 int linux_line;
809 int bsd_line = TTYDISC;
810 error = fo_ioctl(fp, TIOCGETD, (caddr_t)&bsd_line, td);
811 if (error)
812 return (error);
813 switch (bsd_line) {
814 case TTYDISC:
815 linux_line = LINUX_N_TTY;
816 break;
817 case SLIPDISC:
818 linux_line = LINUX_N_SLIP;
819 break;
820 case PPPDISC:
821 linux_line = LINUX_N_PPP;
822 break;
823 default:
824 fdrop(fp, td);
786 return (EINVAL);
787 }
825 return (EINVAL);
826 }
788 return (copyout(&linux_line, (caddr_t)args->arg, sizeof(int)));
827 error = (copyout(&linux_line, (caddr_t)args->arg, sizeof(int)));
828 break;
789 }
790
791 /* LINUX_TCSBRKP */
792 /* LINUX_TIOCTTYGSTRUCT */
793
794 case LINUX_FIONCLEX:
795 args->cmd = FIONCLEX;
829 }
830
831 /* LINUX_TCSBRKP */
832 /* LINUX_TIOCTTYGSTRUCT */
833
834 case LINUX_FIONCLEX:
835 args->cmd = FIONCLEX;
796 return (ioctl(td, (struct ioctl_args *)args));
836 error = (ioctl(td, (struct ioctl_args *)args));
837 break;
797
798 case LINUX_FIOCLEX:
799 args->cmd = FIOCLEX;
838
839 case LINUX_FIOCLEX:
840 args->cmd = FIOCLEX;
800 return (ioctl(td, (struct ioctl_args *)args));
841 error = (ioctl(td, (struct ioctl_args *)args));
842 break;
801
802 case LINUX_FIOASYNC:
803 args->cmd = FIOASYNC;
843
844 case LINUX_FIOASYNC:
845 args->cmd = FIOASYNC;
804 return (ioctl(td, (struct ioctl_args *)args));
846 error = (ioctl(td, (struct ioctl_args *)args));
847 break;
805
806 /* LINUX_TIOCSERCONFIG */
807 /* LINUX_TIOCSERGWILD */
808 /* LINUX_TIOCSERSWILD */
809 /* LINUX_TIOCGLCKTRMIOS */
810 /* LINUX_TIOCSLCKTRMIOS */
811
848
849 /* LINUX_TIOCSERCONFIG */
850 /* LINUX_TIOCSERGWILD */
851 /* LINUX_TIOCSERSWILD */
852 /* LINUX_TIOCGLCKTRMIOS */
853 /* LINUX_TIOCSLCKTRMIOS */
854
855 default:
856 error = ENOIOCTL;
857 break;
812 }
813
858 }
859
814 return (ENOIOCTL);
860 fdrop(fp, td);
861 return (error);
815}
816
817/*
818 * CDROM related ioctls
819 */
820
821struct linux_cdrom_msf
822{

--- 371 unchanged lines hidden (view full) ---

1194 return (EINVAL);
1195 }
1196 return (0);
1197}
1198
1199static int
1200linux_ioctl_cdrom(struct thread *td, struct linux_ioctl_args *args)
1201{
862}
863
864/*
865 * CDROM related ioctls
866 */
867
868struct linux_cdrom_msf
869{

--- 371 unchanged lines hidden (view full) ---

1241 return (EINVAL);
1242 }
1243 return (0);
1244}
1245
1246static int
1247linux_ioctl_cdrom(struct thread *td, struct linux_ioctl_args *args)
1248{
1202 struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd];
1249 struct file *fp;
1203 int error;
1204
1250 int error;
1251
1252 fp = ffind_hold(td, args->fd);
1253 if (fp == NULL)
1254 return (EBADF);
1205 switch (args->cmd & 0xffff) {
1206
1207 case LINUX_CDROMPAUSE:
1208 args->cmd = CDIOCPAUSE;
1255 switch (args->cmd & 0xffff) {
1256
1257 case LINUX_CDROMPAUSE:
1258 args->cmd = CDIOCPAUSE;
1209 return (ioctl(td, (struct ioctl_args *)args));
1259 error = (ioctl(td, (struct ioctl_args *)args));
1260 break;
1210
1211 case LINUX_CDROMRESUME:
1212 args->cmd = CDIOCRESUME;
1261
1262 case LINUX_CDROMRESUME:
1263 args->cmd = CDIOCRESUME;
1213 return (ioctl(td, (struct ioctl_args *)args));
1264 error = (ioctl(td, (struct ioctl_args *)args));
1265 break;
1214
1215 case LINUX_CDROMPLAYMSF:
1216 args->cmd = CDIOCPLAYMSF;
1266
1267 case LINUX_CDROMPLAYMSF:
1268 args->cmd = CDIOCPLAYMSF;
1217 return (ioctl(td, (struct ioctl_args *)args));
1269 error = (ioctl(td, (struct ioctl_args *)args));
1270 break;
1218
1219 case LINUX_CDROMPLAYTRKIND:
1220 args->cmd = CDIOCPLAYTRACKS;
1271
1272 case LINUX_CDROMPLAYTRKIND:
1273 args->cmd = CDIOCPLAYTRACKS;
1221 return (ioctl(td, (struct ioctl_args *)args));
1274 error = (ioctl(td, (struct ioctl_args *)args));
1275 break;
1222
1223 case LINUX_CDROMREADTOCHDR: {
1224 struct ioc_toc_header th;
1225 struct linux_cdrom_tochdr lth;
1226 error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th, td);
1227 if (!error) {
1228 lth.cdth_trk0 = th.starting_track;
1229 lth.cdth_trk1 = th.ending_track;
1230 copyout(&lth, (caddr_t)args->arg, sizeof(lth));
1231 }
1276
1277 case LINUX_CDROMREADTOCHDR: {
1278 struct ioc_toc_header th;
1279 struct linux_cdrom_tochdr lth;
1280 error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&th, td);
1281 if (!error) {
1282 lth.cdth_trk0 = th.starting_track;
1283 lth.cdth_trk1 = th.ending_track;
1284 copyout(&lth, (caddr_t)args->arg, sizeof(lth));
1285 }
1232 return (error);
1286 break;
1233 }
1234
1235 case LINUX_CDROMREADTOCENTRY: {
1236 struct linux_cdrom_tocentry lte, *ltep =
1237 (struct linux_cdrom_tocentry *)args->arg;
1238 struct ioc_read_toc_single_entry irtse;
1239 irtse.address_format = ltep->cdte_format;
1240 irtse.track = ltep->cdte_track;
1241 error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse, td);
1242 if (!error) {
1243 lte = *ltep;
1244 lte.cdte_ctrl = irtse.entry.control;
1245 lte.cdte_adr = irtse.entry.addr_type;
1246 bsd_to_linux_msf_lba(irtse.address_format,
1247 &irtse.entry.addr, &lte.cdte_addr);
1248 copyout(&lte, (caddr_t)args->arg, sizeof(lte));
1249 }
1287 }
1288
1289 case LINUX_CDROMREADTOCENTRY: {
1290 struct linux_cdrom_tocentry lte, *ltep =
1291 (struct linux_cdrom_tocentry *)args->arg;
1292 struct ioc_read_toc_single_entry irtse;
1293 irtse.address_format = ltep->cdte_format;
1294 irtse.track = ltep->cdte_track;
1295 error = fo_ioctl(fp, CDIOREADTOCENTRY, (caddr_t)&irtse, td);
1296 if (!error) {
1297 lte = *ltep;
1298 lte.cdte_ctrl = irtse.entry.control;
1299 lte.cdte_adr = irtse.entry.addr_type;
1300 bsd_to_linux_msf_lba(irtse.address_format,
1301 &irtse.entry.addr, &lte.cdte_addr);
1302 copyout(&lte, (caddr_t)args->arg, sizeof(lte));
1303 }
1250 return (error);
1304 break;
1251 }
1252
1253 case LINUX_CDROMSTOP:
1254 args->cmd = CDIOCSTOP;
1305 }
1306
1307 case LINUX_CDROMSTOP:
1308 args->cmd = CDIOCSTOP;
1255 return (ioctl(td, (struct ioctl_args *)args));
1309 error = (ioctl(td, (struct ioctl_args *)args));
1310 break;
1256
1257 case LINUX_CDROMSTART:
1258 args->cmd = CDIOCSTART;
1311
1312 case LINUX_CDROMSTART:
1313 args->cmd = CDIOCSTART;
1259 return (ioctl(td, (struct ioctl_args *)args));
1314 error = (ioctl(td, (struct ioctl_args *)args));
1315 break;
1260
1261 case LINUX_CDROMEJECT:
1262 args->cmd = CDIOCEJECT;
1316
1317 case LINUX_CDROMEJECT:
1318 args->cmd = CDIOCEJECT;
1263 return (ioctl(td, (struct ioctl_args *)args));
1319 error = (ioctl(td, (struct ioctl_args *)args));
1320 break;
1264
1265 /* LINUX_CDROMVOLCTRL */
1266
1267 case LINUX_CDROMSUBCHNL: {
1268 struct linux_cdrom_subchnl sc;
1269 struct ioc_read_subchannel bsdsc;
1270 struct cd_sub_channel_info *bsdinfo;
1271 caddr_t sg = stackgap_init();
1272 bsdinfo = (struct cd_sub_channel_info*)stackgap_alloc(&sg,
1273 sizeof(struct cd_sub_channel_info));
1274 bsdsc.address_format = CD_LBA_FORMAT;
1275 bsdsc.data_format = CD_CURRENT_POSITION;
1276 bsdsc.track = 0;
1277 bsdsc.data_len = sizeof(struct cd_sub_channel_info);
1278 bsdsc.data = bsdinfo;
1279 error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc, td);
1280 if (error)
1321
1322 /* LINUX_CDROMVOLCTRL */
1323
1324 case LINUX_CDROMSUBCHNL: {
1325 struct linux_cdrom_subchnl sc;
1326 struct ioc_read_subchannel bsdsc;
1327 struct cd_sub_channel_info *bsdinfo;
1328 caddr_t sg = stackgap_init();
1329 bsdinfo = (struct cd_sub_channel_info*)stackgap_alloc(&sg,
1330 sizeof(struct cd_sub_channel_info));
1331 bsdsc.address_format = CD_LBA_FORMAT;
1332 bsdsc.data_format = CD_CURRENT_POSITION;
1333 bsdsc.track = 0;
1334 bsdsc.data_len = sizeof(struct cd_sub_channel_info);
1335 bsdsc.data = bsdinfo;
1336 error = fo_ioctl(fp, CDIOCREADSUBCHANNEL, (caddr_t)&bsdsc, td);
1337 if (error)
1281 return (error);
1338 break;
1282 error = copyin((caddr_t)args->arg, &sc,
1283 sizeof(struct linux_cdrom_subchnl));
1284 if (error)
1339 error = copyin((caddr_t)args->arg, &sc,
1340 sizeof(struct linux_cdrom_subchnl));
1341 if (error)
1285 return (error);
1342 break;
1286 sc.cdsc_audiostatus = bsdinfo->header.audio_status;
1287 sc.cdsc_adr = bsdinfo->what.position.addr_type;
1288 sc.cdsc_ctrl = bsdinfo->what.position.control;
1289 sc.cdsc_trk = bsdinfo->what.position.track_number;
1290 sc.cdsc_ind = bsdinfo->what.position.index_number;
1291 set_linux_cdrom_addr(&sc.cdsc_absaddr, sc.cdsc_format,
1292 bsdinfo->what.position.absaddr.lba);
1293 set_linux_cdrom_addr(&sc.cdsc_reladdr, sc.cdsc_format,
1294 bsdinfo->what.position.reladdr.lba);
1295 error = copyout(&sc, (caddr_t)args->arg,
1296 sizeof(struct linux_cdrom_subchnl));
1343 sc.cdsc_audiostatus = bsdinfo->header.audio_status;
1344 sc.cdsc_adr = bsdinfo->what.position.addr_type;
1345 sc.cdsc_ctrl = bsdinfo->what.position.control;
1346 sc.cdsc_trk = bsdinfo->what.position.track_number;
1347 sc.cdsc_ind = bsdinfo->what.position.index_number;
1348 set_linux_cdrom_addr(&sc.cdsc_absaddr, sc.cdsc_format,
1349 bsdinfo->what.position.absaddr.lba);
1350 set_linux_cdrom_addr(&sc.cdsc_reladdr, sc.cdsc_format,
1351 bsdinfo->what.position.reladdr.lba);
1352 error = copyout(&sc, (caddr_t)args->arg,
1353 sizeof(struct linux_cdrom_subchnl));
1297 return (error);
1354 break;
1298 }
1299
1300 /* LINUX_CDROMREADMODE2 */
1301 /* LINUX_CDROMREADMODE1 */
1302 /* LINUX_CDROMREADAUDIO */
1303 /* LINUX_CDROMEJECT_SW */
1304 /* LINUX_CDROMMULTISESSION */
1305 /* LINUX_CDROM_GET_UPC */
1306
1307 case LINUX_CDROMRESET:
1308 args->cmd = CDIOCRESET;
1355 }
1356
1357 /* LINUX_CDROMREADMODE2 */
1358 /* LINUX_CDROMREADMODE1 */
1359 /* LINUX_CDROMREADAUDIO */
1360 /* LINUX_CDROMEJECT_SW */
1361 /* LINUX_CDROMMULTISESSION */
1362 /* LINUX_CDROM_GET_UPC */
1363
1364 case LINUX_CDROMRESET:
1365 args->cmd = CDIOCRESET;
1309 return (ioctl(td, (struct ioctl_args *)args));
1366 error = (ioctl(td, (struct ioctl_args *)args));
1367 break;
1310
1311 /* LINUX_CDROMVOLREAD */
1312 /* LINUX_CDROMREADRAW */
1313 /* LINUX_CDROMREADCOOKED */
1314 /* LINUX_CDROMSEEK */
1315 /* LINUX_CDROMPLAYBLK */
1316 /* LINUX_CDROMREADALL */
1317 /* LINUX_CDROMCLOSETRAY */

--- 14 unchanged lines hidden (view full) ---

1332 /* LINUX_CDROMAUDIOBUFSIZ */
1333
1334 case LINUX_DVD_READ_STRUCT: {
1335 l_dvd_struct lds;
1336 struct dvd_struct bds;
1337
1338 error = copyin((caddr_t)args->arg, &lds, sizeof(l_dvd_struct));
1339 if (error)
1368
1369 /* LINUX_CDROMVOLREAD */
1370 /* LINUX_CDROMREADRAW */
1371 /* LINUX_CDROMREADCOOKED */
1372 /* LINUX_CDROMSEEK */
1373 /* LINUX_CDROMPLAYBLK */
1374 /* LINUX_CDROMREADALL */
1375 /* LINUX_CDROMCLOSETRAY */

--- 14 unchanged lines hidden (view full) ---

1390 /* LINUX_CDROMAUDIOBUFSIZ */
1391
1392 case LINUX_DVD_READ_STRUCT: {
1393 l_dvd_struct lds;
1394 struct dvd_struct bds;
1395
1396 error = copyin((caddr_t)args->arg, &lds, sizeof(l_dvd_struct));
1397 if (error)
1340 return (error);
1398 break;
1341 error = linux_to_bsd_dvd_struct(&lds, &bds);
1342 if (error)
1399 error = linux_to_bsd_dvd_struct(&lds, &bds);
1400 if (error)
1343 return (error);
1401 break;
1344 error = fo_ioctl(fp, DVDIOCREADSTRUCTURE, (caddr_t)&bds, td);
1345 if (error)
1402 error = fo_ioctl(fp, DVDIOCREADSTRUCTURE, (caddr_t)&bds, td);
1403 if (error)
1346 return (error);
1404 break;
1347 error = bsd_to_linux_dvd_struct(&bds, &lds);
1348 if (error)
1405 error = bsd_to_linux_dvd_struct(&bds, &lds);
1406 if (error)
1349 return (error);
1350 return (copyout(&lds, (caddr_t)args->arg,
1351 sizeof(l_dvd_struct)));
1407 break;
1408 error = copyout(&lds, (caddr_t)args->arg,
1409 sizeof(l_dvd_struct));
1410 break;
1352 }
1353
1354 /* LINUX_DVD_WRITE_STRUCT */
1355
1356 case LINUX_DVD_AUTH: {
1357 l_dvd_authinfo lda;
1358 struct dvd_authinfo bda;
1359 int bcode;
1360
1361 error = copyin((caddr_t)args->arg, &lda,
1362 sizeof(l_dvd_authinfo));
1363 if (error)
1411 }
1412
1413 /* LINUX_DVD_WRITE_STRUCT */
1414
1415 case LINUX_DVD_AUTH: {
1416 l_dvd_authinfo lda;
1417 struct dvd_authinfo bda;
1418 int bcode;
1419
1420 error = copyin((caddr_t)args->arg, &lda,
1421 sizeof(l_dvd_authinfo));
1422 if (error)
1364 return (error);
1423 break;
1365 error = linux_to_bsd_dvd_authinfo(&lda, &bcode, &bda);
1366 if (error)
1424 error = linux_to_bsd_dvd_authinfo(&lda, &bcode, &bda);
1425 if (error)
1367 return (error);
1426 break;
1368 error = fo_ioctl(fp, bcode, (caddr_t)&bda, td);
1369 if (error) {
1370 if (lda.type == LINUX_DVD_HOST_SEND_KEY2) {
1371 lda.type = LINUX_DVD_AUTH_FAILURE;
1372 copyout(&lda, (caddr_t)args->arg,
1373 sizeof(l_dvd_authinfo));
1374 }
1427 error = fo_ioctl(fp, bcode, (caddr_t)&bda, td);
1428 if (error) {
1429 if (lda.type == LINUX_DVD_HOST_SEND_KEY2) {
1430 lda.type = LINUX_DVD_AUTH_FAILURE;
1431 copyout(&lda, (caddr_t)args->arg,
1432 sizeof(l_dvd_authinfo));
1433 }
1375 return (error);
1434 break;
1376 }
1377 error = bsd_to_linux_dvd_authinfo(&bda, &lda);
1378 if (error)
1435 }
1436 error = bsd_to_linux_dvd_authinfo(&bda, &lda);
1437 if (error)
1379 return (error);
1380 return (copyout(&lda, (caddr_t)args->arg,
1381 sizeof(l_dvd_authinfo)));
1438 break;
1439 error = copyout(&lda, (caddr_t)args->arg,
1440 sizeof(l_dvd_authinfo));
1441 break;
1382 }
1383
1384 /* LINUX_CDROM_SEND_PACKET */
1385 /* LINUX_CDROM_NEXT_WRITABLE */
1386 /* LINUX_CDROM_LAST_WRITTEN */
1387
1442 }
1443
1444 /* LINUX_CDROM_SEND_PACKET */
1445 /* LINUX_CDROM_NEXT_WRITABLE */
1446 /* LINUX_CDROM_LAST_WRITTEN */
1447
1448 default:
1449 error = ENOIOCTL;
1450 break;
1388 }
1389
1451 }
1452
1390 return (ENOIOCTL);
1453 fdrop(fp, td);
1454 return (error);
1391}
1392
1393/*
1394 * Sound related ioctls
1395 */
1396
1397static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT };
1398

--- 235 unchanged lines hidden (view full) ---

1634 * Console related ioctls
1635 */
1636
1637#define ISSIGVALID(sig) ((sig) > 0 && (sig) < NSIG)
1638
1639static int
1640linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args)
1641{
1455}
1456
1457/*
1458 * Sound related ioctls
1459 */
1460
1461static u_int32_t dirbits[4] = { IOC_VOID, IOC_IN, IOC_OUT, IOC_INOUT };
1462

--- 235 unchanged lines hidden (view full) ---

1698 * Console related ioctls
1699 */
1700
1701#define ISSIGVALID(sig) ((sig) > 0 && (sig) < NSIG)
1702
1703static int
1704linux_ioctl_console(struct thread *td, struct linux_ioctl_args *args)
1705{
1642 struct file *fp = td->td_proc->p_fd->fd_ofiles[args->fd];
1706 struct file *fp;
1707 int error;
1643
1708
1709 fp = ffind_hold(td, args->fd);
1710 if (fp == NULL)
1711 return (EBADF);
1644 switch (args->cmd & 0xffff) {
1645
1646 case LINUX_KIOCSOUND:
1647 args->cmd = KIOCSOUND;
1712 switch (args->cmd & 0xffff) {
1713
1714 case LINUX_KIOCSOUND:
1715 args->cmd = KIOCSOUND;
1648 return (ioctl(td, (struct ioctl_args *)args));
1716 error = (ioctl(td, (struct ioctl_args *)args));
1717 break;
1649
1650 case LINUX_KDMKTONE:
1651 args->cmd = KDMKTONE;
1718
1719 case LINUX_KDMKTONE:
1720 args->cmd = KDMKTONE;
1652 return (ioctl(td, (struct ioctl_args *)args));
1721 error = (ioctl(td, (struct ioctl_args *)args));
1722 break;
1653
1654 case LINUX_KDGETLED:
1655 args->cmd = KDGETLED;
1723
1724 case LINUX_KDGETLED:
1725 args->cmd = KDGETLED;
1656 return (ioctl(td, (struct ioctl_args *)args));
1726 error = (ioctl(td, (struct ioctl_args *)args));
1727 break;
1657
1658 case LINUX_KDSETLED:
1659 args->cmd = KDSETLED;
1728
1729 case LINUX_KDSETLED:
1730 args->cmd = KDSETLED;
1660 return (ioctl(td, (struct ioctl_args *)args));
1731 error = (ioctl(td, (struct ioctl_args *)args));
1732 break;
1661
1662 case LINUX_KDSETMODE:
1663 args->cmd = KDSETMODE;
1733
1734 case LINUX_KDSETMODE:
1735 args->cmd = KDSETMODE;
1664 return (ioctl(td, (struct ioctl_args *)args));
1736 error = (ioctl(td, (struct ioctl_args *)args));
1737 break;
1665
1666 case LINUX_KDGETMODE:
1667 args->cmd = KDGETMODE;
1738
1739 case LINUX_KDGETMODE:
1740 args->cmd = KDGETMODE;
1668 return (ioctl(td, (struct ioctl_args *)args));
1741 error = (ioctl(td, (struct ioctl_args *)args));
1742 break;
1669
1670 case LINUX_KDGKBMODE:
1671 args->cmd = KDGKBMODE;
1743
1744 case LINUX_KDGKBMODE:
1745 args->cmd = KDGKBMODE;
1672 return (ioctl(td, (struct ioctl_args *)args));
1746 error = (ioctl(td, (struct ioctl_args *)args));
1747 break;
1673
1674 case LINUX_KDSKBMODE: {
1675 int kbdmode;
1676 switch (args->arg) {
1677 case LINUX_KBD_RAW:
1678 kbdmode = K_RAW;
1679 break;
1680 case LINUX_KBD_XLATE:
1681 kbdmode = K_XLATE;
1682 break;
1683 case LINUX_KBD_MEDIUMRAW:
1684 kbdmode = K_RAW;
1685 break;
1686 default:
1748
1749 case LINUX_KDSKBMODE: {
1750 int kbdmode;
1751 switch (args->arg) {
1752 case LINUX_KBD_RAW:
1753 kbdmode = K_RAW;
1754 break;
1755 case LINUX_KBD_XLATE:
1756 kbdmode = K_XLATE;
1757 break;
1758 case LINUX_KBD_MEDIUMRAW:
1759 kbdmode = K_RAW;
1760 break;
1761 default:
1762 fdrop(fp, td);
1687 return (EINVAL);
1688 }
1763 return (EINVAL);
1764 }
1689 return (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode, td));
1765 error = (fo_ioctl(fp, KDSKBMODE, (caddr_t)&kbdmode, td));
1766 break;
1690 }
1691
1692 case LINUX_VT_OPENQRY:
1693 args->cmd = VT_OPENQRY;
1767 }
1768
1769 case LINUX_VT_OPENQRY:
1770 args->cmd = VT_OPENQRY;
1694 return (ioctl(td, (struct ioctl_args *)args));
1771 error = (ioctl(td, (struct ioctl_args *)args));
1772 break;
1695
1696 case LINUX_VT_GETMODE:
1697 args->cmd = VT_GETMODE;
1773
1774 case LINUX_VT_GETMODE:
1775 args->cmd = VT_GETMODE;
1698 return (ioctl(td, (struct ioctl_args *)args));
1776 error = (ioctl(td, (struct ioctl_args *)args));
1777 break;
1699
1700 case LINUX_VT_SETMODE: {
1701 struct vt_mode *mode;
1702 args->cmd = VT_SETMODE;
1703 mode = (struct vt_mode *)args->arg;
1704 if (!ISSIGVALID(mode->frsig) && ISSIGVALID(mode->acqsig))
1705 mode->frsig = mode->acqsig;
1778
1779 case LINUX_VT_SETMODE: {
1780 struct vt_mode *mode;
1781 args->cmd = VT_SETMODE;
1782 mode = (struct vt_mode *)args->arg;
1783 if (!ISSIGVALID(mode->frsig) && ISSIGVALID(mode->acqsig))
1784 mode->frsig = mode->acqsig;
1706 return (ioctl(td, (struct ioctl_args *)args));
1785 error = (ioctl(td, (struct ioctl_args *)args));
1786 break;
1707 }
1708
1709 case LINUX_VT_GETSTATE:
1710 args->cmd = VT_GETACTIVE;
1787 }
1788
1789 case LINUX_VT_GETSTATE:
1790 args->cmd = VT_GETACTIVE;
1711 return (ioctl(td, (struct ioctl_args *)args));
1791 error = (ioctl(td, (struct ioctl_args *)args));
1792 break;
1712
1713 case LINUX_VT_RELDISP:
1714 args->cmd = VT_RELDISP;
1793
1794 case LINUX_VT_RELDISP:
1795 args->cmd = VT_RELDISP;
1715 return (ioctl(td, (struct ioctl_args *)args));
1796 error = (ioctl(td, (struct ioctl_args *)args));
1797 break;
1716
1717 case LINUX_VT_ACTIVATE:
1718 args->cmd = VT_ACTIVATE;
1798
1799 case LINUX_VT_ACTIVATE:
1800 args->cmd = VT_ACTIVATE;
1719 return (ioctl(td, (struct ioctl_args *)args));
1801 error = (ioctl(td, (struct ioctl_args *)args));
1802 break;
1720
1721 case LINUX_VT_WAITACTIVE:
1722 args->cmd = VT_WAITACTIVE;
1803
1804 case LINUX_VT_WAITACTIVE:
1805 args->cmd = VT_WAITACTIVE;
1723 return (ioctl(td, (struct ioctl_args *)args));
1806 error = (ioctl(td, (struct ioctl_args *)args));
1807 break;
1724
1808
1809 default:
1810 error = ENOIOCTL;
1811 break;
1725 }
1726
1812 }
1813
1727 return (ENOIOCTL);
1814 fdrop(fp, td);
1815 return (error);
1728}
1729
1730/*
1731 * Criteria for interface name translation
1732 */
1733#define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
1734
1735/*

--- 420 unchanged lines hidden (view full) ---

2156
2157/*
2158 * main ioctl syscall function
2159 */
2160
2161int
2162linux_ioctl(struct thread *td, struct linux_ioctl_args *args)
2163{
1816}
1817
1818/*
1819 * Criteria for interface name translation
1820 */
1821#define IFP_IS_ETH(ifp) (ifp->if_type == IFT_ETHER)
1822
1823/*

--- 420 unchanged lines hidden (view full) ---

2244
2245/*
2246 * main ioctl syscall function
2247 */
2248
2249int
2250linux_ioctl(struct thread *td, struct linux_ioctl_args *args)
2251{
2164 struct filedesc *fdp;
2165 struct file *fp;
2166 struct handler_element *he;
2167 int error, cmd;
2168
2169#ifdef DEBUG
2170 if (ldebug(ioctl))
2171 printf(ARGS(ioctl, "%d, %04lx, *"), args->fd,
2172 (unsigned long)args->cmd);
2173#endif
2174
2252 struct file *fp;
2253 struct handler_element *he;
2254 int error, cmd;
2255
2256#ifdef DEBUG
2257 if (ldebug(ioctl))
2258 printf(ARGS(ioctl, "%d, %04lx, *"), args->fd,
2259 (unsigned long)args->cmd);
2260#endif
2261
2175 fdp = td->td_proc->p_fd;
2176 if ((unsigned)args->fd >= fdp->fd_nfiles)
2262 fp = ffind_hold(td, args->fd);
2263 if (fp == NULL)
2177 return (EBADF);
2264 return (EBADF);
2178 fp = fdp->fd_ofiles[args->fd];
2179 if (fp == NULL || (fp->f_flag & (FREAD|FWRITE)) == 0)
2265 if ((fp->f_flag & (FREAD|FWRITE)) == 0) {
2266 fdrop(fp, td);
2180 return (EBADF);
2267 return (EBADF);
2268 }
2181
2182 /* Iterate over the ioctl handlers */
2183 cmd = args->cmd & 0xffff;
2184 TAILQ_FOREACH(he, &handlers, list) {
2185 if (cmd >= he->low && cmd <= he->high) {
2186 error = (*he->func)(td, args);
2187 if (error != ENOIOCTL)
2269
2270 /* Iterate over the ioctl handlers */
2271 cmd = args->cmd & 0xffff;
2272 TAILQ_FOREACH(he, &handlers, list) {
2273 if (cmd >= he->low && cmd <= he->high) {
2274 error = (*he->func)(td, args);
2275 if (error != ENOIOCTL)
2276 fdrop(fp, td);
2188 return (error);
2189 }
2190 }
2277 return (error);
2278 }
2279 }
2280 fdrop(fp, td);
2191
2192 printf("linux: 'ioctl' fd=%d, cmd=0x%x ('%c',%d) not implemented\n",
2193 args->fd, (int)(args->cmd & 0xffff),
2194 (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
2195
2196 return (EINVAL);
2197}
2198

--- 58 unchanged lines hidden --- 		2281
2282 printf("linux: 'ioctl' fd=%d, cmd=0x%x ('%c',%d) not implemented\n",
2283 args->fd, (int)(args->cmd & 0xffff),
2284 (int)(args->cmd & 0xff00) >> 8, (int)(args->cmd & 0xff));
2285
2286 return (EINVAL);
2287}
2288

--- 58 unchanged lines hidden ---