Lines Matching defs:vp
157 vnode_setneedinactive(vnode_t vp)
159 cache_purge(vp);
161 vnode_lock_spin(vp);
162 vp->v_lflag |= VL_NEEDINACTIVE;
163 vnode_unlock(vp);
356 VFS_VPTOFH(struct vnode * vp, int *fhlenp, unsigned char * fhp, vfs_context_t ctx)
360 if ((vp->v_mount == dead_mountp) || (vp->v_mount->mnt_op->vfs_vptofh == 0))
367 error = (*vp->v_mount->mnt_op->vfs_vptofh)(vp, fhlenp, fhp, ctx);
704 vnode_t vp = mp->mnt_vnodecovered;
705 if ((vp == NULL) || (vnode_getwithref(vp) != 0)) {
708 return vp;
724 vnode_t vp = mp->mnt_devvp;
726 if ((vp != NULLVP) && (vnode_get(vp) == 0)) {
727 return vp;
1364 vnode_vid(vnode_t vp)
1366 return ((uint32_t)(vp->v_id));
1370 vnode_mount(vnode_t vp)
1372 return (vp->v_mount);
1377 vnode_mountdevvp(vnode_t vp)
1379 if (vp->v_mount)
1380 return (vp->v_mount->mnt_devvp);
1387 vnode_mountedhere(vnode_t vp)
1391 if ((vp->v_type == VDIR) && ((mp = vp->v_mountedhere) != NULL) &&
1392 (mp->mnt_vnodecovered == vp))
1400 vnode_vtype(vnode_t vp)
1402 return (vp->v_type);
1407 vnode_fsnode(vnode_t vp)
1409 return (vp->v_data);
1413 vnode_clearfsnode(vnode_t vp)
1415 vp->v_data = NULL;
1419 vnode_specrdev(vnode_t vp)
1421 return(vp->v_rdev);
1428 vnode_isvroot(vnode_t vp)
1430 return ((vp->v_flag & VROOT)? 1 : 0);
1435 vnode_issystem(vnode_t vp)
1437 return ((vp->v_flag & VSYSTEM)? 1 : 0);
1442 vnode_isswap(vnode_t vp)
1444 return ((vp->v_flag & VSWAP)? 1 : 0);
1449 vnode_istty(vnode_t vp)
1451 return ((vp->v_flag & VISTTY) ? 1 : 0);
1456 vnode_ismount(vnode_t vp)
1458 return ((vp->v_flag & VMOUNT)? 1 : 0);
1463 vnode_isrecycled(vnode_t vp)
1467 vnode_lock_spin(vp);
1468 ret = (vp->v_lflag & (VL_TERMINATE|VL_DEAD))? 1 : 0;
1469 vnode_unlock(vp);
1476 vnode_israge(vnode_t vp)
1478 return ((vp->v_flag & VRAGE)? 1 : 0);
1482 vnode_needssnapshots(vnode_t vp)
1484 return ((vp->v_flag & VNEEDSSNAPSHOT)? 1 : 0);
1517 vnode_isnocache(vnode_t vp)
1519 return ((vp->v_flag & VNOCACHE_DATA)? 1 : 0);
1526 vnode_isnoreadahead(vnode_t vp)
1528 return ((vp->v_flag & VRAOFF)? 1 : 0);
1532 vnode_is_openevt(vnode_t vp)
1534 return ((vp->v_flag & VOPENEVT)? 1 : 0);
1539 vnode_isstandard(vnode_t vp)
1541 return ((vp->v_flag & VSTANDARD)? 1 : 0);
1546 vnode_isnoflush(vnode_t vp)
1548 return ((vp->v_flag & VNOFLUSH)? 1 : 0);
1553 vnode_isreg(vnode_t vp)
1555 return ((vp->v_type == VREG)? 1 : 0);
1560 vnode_isdir(vnode_t vp)
1562 return ((vp->v_type == VDIR)? 1 : 0);
1567 vnode_islnk(vnode_t vp)
1569 return ((vp->v_type == VLNK)? 1 : 0);
1573 vnode_lookup_continue_needed(vnode_t vp, struct componentname *cnp)
1581 if (vnode_isdir(vp)) {
1582 if (vp->v_mountedhere != NULL) {
1587 if (vp->v_resolve) {
1595 if (vnode_islnk(vp)) {
1614 vnode_isfifo(vnode_t vp)
1616 return ((vp->v_type == VFIFO)? 1 : 0);
1621 vnode_isblk(vnode_t vp)
1623 return ((vp->v_type == VBLK)? 1 : 0);
1627 vnode_isspec(vnode_t vp)
1629 return (((vp->v_type == VCHR) || (vp->v_type == VBLK)) ? 1 : 0);
1634 vnode_ischr(vnode_t vp)
1636 return ((vp->v_type == VCHR)? 1 : 0);
1641 vnode_issock(vnode_t vp)
1643 return ((vp->v_type == VSOCK)? 1 : 0);
1648 vnode_isaliased(vnode_t vp)
1650 enum vtype vt = vp->v_type;
1654 return (vp->v_specflags & SI_ALIASED);
1662 vnode_t vp
1664 __unused vnode_t vp
1669 return ((vp->v_flag & VISNAMEDSTREAM) ? 1 : 0);
1678 vnode_t vp
1680 __unused vnode_t vp
1685 return ((vp->v_flag & VISSHADOW) ? 1 : 0);
1695 vnode_t vp
1697 __unused vnode_t vp
1702 return ((vp->v_lflag & VL_HASSTREAMS) ? 1 : 0);
1709 vnode_setnocache(vnode_t vp)
1711 vnode_lock_spin(vp);
1712 vp->v_flag |= VNOCACHE_DATA;
1713 vnode_unlock(vp);
1717 vnode_clearnocache(vnode_t vp)
1719 vnode_lock_spin(vp);
1720 vp->v_flag &= ~VNOCACHE_DATA;
1721 vnode_unlock(vp);
1725 vnode_set_openevt(vnode_t vp)
1727 vnode_lock_spin(vp);
1728 vp->v_flag |= VOPENEVT;
1729 vnode_unlock(vp);
1733 vnode_clear_openevt(vnode_t vp)
1735 vnode_lock_spin(vp);
1736 vp->v_flag &= ~VOPENEVT;
1737 vnode_unlock(vp);
1742 vnode_setnoreadahead(vnode_t vp)
1744 vnode_lock_spin(vp);
1745 vp->v_flag |= VRAOFF;
1746 vnode_unlock(vp);
1750 vnode_clearnoreadahead(vnode_t vp)
1752 vnode_lock_spin(vp);
1753 vp->v_flag &= ~VRAOFF;
1754 vnode_unlock(vp);
1760 vnode_setnoflush(vnode_t vp)
1762 vnode_lock_spin(vp);
1763 vp->v_flag |= VNOFLUSH;
1764 vnode_unlock(vp);
1768 vnode_clearnoflush(vnode_t vp)
1770 vnode_lock_spin(vp);
1771 vp->v_flag &= ~VNOFLUSH;
1772 vnode_unlock(vp);
1778 vnode_ismountedon(vnode_t vp)
1780 return ((vp->v_specflags & SI_MOUNTEDON)? 1 : 0);
1784 vnode_setmountedon(vnode_t vp)
1786 vnode_lock_spin(vp);
1787 vp->v_specflags |= SI_MOUNTEDON;
1788 vnode_unlock(vp);
1792 vnode_clearmountedon(vnode_t vp)
1794 vnode_lock_spin(vp);
1795 vp->v_specflags &= ~SI_MOUNTEDON;
1796 vnode_unlock(vp);
1801 vnode_settag(vnode_t vp, int tag)
1803 vp->v_tag = tag;
1808 vnode_tag(vnode_t vp)
1810 return(vp->v_tag);
1814 vnode_parent(vnode_t vp)
1817 return(vp->v_parent);
1821 vnode_setparent(vnode_t vp, vnode_t dvp)
1823 vp->v_parent = dvp;
1827 vnode_setname(vnode_t vp, char * name)
1829 vp->v_name = name;
1834 vnode_vfsname(vnode_t vp, char * buf)
1836 strncpy(buf, vp->v_mount->mnt_vtable->vfc_name, MFSNAMELEN);
1841 vnode_vfstypenum(vnode_t vp)
1843 return(vp->v_mount->mnt_vtable->vfc_typenum);
1847 vnode_vfs64bitready(vnode_t vp)
1853 if ((vp->v_mount != dead_mountp) && (vp->v_mount->mnt_vtable->vfc_vfsflags & VFC_VFS64BITREADY))
1863 vnode_vfsvisflags(vnode_t vp)
1865 return(vp->v_mount->mnt_flag & MNT_VISFLAGMASK);
1870 vnode_vfscmdflags(vnode_t vp)
1872 return(vp->v_mount->mnt_flag & MNT_CMDFLAGS);
1877 vnode_vfsmaxsymlen(vnode_t vp)
1879 return(vp->v_mount->mnt_maxsymlinklen);
1884 vnode_vfsstatfs(vnode_t vp)
1886 return(&vp->v_mount->mnt_vfsstat);
1891 vnode_vfsfsprivate(vnode_t vp)
1893 return(vp->v_mount->mnt_data);
1898 vnode_vfsisrdonly(vnode_t vp)
1900 return ((vp->v_mount->mnt_flag & MNT_RDONLY)? 1 : 0);
1904 vnode_compound_rename_available(vnode_t vp)
1906 return vnode_compound_op_available(vp, COMPOUND_VNOP_RENAME);
1909 vnode_compound_rmdir_available(vnode_t vp)
1911 return vnode_compound_op_available(vp, COMPOUND_VNOP_RMDIR);
1914 vnode_compound_mkdir_available(vnode_t vp)
1916 return vnode_compound_op_available(vp, COMPOUND_VNOP_MKDIR);
1919 vnode_compound_remove_available(vnode_t vp)
1921 return vnode_compound_op_available(vp, COMPOUND_VNOP_REMOVE);
1924 vnode_compound_open_available(vnode_t vp)
1926 return vnode_compound_op_available(vp, COMPOUND_VNOP_OPEN);
1930 vnode_compound_op_available(vnode_t vp, compound_vnop_id_t opid)
1932 return ((vp->v_mount->mnt_compound_ops & opid) != 0);
1952 struct vnode * vp ;
1954 if ( (vp = proc->p_fd->fd_rdir) ) {
1955 if ( (vnode_getwithref(vp)) )
1958 return vp;
1966 * Parameters: vp The vnode on which to operate.
1995 vnode_get_filesec(vnode_t vp, kauth_filesec_t *fsecp, vfs_context_t ctx)
2010 if (vn_getxattr(vp, KAUTH_FILESEC_XATTR, NULL, &xsize, XATTR_NOSECURITY, ctx) != 0) {
2044 if ((error = vn_getxattr(vp,
2111 * Parameters: vp The vnode on which to operate.
2136 vnode_set_filesec(vnode_t vp, kauth_filesec_t fsec, kauth_acl_t acl, vfs_context_t ctx)
2159 error = vn_setxattr(vp,
2164 VFS_DEBUG(ctx, vp, "SETATTR - set ACL returning %d", error);
2185 vnode_getattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
2194 if (!vfs_extendedsecurity(vnode_mount(vp))) {
2213 error = VNOP_GETATTR(vp, vap, ctx);
2226 if (XATTR_VNODE_SUPPORTED(vp)) {
2228 if ((error = vnode_get_filesec(vp, &fsec, ctx)) != 0)
2296 } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
2297 nuid = vp->v_mount->mnt_fsowner;
2304 nuid = vp->v_mount->mnt_fsowner;
2313 } else if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
2314 ngid = vp->v_mount->mnt_fsgroup;
2321 ngid = vp->v_mount->mnt_fsgroup;
2332 VATTR_RETURN(vap, va_iosize, vp->v_mount->mnt_vfsstat.f_iosize);
2354 if (vp->v_mount->mnt_vfsstat.f_bsize == 0) {
2355 if ((error = vfs_update_vfsstat(vp->v_mount, ctx, VFS_KERNEL_EVENT)) != 0)
2361 VATTR_RETURN(vap, va_data_alloc, roundup(vap->va_data_size, vp->v_mount->mnt_vfsstat.f_bsize));
2369 VATTR_RETURN(vap, va_total_alloc, roundup(vap->va_total_size, vp->v_mount->mnt_vfsstat.f_bsize));
2382 VATTR_RETURN(vap, va_type, vp->v_type);
2387 VATTR_RETURN(vap, va_fsid, vp->v_mount->mnt_vfsstat.f_fsid.val[0]);
2397 * Parameters: vp The vnode whose attributes to set.
2417 vnode_setattr(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
2425 if (vfs_isrdonly(vp->v_mount)) {
2431 if ((vp->v_flag & VISNAMEDSTREAM) && (vap->va_active != VNODE_ATTR_va_data_size)) {
2441 if (vp->v_mount->mnt_flag & MNT_IGNORE_OWNERSHIP) {
2455 if (!vfs_extendedsecurity(vnode_mount(vp)) &&
2462 error = VNOP_SETATTR(vp, vap, ctx);
2465 error = vnode_setattr_fallback(vp, vap, ctx);
2472 if (need_fsevent(FSE_CHOWN, vp)) {
2473 add_fsevent(FSE_CHOWN, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
2475 } else if(need_fsevent(FSE_STAT_CHANGED, vp)) {
2476 add_fsevent(FSE_STAT_CHANGED, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
2491 * Parameters: vp The vnode whose attributes to set.
2510 vnode_setattr_fallback(vnode_t vp, struct vnode_attr *vap, vfs_context_t ctx)
2528 VFS_DEBUG(ctx, vp, "SETATTR - doing filesec fallback");
2534 if (!XATTR_VNODE_SUPPORTED(vp)) {
2535 VFS_DEBUG(ctx, vp, "SETATTR - Can't write ACL to file type %d", vnode_vtype(vp));
2549 if ((error = vnode_get_filesec(vp, &fsec, ctx)) != 0) {
2604 error = vn_removexattr(vp, KAUTH_FILESEC_XATTR, XATTR_NOSECURITY, ctx);
2608 VFS_DEBUG(ctx, vp, "SETATTR - remove filesec returning %d", error);
2611 error = vnode_set_filesec(vp, fsec, facl, ctx);
2612 VFS_DEBUG(ctx, vp, "SETATTR - update filesec returning %d", error);
2629 vnode_notify(vnode_t vp, uint32_t events, struct vnode_attr *vap)
2644 if ((vnode_isdir(vp)) && (events & dir_contents_mask)) {
2649 lock_vnode_and_post(vp, knote_events);
2652 create_fsevent_from_kevent(vp, events, vap);
2665 vnode_isdyldsharedcache(vnode_t vp)
2667 return ((vp->v_flag & VSHARED_DYLD) ? 1 : 0);
2676 vnode_ismonitored(vnode_t vp) {
2677 return (vp->v_knotes.slh_first != NULL);
2990 *#% open vp L L L
3001 VNOP_OPEN(vnode_t vp, int mode, vfs_context_t ctx)
3010 a.a_vp = vp;
3014 _err = (*vp->v_op[vnop_open_desc.vdesc_offset])(&a);
3015 DTRACE_FSINFO(open, vnode_t, vp);
3023 *#% close vp U U U
3034 VNOP_CLOSE(vnode_t vp, int fflag, vfs_context_t ctx)
3043 a.a_vp = vp;
3047 _err = (*vp->v_op[vnop_close_desc.vdesc_offset])(&a);
3048 DTRACE_FSINFO(close, vnode_t, vp);
3056 *#% access vp L L L
3067 VNOP_ACCESS(vnode_t vp, int action, vfs_context_t ctx)
3076 a.a_vp = vp;
3080 _err = (*vp->v_op[vnop_access_desc.vdesc_offset])(&a);
3081 DTRACE_FSINFO(access, vnode_t, vp);
3089 *#% getattr vp = = =
3100 VNOP_GETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
3106 a.a_vp = vp;
3110 _err = (*vp->v_op[vnop_getattr_desc.vdesc_offset])(&a);
3111 DTRACE_FSINFO(getattr, vnode_t, vp);
3119 *#% setattr vp L L L
3130 VNOP_SETATTR(vnode_t vp, struct vnode_attr * vap, vfs_context_t ctx)
3136 a.a_vp = vp;
3140 _err = (*vp->v_op[vnop_setattr_desc.vdesc_offset])(&a);
3141 DTRACE_FSINFO(setattr, vnode_t, vp);
3147 if (_err == 0 && !NATIVE_XATTR(vp)) {
3168 dvp = vnode_getparent(vp);
3169 vname = vnode_getname(vp);
3193 vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);
3196 if (vfs_authopaque(vp->v_mount) && vnode_hasnamedstreams(vp)) {
3198 if (vnode_getnamedstream(vp, &svp, XATTR_RESOURCEFORK_NAME, NS_OPEN, 0, ctx) == 0) {
3207 post_event_if_success(vp, _err, NOTE_ATTRIB);
3216 *#% read vp L L L
3228 VNOP_READ(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
3241 a.a_vp = vp;
3246 _err = (*vp->v_op[vnop_read_desc.vdesc_offset])(&a);
3248 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
3257 *#% write vp L L L
3269 VNOP_WRITE(vnode_t vp, struct uio * uio, int ioflag, vfs_context_t ctx)
3282 a.a_vp = vp;
3287 _err = (*vp->v_op[vnop_write_desc.vdesc_offset])(&a);
3289 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
3291 post_event_if_success(vp, _err, NOTE_WRITE);
3300 *#% ioctl vp U U U
3313 VNOP_IOCTL(vnode_t vp, u_long command, caddr_t data, int fflag, vfs_context_t ctx)
3336 if (vfs_context_is64bit(ctx) && !(vnode_ischr(vp) || vnode_isblk(vp))) {
3337 if (data != NULL && !vnode_vfs64bitready(vp)) {
3343 a.a_vp = vp;
3349 _err = (*vp->v_op[vnop_ioctl_desc.vdesc_offset])(&a);
3350 DTRACE_FSINFO(ioctl, vnode_t, vp);
3359 *#% select vp U U U
3372 VNOP_SELECT(vnode_t vp, int which , int fflags, void * wql, vfs_context_t ctx)
3381 a.a_vp = vp;
3387 _err = (*vp->v_op[vnop_select_desc.vdesc_offset])(&a);
3388 DTRACE_FSINFO(select, vnode_t, vp);
3435 *#% revoke vp U U U
3446 VNOP_REVOKE(vnode_t vp, int flags, vfs_context_t ctx)
3452 a.a_vp = vp;
3456 _err = (*vp->v_op[vnop_revoke_desc.vdesc_offset])(&a);
3457 DTRACE_FSINFO(revoke, vnode_t, vp);
3466 *# mmap - vp U U U
3477 VNOP_MMAP(vnode_t vp, int fflags, vfs_context_t ctx)
3483 a.a_vp = vp;
3487 _err = (*vp->v_op[vnop_mmap_desc.vdesc_offset])(&a);
3488 DTRACE_FSINFO(mmap, vnode_t, vp);
3497 *# mnomap - vp U U U
3507 VNOP_MNOMAP(vnode_t vp, vfs_context_t ctx)
3513 a.a_vp = vp;
3516 _err = (*vp->v_op[vnop_mnomap_desc.vdesc_offset])(&a);
3517 DTRACE_FSINFO(mnomap, vnode_t, vp);
3526 *#% fsync vp L L L
3537 VNOP_FSYNC(vnode_t vp, int waitfor, vfs_context_t ctx)
3543 a.a_vp = vp;
3547 _err = (*vp->v_op[vnop_fsync_desc.vdesc_offset])(&a);
3548 DTRACE_FSINFO(fsync, vnode_t, vp);
3558 *#% remove vp L U U
3571 VNOP_REMOVE(vnode_t dvp, vnode_t vp, struct componentname * cnp, int flags, vfs_context_t ctx)
3578 a.a_vp = vp;
3584 DTRACE_FSINFO(remove, vnode_t, vp);
3587 vnode_setneedinactive(vp);
3598 post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
3657 *#% link vp U U U
3670 VNOP_LINK(vnode_t vp, vnode_t tdvp, struct componentname * cnp, vfs_context_t ctx)
3680 if ( !NATIVE_XATTR(tdvp) && (vp->v_type == VREG)) {
3683 vname = vnode_getname(vp);
3697 a.a_vp = vp;
3703 DTRACE_FSINFO(link, vnode_t, vp);
3705 post_event_if_success(vp, _err, NOTE_LINK);
4255 panic("NULL vp, but not a compound VNOP?");
4268 *#% rmdir vp L U U
4281 VNOP_RMDIR(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, vfs_context_t ctx)
4288 a.a_vp = vp;
4292 _err = (*vp->v_op[vnop_rmdir_desc.vdesc_offset])(&a);
4293 DTRACE_FSINFO(rmdir, vnode_t, vp);
4296 vnode_setneedinactive(vp);
4308 post_event_if_success(vp, _err, NOTE_DELETE | NOTE_LINK);
4355 #if 0 /* Removing orphaned ._ files requires a vp.... */
4551 *#% readdir vp L L L
4566 VNOP_READDIR(struct vnode *vp, struct uio *uio, int flags, int *eofflag,
4576 a.a_vp = vp;
4583 _err = (*vp->v_op[vnop_readdir_desc.vdesc_offset])(&a);
4585 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
4593 *#% readdirattr vp L L L
4611 VNOP_READDIRATTR(struct vnode *vp, struct attrlist *alist, struct uio *uio, uint32_t maxcount,
4621 a.a_vp = vp;
4631 _err = (*vp->v_op[vnop_readdirattr_desc.vdesc_offset])(&a);
4633 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
4653 VNOP_GETATTRLISTBULK(struct vnode *vp, struct attrlist *alist,
4664 a.a_vp = vp;
4674 _err = (*vp->v_op[vnop_getattrlistbulk_desc.vdesc_offset])(&a);
4676 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
4684 *#% readlink vp L L L
4715 VNOP_READLINK(struct vnode *vp, struct uio *uio, vfs_context_t ctx)
4723 a.a_vp = vp;
4727 _err = (*vp->v_op[vnop_readlink_desc.vdesc_offset])(&a);
4729 vnode_t, vp, user_ssize_t, (resid - uio_resid(uio)));
4737 *#% inactive vp L U U
4747 VNOP_INACTIVE(struct vnode *vp, vfs_context_t ctx)
4753 a.a_vp = vp;
4756 _err = (*vp->v_op[vnop_inactive_desc.vdesc_offset])(&a);
4757 DTRACE_FSINFO(inactive, vnode_t, vp);
4765 if (vnode_isnamedstream(vp) &&
4766 (vp->v_parent != NULLVP) &&
4767 vnode_isshadow(vp) &&
4768 ((vp->v_lflag & VL_TERMINATE) == 0)) {
4769 vnode_recycle(vp);
4780 *#% reclaim vp U U U
4790 VNOP_RECLAIM(struct vnode *vp, vfs_context_t ctx)
4796 a.a_vp = vp;
4799 _err = (*vp->v_op[vnop_reclaim_desc.vdesc_offset])(&a);
4800 DTRACE_FSINFO(reclaim, vnode_t, vp);
4816 *#% pathconf vp L L L
4828 VNOP_PATHCONF(struct vnode *vp, int name, int32_t *retval, vfs_context_t ctx)
4834 a.a_vp = vp;
4839 _err = (*vp->v_op[vnop_pathconf_desc.vdesc_offset])(&a);
4840 DTRACE_FSINFO(pathconf, vnode_t, vp);
4859 *#% advlock vp U U U
4873 VNOP_ADVLOCK(struct vnode *vp, caddr_t id, int op, struct flock *fl, int flags, vfs_context_t ctx, struct timespec *timeout)
4879 a.a_vp = vp;
4888 if (vnode_isfifo(vp)) {
4891 if ((vp->v_flag & VLOCKLOCAL)) {
4896 _err = (*vp->v_op[vnop_advlock_desc.vdesc_offset])(&a);
4898 DTRACE_FSINFO(advlock, vnode_t, vp);
4909 *#% allocate vp L L L
4924 VNOP_ALLOCATE(struct vnode *vp, off_t length, u_int32_t flags, off_t *bytesallocated, off_t offset, vfs_context_t ctx)
4930 a.a_vp = vp;
4937 _err = (*vp->v_op[vnop_allocate_desc.vdesc_offset])(&a);
4938 DTRACE_FSINFO(allocate, vnode_t, vp);
4941 add_fsevent(FSE_STAT_CHANGED, ctx, FSE_ARG_VNODE, vp, FSE_ARG_DONE);
4951 *#% pagein vp = = =
4966 VNOP_PAGEIN(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
4972 a.a_vp = vp;
4980 _err = (*vp->v_op[vnop_pagein_desc.vdesc_offset])(&a);
4981 DTRACE_FSINFO(pagein, vnode_t, vp);
4989 *#% pageout vp = = =
5005 VNOP_PAGEOUT(struct vnode *vp, upl_t pl, upl_offset_t pl_offset, off_t f_offset, size_t size, int flags, vfs_context_t ctx)
5011 a.a_vp = vp;
5019 _err = (*vp->v_op[vnop_pageout_desc.vdesc_offset])(&a);
5020 DTRACE_FSINFO(pageout, vnode_t, vp);
5022 post_event_if_success(vp, _err, NOTE_WRITE);
5042 *#% searchfs vp L L L
5064 VNOP_SEARCHFS(struct vnode *vp, void *searchparams1, void *searchparams2, struct attrlist *searchattrs, uint32_t maxmatches, struct timeval *timelimit, struct attrlist *returnattrs, uint32_t *nummatches, uint32_t scriptcode, uint32_t options, struct uio *uio, struct searchstate *searchstate, vfs_context_t ctx)
5070 a.a_vp = vp;
5084 _err = (*vp->v_op[vnop_searchfs_desc.vdesc_offset])(&a);
5085 DTRACE_FSINFO(searchfs, vnode_t, vp);
5130 VNOP_GETXATTR(vnode_t vp, const char *name, uio_t uio, size_t *size, int options, vfs_context_t ctx)
5136 a.a_vp = vp;
5143 error = (*vp->v_op[vnop_getxattr_desc.vdesc_offset])(&a);
5144 DTRACE_FSINFO(getxattr, vnode_t, vp);
5150 VNOP_SETXATTR(vnode_t vp, const char *name, uio_t uio, int options, vfs_context_t ctx)
5156 a.a_vp = vp;
5162 error = (*vp->v_op[vnop_setxattr_desc.vdesc_offset])(&a);
5163 DTRACE_FSINFO(setxattr, vnode_t, vp);
5166 vnode_uncache_authorized_action(vp, KAUTH_INVALIDATE_CACHED_RIGHTS);
5168 post_event_if_success(vp, error, NOTE_ATTRIB);
5174 VNOP_REMOVEXATTR(vnode_t vp, const char *name, int options, vfs_context_t ctx)
5180 a.a_vp = vp;
5185 error = (*vp->v_op[vnop_removexattr_desc.vdesc_offset])(&a);
5186 DTRACE_FSINFO(removexattr, vnode_t, vp);
5188 post_event_if_success(vp, error, NOTE_ATTRIB);
5194 VNOP_LISTXATTR(vnode_t vp, uio_t uio, size_t *size, int options, vfs_context_t ctx)
5200 a.a_vp = vp;
5206 error = (*vp->v_op[vnop_listxattr_desc.vdesc_offset])(&a);
5207 DTRACE_FSINFO(listxattr, vnode_t, vp);
5216 *#% blktooff vp = = =
5227 VNOP_BLKTOOFF(struct vnode *vp, daddr64_t lblkno, off_t *offset)
5233 a.a_vp = vp;
5237 _err = (*vp->v_op[vnop_blktooff_desc.vdesc_offset])(&a);
5238 DTRACE_FSINFO(blktooff, vnode_t, vp);
5246 *#% offtoblk vp = = =
5257 VNOP_OFFTOBLK(struct vnode *vp, off_t offset, daddr64_t *lblkno)
5263 a.a_vp = vp;
5267 _err = (*vp->v_op[vnop_offtoblk_desc.vdesc_offset])(&a);
5268 DTRACE_FSINFO(offtoblk, vnode_t, vp);
5276 *#% blockmap vp L L L
5292 VNOP_BLOCKMAP(struct vnode *vp, off_t foffset, size_t size, daddr64_t *bpn, size_t *run, void *poff, int flags, vfs_context_t ctx)
5302 a.a_vp = vp;
5311 _err = (*vp->v_op[vnop_blockmap_desc.vdesc_offset])(&a);
5312 DTRACE_FSINFO(blockmap, vnode_t, vp);
5345 vnode_t vp = buf_vnode(bp);
5348 _err = (*vp->v_op[vnop_strategy_desc.vdesc_offset])(&a);
5349 DTRACE_FSINFO(strategy, vnode_t, vp);
5364 vnode_t vp = buf_vnode(bp);
5367 _err = (*vp->v_op[vnop_bwrite_desc.vdesc_offset])(&a);
5368 DTRACE_FSINFO(bwrite, vnode_t, vp);
5381 VNOP_KQFILT_ADD(struct vnode *vp, struct knote *kn, vfs_context_t ctx)
5387 a.a_vp = vp;
5391 _err = (*vp->v_op[vnop_kqfilt_add_desc.vdesc_offset])(&a);
5392 DTRACE_FSINFO(kqfilt_add, vnode_t, vp);
5406 VNOP_KQFILT_REMOVE(struct vnode *vp, uintptr_t ident, vfs_context_t ctx)
5412 a.a_vp = vp;
5416 _err = (*vp->v_op[vnop_kqfilt_remove_desc.vdesc_offset])(&a);
5417 DTRACE_FSINFO(kqfilt_remove, vnode_t, vp);
5423 VNOP_MONITOR(vnode_t vp, uint32_t events, uint32_t flags, void *handle, vfs_context_t ctx)
5429 a.a_vp = vp;
5435 _err = (*vp->v_op[vnop_monitor_desc.vdesc_offset])(&a);
5436 DTRACE_FSINFO(monitor, vnode_t, vp);
5450 VNOP_SETLABEL(struct vnode *vp, struct label *label, vfs_context_t ctx)
5456 a.a_vp = vp;
5460 _err = (*vp->v_op[vnop_setlabel_desc.vdesc_offset])(&a);
5461 DTRACE_FSINFO(setlabel, vnode_t, vp);
5472 VNOP_GETNAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, enum nsoperation operation, int flags, vfs_context_t ctx)
5478 a.a_vp = vp;
5485 _err = (*vp->v_op[vnop_getnamedstream_desc.vdesc_offset])(&a);
5486 DTRACE_FSINFO(getnamedstream, vnode_t, vp);
5494 VNOP_MAKENAMEDSTREAM(vnode_t vp, vnode_t *svpp, const char *name, int flags, vfs_context_t ctx)
5500 a.a_vp = vp;
5506 _err = (*vp->v_op[vnop_makenamedstream_desc.vdesc_offset])(&a);
5507 DTRACE_FSINFO(makenamedstream, vnode_t, vp);
5516 VNOP_REMOVENAMEDSTREAM(vnode_t vp, vnode_t svp, const char *name, int flags, vfs_context_t ctx)
5522 a.a_vp = vp;
5528 _err = (*vp->v_op[vnop_removenamedstream_desc.vdesc_offset])(&a);
5529 DTRACE_FSINFO(removenamedstream, vnode_t, vp);