Lines Matching defs:np
197 nfsnode_t np;
219 for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
220 mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
221 if (mp != mp2 || np->n_fhsize != fhsize ||
222 bcmp(fhp, np->n_fhp, fhsize))
228 const char *vname = vnode_getname(NFSTOV(np));
239 FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
241 if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
242 np->n_hflag |= NHLOCKWANT;
243 FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
244 msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
245 FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
248 vp = NFSTOV(np);
259 if ((error = nfs_node_lock(np))) {
273 error = nfs_loadattrcache(np, nvap, xidp, 0);
275 nfs_node_unlock(np);
358 *npp = np;
378 MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
379 if (!np) {
385 bzero(np, sizeof *np);
386 np->n_hflag |= (NHINIT | NHLOCKED);
387 np->n_mount = mp;
388 np->n_auth = auth;
389 TAILQ_INIT(&np->n_opens);
390 TAILQ_INIT(&np->n_lock_owners);
391 TAILQ_INIT(&np->n_locks);
392 np->n_dlink.tqe_next = NFSNOLIST;
393 np->n_dreturn.tqe_next = NFSNOLIST;
394 np->n_monlink.le_next = NFSNOLIST;
400 np->n_flag |= NISDOTZFS;
402 np->n_flag |= NISDOTZFSCHILD;
409 np->n_parent = dvp;
416 MALLOC_ZONE(np->n_fhp, u_char *,
418 if (!np->n_fhp) {
420 FREE_ZONE(np, sizeof *np, M_NFSNODE);
426 np->n_fhp = &np->n_fh[0];
428 bcopy(fhp, np->n_fhp, fhsize);
429 np->n_fhsize = fhsize;
432 LIST_INSERT_HEAD(nhpp, np, n_hash);
433 np->n_hflag |= NHHASHED;
434 FSDBG(266, 0, np, np->n_flag, np->n_hflag);
437 lck_mtx_init(&np->n_lock, nfs_node_lck_grp, LCK_ATTR_NULL);
438 lck_rw_init(&np->n_datalock, nfs_data_lck_grp, LCK_ATTR_NULL);
439 lck_mtx_init(&np->n_openlock, nfs_open_grp, LCK_ATTR_NULL);
440 lck_mtx_lock(&np->n_lock);
446 NACLINVALIDATE(np);
447 NACCESSINVALIDATE(np);
448 error = nfs_loadattrcache(np, nvap, xidp, 1);
450 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
451 nfs_node_unlock(np);
453 LIST_REMOVE(np, n_hash);
454 np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
455 if (np->n_hflag & NHLOCKWANT) {
456 np->n_hflag &= ~NHLOCKWANT;
457 wakeup(np);
460 if (np->n_parent) {
461 if (!vnode_get(np->n_parent)) {
462 vnode_rele(np->n_parent);
463 vnode_put(np->n_parent);
465 np->n_parent = NULL;
467 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
468 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
469 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
470 if (np->n_fhsize > NFS_SMALLFH)
471 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
472 FREE_ZONE(np, sizeof *np, M_NFSNODE);
477 NFS_CHANGED_UPDATE(nfsvers, np, nvap);
479 NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
486 vfsp.vnfs_fsnode = np;
518 if ((nfsvers >= NFS_VER4) && (nvap->nva_type == VDIR) && (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER)) {
526 error = vnode_create(VNCREATE_TRIGGER, VNCREATE_TRIGGER_SIZE, &vtp, &np->n_vnode);
530 error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &np->n_vnode);
533 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
534 nfs_node_unlock(np);
536 LIST_REMOVE(np, n_hash);
537 np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
538 if (np->n_hflag & NHLOCKWANT) {
539 np->n_hflag &= ~NHLOCKWANT;
540 wakeup(np);
543 if (np->n_parent) {
544 if (!vnode_get(np->n_parent)) {
545 vnode_rele(np->n_parent);
546 vnode_put(np->n_parent);
548 np->n_parent = NULL;
550 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
551 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
552 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
553 if (np->n_fhsize > NFS_SMALLFH)
554 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
555 FREE_ZONE(np, sizeof *np, M_NFSNODE);
560 vp = np->n_vnode;
566 np->n_hflag &= ~(NHINIT|NHLOCKED);
567 if (np->n_hflag & NHLOCKWANT) {
568 np->n_hflag &= ~NHLOCKWANT;
569 wakeup(np);
573 *npp = np;
590 nfsnode_t np = VTONFS(ap->a_vp);
596 struct nfsmount *nmp = NFSTONMP(np);
605 lck_mtx_lock(&np->n_openlock);
606 if (np->n_openrefcnt && !force)
607 NP(np, "nfs_vnop_inactive: still open: %d", np->n_openrefcnt);
608 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
612 NP(np, "nfs_vnop_inactive: open file busy");
619 if ((np->n_flag & NREVOKE) || (nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
632 lck_mtx_unlock(&np->n_openlock);
641 lck_mtx_unlock(&np->n_openlock);
642 error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, ctx);
644 NP(np, "nfs_vnop_inactive: create close error: %d", error);
665 lck_mtx_unlock(&np->n_openlock);
674 error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
676 NP(np, "nfs_vnop_inactive: need close error: %d", error);
687 NP(np, "nfs_vnop_inactive: file still open: %d", nofp->nof_opencnt);
696 NP(np, "nfs_vnop_inactive: non-zero access: %d %d %d %d # %u.%u %u.%u %u.%u dw %u.%u %u.%u %u.%u drw %u.%u %u.%u %u.%u",
712 lck_mtx_unlock(&np->n_openlock);
717 nfs_node_lock_force(np);
720 nsp = np->n_sillyrename;
721 np->n_sillyrename = NULL;
726 FSDBG_TOP(264, vp, np, np->n_flag, nsp);
731 np->n_flag &= (NMODIFIED);
732 nfs_node_unlock(np);
733 FSDBG_BOT(264, vp, np, np->n_flag, 0);
736 nfs_node_unlock(np);
744 attrerr = nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED);
756 busyerror = nfs_node_set_busy2(nsp->nsr_dnp, np, vfs_context_thread(ctx));
760 while (np->n_hflag & NHLOCKED) {
761 np->n_hflag |= NHLOCKWANT;
762 msleep(np, nfs_node_hash_mutex, PINOD, "nfs_inactive", NULL);
764 np->n_hflag |= NHLOCKED;
771 nfs_name_cache_purge(nsp->nsr_dnp, np, &cn, ctx);
773 FSDBG(264, np, np->n_size, np->n_vattr.nva_size, 0xf00d00f1);
779 nfs_node_lock_force(np);
780 np->n_flag &= (NMODIFIED);
781 nfs_node_unlock(np);
784 nfs_node_clear_busy2(nsp->nsr_dnp, np);
789 ubc_setsize(vp, np->n_size);
799 if (np->n_hflag & NHHASHED) {
800 LIST_REMOVE(np, n_hash);
801 np->n_hflag &= ~NHHASHED;
802 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
807 np->n_hflag &= ~NHLOCKED;
808 if (np->n_hflag & NHLOCKWANT) {
809 np->n_hflag &= ~NHLOCKWANT;
810 wakeup(np);
820 FSDBG_BOT(264, vp, np, np->n_flag, 0);
836 nfsnode_t np = VTONFS(vp);
841 struct nfsmount *nmp = np->n_mount ? VFSTONFS(np->n_mount) : NFSTONMP(np);
845 FSDBG_TOP(265, vp, np, np->n_flag, 0);
849 lck_mtx_lock(&np->n_openlock);
853 if (np->n_dreturn.tqe_next != NFSNOLIST) {
856 if (np->n_dreturn.tqe_next != NFSNOLIST) {
857 TAILQ_REMOVE(&nmp->nm_dreturnq, np, n_dreturn);
858 np->n_dreturn.tqe_next = NFSNOLIST;
862 if (np->n_dlink.tqe_next != NFSNOLIST) {
865 if (np->n_dlink.tqe_next != NFSNOLIST) {
866 TAILQ_REMOVE(&nmp->nm_delegations, np, n_dlink);
867 np->n_dlink.tqe_next = NFSNOLIST;
871 if ((np->n_openflags & N_DELEG_MASK) && !force) {
873 np->n_openflags &= ~N_DELEG_MASK;
874 nfs4_delegreturn_rpc(nmp, np->n_fhp, np->n_fhsize, &np->n_dstateid,
877 if (np->n_attrdirfh) {
878 FREE(np->n_attrdirfh, M_TEMP);
879 np->n_attrdirfh = NULL;
884 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
886 NP(np, "nfs_vnop_reclaim: lock 0x%llx 0x%llx 0x%x (bc %d)",
892 nmp->nm_funcs->nf_unlock_rpc(np, nflp->nfl_owner, F_WRLCK, nflp->nfl_start, nflp->nfl_end, R_RECOVER,
898 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
902 TAILQ_FOREACH_SAFE(nlop, &np->n_lock_owners, nlo_link, nextnlop) {
904 NP(np, "nfs_vnop_reclaim: lock owner with locks");
905 TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link);
909 if (np->n_openrefcnt && !force)
910 NP(np, "nfs_vnop_reclaim: still open: %d", np->n_openrefcnt);
911 TAILQ_FOREACH_SAFE(nofp, &np->n_opens, nof_link, nextnofp) {
913 NP(np, "nfs_vnop_reclaim: open file busy");
914 if (!(np->n_flag & NREVOKE) && !(nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
916 NP(np, "nfs_vnop_reclaim: file still open: %d", nofp->nof_opencnt);
925 NP(np, "nfs_vnop_reclaim: non-zero access: %d %d %d %d # %u.%u %u.%u %u.%u dw %u.%u %u.%u %u.%u drw %u.%u %u.%u %u.%u",
941 nfs4_close_rpc(np, nofp, NULL, nofp->nof_owner->noo_cred, R_RECOVER);
944 TAILQ_REMOVE(&np->n_opens, nofp, nof_link);
947 lck_mtx_unlock(&np->n_openlock);
949 if (np->n_monlink.le_next != NFSNOLIST) {
953 while (np->n_mflag & NMMONSCANINPROG) {
955 np->n_mflag |= NMMONSCANWANT;
956 msleep(&np->n_mflag, &nmp->nm_lock, PZERO-1, "nfswaitmonscan", &ts);
958 if (np->n_monlink.le_next != NFSNOLIST) {
959 LIST_REMOVE(np, n_monlink);
960 np->n_monlink.le_next = NFSNOLIST;
966 if (!force && (!LIST_EMPTY(&np->n_dirtyblkhd) || !LIST_EMPTY(&np->n_cleanblkhd)))
967 NP(np, "nfs_reclaim: dropping %s buffers", (!LIST_EMPTY(&np->n_dirtyblkhd) ? "dirty" : "clean"));
973 if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename) {
975 NP(np, "nfs_reclaim: leaving unlinked file %s", np->n_sillyrename->nsr_name);
976 if (np->n_sillyrename->nsr_cred != NOCRED)
977 kauth_cred_unref(&np->n_sillyrename->nsr_cred);
978 vnode_rele(NFSTOV(np->n_sillyrename->nsr_dnp));
979 FREE_ZONE(np->n_sillyrename, sizeof(*np->n_sillyrename), M_NFSREQ);
984 if (np->n_hflag & NHHASHED) {
985 LIST_REMOVE(np, n_hash);
986 np->n_hflag &= ~NHHASHED;
987 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
995 nfs_node_lock_force(np);
996 if ((vnode_vtype(vp) == VDIR) && np->n_cookiecache)
997 FREE_ZONE(np->n_cookiecache, sizeof(struct nfsdmap), M_NFSDIROFF);
998 if (np->n_fhsize > NFS_SMALLFH)
999 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
1000 if (np->n_vattr.nva_acl)
1001 kauth_acl_free(np->n_vattr.nva_acl);
1002 nfs_node_unlock(np);
1005 if (np->n_parent) {
1006 if (!vnode_get(np->n_parent)) {
1007 vnode_rele(np->n_parent);
1008 vnode_put(np->n_parent);
1010 np->n_parent = NULL;
1013 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
1014 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
1015 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
1017 FSDBG_BOT(265, vp, np, np->n_flag, 0xd1ed1e);
1018 FREE_ZONE(np, sizeof(struct nfsnode), M_NFSNODE);
1027 nfs_node_lock_internal(nfsnode_t np, int force)
1029 FSDBG_TOP(268, np, force, 0, 0);
1030 lck_mtx_lock(&np->n_lock);
1031 if (!force && !(np->n_hflag && NHHASHED)) {
1032 FSDBG_BOT(268, np, 0xdead, 0, 0);
1033 lck_mtx_unlock(&np->n_lock);
1036 FSDBG_BOT(268, np, force, 0, 0);
1041 nfs_node_lock(nfsnode_t np)
1043 return nfs_node_lock_internal(np, 0);
1047 nfs_node_lock_force(nfsnode_t np)
1049 nfs_node_lock_internal(np, 1);
1056 nfs_node_unlock(nfsnode_t np)
1058 FSDBG(269, np, current_thread(), 0, 0);
1059 lck_mtx_unlock(&np->n_lock);
1098 nfs_node_set_busy(nfsnode_t np, thread_t thd)
1103 if ((error = nfs_node_lock(np)))
1105 while (ISSET(np->n_flag, NBUSY)) {
1106 SET(np->n_flag, NBUSYWANT);
1107 msleep(np, &np->n_lock, PZERO-1, "nfsbusywant", &ts);
1108 if ((error = nfs_sigintr(NFSTONMP(np), NULL, thd, 0)))
1112 SET(np->n_flag, NBUSY);
1113 nfs_node_unlock(np);
1118 nfs_node_clear_busy(nfsnode_t np)
1122 nfs_node_lock_force(np);
1123 wanted = ISSET(np->n_flag, NBUSYWANT);
1124 CLR(np->n_flag, NBUSY|NBUSYWANT);
1125 nfs_node_unlock(np);
1127 wakeup(np);
1216 nfs_data_lock(nfsnode_t np, int locktype)
1218 nfs_data_lock_internal(np, locktype, 1);
1221 nfs_data_lock_noupdate(nfsnode_t np, int locktype)
1223 nfs_data_lock_internal(np, locktype, 0);
1226 nfs_data_lock_internal(nfsnode_t np, int locktype, int updatesize)
1228 FSDBG_TOP(270, np, locktype, np->n_datalockowner, 0);
1230 if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
1231 nfs_data_update_size(np, 0);
1232 lck_rw_lock_shared(&np->n_datalock);
1234 lck_rw_lock_exclusive(&np->n_datalock);
1235 np->n_datalockowner = current_thread();
1236 if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
1237 nfs_data_update_size(np, 1);
1239 FSDBG_BOT(270, np, locktype, np->n_datalockowner, 0);
1246 nfs_data_unlock(nfsnode_t np)
1248 nfs_data_unlock_internal(np, 1);
1251 nfs_data_unlock_noupdate(nfsnode_t np)
1253 nfs_data_unlock_internal(np, 0);
1256 nfs_data_unlock_internal(nfsnode_t np, int updatesize)
1258 int mine = (np->n_datalockowner == current_thread());
1259 FSDBG_TOP(271, np, np->n_datalockowner, current_thread(), 0);
1260 if (updatesize && mine && ISSET(np->n_flag, NUPDATESIZE))
1261 nfs_data_update_size(np, 1);
1262 np->n_datalockowner = NULL;
1263 lck_rw_done(&np->n_datalock);
1264 if (updatesize && !mine && ISSET(np->n_flag, NUPDATESIZE))
1265 nfs_data_update_size(np, 0);
1266 FSDBG_BOT(271, np, np->n_datalockowner, current_thread(), 0);
1274 nfs_data_update_size(nfsnode_t np, int datalocked)
1278 FSDBG_TOP(272, np, np->n_flag, np->n_size, np->n_newsize);
1280 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
1282 nfs_data_unlock(np);
1283 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1286 error = nfs_node_lock(np);
1287 if (error || !ISSET(np->n_flag, NUPDATESIZE)) {
1289 nfs_node_unlock(np);
1290 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1293 CLR(np->n_flag, NUPDATESIZE);
1294 np->n_size = np->n_newsize;
1296 SET(np->n_flag, NNEEDINVALIDATE);
1297 nfs_node_unlock(np);
1298 ubc_setsize(NFSTOV(np), (off_t)np->n_size); /* XXX error? */
1299 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1307 nfsnode_t np;
1315 LIST_FOREACH(np, &nfsnodehashtbl[i], n_hash) {
1319 if (np->n_mount == mp && !LIST_EMPTY(&np->n_dirtyblkhd))