自学教程：C++ sys_ioctl函数代码示例

static int rtc32_ioctl(unsigned fd, unsigned cmd, unsigned long arg) { 	unsigned long val;	mm_segment_t oldfs = get_fs(); 	int ret; 		switch (cmd) { 	case RTC_IRQP_READ32: 		set_fs(KERNEL_DS); 		ret = sys_ioctl(fd, RTC_IRQP_READ, (unsigned long)&val); 		set_fs(oldfs); 		if (!ret)			ret = put_user(val, (unsigned int __user *) arg); 		return ret; 	case RTC_IRQP_SET32: 		cmd = RTC_IRQP_SET; 		break; 	case RTC_EPOCH_READ32:		set_fs(KERNEL_DS); 		ret = sys_ioctl(fd, RTC_EPOCH_READ, (unsigned long) &val); 		set_fs(oldfs); 		if (!ret)			ret = put_user(val, (unsigned int __user *) arg); 		return ret; 	case RTC_EPOCH_SET32:		cmd = RTC_EPOCH_SET; 		break; 	} 	return sys_ioctl(fd,cmd,arg); } 

static int solaris_m(unsigned int fd, unsigned int cmd, u32 arg){	int ret;	switch (cmd & 0xff) {	case 1: /* MTIOCTOP */		ret = sys_ioctl(fd, MTIOCTOP, (unsigned long)&arg);		break;	case 2: /* MTIOCGET */		ret = sys_ioctl(fd, MTIOCGET, (unsigned long)&arg);		break;	case 3: /* MTIOCGETDRIVETYPE */	case 4: /* MTIOCPERSISTENT */	case 5: /* MTIOCPERSISTENTSTATUS */	case 6: /* MTIOCLRERR */	case 7: /* MTIOCGUARANTEEDORDER */	case 8: /* MTIOCRESERVE */	case 9: /* MTIOCRELEASE */	case 10: /* MTIOCFORCERESERVE */	case 13: /* MTIOCSTATE */	case 14: /* MTIOCREADIGNOREILI */	case 15: /* MTIOCREADIGNOREEOFS */	case 16: /* MTIOCSHORTFMK */	default:		ret = -ENOSYS; /* linux doesn't support these */		break;	};	return ret;}

static inline int solaris_T(unsigned int fd, unsigned int cmd, u32 arg){	switch (cmd & 0xff) {	case 1: /* TCGETA */		return linux_to_solaris_termio(fd, TCGETA, arg);	case 2: /* TCSETA */		return solaris_to_linux_termio(fd, TCSETA, arg);	case 3: /* TCSETAW */		return solaris_to_linux_termio(fd, TCSETAW, arg);	case 4: /* TCSETAF */		return solaris_to_linux_termio(fd, TCSETAF, arg);	case 5: /* TCSBRK */		return sys_ioctl(fd, TCSBRK, arg);	case 6: /* TCXONC */		return sys_ioctl(fd, TCXONC, arg);	case 7: /* TCFLSH */		return sys_ioctl(fd, TCFLSH, arg);	case 13: /* TCGETS */		return linux_to_solaris_termios(fd, TCGETS, arg);	case 14: /* TCSETS */		return solaris_to_linux_termios(fd, TCSETS, arg);	case 15: /* TCSETSW */		return solaris_to_linux_termios(fd, TCSETSW, arg);	case 16: /* TCSETSF */		return solaris_to_linux_termios(fd, TCSETSF, arg);	case 103: /* TIOCSWINSZ */		return sys_ioctl(fd, TIOCSWINSZ, arg);	case 104: /* TIOCGWINSZ */		return sys_ioctl(fd, TIOCGWINSZ, arg);	}	return -ENOSYS;}

