static int freebsd32_ioctl_ioc_read_toc(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct ioc_read_toc_entry toce; struct ioc_read_toc_entry32 toce32; int error; if ((error = copyin(uap->data, &toce32, sizeof(toce32)))) return (error); CP(toce32, toce, address_format); CP(toce32, toce, starting_track); CP(toce32, toce, data_len); PTRIN_CP(toce32, toce, data); if ((error = fo_ioctl(fp, CDIOREADTOCENTRYS, (caddr_t)&toce, td->td_ucred, td))) { CP(toce, toce32, address_format); CP(toce, toce32, starting_track); CP(toce, toce32, data_len); PTROUT_CP(toce, toce32, data); error = copyout(&toce32, uap->data, sizeof(toce32)); } return error; }
static int aacraid_linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { struct file *fp; #if __FreeBSD_version >= 900000 cap_rights_t rights; #endif u_long cmd; int error; if ((error = fget(td, args->fd, #if __FreeBSD_version >= 900000 cap_rights_init(&rights, CAP_IOCTL), #endif &fp)) != 0) { return (error); } cmd = args->cmd; /* * Pass the ioctl off to our standard handler. */ error = (fo_ioctl(fp, cmd, (caddr_t)args->arg, td->td_ucred, td)); fdrop(fp, td); return (error); }
static int ipmi_linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { cap_rights_t rights; struct file *fp; u_long cmd; int error; error = fget(td, args->fd, cap_rights_init(&rights, CAP_IOCTL), &fp); if (error != 0) return (error); cmd = args->cmd; switch(cmd) { case L_IPMICTL_GET_MY_ADDRESS_CMD: cmd = IPMICTL_GET_MY_ADDRESS_CMD; break; case L_IPMICTL_GET_MY_LUN_CMD: cmd = IPMICTL_GET_MY_LUN_CMD; break; } /* * Pass the ioctl off to our standard handler. */ error = (fo_ioctl(fp, cmd, (caddr_t)args->arg, td->td_ucred, td)); fdrop(fp, td); return (error); }
static int amr_linux_ioctl(struct thread *p, struct linux_ioctl_args *args) { cap_rights_t rights; struct file *fp; int error; error = fget(p, args->fd, cap_rights_init(&rights, CAP_IOCTL), &fp); if (error != 0) return (error); error = fo_ioctl(fp, args->cmd, (caddr_t)args->arg, p->td_ucred, p); fdrop(fp, p); return (error); }
static int aac_linux_ioctl(struct proc *p, struct linux_ioctl_args *args) { struct file *fp; u_long cmd; fp = p->p_fd->fd_ofiles[args->fd]; cmd = args->cmd; /* * Pass the ioctl off to our standard handler. */ return(fo_ioctl(fp, cmd, (caddr_t)args->arg, p)); }
static int freebsd32_ioctl_fiodgname(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct fiodgname_arg fgn; struct fiodgname_arg32 fgn32; int error; if ((error = copyin(uap->data, &fgn32, sizeof fgn32)) != 0) return (error); CP(fgn32, fgn, len); PTRIN_CP(fgn32, fgn, buf); error = fo_ioctl(fp, FIODGNAME, (caddr_t)&fgn, td->td_ucred, td); return (error); }
static int freebsd32_ioctl_ioc_toc_header(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct ioc_toc_header toch; struct ioc_toc_header32 toch32; int error; if ((error = copyin(uap->data, &toch32, sizeof(toch32)))) return (error); CP(toch32, toch, len); CP(toch32, toch, starting_track); CP(toch32, toch, ending_track); error = fo_ioctl(fp, CDIOREADTOCHEADER, (caddr_t)&toch, td->td_ucred, td); return (error); }
static int aac_linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { struct file *fp; u_long cmd; int error; if ((error = fget(td, args->fd, CAP_IOCTL, &fp)) != 0) return (error); cmd = args->cmd; /* * Pass the ioctl off to our standard handler. */ error = (fo_ioctl(fp, cmd, (caddr_t)args->arg, td->td_ucred, td)); fdrop(fp, td); return (error); }
int sys_socket(struct thread *td, struct socket_args *uap) { struct socket *so; struct file *fp; int fd, error, type, oflag, fflag; AUDIT_ARG_SOCKET(uap->domain, uap->type, uap->protocol); type = uap->type; oflag = 0; fflag = 0; if ((type & SOCK_CLOEXEC) != 0) { type &= ~SOCK_CLOEXEC; oflag |= O_CLOEXEC; } if ((type & SOCK_NONBLOCK) != 0) { type &= ~SOCK_NONBLOCK; fflag |= FNONBLOCK; } #ifdef MAC error = mac_socket_check_create(td->td_ucred, uap->domain, type, uap->protocol); if (error != 0) return (error); #endif error = falloc(td, &fp, &fd, oflag); if (error != 0) return (error); /* An extra reference on `fp' has been held for us by falloc(). */ error = socreate(uap->domain, &so, type, uap->protocol, td->td_ucred, td); if (error != 0) { fdclose(td, fp, fd); } else { finit(fp, FREAD | FWRITE | fflag, DTYPE_SOCKET, so, &socketops); if ((fflag & FNONBLOCK) != 0) (void) fo_ioctl(fp, FIONBIO, &fflag, td->td_ucred, td); td->td_retval[0] = fd; } fdrop(fp, td); return (error); }
static int sgx_linux_ioctl(struct thread *td, struct linux_ioctl_args *args) { uint8_t data[SGX_IOCTL_MAX_DATA_LEN]; cap_rights_t rights; struct file *fp; u_long cmd; int error; int len; error = fget(td, args->fd, cap_rights_init(&rights, CAP_IOCTL), &fp); if (error != 0) return (error); cmd = args->cmd; args->cmd &= ~(LINUX_IOC_IN | LINUX_IOC_OUT); if (cmd & LINUX_IOC_IN) args->cmd |= IOC_IN; if (cmd & LINUX_IOC_OUT) args->cmd |= IOC_OUT; len = IOCPARM_LEN(cmd); if (len > SGX_IOCTL_MAX_DATA_LEN) { printf("%s: Can't copy data: cmd len is too big %d\n", __func__, len); return (EINVAL); } if (cmd & LINUX_IOC_IN) { error = copyin((void *)args->arg, data, len); if (error) { printf("%s: Can't copy data, error %d\n", __func__, error); return (EINVAL); } } error = (fo_ioctl(fp, args->cmd, (caddr_t)data, td->td_ucred, td)); fdrop(fp, td); return (error); }
static int freebsd32_ioctl_memrange(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct mem_range_op mro; struct mem_range_op32 mro32; int error; u_long com; if ((error = copyin(uap->data, &mro32, sizeof(mro32))) != 0) return (error); PTRIN_CP(mro32, mro, mo_desc); CP(mro32, mro, mo_arg[0]); CP(mro32, mro, mo_arg[1]); com = 0; switch (uap->com) { case MEMRANGE_GET32: com = MEMRANGE_GET; break; case MEMRANGE_SET32: com = MEMRANGE_SET; break; default: panic("%s: unknown MEMRANGE %#x", __func__, uap->com); } if ((error = fo_ioctl(fp, com, (caddr_t)&mro, td->td_ucred, td)) != 0) return (error); if ( (com & IOC_OUT) ) { CP(mro, mro32, mo_arg[0]); CP(mro, mro32, mo_arg[1]); error = copyout(&mro32, uap->data, sizeof(mro32)); } return (error); }
/* * Linux emulation IOCTL for /dev/tdfx */ static int linux_ioctl_tdfx(struct thread *td, struct linux_ioctl_args* args) { int error = 0; u_long cmd = args->cmd & 0xffff; /* The structure passed to ioctl has two shorts, one int and one void*. */ char d_pio[2*sizeof(short) + sizeof(int) + sizeof(void*)]; struct file *fp; if ((error = fget(td, args->fd, &fp)) != 0) return (error); /* We simply copy the data and send it right to ioctl */ copyin((caddr_t)args->arg, &d_pio, sizeof(d_pio)); error = fo_ioctl(fp, cmd, (caddr_t)&d_pio, td->td_ucred, td); fdrop(fp, td); return error; }
static int mfi_linux_ioctl(d_thread_t *p, struct linux_ioctl_args *args) { struct file *fp; int error; u_long cmd = args->cmd; switch (cmd) { case MFI_LINUX_CMD: cmd = MFI_LINUX_CMD_2; break; case MFI_LINUX_SET_AEN: cmd = MFI_LINUX_SET_AEN_2; break; } if ((error = fget(p, args->fd, &fp)) != 0) return (error); error = fo_ioctl(fp, cmd, (caddr_t)args->arg, p->td_ucred, p); fdrop(fp, p); return (error); }
static int mfi_linux_ioctl(struct thread *p, struct linux_ioctl_args *args) { cap_rights_t rights; struct file *fp; int error; u_long cmd = args->cmd; switch (cmd) { case MFI_LINUX_CMD: cmd = MFI_LINUX_CMD_2; break; case MFI_LINUX_SET_AEN: cmd = MFI_LINUX_SET_AEN_2; break; } error = fget(p, args->fd, cap_rights_init(&rights, CAP_IOCTL), &fp); if (error != 0) return (error); error = fo_ioctl(fp, cmd, (caddr_t)args->arg, p->td_ucred, p); fdrop(fp, p); return (error); }
static int linux_common_open(struct thread *td, int dirfd, char *path, int l_flags, int mode) { cap_rights_t rights; struct proc *p = td->td_proc; struct file *fp; int fd; int bsd_flags, error; bsd_flags = 0; switch (l_flags & LINUX_O_ACCMODE) { case LINUX_O_WRONLY: bsd_flags |= O_WRONLY; break; case LINUX_O_RDWR: bsd_flags |= O_RDWR; break; default: bsd_flags |= O_RDONLY; } if (l_flags & LINUX_O_NDELAY) bsd_flags |= O_NONBLOCK; if (l_flags & LINUX_O_APPEND) bsd_flags |= O_APPEND; if (l_flags & LINUX_O_SYNC) bsd_flags |= O_FSYNC; if (l_flags & LINUX_O_NONBLOCK) bsd_flags |= O_NONBLOCK; if (l_flags & LINUX_FASYNC) bsd_flags |= O_ASYNC; if (l_flags & LINUX_O_CREAT) bsd_flags |= O_CREAT; if (l_flags & LINUX_O_TRUNC) bsd_flags |= O_TRUNC; if (l_flags & LINUX_O_EXCL) bsd_flags |= O_EXCL; if (l_flags & LINUX_O_NOCTTY) bsd_flags |= O_NOCTTY; if (l_flags & LINUX_O_DIRECT) bsd_flags |= O_DIRECT; if (l_flags & LINUX_O_NOFOLLOW) bsd_flags |= O_NOFOLLOW; if (l_flags & LINUX_O_DIRECTORY) bsd_flags |= O_DIRECTORY; /* XXX LINUX_O_NOATIME: unable to be easily implemented. */ error = kern_openat(td, dirfd, path, UIO_SYSSPACE, bsd_flags, mode); if (error != 0) goto done; if (bsd_flags & O_NOCTTY) goto done; /* * XXX In between kern_open() and fget(), another process * having the same filedesc could use that fd without * checking below. */ fd = td->td_retval[0]; if (fget(td, fd, cap_rights_init(&rights, CAP_IOCTL), &fp) == 0) { if (fp->f_type != DTYPE_VNODE) { fdrop(fp, td); goto done; } sx_slock(&proctree_lock); PROC_LOCK(p); if (SESS_LEADER(p) && !(p->p_flag & P_CONTROLT)) { PROC_UNLOCK(p); sx_sunlock(&proctree_lock); /* XXXPJD: Verify if TIOCSCTTY is allowed. */ (void) fo_ioctl(fp, TIOCSCTTY, (caddr_t) 0, td->td_ucred, td); } else { PROC_UNLOCK(p); sx_sunlock(&proctree_lock); } fdrop(fp, td); } done: #ifdef DEBUG if (ldebug(open)) printf(LMSG("open returns error %d"), error); #endif LFREEPATH(path); return (error); }
static int freebsd32_ioctl_md(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct md_ioctl mdv; struct md_ioctl32 md32; u_long com = 0; int i, error; if (uap->com & IOC_IN) { if ((error = copyin(uap->data, &md32, sizeof(md32)))) { return (error); } CP(md32, mdv, md_version); CP(md32, mdv, md_unit); CP(md32, mdv, md_type); PTRIN_CP(md32, mdv, md_file); CP(md32, mdv, md_mediasize); CP(md32, mdv, md_sectorsize); CP(md32, mdv, md_options); CP(md32, mdv, md_base); CP(md32, mdv, md_fwheads); CP(md32, mdv, md_fwsectors); } else if (uap->com & IOC_OUT) { /* * Zero the buffer so the user always * gets back something deterministic. */ bzero(&mdv, sizeof mdv); } switch (uap->com) { case MDIOCATTACH_32: com = MDIOCATTACH; break; case MDIOCDETACH_32: com = MDIOCDETACH; break; case MDIOCQUERY_32: com = MDIOCQUERY; break; case MDIOCLIST_32: com = MDIOCLIST; break; default: panic("%s: unknown MDIOC %#x", __func__, uap->com); } error = fo_ioctl(fp, com, (caddr_t)&mdv, td->td_ucred, td); if (error == 0 && (com & IOC_OUT)) { CP(mdv, md32, md_version); CP(mdv, md32, md_unit); CP(mdv, md32, md_type); PTROUT_CP(mdv, md32, md_file); CP(mdv, md32, md_mediasize); CP(mdv, md32, md_sectorsize); CP(mdv, md32, md_options); CP(mdv, md32, md_base); CP(mdv, md32, md_fwheads); CP(mdv, md32, md_fwsectors); if (com == MDIOCLIST) { /* * Use MDNPAD, and not MDNPAD32. Padding is * allocated and used by compat32 ABI. */ for (i = 0; i < MDNPAD; i++) CP(mdv, md32, md_pad[i]); } error = copyout(&md32, uap->data, sizeof(md32)); } return error; }
static int freebsd32_ioctl_sg(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct sg_io_hdr io; struct sg_io_hdr32 io32; int error; if ((error = copyin(uap->data, &io32, sizeof(io32))) != 0) return (error); CP(io32, io, interface_id); CP(io32, io, dxfer_direction); CP(io32, io, cmd_len); CP(io32, io, mx_sb_len); CP(io32, io, iovec_count); CP(io32, io, dxfer_len); PTRIN_CP(io32, io, dxferp); PTRIN_CP(io32, io, cmdp); PTRIN_CP(io32, io, sbp); CP(io32, io, timeout); CP(io32, io, flags); CP(io32, io, pack_id); PTRIN_CP(io32, io, usr_ptr); CP(io32, io, status); CP(io32, io, masked_status); CP(io32, io, msg_status); CP(io32, io, sb_len_wr); CP(io32, io, host_status); CP(io32, io, driver_status); CP(io32, io, resid); CP(io32, io, duration); CP(io32, io, info); if ((error = fo_ioctl(fp, SG_IO, (caddr_t)&io, td->td_ucred, td)) != 0) return (error); CP(io, io32, interface_id); CP(io, io32, dxfer_direction); CP(io, io32, cmd_len); CP(io, io32, mx_sb_len); CP(io, io32, iovec_count); CP(io, io32, dxfer_len); PTROUT_CP(io, io32, dxferp); PTROUT_CP(io, io32, cmdp); PTROUT_CP(io, io32, sbp); CP(io, io32, timeout); CP(io, io32, flags); CP(io, io32, pack_id); PTROUT_CP(io, io32, usr_ptr); CP(io, io32, status); CP(io, io32, masked_status); CP(io, io32, msg_status); CP(io, io32, sb_len_wr); CP(io, io32, host_status); CP(io, io32, driver_status); CP(io, io32, resid); CP(io, io32, duration); CP(io, io32, info); error = copyout(&io32, uap->data, sizeof(io32)); return (error); }
static int freebsd32_ioctl_pciocgetconf(struct thread *td, struct freebsd32_ioctl_args *uap, struct file *fp) { struct pci_conf_io pci; struct pci_conf_io32 pci32; struct pci_match_conf32 pmc32; struct pci_match_conf32 *pmc32p; struct pci_match_conf pmc; struct pci_match_conf *pmcp; struct pci_conf32 pc32; struct pci_conf32 *pc32p; struct pci_conf pc; struct pci_conf *pcp; u_int32_t i; u_int32_t npat_to_convert; u_int32_t nmatch_to_convert; vm_offset_t addr; int error; if ((error = copyin(uap->data, &pci32, sizeof(pci32))) != 0) return (error); CP(pci32, pci, num_patterns); CP(pci32, pci, offset); CP(pci32, pci, generation); npat_to_convert = pci32.pat_buf_len / sizeof(struct pci_match_conf32); pci.pat_buf_len = npat_to_convert * sizeof(struct pci_match_conf); pci.patterns = NULL; nmatch_to_convert = pci32.match_buf_len / sizeof(struct pci_conf32); pci.match_buf_len = nmatch_to_convert * sizeof(struct pci_conf); pci.matches = NULL; if ((error = copyout_map(td, &addr, pci.pat_buf_len)) != 0) goto cleanup; pci.patterns = (struct pci_match_conf *)addr; if ((error = copyout_map(td, &addr, pci.match_buf_len)) != 0) goto cleanup; pci.matches = (struct pci_conf *)addr; npat_to_convert = min(npat_to_convert, pci.num_patterns); for (i = 0, pmc32p = (struct pci_match_conf32 *)PTRIN(pci32.patterns), pmcp = pci.patterns; i < npat_to_convert; i++, pmc32p++, pmcp++) { if ((error = copyin(pmc32p, &pmc32, sizeof(pmc32))) != 0) goto cleanup; CP(pmc32,pmc,pc_sel); strlcpy(pmc.pd_name, pmc32.pd_name, sizeof(pmc.pd_name)); CP(pmc32,pmc,pd_unit); CP(pmc32,pmc,pc_vendor); CP(pmc32,pmc,pc_device); CP(pmc32,pmc,pc_class); CP(pmc32,pmc,flags); if ((error = copyout(&pmc, pmcp, sizeof(pmc))) != 0) goto cleanup; } if ((error = fo_ioctl(fp, PCIOCGETCONF, (caddr_t)&pci, td->td_ucred, td)) != 0) goto cleanup; nmatch_to_convert = min(nmatch_to_convert, pci.num_matches); for (i = 0, pcp = pci.matches, pc32p = (struct pci_conf32 *)PTRIN(pci32.matches); i < nmatch_to_convert; i++, pcp++, pc32p++) { if ((error = copyin(pcp, &pc, sizeof(pc))) != 0) goto cleanup; CP(pc,pc32,pc_sel); CP(pc,pc32,pc_hdr); CP(pc,pc32,pc_subvendor); CP(pc,pc32,pc_subdevice); CP(pc,pc32,pc_vendor); CP(pc,pc32,pc_device); CP(pc,pc32,pc_class); CP(pc,pc32,pc_subclass); CP(pc,pc32,pc_progif); CP(pc,pc32,pc_revid); strlcpy(pc32.pd_name, pc.pd_name, sizeof(pc32.pd_name)); CP(pc,pc32,pd_unit); if ((error = copyout(&pc32, pc32p, sizeof(pc32))) != 0) goto cleanup; } CP(pci, pci32, num_matches); CP(pci, pci32, offset); CP(pci, pci32, generation); CP(pci, pci32, status); error = copyout(&pci32, uap->data, sizeof(pci32)); cleanup: if (pci.patterns) copyout_unmap(td, (vm_offset_t)pci.patterns, pci.pat_buf_len); if (pci.matches) copyout_unmap(td, (vm_offset_t)pci.matches, pci.match_buf_len); return (error); }