Lines Matching defs:vp
80 static int smbfs_setattr(struct smb_share *share, vnode_t vp, struct vnode_attr *vap,
82 static void smbfs_set_create_vap(struct smb_share *share, struct vnode_attr *vap, vnode_t vp,
96 smbfs_io_reopen(struct smb_share *share, vnode_t vp, uio_t uio,
100 struct smbnode *np = VTOSMB(vp);
109 if (FindFileRef(vp, vfs_context_proc(context), accessMode, kCheckDenyOrLocks,
130 smbfs_update_cache(struct smb_share *share, vnode_t vp,
139 if (VTOSMB(vp)->attribute_cache_timer != 0) {
143 error = smbfs_attr_cachelookup(share, vp, vap, context, use_cached_data);
152 error = smbfs_lookup(share, VTOSMB(vp), NULL, NULL, &fattr, context);
156 if ((error == ETIMEDOUT) && (VTOSMB(vp)->attribute_cache_timer != 0)) {
173 smbfs_attr_cacheenter(share, vp, &fattr, TRUE, context);
176 error = smbfs_attr_cachelookup(share, vp, vap, context, use_cached_data);
191 smbfs_close(struct smb_share *share, vnode_t vp, int openMode,
194 struct smbnode *np = VTOSMB(vp);
230 ubc_msync(vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC | UBC_INVALIDATE);
282 RemoveFileRef (vp, NULL); /* remove all file refs */
320 if (vnode_isnocache(vp))
321 vnode_clearnocache(vp);
371 error = FindFileRef(vp, p, tempAccessMode, kExactMatch, 0, 0, &fndEntry,
375 error = FindFileRef(vp, p, tempAccessMode, kExactMatch, 0, 0,
385 error = FindFileRef(vp, p, accessMode, kExactMatch, 0, 0, &fndEntry, &fid);
414 RemoveFileRef(vp, fndEntry);
495 ubc_msync(vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC | UBC_INVALIDATE);
542 vnode_t vp = ap->a_vp;
546 if (smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK) != 0)
551 np = VTOSMB(vp);
554 if (vnode_isdir(vp)) {
560 } else if ( vnode_isreg(vp) || vnode_islnk(vp) ) {
565 if (!vnode_vfsisrdonly(vp) && smbfsIsCacheable(vp)) {
568 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
571 cluster_push(vp, IO_CLOSE);
574 share = smb_get_share_with_reference(VTOSMBFS(vp));
579 error = smbfs_close(share, vp, ap->a_fflag, ap->a_context);
632 smbfs_update_RW_cnts(vnode_t vp, uint16_t accessMode)
635 struct smbnode *np = VTOSMB(vp);
658 vnode_t vp;
738 fattrp, &vp,
757 *vpp = vp;
758 np = VTOSMB(vp);
765 if (vnode_isdir(vp)) {
769 } else if (vnode_islnk(vp)) {
775 } else if (vnode_isreg(vp)) {
819 AddFileRef (vp, vfs_context_proc(context), accessMode, rights,
825 smbfs_update_RW_cnts(vp, savedAccessMode);
828 vnode_setnocache(vp);
845 VTOSMB(vp)->finfo_cache_timer = ts.tv_sec;
846 VTOSMB(vp)->rfrk_cache_timer = ts.tv_sec;
853 smbfs_set_create_vap(share, vap, vp, context, TRUE); /* Set the REAL create attributes NOW */
870 smbnode_unlock(VTOSMB(vp)); /* Release the smbnode lock */
883 smbfs_open(struct smb_share *share, vnode_t vp, int mode,
887 struct smbnode *np = VTOSMB(vp);
935 warning = smbfs_close(share, vp, FREAD, context);
944 error = FindFileRef(vp, p, accessMode, kExactMatch, 0, 0, &fndEntry, &fid);
985 error = FindFileRef(vp, NULL, accessMode, kPreflightOpen, 0, 0, &fndEntry, &fid);
1017 AddFileRef (vp, p, accessMode, rights, fid, dur_handle, NULL);
1071 error = FindFileRef(vp, NULL, accessMode | kAccessRead, kPreflightOpen,
1092 error = FindFileRef(vp, NULL, accessMode, kPreflightOpen, 0, 0, &fndEntry,
1125 smbfs_update_RW_cnts(vp, savedAccessMode);
1128 vnode_setnocache(vp);
1150 smbfs_vnop_open_common(vnode_t vp, int mode, vfs_context_t context, void *n_lastvop)
1156 if (!vnode_isreg(vp) && !vnode_isdir(vp) && !vnode_islnk(vp)) {
1160 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
1163 np = VTOSMB(vp);
1167 if (vnode_isdir(vp)) {
1173 share = smb_get_share_with_reference(VTOSMBFS(vp));
1180 error = smbfs_open(share, vp, mode, context);
1194 error = smbfs_setattr(share, vp, &vap, context);
1196 (void)smbfs_close(share, vp, mode, context);
1329 * int vnode_lookup_continue_needed(vnode_t vp, struct componentname *cnp);
1374 vnode_t vp = (ap->a_vpp) ? *ap->a_vpp : NULL;
1450 if (vp == NULLVP) {
1463 vp = dvp;
1518 * If it is in hash, then update its meta data and return vp
1520 * return it in vp. Either way, we get back a vp.
1524 fap, &vp,
1531 smbnode_unlock(VTOSMB(vp));
1544 /* Probably not found, either way vp is left at NULL */
1561 * return ENOENT (since fap == NULL) and vp will be left as NULL
1568 NULL, &vp,
1575 smbnode_unlock(VTOSMB(vp));
1589 if (vp && (vnode_islnk(vp) || (VTOSMB(vp)->n_dosattr & SMB_EFA_REPARSE_POINT))) {
1590 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
1591 SMBDEBUG("symlink %s\n", VTOSMB(vp)->n_name);
1592 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
1594 error = vnode_lookup_continue_needed(vp, cnp);
1596 *vpp = vp;
1597 vp = NULL;
1615 if (vp && (!(fmode & (O_CREAT | O_TRUNC)) || (vnode_isreg(vp) && VTOSMB(vp)->f_refcnt))) {
1617 if ((fmode & O_EXCL) && vnode_isreg(vp) && VTOSMB(vp)->f_refcnt) {
1620 * a vp and it's opened). No need to go to the server,
1630 *vpp = vp;
1631 vp = NULL;
1636 error = ap->a_open_existing_authorizer(vp, cnp, fmode, context, NULL);
1638 error = smbfs_vnop_open_common(vp, fmode, context, smbfs_vnop_compound_open);
1650 error = smbfs_setattr(share, vp, &va, context);
1653 (void)smbfs_close(share, vp, fmode, context);
1657 *vpp = vp;
1658 vp = NULL;
1668 if (vp) {
1670 smbfs_smb_fsync(share, VTOSMB(vp), context);
1701 error = smbfs_create_open(share, dvp, cnp, vap, open_disp, fmode, &fid, fap, &vp, context);
1725 error = ap->a_open_existing_authorizer(vp, cnp, fmode, context, NULL);
1731 if (vnode_islnk(vp) || (VTOSMB(vp)->n_dosattr & SMB_EFA_REPARSE_POINT)) {
1732 error = vnode_lookup_continue_needed(vp, cnp);
1733 if (!error && (vnode_islnk(vp))) {
1740 *vpp = vp;
1741 vp = NULL; /* Don't release the reference */
1785 if (error && (*vpp == NULLVP) && vp) {
1786 vnode_put(vp);
1836 vnode_t vp = ap->a_vp;
1844 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
1849 np = VTOSMB(vp);
1871 } else if (FindFileRef(vp, vfs_context_proc(ap->a_context), accessMode,
1908 vnode_t vp = ap->a_vp;
1913 if (smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK))
1918 np = VTOSMB(vp);
1925 share = smb_get_share_with_reference(VTOSMBFS(vp));
1926 error = smbfs_close(share, vp, np->f_mmapMode, ap->a_context);
1944 if (FindMappedFileRef(vp, &entry, NULL) == TRUE) {
1949 RemoveFileRef(vp, entry);
1968 vnode_t vp = ap->a_vp;
1976 (void)smbnode_lock(VTOSMB(vp), SMBFS_RECLAIM_LOCK);
1977 np = VTOSMB(vp);
1979 share = smb_get_share_with_reference(VTOSMBFS(vp));
1990 if (!vnode_isnamedstream(vp))
1999 if ((vnode_isinuse(vp, 0)) && !(vfs_isforce(vnode_mount(vp))))
2002 if (vnode_isdir(vp)) {
2014 error = smbfs_close(share, vp, FREAD, ap->a_context);
2063 vnode_t vp = ap->a_vp;
2070 (void) smbnode_lock(VTOSMB(vp), SMBFS_RECLAIM_LOCK);
2072 np = VTOSMB(vp);
2074 smp = VTOSMBFS(vp);
2078 if (vnode_isreg(vp)) {
2080 } else if (vnode_isdir(vp)) {
2105 vfs_isforce(vnode_mount(vp)), 0, 0);
2109 if (!(vfs_isforce(vnode_mount(vp)))) {
2116 if (vnode_getname(vp) != NULL) {
2118 __FUNCTION__, vnode_getname(vp), (long) np->n_child_refcnt);
2158 cache_purge(vp);
2159 if (smp->sm_rvp == vp) {
2165 if (!vnode_isdir(vp)) {
2169 if (!vnode_isnamedstream(vp))
2181 if (!vnode_isnamedstream(vp)) {
2200 * race with another thread doing a 'np = VTOSMB(vp)'.
2202 vnode_clearfsnode(vp);
2230 smbfs_getattr(struct smb_share *share, vnode_t vp, struct vnode_attr *vap,
2236 DBG_ASSERT(!vnode_isnamedstream(vp));
2237 (void)smbfs_getsecurity(share, VTOSMB(vp), vap, context);
2239 return smbfs_update_cache(share, vp, vap, context);
2291 smbfs_setattr(struct smb_share *share, vnode_t vp, struct vnode_attr *vap,
2294 struct smbnode *np = VTOSMB(vp);
2295 struct smbmount *smp = VTOSMBFS(vp);
2318 if ((vnode_isnamedstream(vp)) &&
2340 error = smbfs_setsecurity(share, vp, vap, context);
2420 if (UNIX_SERVER(SSTOVC(share)) || (!vnode_isdir(vp))) {
2431 if (supportUnixBSDFlags || darwin || (!vnode_isdir(vp))) {
2445 if ((! supportUnixBSDFlags) && (vnode_isdir(vp)))
2465 if (supportUnixInfo2 && (!vnode_islnk(vp))) {
2533 if (VATTR_IS_ACTIVE(vap, va_data_size) && (vnode_isreg(vp))) {
2536 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
2597 smbfs_setsize(vp, (off_t)tsize);
2600 smbfs_setsize(vp, (off_t)vap->va_data_size);
2607 if (vnode_isnamedstream(vp)) {
2608 vnode_t parent_vp = smb_update_rsrc_and_getparent(vp, TRUE);
2756 ((!vnode_isdir(vp)) && np->f_refcnt && (np->f_rights & rights))) {
2920 vnode_t vp = buf_vnode(bp);
2922 struct smbnode *np = VTOSMB(vp);
2993 if (FindFileRef(vp, buf_proc(bp), (bflags & B_READ) ? kAccessRead : kAccessWrite,
3006 share = smb_get_share_with_reference(VTOSMBFS(vp));
3051 share = smb_get_share_with_reference(VTOSMBFS(vp));
3176 vnode_t vp = ap->a_vp;
3184 if (!vnode_isreg(vp)) {
3186 if (vnode_isdir(vp))
3198 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_SHARED_LOCK)))
3205 np = VTOSMB(vp);
3207 share = smb_get_share_with_reference(VTOSMBFS(vp));
3217 error = smbfs_open(share, vp, FREAD, ap->a_context);
3243 if ( smbfsIsCacheable(vp) && !(ap->a_ioflag & IO_NOCACHE)) {
3244 error = cluster_read(vp, uio, (off_t) np->n_size, ap->a_ioflag);
3266 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
3269 cluster_push(vp, IO_SYNC);
3271 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_INVALIDATE);
3272 vnode_setnocache(vp);
3295 if (VTOSMB(vp)->n_flag & NISMAPPED) {
3297 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
3300 cluster_push(vp, IO_SYNC);
3307 ubc_msync (vp, uio_offset(uio), uio_offset(uio)+ uio_resid(uio), NULL,
3310 if (FindFileRef(vp, vfs_context_proc(ap->a_context), kAccessRead,
3334 share = smb_get_share_with_reference(VTOSMBFS(vp));
3336 if (smbfs_io_reopen(share, vp, uio, kAccessRead, &fid, error, ap->a_context) == 0) {
3375 vnode_t vp = ap->a_vp;
3386 if (!vnode_isreg(vp)) {
3388 if (vnode_isdir(vp))
3400 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
3407 np = VTOSMB(vp);
3409 share = smb_get_share_with_reference(VTOSMBFS(vp));
3437 if (smbfsIsCacheable(vp) && !(ap->a_ioflag & IO_NOCACHE)) {
3487 error = cluster_write(vp, uio, originalEOF, newEOF, zero_head_off, zero_tail_off, lflag);
3514 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
3517 cluster_push(vp, IO_SYNC);
3519 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_INVALIDATE);
3520 vnode_setnocache(vp);
3535 ubc_msync(vp, uio_offset(uio), uio_offset(uio)+ uio_resid(uio), NULL,
3537 ubc_msync(vp, uio_offset(uio), uio_offset(uio)+ uio_resid(uio), NULL,
3541 if (FindFileRef(vp, vfs_context_proc(ap->a_context), kAccessWrite,
3576 share = smb_get_share_with_reference(VTOSMBFS(vp));
3577 if (smbfs_io_reopen(share, vp, uio, kAccessWrite, &fid, error,
3601 VTOSMB(vp)->n_flag |= NNEEDS_FLUSH;
3643 smbfs_setsize(vp, uio_offset(uio));
3661 if (vnode_isnamedstream(vp))
3662 parent_vp = smb_update_rsrc_and_getparent(vp, FALSE);
3665 smbnode_unlock(VTOSMB(vp));
3692 smbfs_set_create_vap(struct smb_share *share, struct vnode_attr *vap, vnode_t vp,
3695 struct smbnode *np = VTOSMB(vp);
3756 if ( !vnode_isreg(vp) || !has_posix_modes ) {
3774 if (vnode_isreg(vp) && has_posix_modes &&
3857 error = smbfs_getattr(share, vp, &svrva, context);
3876 error = smbfs_setattr(share, vp, vap, context);
3907 vnode_t vp;
3966 &fattr, &vp,
3982 VTOSMB(vp)->finfo_cache_timer = ts.tv_sec;
3983 VTOSMB(vp)->rfrk_cache_timer = ts.tv_sec;
3985 smbfs_set_create_vap(share, vap, vp, ap->a_context, FALSE);
3988 smbfs_update_symlink_cache(VTOSMB(vp), target, targetlen);
3989 VTOSMB(vp)->n_size = targetlen; /* Set it to the correct size */
3991 VTOSMB(vp)->n_flag |= NWINDOWSYMLNK;
3993 *vpp = vp;
3994 smbnode_unlock(VTOSMB(vp)); /* Done with the smbnode unlock it. */
4053 smbfs_remove(struct smb_share *share, vnode_t dvp, vnode_t vp,
4059 struct smbnode *np = VTOSMB(vp);
4060 struct smbmount *smp = VTOSMBFS(vp);
4066 DBG_ASSERT((!vnode_isnamedstream(vp)))
4067 cache_purge(vp);
4078 if (vnode_isinuse(vp, 0)) {
4094 SMBDEBUG("%s: Cannot delete %s, resource fork in use\n", __FUNCTION__, vnode_getname(vp));
4109 error = smbfs_close(share, vp, FREAD, context);
4186 (void) vnode_recycle(vp);
4209 vnode_t vp = ap->a_vp;
4213 if (dvp == vp)
4217 if ((error = smbnode_lockpair(VTOSMB(dvp), VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
4223 VTOSMB(vp)->n_lastvop = smbfs_vnop_remove;
4225 error = smbfs_remove(share, dvp, vp, ap->a_cnp, ap->a_flags, ap->a_context);
4227 smbnode_unlockpair(VTOSMB(dvp), VTOSMB(vp));
4240 smbfs_rmdir(struct smb_share *share, vnode_t dvp, vnode_t vp,
4244 struct smbmount *smp = VTOSMBFS(vp);
4246 struct smbnode *np = VTOSMB(vp);
4252 if (dvp == vp) {
4281 cache_purge(vp);
4318 (void) vnode_recycle(vp);
4334 vnode_t vp = ap->a_vp;
4338 if (!vnode_isdir(vp))
4341 if (dvp == vp)
4345 if ((error = smbnode_lockpair(VTOSMB(dvp), VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
4351 VTOSMB(vp)->n_lastvop = smbfs_vnop_rmdir;
4353 error = smbfs_rmdir(share, dvp, vp, ap->a_cnp, ap->a_context);
4355 smbnode_unlockpair(VTOSMB(dvp), VTOSMB(vp));
4982 vnode_t vp = ap->a_vp;
4990 if (vnode_vtype(vp) != VLNK)
4993 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
4998 np = VTOSMB(vp);
5000 share = smb_get_share_with_reference(VTOSMBFS(vp));
5074 vnode_t vp;
5111 &fattr, &vp,
5122 VTOSMB(vp)->finfo_cache_timer = ts.tv_sec;
5123 smbfs_set_create_vap(share, vap, vp, ap->a_context, FALSE);
5124 *ap->a_vpp = vp;
5125 smbnode_unlock(VTOSMB(vp)); /* Done with the smbnode unlock it. */
5159 vnode_t vp = ap->a_vp;
5167 if (!vnode_isdir(vp))
5176 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
5179 SMB_LOG_KTRACE(SMB_DBG_READ_DIR | DBG_FUNC_START, VTOSMB(vp)->d_fid, 0, 0, 0, 0);
5181 VTOSMB(vp)->n_lastvop = smbfs_vnop_readdir;
5183 error = smbfs_readvdir(vp, uio, ap->a_context, ap->a_flags, &numdirent);
5195 smbnode_unlock(VTOSMB(vp));
5202 smbfs_fsync(struct smb_share *share, vnode_t vp, int waitfor, int ubc_flags,
5209 if (!vnode_isreg(vp)) {
5215 size = smb_ubc_getsize(vp);
5216 if ((size > 0) && smbfsIsCacheable(vp)) {
5217 if (VTOSMB(vp)->n_flag & NISMAPPED) {
5219 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
5222 cluster_push(vp, IO_SYNC);
5225 error = smbfs_smb_fsync(share, VTOSMB(vp), context);
5227 VTOSMBFS(vp)->sm_statfstime = 0;
5341 * *retval = vfs_extendedsecurity(vnode_mount(vp)) ? 1 : 0;
5344 * *retval = vfs_authopaque(vnode_mount(vp));
5415 vnode_t vp = ap->a_vp;
5428 np = VTOSMB(vp);
5430 smp = VTOSMBFS(vp);
5431 share = smb_get_share_with_reference(VTOSMBFS(vp));
5499 if (vnode_isdir(vp)) {
5518 if (smbfsIsCacheable(vp)) {
5521 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_PUSHDIRTY | UBC_SYNC);
5524 cluster_push(vp, IO_SYNC);
5526 ubc_msync (vp, 0, ubc_getsize(vp), NULL, UBC_INVALIDATE);
5527 vnode_setnocache(vp);
5580 error = FindFileRef(vp, p, accessMode, kExactMatch, 0, 0,
5584 error = FindFileRef(vp, p, accessMode, kExactMatch, 0, 0,
5595 error = FindFileRef(vp, p, accessMode, kExactMatch, 0, 0,
5599 error = FindFileRef(vp, p, kAccessRead | kAccessWrite, kAnyMatch,
5672 AddFileRef(vp, p, accessMode, rights, fid, dur_handle, &fndEntry);
5769 vnode_t vp = ap->a_vp;
5779 if (!vnode_isreg(vp)) {
5781 if (vnode_isdir(vp))
5787 share = smb_get_share_with_reference(VTOSMBFS(vp));
5801 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK))) {
5810 np = VTOSMB(vp);
6088 vnode_t vp;
6257 fap, &vp,
6261 smbnode_unlock(VTOSMB(vp)); /* Release the smbnode lock */
6262 *vpp = vp;
6273 fap, &vp,
6277 smbnode_unlock(VTOSMB(vp)); /* Release the smbnode lock */
6278 *vpp = vp;
6285 vp = VTOSMB(dvp)->n_parent->n_vnode;
6286 error = vnode_get(vp);
6288 *vpp = vp;
6299 fap, &vp,
6303 smbnode_unlock(VTOSMB(vp)); /* Release the smbnode lock */
6304 *vpp = vp;
6371 vnode_t vp = ap->a_vp;
6380 np = VTOSMB(vp);
6387 share = smb_get_share_with_reference(VTOSMBFS(vp));
6413 error = cluster_pagein(vp, ap->a_pl, ap->a_pl_offset, ap->a_f_offset,
6444 vnode_t vp = ap->a_vp;
6452 if (vnode_vfsisrdonly(vp))
6457 np = VTOSMB(vp);
6467 share = smb_get_share_with_reference(VTOSMBFS(vp));
6481 error = cluster_pageout(vp, ap->a_pl, ap->a_pl_offset, ap->a_f_offset,
6492 if (vnode_isnamedstream(vp)) {
6493 vnode_t parent_vp = vnode_getparent(vp);
6695 vnode_t vp = ap->a_vp;
6708 DBG_ASSERT(!vnode_isnamedstream(vp));
6710 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
6715 np = VTOSMB(vp);
6717 share = smb_get_share_with_reference(VTOSMBFS(vp));
6828 if (sizep && (VTOSMBFS(vp)->sm_flags & MNT_IS_SFM_VOLUME)) {
6956 vnode_t vp = ap->a_vp;
6965 DBG_ASSERT(!vnode_isnamedstream(vp));
6967 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
6972 np = VTOSMB(vp);
6974 share = smb_get_share_with_reference(VTOSMBFS(vp));
7043 vnode_t vp = ap->a_vp;
7051 DBG_ASSERT(!vnode_isnamedstream(vp));
7053 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
7058 np = VTOSMB(vp);
7060 share = smb_get_share_with_reference(VTOSMBFS(vp));
7089 if (VTOSMBFS(vp)->sm_flags & MNT_IS_SFM_VOLUME) {
7231 vnode_t vp = ap->a_vp;
7252 DBG_ASSERT(!vnode_isnamedstream(vp));
7254 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
7260 np = VTOSMB(vp);
7262 share = smb_get_share_with_reference(VTOSMBFS(vp));
7298 error = smb_get_rsrcfrk_size(share, vp, ap->a_context);
7401 if (vnode_isreg(vp) && (bcmp(np->finfo, "brokMACS", 8) == 0)) {
7413 if ((!(VTOSMBFS(vp)->sm_flags & MNT_IS_SFM_VOLUME)) &&
7539 vnode_t vp = ap->a_vp;
7557 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
7563 np = VTOSMB(vp);
7565 share = smb_get_share_with_reference(VTOSMBFS(vp));
7579 if ( !vnode_isreg(vp) ) {
7595 error = smbfs_getattr(share, vp, &vap, ap->a_context);
7607 if ((*svpp = smbfs_find_vgetstrm(VTOSMBFS(vp), np, sname,
7703 error = smbfs_vgetstrm(share, VTOSMBFS(vp), vp, svpp, &fattr, sname);
7734 vnode_t vp = ap->a_vp;
7745 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK)))
7750 np = VTOSMB(vp);
7752 share = smb_get_share_with_reference(VTOSMBFS(vp));
7772 if ( !vnode_isreg(vp) ) {
7794 error = smbfs_vgetstrm(share, VTOSMBFS(vp), vp, svpp, &fattr, streamname);
7833 vnode_t vp = ap->a_vp;
7843 if ((error = smbnode_lockpair(VTOSMB(vp), VTOSMB(svp), SMBFS_EXCLUSIVE_LOCK)))
7850 share = smb_get_share_with_reference(VTOSMBFS(vp));
7868 if ( !vnode_isreg(vp) ) {
7891 smbnode_unlockpair(VTOSMB(vp), VTOSMB(svp));
7976 vnode_t vp = ap->a_vp;
7980 struct smbmount *smp = VTOSMBFS(vp);
7987 share = smb_get_share_with_reference(VTOSMBFS(vp));
7995 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
7997 kauth_cred_getuid(cred), VTOSMB(vp)->n_name, action);
7998 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8012 (!vnode_isreg(vp)))) {
8022 if (node_isimmutable(share, vp, NULL) && (action & write_rights)) {
8023 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8024 SMB_LOG_ACCESS("%s action = 0x%x %s denied\n", VTOSMB(vp)->n_name, action,
8025 vnode_isdir(vp) ? "IMMUTABLE_DIR" : "IMMUTABLE_FILE");
8026 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8055 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8058 VTOSMB(vp)->n_name, action);
8061 SMB_LOG_ACCESS("%s action = 0x%x\n", VTOSMB(vp)->n_name, action);
8063 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8073 if (vnode_isnamedstream(vp)) {
8074 vnode_t parent_vp = vnode_getparent(vp);
8080 maxAccessRights = smbfs_get_maximum_access(share, vp, context);
8086 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8087 SMB_LOG_ACCESS("%s action = 0x%x %s denied\n", VTOSMB(vp)->n_name, action,
8088 vnode_isdir(vp) ? "KAUTH_VNODE_LIST_DIRECTORY" : "KAUTH_VNODE_READ_DATA");
8089 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8098 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8099 SMB_LOG_ACCESS("%s action = 0x%x %s denied\n", VTOSMB(vp)->n_name, action,
8100 vnode_isdir(vp) ? "KAUTH_VNODE_ADD_FILE" : "KAUTH_VNODE_WRITE_DATA");
8101 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8109 if ((vnode_isdir(vp)) &&
8117 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8118 SMB_LOG_ACCESS("%s action = 0x%x KAUTH_VNODE_SEARCH denied\n", VTOSMB(vp)->n_name, action);
8119 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8123 } else if (!vnode_isdir(vp) &&
8140 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8142 VTOSMB(vp)->n_name, action);
8143 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8152 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8154 VTOSMB(vp)->n_name, action);
8155 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8164 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8165 SMB_LOG_ACCESS("%s action = 0x%x %s denied\n", VTOSMB(vp)->n_name, action,
8166 vnode_isdir(vp) ? "KAUTH_VNODE_ADD_SUBDIRECTORY" : "KAUTH_VNODE_APPEND_DATA");
8167 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8177 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8179 VTOSMB(vp)->n_name, action, KAUTH_VNODE_DELETE_CHILD);
8180 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8189 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8191 VTOSMB(vp)->n_name, action, KAUTH_VNODE_READ_ATTRIBUTES);
8192 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8198 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8200 VTOSMB(vp)->n_name, action);
8201 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8209 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8211 VTOSMB(vp)->n_name, action);
8212 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8220 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8222 VTOSMB(vp)->n_name, action);
8223 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8231 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8233 VTOSMB(vp)->n_name, action);
8234 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8243 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8245 VTOSMB(vp)->n_name, action);
8246 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8255 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8257 VTOSMB(vp)->n_name, action);
8258 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8266 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8268 VTOSMB(vp)->n_name, action);
8269 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8277 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8279 VTOSMB(vp)->n_name, action);
8280 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8288 lck_rw_lock_shared(&VTOSMB(vp)->n_name_rwlock);
8289 SMB_LOG_ACCESS("%s action = 0x%x denied\n", VTOSMB(vp)->n_name, action);
8290 lck_rw_unlock_shared(&VTOSMB(vp)->n_name_rwlock);
8313 vnode_t vp = ap->a_vp;
8322 if (!vnode_isreg(vp)) {
8324 if (vnode_isdir(vp))
8330 if ((error = smbnode_lock(VTOSMB(vp), SMBFS_EXCLUSIVE_LOCK))) {
8336 np = VTOSMB(vp);
8352 if (FindFileRef(vp, vfs_context_proc(ap->a_context), kAccessWrite,
8370 share = smb_get_share_with_reference(VTOSMBFS(vp));
8371 length = roundup(length, VTOSMBFS(vp)->sm_statfsbuf.f_bsize);
8846 smbfs_update_ctx(struct vnode *vp,
8910 if (vp != NULL) {
8911 np = VTOSMB(vp);
9166 if (vp) {
9167 np = VTOSMB(vp);
9263 struct vnode *vp = NULL;
9434 &ctx->f_attr, &vp,
9454 &ctx->f_attr, &vp,
9462 /* Dont care if we got an error or not, just whether vp == NULL or not */
9463 if (vp != NULL) {
9468 smbfs_update_name_par(ctx->f_share, dvp, vp,
9478 if (vp != NULL) {
9479 smbnode_unlock(VTOSMB(vp));
9480 vnode_put(vp);
9488 smbfs_update_ctx(vp, vap, ctx, context);
9495 (vp != NULL) &&
9499 DBG_ASSERT(!vnode_isnamedstream(vp));
9500 (void)smbfs_getsecurity(share, VTOSMB(vp), vap, context);
9507 if (vp != NULL) {
9508 smbnode_unlock(VTOSMB(vp));
9520 tmp_error = vfs_attr_pack(vp, uio, ap->a_alist, ap->a_options,
9552 /* Done with the vp */
9553 if (vp != NULL) {
9554 vnode_put(vp);