static	int	pci_init(pci_bus_cookie *cookie){	id_list 	*vendor_ids;	id_list 	*device_ids;	int 		err;	device 		dev;	int 		i,j;	int		fd;	struct pci_cfg 	cfg;	int		pp;	vendor_ids = kmalloc(sizeof(id_list) + sizeof(uint32));	vendor_ids->num_ids = 1;	vendor_ids->id[0] = _INTEL_VENDORID;	device_ids = kmalloc(sizeof(id_list) + sizeof(uint32));	device_ids->num_ids = 1;	device_ids->id[0] = _82371AB_DEVICE_ID;	err = bus_find_device(1, vendor_ids, device_ids, &dev);	if(err < 0)	{		TRACE(("unable to pci find controller/n"));		err = -1;		goto err;	}	fd = sys_open(dev.dev_path,STREAM_TYPE_DEVICE,0);	sys_ioctl(fd, PCI_DUMP_CFG, NULL, 0);	sys_ioctl(fd, PCI_GET_CFG, &cfg, sizeof(struct pci_cfg));	sys_close(fd);	cookie->io_port = dev.base[4];	cookie->busMasterActivated = /*(buffer[0x9] & 0x80)!=0*/true;	if(cookie->channel==0)	{		cookie->irq = 0x14;		cookie->base_reg = 0x1F0;		cookie->status_reg = 0x200 + cookie->base_reg;	}	else	{		cookie->irq = 0x15;		cookie->base_reg = 0x170;		cookie->status_reg = 0x200 + cookie->base_reg;	}	TRACE(("pci_init:irq=%X/n",cfg.irq));	TRACE(("pci_init:header=%X/n",cfg.header_type));	TRACE(("pci_init: found device at '%s'/n", dev.dev_path));	for(i=0; i<MAX_DEV_IO_RANGES; i++)	{		TRACE(("pci_init: found device at base '%X'/n", dev.base[i]));	}	TRACE(("pci_init: found device at irq '%X'/n", dev.irq));err:	kfree(vendor_ids);	kfree(device_ids);	return err;}

/** Description : open uart* Input : None* Output : success : 0 fail : others*/int felica_uart_open(void){//  struct termios newtio;  int rc;  mm_segment_t old_fs = get_fs();  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] open_hs_uart - start /n");  #endif  if(0 <= fd)  {    FELICA_DEBUG_MSG("[FELICA_UART] felica_uart is already opened fd : %d/n",fd);    return 0;  }  set_fs(KERNEL_DS);    fd = sys_open("/dev/ttyO3", O_RDWR | O_NOCTTY | O_NONBLOCK, 0);      FELICA_DEBUG_MSG("[FELICA_UART] open UART - fd : %d /n",fd);            if (fd < 0)    {    FELICA_DEBUG_MSG("[FELICA_UART] ERROR - can not sys_open /n");      set_fs(old_fs);      return fd;    }    {      /*  Set speed */      struct termios newtio;      // yjchoi; 120412 temporary block due to build error      serial_omap_disable_console_port();            // yjchoi; 120412 temporary block due to build error      rc = felica_gpio_open(GPIO_FELICA_UART_SW, GPIO_DIRECTION_OUT, GPIO_LOW_VALUE);      felica_gpio_write(GPIO_FELICA_UART_SW, 0);      sys_ioctl(fd, TCGETS, (unsigned long)&newtio);      memcpy(&console_settings, &newtio, sizeof(struct termios));      memset(&newtio, 0, sizeof(newtio));      newtio.c_cflag = B460800 | CS8 | CLOCAL | CREAD;      newtio.c_cc[VMIN] = 1;      newtio.c_cc[VTIME] = 5;      sys_ioctl(fd, TCFLSH, TCIOFLUSH);      sys_ioctl(fd, TCSETSF, (unsigned long)&newtio);    }    set_fs(old_fs);  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] open_hs_uart - end /n");  #endif  return 0;}

static inline int solaris_t(unsigned int fd, unsigned int cmd, u32 arg){	switch (cmd & 0xff) {	case 20: /* TIOCGPGRP */		return sys_ioctl(fd, TIOCGPGRP, arg);	case 21: /* TIOCSPGRP */		return sys_ioctl(fd, TIOCSPGRP, arg);	}	return -ENOSYS;}

/** Description : close uart* Input : None* Output : success : 0*/int felica_uart_close(void){  mm_segment_t old_fs = get_fs();  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] close_hs_uart - start /n");  #endif  if(0 > fd)  {    FELICA_DEBUG_MSG("[FELICA_UART] felica_uart is not opened/n");    return 0;  }    set_fs(KERNEL_DS);    {      /*  Set speed */      struct termios settings;        sys_ioctl(fd, TCGETS, (unsigned long)&settings);#if 1      memcpy(&settings, &console_settings, sizeof(struct termios));      FELICA_DEBUG_MSG("[FELICA_UART] Set BAUD rate to 115200/n");#else      if((settings.c_cflag & CBAUD) == B460800)      {        settings.c_cflag &= ~(CBAUD);        settings.c_cflag |= B115200;        FELICA_DEBUG_MSG("[FELICA_UART] Set BAUD rate to 115200/n");      }#endif      sys_ioctl(fd, TCSETS, (unsigned long)&settings);    }  sys_close(fd);  fd = -1;  felica_gpio_write(GPIO_FELICA_UART_SW, 1);  // yjchoi; 120412 temporary block due to build error  serial_omap_enable_console_port();  set_fs(old_fs);  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] close_hs_uart - end /n");  #endif  return 0;}

