Lines Matching defs:dnp
1535 nfsnode_t dnp = NULL;
1742 dnp = (dvp && vname) ? VTONFS(dvp) : NULL;
1743 if (dnp) {
1744 error = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
1746 dnp = NULL;
1750 if (dnp) {
1751 nfs_dulookup_init(&dul, dnp, vname, strlen(vname), ctx);
1752 nfs_dulookup_start(&dul, dnp, ctx);
1763 if (dnp) {
1764 nfs_dulookup_finish(&dul, dnp, ctx);
1765 nfs_node_clear_busy(dnp);
2013 nfsnode_t dnp, np;
2026 dnp = VTONFS(dvp);
2038 if ((error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx))))
2041 if ((error = nfs_getattr(dnp, NULL, ctx, NGA_CACHED)))
2053 error = nfs_dir_buf_cache_lookup(dnp, &np, cnp, ctx, 0);
2067 nfs_node_clear_busy(dnp);
2096 if ((nfsvers >= NFS_VER4) && (dnp->n_vattr.nva_flags & NFS_FFLAG_TRIGGER)) {
2119 error = nmp->nm_funcs->nf_lookup_rpc_async(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &req);
2121 error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, req, &xid, &fh, &nvattr);
2125 isdot = NFS_CMPFH(dnp, fh.fh_data, fh.fh_len);
2154 nfs_node_lock_force(dnp);
2155 if (fh.fh_len && (dnp->n_xid <= xid))
2156 nfs_loadattrcache(dnp, &nvattr, &xid, 0);
2157 nfs_node_unlock(dnp);
2160 error = nfs_nget(mp, dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, ngflags, &np);
2181 nfs_node_lock_force(dnp);
2183 dnp->n_flag |= NNEGNCENTRIES;
2184 nfs_node_unlock(dnp);
2189 nfs_node_clear_busy(dnp);
3331 nfsnode_t dnp = VTONFS(dvp);
3361 nfs_avoid_needless_id_setting_on_create(dnp, vap, ctx);
3378 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
3392 error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
3395 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_MKNOD,
3400 if ((lockerror = nfs_node_lock(dnp)))
3405 if (dnp->n_flag & NNEGNCENTRIES) {
3406 dnp->n_flag &= ~NNEGNCENTRIES;
3409 error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
3412 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
3420 dnp->n_flag |= NMODIFIED;
3422 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
3423 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
3424 nfs_node_unlock(dnp);
3426 nfs_getattr(dnp, NULL, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
3430 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
3432 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3436 nfs_node_clear_busy(dnp);
3481 nfsnode_t dnp = VTONFS(dvp);
3500 nfs_avoid_needless_id_setting_on_create(dnp, vap, ctx);
3518 error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
3519 nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
3527 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
3551 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_CREATE,
3554 nfs_dulookup_start(&dul, dnp, ctx);
3558 if ((lockerror = nfs_node_lock(dnp)))
3562 if (dnp->n_flag & NNEGNCENTRIES) {
3563 dnp->n_flag &= ~NNEGNCENTRIES;
3566 error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
3569 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
3577 dnp->n_flag |= NMODIFIED;
3579 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
3580 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
3581 nfs_node_unlock(dnp);
3583 nfs_getattr(dnp, NULL, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
3587 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
3589 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
3593 nfs_dulookup_finish(&dul, dnp, ctx);
3595 nfs_node_clear_busy(dnp);
3662 nfsnode_t dnp = VTONFS(dvp);
3671 nmp = NFSTONMP(dnp);
3678 error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx));
3692 nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
3717 nfs_node_clear_busy2(dnp, np);
3728 nfs_dulookup_finish(&dul, dnp, ctx);
3740 nfs_name_cache_purge(dnp, np, cnp, ctx);
3743 nfs_dulookup_start(&dul, dnp, ctx);
3746 error = nmp->nm_funcs->nf_remove_rpc(dnp, cnp->cn_nameptr, cnp->cn_namelen,
3787 nfs_dulookup_start(&dul, dnp, ctx);
3788 error = nfs_sillyrename(dnp, np, cnp, ctx);
3797 nfs_dulookup_start(&dul, dnp, ctx);
3801 nfs_getattr(dnp, NULL, ctx, NGA_CACHED);
3803 nfs_dulookup_finish(&dul, dnp, ctx);
3813 nfs_node_clear_busy2(dnp, np);
3836 nfsnode_t dnp,
3849 nmp = NFSTONMP(dnp);
3861 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
3866 error = nfs_request2(dnp, NULL, &nmreq, NFSPROC_REMOVE, thd, cred, NULL, 0, &nmrep, &xid, &status);
3868 if ((lockerror = nfs_node_lock(dnp)))
3871 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &xid);
3873 dnp->n_flag |= NMODIFIED;
3875 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
3876 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
3878 NATTRINVALIDATE(dnp);
3883 nfs_node_unlock(dnp);
4259 nfsnode_t dnp = VTONFS(dvp);
4275 nfs_avoid_needless_id_setting_on_create(dnp, vap, ctx);
4286 error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
4287 nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
4295 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
4305 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_SYMLINK,
4308 nfs_dulookup_start(&dul, dnp, ctx);
4312 if ((lockerror = nfs_node_lock(dnp)))
4316 if (dnp->n_flag & NNEGNCENTRIES) {
4317 dnp->n_flag &= ~NNEGNCENTRIES;
4321 error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
4326 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
4334 dnp->n_flag |= NMODIFIED;
4336 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
4337 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
4338 nfs_node_unlock(dnp);
4340 nfs_getattr(dnp, NULL, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
4344 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
4348 nfs_dulookup_finish(&dul, dnp, ctx);
4360 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
4368 nfs_node_clear_busy(dnp);
4410 nfsnode_t dnp = VTONFS(dvp);
4428 nfs_avoid_needless_id_setting_on_create(dnp, vap, ctx);
4439 error = busyerror = nfs_node_set_busy(dnp, vfs_context_thread(ctx));
4440 nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
4448 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
4457 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_MKDIR,
4460 nfs_dulookup_start(&dul, dnp, ctx);
4464 if ((lockerror = nfs_node_lock(dnp)))
4468 if (dnp->n_flag & NNEGNCENTRIES) {
4469 dnp->n_flag &= ~NNEGNCENTRIES;
4472 error = nfsm_chain_get_fh_attr(&nmrep, dnp, ctx, nfsvers, &xid, &fh, &nvattr);
4475 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &dxid);
4483 dnp->n_flag |= NMODIFIED;
4485 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
4486 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
4487 nfs_node_unlock(dnp);
4489 nfs_getattr(dnp, NULL, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
4493 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len, &nvattr, &xid, rq.r_auth, NG_MAKEENTRY, &np);
4497 nfs_dulookup_finish(&dul, dnp, ctx);
4509 error = nfs_lookitup(dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx, &np);
4517 nfs_node_clear_busy(dnp);
4559 nfsnode_t dnp = VTONFS(dvp);
4573 if ((error = nfs_node_set_busy2(dnp, np, vfs_context_thread(ctx))))
4576 nfs_dulookup_init(&dul, dnp, cnp->cn_nameptr, cnp->cn_namelen, ctx);
4583 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
4588 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_RMDIR,
4591 nfs_dulookup_start(&dul, dnp, ctx);
4595 if ((lockerror = nfs_node_lock(dnp)))
4598 nfsm_chain_get_wcc_data(error, &nmrep, dnp, &premtime, &wccpostattr, &xid);
4606 dnp->n_flag |= NMODIFIED;
4608 if (nfstimespeccmp(&dnp->n_ncmtime, &premtime, ==))
4609 NFS_CHANGED_UPDATE_NC(nfsvers, dnp, &dnp->n_vattr);
4610 nfs_node_unlock(dnp);
4611 nfs_name_cache_purge(dnp, np, cnp, ctx);
4613 nfs_getattr(dnp, NULL, ctx, wccpostattr ? NGA_CACHED : NGA_UNCACHED);
4615 nfs_dulookup_finish(&dul, dnp, ctx);
4616 nfs_node_clear_busy2(dnp, np);
4676 nfsnode_t dnp = VTONFS(dvp);
4705 if ((nfsvers >= NFS_VER4) && (dnp->n_vattr.nva_flags & NFS_FFLAG_TRIGGER)) {
4715 if ((error = nfs_node_lock(dnp)))
4718 if (dnp->n_flag & NNEEDINVALIDATE) {
4719 dnp->n_flag &= ~NNEEDINVALIDATE;
4720 nfs_invaldir(dnp);
4721 nfs_node_unlock(dnp);
4724 error = nfs_node_lock(dnp);
4733 if (dnp->n_flag & NMODIFIED) {
4734 nfs_invaldir(dnp);
4735 nfs_node_unlock(dnp);
4739 nfs_node_unlock(dnp);
4742 if ((error = nfs_getattr(dnp, NULL, ctx, NGA_UNCACHED)))
4745 nfs_node_unlock(dnp);
4748 error = nfs_dir_cookie_to_lbn(dnp, nextcookie, &ptc, &lbn);
4762 error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ, &bp);
4771 ndbhp->ndbh_ncgen = dnp->n_ncgen;
4779 if (!nfs_node_lock(dnp)) {
4780 nfs_invaldir(dnp);
4781 nfs_node_unlock(dnp);
4870 nfs_dir_cookie_cache(dnp, nextcookie, lbn);
4884 nfs_invaldir(nfsnode_t dnp)
4886 if (vnode_vtype(NFSTOV(dnp)) != VDIR)
4888 dnp->n_eofcookie = 0;
4889 dnp->n_cookieverf = 0;
4890 if (!dnp->n_cookiecache)
4892 dnp->n_cookiecache->free = 0;
4893 dnp->n_cookiecache->mru = -1;
4894 memset(dnp->n_cookiecache->next, -1, NFSNUMCOOKIES);
4918 nfs_dir_cookie_cache(nfsnode_t dnp, uint64_t cookie, uint64_t lbn)
4926 if (nfs_node_lock(dnp))
4929 if (cookie == dnp->n_eofcookie) { /* EOF cookie */
4930 nfs_node_unlock(dnp);
4934 ndcc = dnp->n_cookiecache;
4937 MALLOC_ZONE(dnp->n_cookiecache, struct nfsdmap *,
4939 if (!dnp->n_cookiecache) {
4940 nfs_node_unlock(dnp);
4943 ndcc = dnp->n_cookiecache;
4979 nfs_node_unlock(dnp);
4987 nfs_dir_cookie_to_lbn(nfsnode_t dnp, uint64_t cookie, int *ptc, uint64_t *lbnp)
4989 struct nfsdmap *ndcc = dnp->n_cookiecache;
5004 if (nfs_node_lock(dnp))
5007 if (cookie == dnp->n_eofcookie) { /* EOF cookie */
5008 nfs_node_unlock(dnp);
5014 eofptc = *ptc ? NFS_DIR_COOKIE_SAME32(cookie, dnp->n_eofcookie) : 0;
5022 nfs_node_unlock(dnp);
5034 nfs_node_unlock(dnp);
5041 nfs_node_unlock(dnp);
5045 nfs_node_unlock(dnp);
5051 nmp = NFSTONMP(dnp);
5067 if (!nfs_buf_iterprepare(dnp, &blist, NBI_CLEAN)) {
5072 LIST_INSERT_HEAD(&dnp->n_cleanblkhd, bp, nb_vnbufs);
5115 nfs_buf_itercomplete(dnp, &blist, NBI_CLEAN);
5208 nfs_dir_buf_cache_lookup(nfsnode_t dnp, nfsnode_t *npp, struct componentname *cnp, vfs_context_t ctx, int purge)
5223 if (!(nmp = NFSTONMP(dnp)))
5229 lbn = dnp->n_lastdbl;
5231 if ((error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ|NBLK_ONLYVALID, &bp)))
5249 dnp->n_lastdbl = lbn;
5262 if (!nfs_buf_iterprepare(dnp, &blist, NBI_CLEAN)) {
5267 LIST_INSERT_HEAD(&dnp->n_cleanblkhd, bp, nb_vnbufs);
5295 LIST_INSERT_HEAD(&dnp->n_cleanblkhd, foundbp, nb_vnbufs);
5296 dnp->n_lastdbl = foundbp->nb_lblkno;
5298 nfs_buf_itercomplete(dnp, &blist, NBI_CLEAN);
5304 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len,
5305 &nvattr, &xid, dnp->n_auth, NG_MAKEENTRY, &newnp);
5315 error = nfs_buf_get(dnp, lbn, NFS_DIRBLKSIZ, thd, NBLK_READ|NBLK_ONLYVALID, &bp);
5334 nfs_name_cache_purge(nfsnode_t dnp, nfsnode_t np, struct componentname *cnp, vfs_context_t ctx)
5336 struct nfsmount *nmp = NFSTONMP(dnp);
5340 nfs_dir_buf_cache_lookup(dnp, NULL, cnp, ctx, 1);
5347 nfs3_readdir_rpc(nfsnode_t dnp, struct nfsbuf *bp, vfs_context_t ctx)
5363 nmp = NFSTONMP(dnp);
5373 if ((lockerror = nfs_node_lock(dnp)))
5401 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
5406 nfsm_chain_add_64(error, &nmreq, dnp->n_cookieverf);
5414 nfs_node_unlock(dnp);
5418 error = nfs_request(dnp, NULL, &nmreq,
5422 if ((lockerror = nfs_node_lock(dnp)))
5427 nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
5431 nfsm_chain_get_64(error, &nmrep, dnp->n_cookieverf);
5435 nfs_node_unlock(dnp);
5470 fhlen = rdirplus ? (1 + dnp->n_fhsize) : 0;
5489 error = nfs_buf_get(dnp, lastcookie, NFS_DIRBLKSIZ, vfs_context_thread(ctx), NBLK_READ, &bp);
5496 ndbhp->ndbh_ncgen = dnp->n_ncgen;
5519 if (!bigcookies && (cookie >> 32) && (nmp == NFSTONMP(dnp))) {
5590 nfs_node_lock_force(dnp);
5591 dnp->n_eofcookie = lastcookie;
5592 nfs_node_unlock(dnp);
5601 if ((lockerror = nfs_node_lock(dnp)))
5611 nfs_node_unlock(dnp);
5634 nfsnode_t dnp,
5646 nmp = NFSTONMP(dnp);
5650 nfs_name_cache_purge(dnp, np, cnp, ctx);
5659 nsp->nsr_dnp = dnp;
5660 error = vnode_ref(NFSTOV(dnp));
5673 while (nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, NULL) == 0) {
5682 error = nmp->nm_funcs->nf_rename_rpc(dnp, cnp->cn_nameptr, cnp->cn_namelen,
5683 dnp, nsp->nsr_name, nsp->nsr_namlen, ctx);
5689 nfs_node_lock_force(dnp);
5690 if (dnp->n_flag & NNEGNCENTRIES) {
5691 dnp->n_flag &= ~NNEGNCENTRIES;
5692 cache_purge_negatives(NFSTOV(dnp));
5694 nfs_node_unlock(dnp);
5696 FSDBG(267, dnp, np, num, error);
5699 error = nfs_lookitup(dnp, nsp->nsr_name, nsp->nsr_namlen, ctx, &np);
5705 vnode_rele(NFSTOV(dnp));
5715 nfsnode_t dnp,
5725 nmp = NFSTONMP(dnp);
5734 nfsm_chain_add_fh(error, &nmreq, nfsvers, dnp->n_fhp, dnp->n_fhsize);
5738 error = nfs_request_async(dnp, NULL, &nmreq, NFSPROC_LOOKUP,
5747 nfsnode_t dnp,
5761 nmp = NFSTONMP(dnp);
5768 if ((lockerror = nfs_node_lock(dnp)))
5773 nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
5787 nfsm_chain_postop_attr_update(error, &nmrep, dnp, &xid);
5789 error = nfs3_getattr_rpc(NULL, NFSTOMP(dnp), fhp->fh_data, fhp->fh_len, 0, ctx, nvap, xidp);
5795 nfs_node_unlock(dnp);
5810 nfsnode_t dnp,
5824 nmp = NFSTONMP(dnp);
5838 newnp = dnp;
5842 error = nmp->nm_funcs->nf_lookup_rpc_async(dnp, name, namelen, ctx, &req);
5844 error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, name, namelen, ctx, req, &xid, &fh, &nvattr);
5871 } else if (NFS_CMPFH(dnp, fh.fh_data, fh.fh_len)) {
5872 nfs_node_lock_force(dnp);
5873 if (dnp->n_xid <= xid)
5874 error = nfs_loadattrcache(dnp, &nvattr, &xid, 0);
5875 nfs_node_unlock(dnp);
5877 newnp = dnp;
5883 error = nfs_nget(NFSTOMP(dnp), dnp, cnp, fh.fh_data, fh.fh_len,
5901 nfs_dulookup_init(struct nfs_dulookup *dulp, nfsnode_t dnp, const char *name, int namelen, vfs_context_t ctx)
5905 struct nfsmount *nmp = NFSTONMP(dnp);
5927 error = cache_lookup(NFSTOV(dnp), &du_vp, &dulp->du_cn);
5931 nmp = NFSTONMP(dnp);
5935 if (!nfs_dir_buf_cache_lookup(dnp, &du_np, &dulp->du_cn, ctx, 0) && du_np) {
5951 nfs_dulookup_start(struct nfs_dulookup *dulp, nfsnode_t dnp, vfs_context_t ctx)
5953 struct nfsmount *nmp = NFSTONMP(dnp);
5958 if (!nmp->nm_funcs->nf_lookup_rpc_async(dnp, dulp->du_cn.cn_nameptr,
5967 nfs_dulookup_finish(struct nfs_dulookup *dulp, nfsnode_t dnp, vfs_context_t ctx)
5969 struct nfsmount *nmp = NFSTONMP(dnp);
5980 error = nmp->nm_funcs->nf_lookup_rpc_async_finish(dnp, dulp->du_cn.cn_nameptr,
5985 nfs_node_lock_force(dnp);
5986 cache_enter(NFSTOV(dnp), NULL, &dulp->du_cn);
5987 dnp->n_flag |= NNEGNCENTRIES;
5988 nfs_node_unlock(dnp);
5990 error = nfs_nget(NFSTOMP(dnp), dnp, &dulp->du_cn, fh.fh_data, fh.fh_len,