/* * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * The contents of this file constitute Original Code as defined in and * are subject to the Apple Public Source License Version 1.1 (the * "License"). You may not use this file except in compliance with the * License. Please obtain a copy of the License at * http://www.apple.com/publicsource and read it before using this file. * * This Original Code and all software distributed under the License are * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the * License for the specific language governing rights and limitations * under the License. * * @APPLE_LICENSE_HEADER_END@ */ /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */ /* * Copyright (c) 1982, 1986, 1989, 1993 * The Regents of the University of California. All rights reserved. * (c) UNIX System Laboratories, Inc. * All or some portions of this file are derived from material licensed * to the University of California by American Telephone and Telegraph * Co. or Unix System Laboratories, Inc. and are reproduced herein with * the permission of UNIX System Laboratories, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)vfs_vnops.c 8.14 (Berkeley) 6/15/95 * */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static int vn_closefile(struct fileglob *fp, struct proc *p); static int vn_ioctl(struct fileproc *fp, u_long com, caddr_t data, struct proc *p); static int vn_read(struct fileproc *fp, struct uio *uio, kauth_cred_t cred, int flags, struct proc *p); static int vn_write(struct fileproc *fp, struct uio *uio, kauth_cred_t cred, int flags, struct proc *p); static int vn_select( struct fileproc *fp, int which, void * wql, struct proc *p); static int vn_kqfilt_add(struct fileproc *fp, struct knote *kn, struct proc *p); #if 0 static int vn_kqfilt_remove(struct vnode *vp, uintptr_t ident, struct proc *p); #endif struct fileops vnops = { vn_read, vn_write, vn_ioctl, vn_select, vn_closefile, vn_kqfilt_add, 0 }; /* * Common code for vnode open operations. * Check permissions, and call the VNOP_OPEN or VNOP_CREATE routine. * * XXX the profusion of interfaces here is probably a bad thing. */ int vn_open(struct nameidata *ndp, int fmode, int cmode) { return(vn_open_modflags(ndp, &fmode, cmode)); } int vn_open_modflags(struct nameidata *ndp, int *fmodep, int cmode) { struct vnode_attr va; VATTR_INIT(&va); VATTR_SET(&va, va_mode, cmode); return(vn_open_auth(ndp, fmodep, &va)); } int vn_open_auth(struct nameidata *ndp, int *fmodep, struct vnode_attr *vap) { struct vnode *vp; struct vnode *dvp; vfs_context_t ctx = ndp->ni_cnd.cn_context; int error; int fmode; kauth_action_t action; again: vp = NULL; dvp = NULL; fmode = *fmodep; if (fmode & O_CREAT) { ndp->ni_cnd.cn_nameiop = CREATE; ndp->ni_cnd.cn_flags = LOCKPARENT | LOCKLEAF | AUDITVNPATH1; if ((fmode & O_EXCL) == 0) ndp->ni_cnd.cn_flags |= FOLLOW; if ( (error = namei(ndp)) ) goto out; dvp = ndp->ni_dvp; vp = ndp->ni_vp; /* not found, create */ if (vp == NULL) { /* must have attributes for a new file */ if (vap == NULL) { error = EINVAL; goto badcreate; } /* authorize before creating */ if ((error = vnode_authorize(dvp, NULL, KAUTH_VNODE_ADD_FILE, ctx)) != 0) goto badcreate; VATTR_SET(vap, va_type, VREG); if (fmode & O_EXCL) vap->va_vaflags |= VA_EXCLUSIVE; if ((error = vn_create(dvp, &ndp->ni_vp, &ndp->ni_cnd, vap, 0, ctx)) != 0) goto badcreate; vp = ndp->ni_vp; if (vp) { int update_flags = 0; // Make sure the name & parent pointers are hooked up if (vp->v_name == NULL) update_flags |= VNODE_UPDATE_NAME; if (vp->v_parent == NULLVP) update_flags |= VNODE_UPDATE_PARENT; if (update_flags) vnode_update_identity(vp, dvp, ndp->ni_cnd.cn_nameptr, ndp->ni_cnd.cn_namelen, ndp->ni_cnd.cn_hash, update_flags); if (need_fsevent(FSE_CREATE_FILE, vp)) { add_fsevent(FSE_CREATE_FILE, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE); } } /* * nameidone has to happen before we vnode_put(dvp) * and clear the ni_dvp field, since it may need * to release the fs_nodelock on the dvp */ badcreate: nameidone(ndp); ndp->ni_dvp = NULL; vnode_put(dvp); if (error) { /* * Check for a creation race. */ if ((error == EEXIST) && !(fmode & O_EXCL)) { goto again; } goto bad; } fmode &= ~O_TRUNC; } else { nameidone(ndp); ndp->ni_dvp = NULL; vnode_put(dvp); if (fmode & O_EXCL) { error = EEXIST; goto bad; } fmode &= ~O_CREAT; } } else { ndp->ni_cnd.cn_nameiop = LOOKUP; ndp->ni_cnd.cn_flags = FOLLOW | LOCKLEAF | AUDITVNPATH1; if ( (error = namei(ndp)) ) goto out; vp = ndp->ni_vp; nameidone(ndp); ndp->ni_dvp = NULL; } if (vp->v_type == VSOCK && vp->v_tag != VT_FDESC) { error = EOPNOTSUPP; /* Operation not supported on socket */ goto bad; } #if DIAGNOSTIC if (UBCINFOMISSING(vp)) panic("vn_open: ubc_info_init"); #endif /* DIAGNOSTIC */ /* authorize open of an existing file */ if ((fmode & O_CREAT) == 0) { /* disallow write operations on directories */ if (vnode_isdir(vp) && (fmode & (FWRITE | O_TRUNC))) { error = EISDIR; goto bad; } /* compute action to be authorized */ action = 0; if (fmode & FREAD) action |= KAUTH_VNODE_READ_DATA; if (fmode & (FWRITE | O_TRUNC)) action |= KAUTH_VNODE_WRITE_DATA; if ((error = vnode_authorize(vp, NULL, action, ctx)) != 0) goto bad; } if ( (error = VNOP_OPEN(vp, fmode, ctx)) ) { goto bad; } if ( (error = vnode_ref_ext(vp, fmode)) ) goto bad; /* call out to allow 3rd party notification of open. * Ignore result of kauth_authorize_fileop call. */ kauth_authorize_fileop(vfs_context_ucred(ctx), KAUTH_FILEOP_OPEN, (uintptr_t)vp, 0); *fmodep = fmode; return (0); bad: ndp->ni_vp = NULL; if (vp) { vnode_put(vp); /* * Check for a race against unlink. We had a vnode * but according to vnode_authorize or VNOP_OPEN it * no longer exists. */ if ((error == ENOENT) && (*fmodep & O_CREAT)) { goto again; } } out: return (error); } /* * Authorize an action against a vnode. This has been the canonical way to * ensure that the credential/process/etc. referenced by a vfs_context * is granted the rights called out in 'mode' against the vnode 'vp'. * * Unfortunately, the use of VREAD/VWRITE/VEXEC makes it very difficult * to add support for more rights. As such, this interface will be deprecated * and callers will use vnode_authorize instead. */ #warning vn_access is deprecated int vn_access(vnode_t vp, int mode, vfs_context_t context) { kauth_action_t action; action = 0; if (mode & VREAD) action |= KAUTH_VNODE_READ_DATA; if (mode & VWRITE) action |= KAUTH_VNODE_WRITE_DATA; if (mode & VEXEC) action |= KAUTH_VNODE_EXECUTE; return(vnode_authorize(vp, NULL, action, context)); } /* * Vnode close call */ int vn_close(struct vnode *vp, int flags, kauth_cred_t cred, struct proc *p) { struct vfs_context context; int error; context.vc_proc = p; context.vc_ucred = cred; if (flags & FWASWRITTEN) { if (need_fsevent(FSE_CONTENT_MODIFIED, vp)) { add_fsevent(FSE_CONTENT_MODIFIED, &context, FSE_ARG_VNODE, vp, FSE_ARG_DONE); } } error = VNOP_CLOSE(vp, flags, &context); (void)vnode_rele_ext(vp, flags, 0); return (error); } static int vn_read_swapfile( struct vnode *vp, uio_t uio) { static char *swap_read_zero_page = NULL; int error; off_t swap_count, this_count; off_t file_end, read_end; off_t prev_resid; /* * Reading from a swap file will get you all zeroes. */ error = 0; swap_count = uio_resid(uio); file_end = ubc_getsize(vp); read_end = uio->uio_offset + uio_resid(uio); if (uio->uio_offset >= file_end) { /* uio starts after end of file: nothing to read */ swap_count = 0; } else if (read_end > file_end) { /* uio extends beyond end of file: stop before that */ swap_count -= (read_end - file_end); } while (swap_count > 0) { if (swap_read_zero_page == NULL) { char *my_zero_page; int funnel_state; /* * Take kernel funnel so that only one thread * sets up "swap_read_zero_page". */ funnel_state = thread_funnel_set(kernel_flock, TRUE); if (swap_read_zero_page == NULL) { MALLOC(my_zero_page, char *, PAGE_SIZE, M_TEMP, M_WAITOK); memset(my_zero_page, '?', PAGE_SIZE); /* * Adding a newline character here * and there prevents "less(1)", for * example, from getting too confused * about a file with one really really * long line. */ my_zero_page[PAGE_SIZE-1] = '\n'; if (swap_read_zero_page == NULL) { swap_read_zero_page = my_zero_page; } else { FREE(my_zero_page, M_TEMP); } } else { /* * Someone else raced us here and won; * just use their page. */ } thread_funnel_set(kernel_flock, funnel_state); } this_count = swap_count; if (this_count > PAGE_SIZE) { this_count = PAGE_SIZE; } prev_resid = uio_resid(uio); error = uiomove((caddr_t) swap_read_zero_page, this_count, uio); if (error) { break; } swap_count -= (prev_resid - uio_resid(uio)); } return error; } /* * Package up an I/O request on a vnode into a uio and do it. */ int vn_rdwr( enum uio_rw rw, struct vnode *vp, caddr_t base, int len, off_t offset, enum uio_seg segflg, int ioflg, kauth_cred_t cred, int *aresid, struct proc *p) { return vn_rdwr_64(rw, vp, (uint64_t)(uintptr_t)base, (int64_t)len, offset, segflg, ioflg, cred, aresid, p); } int vn_rdwr_64( enum uio_rw rw, struct vnode *vp, uint64_t base, int64_t len, off_t offset, enum uio_seg segflg, int ioflg, kauth_cred_t cred, int *aresid, struct proc *p) { uio_t auio; int spacetype; struct vfs_context context; int error=0; char uio_buf[ UIO_SIZEOF(1) ]; context.vc_proc = p; context.vc_ucred = cred; if (UIO_SEG_IS_USER_SPACE(segflg)) { spacetype = proc_is64bit(p) ? UIO_USERSPACE64 : UIO_USERSPACE32; } else { spacetype = UIO_SYSSPACE; } auio = uio_createwithbuffer(1, offset, spacetype, rw, &uio_buf[0], sizeof(uio_buf)); uio_addiov(auio, base, len); if (rw == UIO_READ) { if (vp->v_flag & VSWAP) { error = vn_read_swapfile(vp, auio); } else { error = VNOP_READ(vp, auio, ioflg, &context); } } else { error = VNOP_WRITE(vp, auio, ioflg, &context); } if (aresid) // LP64todo - fix this *aresid = uio_resid(auio); else if (uio_resid(auio) && error == 0) error = EIO; return (error); } /* * File table vnode read routine. */ static int vn_read(struct fileproc *fp, struct uio *uio, kauth_cred_t cred, int flags, struct proc *p) { struct vnode *vp; int error, ioflag; off_t count; struct vfs_context context; context.vc_proc = p; context.vc_ucred = cred; vp = (struct vnode *)fp->f_fglob->fg_data; if ( (error = vnode_getwithref(vp)) ) { return(error); } ioflag = 0; if (fp->f_fglob->fg_flag & FNONBLOCK) ioflag |= IO_NDELAY; if ((flags & FOF_OFFSET) == 0) uio->uio_offset = fp->f_fglob->fg_offset; count = uio_resid(uio); if (vp->v_flag & VSWAP) { /* special case for swap files */ error = vn_read_swapfile(vp, uio); } else { error = VNOP_READ(vp, uio, ioflag, &context); } if ((flags & FOF_OFFSET) == 0) fp->f_fglob->fg_offset += count - uio_resid(uio); (void)vnode_put(vp); return (error); } /* * File table vnode write routine. */ static int vn_write(struct fileproc *fp, struct uio *uio, kauth_cred_t cred, int flags, struct proc *p) { struct vnode *vp; int error, ioflag; off_t count; struct vfs_context context; context.vc_proc = p; context.vc_ucred = cred; count = 0; vp = (struct vnode *)fp->f_fglob->fg_data; if ( (error = vnode_getwithref(vp)) ) { return(error); } ioflag = IO_UNIT; if (vp->v_type == VREG && (fp->f_fglob->fg_flag & O_APPEND)) ioflag |= IO_APPEND; if (fp->f_fglob->fg_flag & FNONBLOCK) ioflag |= IO_NDELAY; if ((fp->f_fglob->fg_flag & O_FSYNC) || (vp->v_mount && (vp->v_mount->mnt_flag & MNT_SYNCHRONOUS))) ioflag |= IO_SYNC; if ((flags & FOF_OFFSET) == 0) { uio->uio_offset = fp->f_fglob->fg_offset; count = uio_resid(uio); } if (p && (vp->v_type == VREG) && (((uio->uio_offset + uio_uio_resid(uio)) > p->p_rlimit[RLIMIT_FSIZE].rlim_cur) || (uio_uio_resid(uio) > (p->p_rlimit[RLIMIT_FSIZE].rlim_cur - uio->uio_offset)))) { psignal(p, SIGXFSZ); vnode_put(vp); return (EFBIG); } error = VNOP_WRITE(vp, uio, ioflag, &context); if ((flags & FOF_OFFSET) == 0) { if (ioflag & IO_APPEND) fp->f_fglob->fg_offset = uio->uio_offset; else fp->f_fglob->fg_offset += count - uio_resid(uio); } /* * Set the credentials on successful writes */ if ((error == 0) && (vp->v_tag == VT_NFS) && (UBCINFOEXISTS(vp))) { /* * When called from aio subsystem, we only have the proc from * which to get the credential, at this point, so use that * instead. This means aio functions are incompatible with * per-thread credentials (aio operations are proxied). We * can't easily correct the aio vs. settid race in this case * anyway, so we disallow it. */ if ((flags & FOF_PCRED) == 0) { ubc_setthreadcred(vp, p, current_thread()); } else { ubc_setcred(vp, p); } } (void)vnode_put(vp); return (error); } /* * File table vnode stat routine. */ int vn_stat_noauth(struct vnode *vp, struct stat *sb, kauth_filesec_t *xsec, vfs_context_t ctx) { struct vnode_attr va; int error; u_short mode; kauth_filesec_t fsec; VATTR_INIT(&va); VATTR_WANTED(&va, va_fsid); VATTR_WANTED(&va, va_fileid); VATTR_WANTED(&va, va_mode); VATTR_WANTED(&va, va_type); VATTR_WANTED(&va, va_nlink); VATTR_WANTED(&va, va_uid); VATTR_WANTED(&va, va_gid); VATTR_WANTED(&va, va_rdev); VATTR_WANTED(&va, va_data_size); VATTR_WANTED(&va, va_access_time); VATTR_WANTED(&va, va_modify_time); VATTR_WANTED(&va, va_change_time); VATTR_WANTED(&va, va_flags); VATTR_WANTED(&va, va_gen); VATTR_WANTED(&va, va_iosize); /* lower layers will synthesise va_total_alloc from va_data_size if required */ VATTR_WANTED(&va, va_total_alloc); if (xsec != NULL) { VATTR_WANTED(&va, va_uuuid); VATTR_WANTED(&va, va_guuid); VATTR_WANTED(&va, va_acl); } error = vnode_getattr(vp, &va, ctx); if (error) goto out; /* * Copy from vattr table */ sb->st_dev = va.va_fsid; sb->st_ino = (ino_t)va.va_fileid; mode = va.va_mode; switch (vp->v_type) { case VREG: mode |= S_IFREG; break; case VDIR: mode |= S_IFDIR; break; case VBLK: mode |= S_IFBLK; break; case VCHR: mode |= S_IFCHR; break; case VLNK: mode |= S_IFLNK; break; case VSOCK: mode |= S_IFSOCK; break; case VFIFO: mode |= S_IFIFO; break; default: error = EBADF; goto out; }; sb->st_mode = mode; sb->st_nlink = VATTR_IS_SUPPORTED(&va, va_nlink) ? (u_int16_t)va.va_nlink : 1; sb->st_uid = va.va_uid; sb->st_gid = va.va_gid; sb->st_rdev = va.va_rdev; sb->st_size = va.va_data_size; sb->st_atimespec = va.va_access_time; sb->st_mtimespec = va.va_modify_time; sb->st_ctimespec = va.va_change_time; sb->st_blksize = va.va_iosize; sb->st_flags = va.va_flags; sb->st_blocks = roundup(va.va_total_alloc, 512) / 512; /* if we're interested in exended security data and we got an ACL */ if (xsec != NULL) { if (!VATTR_IS_SUPPORTED(&va, va_acl) && !VATTR_IS_SUPPORTED(&va, va_uuuid) && !VATTR_IS_SUPPORTED(&va, va_guuid)) { *xsec = KAUTH_FILESEC_NONE; } else { if (VATTR_IS_SUPPORTED(&va, va_acl) && (va.va_acl != NULL)) { fsec = kauth_filesec_alloc(va.va_acl->acl_entrycount); } else { fsec = kauth_filesec_alloc(0); } if (fsec == NULL) { error = ENOMEM; goto out; } fsec->fsec_magic = KAUTH_FILESEC_MAGIC; if (VATTR_IS_SUPPORTED(&va, va_uuuid)) { fsec->fsec_owner = va.va_uuuid; } else { fsec->fsec_owner = kauth_null_guid; } if (VATTR_IS_SUPPORTED(&va, va_guuid)) { fsec->fsec_group = va.va_guuid; } else { fsec->fsec_group = kauth_null_guid; } if (VATTR_IS_SUPPORTED(&va, va_acl) && (va.va_acl != NULL)) { bcopy(va.va_acl, &(fsec->fsec_acl), KAUTH_ACL_COPYSIZE(va.va_acl)); } else { fsec->fsec_acl.acl_entrycount = KAUTH_FILESEC_NOACL; } *xsec = fsec; } } /* Do not give the generation number out to unpriviledged users */ if (va.va_gen && !vfs_context_issuser(ctx)) sb->st_gen = 0; else sb->st_gen = va.va_gen; error = 0; out: if (VATTR_IS_SUPPORTED(&va, va_acl) && va.va_acl != NULL) kauth_acl_free(va.va_acl); return (error); } int vn_stat(struct vnode *vp, struct stat *sb, kauth_filesec_t *xsec, vfs_context_t ctx) { int error; /* authorize */ if ((error = vnode_authorize(vp, NULL, KAUTH_VNODE_READ_ATTRIBUTES | KAUTH_VNODE_READ_SECURITY, ctx)) != 0) return(error); /* actual stat */ return(vn_stat_noauth(vp, sb, xsec, ctx)); } /* * File table vnode ioctl routine. */ static int vn_ioctl(fp, com, data, p) struct fileproc *fp; u_long com; caddr_t data; struct proc *p; { register struct vnode *vp = ((struct vnode *)fp->f_fglob->fg_data); struct vfs_context context; off_t file_size; int error; struct vnode *ttyvp; int funnel_state; if ( (error = vnode_getwithref(vp)) ) { return(error); } context.vc_proc = p; context.vc_ucred = p->p_ucred; /* XXX kauth_cred_get() ??? */ switch (vp->v_type) { case VREG: case VDIR: if (com == FIONREAD) { if ((error = vnode_size(vp, &file_size, &context)) != 0) goto out; *(int *)data = file_size - fp->f_fglob->fg_offset; goto out; } if (com == FIONBIO || com == FIOASYNC) { /* XXX */ goto out; } /* fall into ... */ default: error = ENOTTY; goto out; case VFIFO: case VCHR: case VBLK: /* Should not be able to set block size from user space */ if (com == DKIOCSETBLOCKSIZE) { error = EPERM; goto out; } if (com == FIODTYPE) { if (vp->v_type == VBLK) { if (major(vp->v_rdev) >= nblkdev) { error = ENXIO; goto out; } *(int *)data = bdevsw[major(vp->v_rdev)].d_type; } else if (vp->v_type == VCHR) { if (major(vp->v_rdev) >= nchrdev) { error = ENXIO; goto out; } *(int *)data = cdevsw[major(vp->v_rdev)].d_type; } else { error = ENOTTY; goto out; } goto out; } error = VNOP_IOCTL(vp, com, data, fp->f_fglob->fg_flag, &context); if (error == 0 && com == TIOCSCTTY) { vnode_ref(vp); funnel_state = thread_funnel_set(kernel_flock, TRUE); ttyvp = p->p_session->s_ttyvp; p->p_session->s_ttyvp = vp; thread_funnel_set(kernel_flock, funnel_state); if (ttyvp) vnode_rele(ttyvp); } } out: (void)vnode_put(vp); return(error); } /* * File table vnode select routine. */ static int vn_select(fp, which, wql, p) struct fileproc *fp; int which; void * wql; struct proc *p; { int error; struct vnode * vp = (struct vnode *)fp->f_fglob->fg_data; struct vfs_context context; if ( (error = vnode_getwithref(vp)) == 0 ) { context.vc_proc = p; context.vc_ucred = fp->f_fglob->fg_cred; error = VNOP_SELECT(vp, which, fp->f_fglob->fg_flag, wql, &context); (void)vnode_put(vp); } return(error); } /* * Check that the vnode is still valid, and if so * acquire requested lock. */ int vn_lock(__unused vnode_t vp, __unused int flags, __unused proc_t p) { return (0); } /* * File table vnode close routine. */ static int vn_closefile(fg, p) struct fileglob *fg; struct proc *p; { struct vnode *vp = (struct vnode *)fg->fg_data; int error; if ( (error = vnode_getwithref(vp)) == 0 ) { error = vn_close(vp, fg->fg_flag, fg->fg_cred, p); (void)vnode_put(vp); } return(error); } int vn_pathconf(vnode_t vp, int name, register_t *retval, vfs_context_t ctx) { int error = 0; switch(name) { case _PC_EXTENDED_SECURITY_NP: *retval = vfs_extendedsecurity(vnode_mount(vp)); break; case _PC_AUTH_OPAQUE_NP: *retval = vfs_authopaque(vnode_mount(vp)); break; default: error = VNOP_PATHCONF(vp, name, retval, ctx); break; } return (error); } static int vn_kqfilt_add(fp, kn, p) struct fileproc *fp; struct knote *kn; struct proc *p; { struct vnode *vp = (struct vnode *)fp->f_fglob->fg_data; struct vfs_context context; int error; int funnel_state; if ( (error = vnode_getwithref(vp)) == 0 ) { context.vc_proc = p; context.vc_ucred = p->p_ucred; /* XXX kauth_cred_get() ??? */ funnel_state = thread_funnel_set(kernel_flock, TRUE); error = VNOP_KQFILT_ADD(vp, kn, &context); thread_funnel_set(kernel_flock, funnel_state); (void)vnode_put(vp); } return (error); } #if 0 /* No one calls this yet. */ static int vn_kqfilt_remove(vp, ident, p) struct vnode *vp; uintptr_t ident; struct proc *p; { struct vfs_context context; int error; int funnel_state; if ( (error = vnode_getwithref(vp)) == 0 ) { context.vc_proc = p; context.vc_ucred = p->p_ucred; /* XXX kauth_cred_get() ??? */ funnel_state = thread_funnel_set(kernel_flock, TRUE); error = VNOP_KQFILT_REMOVE(vp, ident, &context); thread_funnel_set(kernel_flock, funnel_state); (void)vnode_put(vp); } return (error); } #endif