static int drm32_getsetunique(unsigned int fd, unsigned int cmd, unsigned long arg){	drm32_unique_t __user *uarg = (drm32_unique_t __user *)arg;	drm_unique_t karg;	mm_segment_t old_fs;	char __user *uptr;	u32 tmp;	int ret;	if (get_user(karg.unique_len, &uarg->unique_len))		return -EFAULT;	karg.unique = NULL;	if (get_user(tmp, &uarg->unique))		return -EFAULT;	uptr = A(tmp);	if (uptr) {		karg.unique = kmalloc(karg.unique_len, GFP_KERNEL);		if (!karg.unique)			return -ENOMEM;		if (cmd == DRM32_IOCTL_SET_UNIQUE &&		    copy_from_user(karg.unique, uptr, karg.unique_len)) {			kfree(karg.unique);			return -EFAULT;		}	}	old_fs = get_fs();	set_fs(KERNEL_DS);	if (cmd == DRM32_IOCTL_GET_UNIQUE)		ret = sys_ioctl (fd, DRM_IOCTL_GET_UNIQUE, (unsigned long)&karg);	else		ret = sys_ioctl (fd, DRM_IOCTL_SET_UNIQUE, (unsigned long)&karg);        set_fs(old_fs);	if (!ret) {		if (cmd == DRM32_IOCTL_GET_UNIQUE &&		    uptr != NULL &&		    copy_to_user(uptr, karg.unique, karg.unique_len))			ret = -EFAULT;		if (put_user(karg.unique_len, &uarg->unique_len))			ret = -EFAULT;	}	if (karg.unique != NULL)		kfree(karg.unique);	return ret;}

static int hpux_ioctl_t(int fd, unsigned long cmd, unsigned long arg){	int result = -EOPNOTSUPP;	int nr = _IOC_NR(cmd);	switch (nr) {	case 106:		result = sys_ioctl(fd, TIOCSWINSZ, arg);		break;	case 107:		result = sys_ioctl(fd, TIOCGWINSZ, arg);		break;	}	return result;}

static int loop_status(unsigned int fd, unsigned int cmd,		       unsigned long arg, struct file *f){	mm_segment_t old_fs = get_fs();	struct loop_info l;	int err = -EINVAL;	switch(cmd) {	case LOOP_SET_STATUS:		err = get_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);		err |= __get_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);		err |= __get_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);		err |= __get_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);		err |= __copy_from_user((char *)&l.lo_offset, (char *)&((struct loop_info32 *)arg)->lo_offset,					   8 + (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);		if (err) {			err = -EFAULT;		} else {			set_fs (KERNEL_DS);			err = sys_ioctl (fd, cmd, (unsigned long)&l);			set_fs (old_fs);		}		break;	case LOOP_GET_STATUS:		set_fs (KERNEL_DS);		err = sys_ioctl (fd, cmd, (unsigned long)&l);		set_fs (old_fs);		if (!err) {			err = put_user(l.lo_number, &((struct loop_info32 *)arg)->lo_number);			err |= __put_user(l.lo_device, &((struct loop_info32 *)arg)->lo_device);			err |= __put_user(l.lo_inode, &((struct loop_info32 *)arg)->lo_inode);			err |= __put_user(l.lo_rdevice, &((struct loop_info32 *)arg)->lo_rdevice);			err |= __copy_to_user((char *)&((struct loop_info32 *)arg)->lo_offset,					   (char *)&l.lo_offset, (unsigned long)l.lo_init - (unsigned long)&l.lo_offset);			if (err)				err = -EFAULT;		}		break;	default: {		static int count = 0;		if (++count <= 20)			printk("%s: Unknown loop ioctl cmd, fd(%d) "			       "cmd(%08x) arg(%08lx)/n",			       __FUNCTION__, fd, cmd, arg);	}	}	return err;}

intfreebsd32_ioctl(struct thread *td, struct freebsd32_ioctl_args *uap){	struct ioctl_args ap /*{		int	fd;		u_long	com;		caddr_t	data;	}*/ ;	struct file *fp;	cap_rights_t rights;	int error;	error = fget(td, uap->fd, cap_rights_init(&rights, CAP_IOCTL), &fp);	if (error != 0)		return (error);	if ((fp->f_flag & (FREAD | FWRITE)) == 0) {		fdrop(fp, td);		return (EBADF);	}	switch (uap->com) {	case MDIOCATTACH_32:	/* FALLTHROUGH */	case MDIOCDETACH_32:	/* FALLTHROUGH */	case MDIOCQUERY_32:	/* FALLTHROUGH */	case MDIOCLIST_32:		error = freebsd32_ioctl_md(td, uap, fp);		break;	case CDIOREADTOCENTRYS_32:		error = freebsd32_ioctl_ioc_read_toc(td, uap, fp);		break;	case FIODGNAME_32:		error = freebsd32_ioctl_fiodgname(td, uap, fp);		break;	case MEMRANGE_GET32:	/* FALLTHROUGH */	case MEMRANGE_SET32:		error = freebsd32_ioctl_memrange(td, uap, fp);		break;	case PCIOCGETCONF_32:		error = freebsd32_ioctl_pciocgetconf(td, uap, fp);		break;	case SG_IO_32:		error = freebsd32_ioctl_sg(td, uap, fp);		break;	default:		fdrop(fp, td);		ap.fd = uap->fd;		ap.com = uap->com;		PTRIN_CP(*uap, ap, data);		return sys_ioctl(td, &ap);	}	fdrop(fp, td);	return error;}

static inline int routing_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg){	struct rtentry32 *ur = (struct rtentry32 *) A(arg);	struct rtentry r;	char devname[16];	u32 rtdev;	int ret;	mm_segment_t old_fs = get_fs();		ret = copy_from_user (&r.rt_dst, &(ur->rt_dst), 3 * sizeof(struct sockaddr));	ret |= __get_user (r.rt_flags, &(ur->rt_flags));	ret |= __get_user (r.rt_metric, &(ur->rt_metric));	ret |= __get_user (r.rt_mtu, &(ur->rt_mtu));	ret |= __get_user (r.rt_window, &(ur->rt_window));	ret |= __get_user (r.rt_irtt, &(ur->rt_irtt));	ret |= __get_user (rtdev, &(ur->rt_dev));	if (rtdev) {		ret |= copy_from_user (devname, (char *) A(rtdev), 15);		r.rt_dev = devname; devname[15] = 0;	} else		r.rt_dev = 0;	if (ret)		return -EFAULT;	set_fs (KERNEL_DS);	ret = sys_ioctl (fd, cmd, (long)&r);	set_fs (old_fs);	return ret;}

static inline int dev_ifsioc(unsigned int fd, unsigned int cmd,			     unsigned long arg){	struct ifreq32 *uifr = (struct ifreq32 *) A(arg);	struct ifreq ifr;	mm_segment_t old_fs;	int err;		switch (cmd) {	case SIOCSIFMAP:		err = copy_from_user(&ifr, uifr, sizeof(ifr.ifr_name));		err |= __get_user(ifr.ifr_map.mem_start, &(uifr->ifr_ifru.ifru_map.mem_start));		err |= __get_user(ifr.ifr_map.mem_end, &(uifr->ifr_ifru.ifru_map.mem_end));		err |= __get_user(ifr.ifr_map.base_addr, &(uifr->ifr_ifru.ifru_map.base_addr));		err |= __get_user(ifr.ifr_map.irq, &(uifr->ifr_ifru.ifru_map.irq));		err |= __get_user(ifr.ifr_map.dma, &(uifr->ifr_ifru.ifru_map.dma));		err |= __get_user(ifr.ifr_map.port, &(uifr->ifr_ifru.ifru_map.port));		if (err)			return -EFAULT;		break;	default:		if (copy_from_user(&ifr, uifr, sizeof(struct ifreq32)))			return -EFAULT;		break;	}	old_fs = get_fs();	set_fs (KERNEL_DS);	err = sys_ioctl (fd, cmd, (unsigned long)&ifr);	set_fs (old_fs);	if (!err) {		switch (cmd) {		case SIOCGIFFLAGS:		case SIOCGIFMETRIC:		case SIOCGIFMTU:		case SIOCGIFMEM:		case SIOCGIFHWADDR:		case SIOCGIFINDEX:		case SIOCGIFADDR:		case SIOCGIFBRDADDR:		case SIOCGIFDSTADDR:		case SIOCGIFNETMASK:		case SIOCGIFTXQLEN:			if (copy_to_user(uifr, &ifr, sizeof(struct ifreq32)))				return -EFAULT;			break;		case SIOCGIFMAP:			err = copy_to_user(uifr, &ifr, sizeof(ifr.ifr_name));			err |= __put_user(ifr.ifr_map.mem_start, &(uifr->ifr_ifru.ifru_map.mem_start));			err |= __put_user(ifr.ifr_map.mem_end, &(uifr->ifr_ifru.ifru_map.mem_end));			err |= __put_user(ifr.ifr_map.base_addr, &(uifr->ifr_ifru.ifru_map.base_addr));			err |= __put_user(ifr.ifr_map.irq, &(uifr->ifr_ifru.ifru_map.irq));			err |= __put_user(ifr.ifr_map.dma, &(uifr->ifr_ifru.ifru_map.dma));			err |= __put_user(ifr.ifr_map.port, &(uifr->ifr_ifru.ifru_map.port));			if (err)				err = -EFAULT;			break;		}	}	return err;}

/** Description : get size of remaing data* Input : none* Output : success : data length fail : 0*/int felica_uart_ioctrl(int *count){  mm_segment_t old_fs = get_fs();  int rc = 0;  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] felica_uart_ioctrl - start /n");  #endif  if(0 > fd)  {    FELICA_DEBUG_MSG("[FELICA_UART] felica_uart is not opened/n");    return rc;  }  set_fs(KERNEL_DS);    rc = sys_ioctl(fd, TIOCINQ, (unsigned long)count);  set_fs(old_fs);  #ifdef FEATURE_DEBUG_LOW  FELICA_DEBUG_MSG("[FELICA_UART] felica_uart_ioctrl - end /n");  #endif  return rc;}

static int do_ncp_setprivatedata(unsigned int fd, unsigned int cmd, unsigned long arg){	struct ncp_privatedata_ioctl_32 n32;	struct ncp_privatedata_ioctl n;	mm_segment_t old_fs;	int err;	size_t tl;	if (copy_from_user(&n32, (struct ncp_privatedata_ioctl_32*)arg,	    sizeof(n32)))		return -EFAULT;	n.len = tl = n32.len;	if (tl) {		n.data = kmalloc(tl, GFP_KERNEL);		if (!n.data)			return -ENOMEM;		err = -EFAULT;		if (copy_from_user(n.data, (void *)A(n32.data), tl))			goto out;	} else {		n.data = NULL;	}		old_fs = get_fs(); set_fs (KERNEL_DS);	err = sys_ioctl (fd, NCP_IOC_SETPRIVATEDATA, (unsigned long)&n);	set_fs (old_fs);		 out:	if (n.data)		kfree(n.data);	return err;}

static int do_ncp_setobjectname(unsigned int fd, unsigned int cmd, unsigned long arg){	struct ncp_objectname_ioctl_32 n32;	struct ncp_objectname_ioctl n;	mm_segment_t old_fs;	int err;	size_t tl;	if (copy_from_user(&n32, (struct ncp_objectname_ioctl_32*)arg,	    sizeof(n32)))		return -EFAULT;	n.auth_type = n32.auth_type;	n.object_name_len = tl = n32.object_name_len;	if (tl) {		n.object_name = kmalloc(tl, GFP_KERNEL);		if (!n.object_name)			return -ENOMEM;		err = -EFAULT;		if (copy_from_user(n.object_name, (void *)A(n32.object_name), tl))			goto out;	} else {		n.object_name = NULL;	}		old_fs = get_fs(); set_fs (KERNEL_DS);	err = sys_ioctl (fd, NCP_IOC_SETOBJECTNAME, (unsigned long)&n);	set_fs (old_fs);		 out:	if (n.object_name)		kfree(n.object_name);	return err;}

static int do_ncp_getfsinfo2(unsigned int fd, unsigned int cmd, unsigned long arg){	mm_segment_t old_fs = get_fs();	struct ncp_fs_info_v2_32 n32;	struct ncp_fs_info_v2 n;	int err;	if (copy_from_user(&n32, (struct ncp_fs_info_v2_32*)arg, sizeof(n32)))		return -EFAULT;	if (n32.version != NCP_GET_FS_INFO_VERSION_V2)		return -EINVAL;	n.version = NCP_GET_FS_INFO_VERSION_V2;	set_fs(KERNEL_DS);	err = sys_ioctl(fd, NCP_IOC_GET_FS_INFO_V2, (unsigned long)&n);	set_fs(old_fs);	if (!err) {		n32.version = n.version;		n32.mounted_uid = n.mounted_uid;		n32.connection = n.connection;		n32.buffer_size = n.buffer_size;		n32.volume_number = n.volume_number;		n32.directory_id = n.directory_id;		n32.dummy1 = n.dummy1;		n32.dummy2 = n.dummy2;		n32.dummy3 = n.dummy3;		err = copy_to_user((struct ncp_fs_info_v2_32*)arg, &n32, sizeof(n32)) ? -EFAULT : 0;	}	return err;}

static int blkpg_ioctl_trans(unsigned int fd, unsigned int cmd,			     unsigned long uarg, struct file *f){	struct blkpg_ioctl_arg a;	struct blkpg_partition p;	struct blkpg_ioctl_arg32 *arg = (void*)A(uarg);	int err;	mm_segment_t old_fs = get_fs();		err = get_user(a.op, &arg->op);	err |= __get_user(a.flags, &arg->flags);	err |= __get_user(a.datalen, &arg->datalen);	err |= __get_user((long)a.data, &arg->data);	if (err) return err;	switch (a.op) {	case BLKPG_ADD_PARTITION:	case BLKPG_DEL_PARTITION:		if (a.datalen < sizeof(struct blkpg_partition))			return -EINVAL;                if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))			return -EFAULT;		a.data = &p;		set_fs (KERNEL_DS);		err = sys_ioctl(fd, cmd, (unsigned long)&a);		set_fs (old_fs);	default:		return -EINVAL;	}                                        	return err;}

static intosf1_ioctl_i(struct lwp *l, const struct sys_ioctl_args *uap, register_t *retval, int cmd, int dir, int len){	switch (cmd) {	case 12:			/* OSF/1 SIOCSIFADDR */	case 14:			/* OSF/1 SIOCSIFDSTADDR */	case 16:			/* OSF/1 SIOCSIFFLAGS (XXX) */	case 17:			/* OSF/1 SIOCGIFFLAGS (XXX) */	case 19:			/* OSF/1 SIOCSIFBRDADDR */	case 22:			/* OSF/1 SIOCSIFNETMASK */	case 23:			/* OSF/1 SIOCGIFMETRIC */	case 24:			/* OSF/1 SIOCSIFMETRIC */	case 25:			/* OSF/1 SIOCDIFADDR */	case 33:			/* OSF/1 SIOCGIFADDR */	case 34:			/* OSF/1 SIOCGIFDSTADDR */	case 35:			/* OSF/1 SIOCGIFBRDADDR */	case 37:			/* OSF/1 SIOCGIFNETMASK */		/* same as in NetBSD */		break;	default:		return (ENOTTY);	}	return sys_ioctl(l, uap, retval);}

static intosf1_ioctl_t(struct lwp *l, const struct sys_ioctl_args *uap, register_t *retval, int cmd, int dir, int len){	switch (cmd) {#ifdef COMPAT_43	case 8:				/* OSF/1 COMPAT_43 TIOCGETP (XXX) */	case 9:				/* OSF/1 COMPAT_43 TIOCSETP (XXX) */#endif	case 19:			/* OSF/1 TIOCGETA (XXX) */	case 20:			/* OSF/1 TIOCSETA (XXX) */	case 21:			/* OSF/1 TIOCSETAW (XXX) */	case 22:			/* OSF/1 TIOCSETAF (XXX) */	case 26:			/* OSF/1 TIOCGETD (XXX) */	case 27:			/* OSF/1 TIOCSETD (XXX) */	case 97:			/* OSF/1 TIOCSCTTY */	case 103:			/* OSF/1 TIOCSWINSZ */	case 104:			/* OSF/1 TIOCGWINSZ */		/* same as in NetBSD */		break;	default:		return (ENOTTY);	}	return sys_ioctl(l, uap, retval);}

static int drm32_free_bufs(unsigned int fd, unsigned int cmd, unsigned long arg){	drm32_buf_free_t __user *uarg = (drm32_buf_free_t __user *)arg;	drm_buf_free_t karg;	mm_segment_t old_fs;	int __user *ulist;	int ret;	u32 tmp;	if (get_user(karg.count, &uarg->count) ||	    get_user(tmp, &uarg->list))		return -EFAULT;	ulist = A(tmp);	karg.list = kmalloc(karg.count * sizeof(int), GFP_KERNEL);	if (!karg.list)		return -ENOMEM;	ret = -EFAULT;	if (copy_from_user(karg.list, ulist, (karg.count * sizeof(int))))		goto out;	old_fs = get_fs();	set_fs(KERNEL_DS);	ret = sys_ioctl(fd, DRM_IOCTL_FREE_BUFS, (unsigned long) &karg);	set_fs(old_fs);out:	kfree(karg.list);	return ret;}

int hpux_ioctl(int fd, unsigned long cmd, unsigned long arg){	int result = -EOPNOTSUPP;	int type = _IOC_TYPE(cmd);	switch (type) {	case 'T':		/* Our structures are now compatible with HPUX's */		result = sys_ioctl(fd, cmd, arg);		break;	case 't':		result = hpux_ioctl_t(fd, cmd, arg);		break;	default:		/* If my mother ever sees this, I hope she disowns me.		 * Take this out after NYLWE. */		result = sys_ioctl(fd, cmd, arg);	}	return result;}

static int do_ext2_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg){	/* These are just misnamed, they actually get/put from/to user an int */	switch (cmd) {	case EXT2_IOC32_GETFLAGS: cmd = EXT2_IOC_GETFLAGS; break;	case EXT2_IOC32_SETFLAGS: cmd = EXT2_IOC_SETFLAGS; break;	case EXT2_IOC32_GETVERSION: cmd = EXT2_IOC_GETVERSION; break;	case EXT2_IOC32_SETVERSION: cmd = EXT2_IOC_SETVERSION; break;	}	return sys_ioctl(fd, cmd, arg);}

static inline int solaris_s(unsigned int fd, unsigned int cmd, u32 arg){	switch (cmd & 0xff) {	case 0: /* SIOCSHIWAT */	case 2: /* SIOCSLOWAT */		return 0; /* We don't support them */	case 1: /* SIOCGHIWAT */	case 3: /* SIOCGLOWAT */		if (put_user (0, (u32 *)A(arg)))			return -EFAULT;		return 0; /* Lie */	case 7: /* SIOCATMARK */		return sys_ioctl(fd, SIOCATMARK, arg);	case 8: /* SIOCSPGRP */		return sys_ioctl(fd, SIOCSPGRP, arg);	case 9: /* SIOCGPGRP */		return sys_ioctl(fd, SIOCGPGRP, arg);	}	return -ENOSYS;}

static inline int tty_ioctl(int fd, int cmd, int *arg){	int ret;	ret = sys_ioctl(fd, cmd, (unsigned long)arg);	if (ret < 0) {		if (ret != -ENOTTY)			return ret;		*arg = 0;	}	return 0;}

static void initialise_window (){#if defined(have_sys_ioctl) && defined(TIOCGWINSZ)    struct winsize size;    if (sys_ioctl (0, TIOCGWINSZ, (long)&size) == 0)    {        width  = size.ws_col;        height = size.ws_row;    }#endif}

linux_ioctl_rtc(struct proc *p, struct linux_ioctl_args *args)#endif{	switch (args->cmd & 0xffff) {	case LINUX_RTC_PIE_ON:		args->cmd=RTCIO_PIE_ON;#if __FreeBSD_version >= 900044		return sys_ioctl(p, (struct ioctl_args*)args);#else		return ioctl(p, (struct ioctl_args*)args);	#endif	case LINUX_RTC_IRQP_SET:		args->cmd=RTCIO_IRQP_SET;#if __FreeBSD_version >= 900044		return sys_ioctl(p, (struct ioctl_args*)args);#else		return ioctl(p, (struct ioctl_args*)args);	#endif	}	return (ENOIOCTL);}