Lines Matching refs:np
199 nfsnode_t np;
221 for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
222 mp2 = (np->n_hflag & NHINIT) ? np->n_mount : NFSTOMP(np);
223 if (mp != mp2 || np->n_fhsize != fhsize ||
224 bcmp(fhp, np->n_fhp, fhsize))
230 const char *vname = vnode_getname(NFSTOV(np));
241 FSDBG(263, dnp, np, np->n_flag, 0xcace0000);
243 if ((np->n_hflag & NHLOCKED) && !(flags & NG_NOCREATE)) {
244 np->n_hflag |= NHLOCKWANT;
245 FSDBG(263, dnp, np, np->n_flag, 0xcace2222);
246 msleep(np, nfs_node_hash_mutex, PDROP | PINOD, "nfs_nget", NULL);
247 FSDBG(263, dnp, np, np->n_flag, 0xcace3333);
250 vp = NFSTOV(np);
261 if ((error = nfs_node_lock(np))) {
275 error = nfs_loadattrcache(np, nvap, xidp, 0);
277 nfs_node_unlock(np);
362 *npp = np;
382 MALLOC_ZONE(np, nfsnode_t, sizeof *np, M_NFSNODE, M_WAITOK);
383 if (!np) {
389 bzero(np, sizeof *np);
390 np->n_hflag |= (NHINIT | NHLOCKED);
391 np->n_mount = mp;
392 np->n_auth = auth;
393 TAILQ_INIT(&np->n_opens);
394 TAILQ_INIT(&np->n_lock_owners);
395 TAILQ_INIT(&np->n_locks);
396 np->n_dlink.tqe_next = NFSNOLIST;
397 np->n_dreturn.tqe_next = NFSNOLIST;
398 np->n_monlink.le_next = NFSNOLIST;
404 np->n_flag |= NISDOTZFS;
406 np->n_flag |= NISDOTZFSCHILD;
413 np->n_parent = dvp;
420 MALLOC_ZONE(np->n_fhp, u_char *,
422 if (!np->n_fhp) {
424 FREE_ZONE(np, sizeof *np, M_NFSNODE);
430 np->n_fhp = &np->n_fh[0];
432 bcopy(fhp, np->n_fhp, fhsize);
433 np->n_fhsize = fhsize;
436 LIST_INSERT_HEAD(nhpp, np, n_hash);
437 np->n_hflag |= NHHASHED;
438 FSDBG(266, 0, np, np->n_flag, np->n_hflag);
441 lck_mtx_init(&np->n_lock, nfs_node_lck_grp, LCK_ATTR_NULL);
442 lck_rw_init(&np->n_datalock, nfs_data_lck_grp, LCK_ATTR_NULL);
443 lck_mtx_init(&np->n_openlock, nfs_open_grp, LCK_ATTR_NULL);
444 lck_mtx_lock(&np->n_lock);
450 NACLINVALIDATE(np);
451 NACCESSINVALIDATE(np);
452 error = nfs_loadattrcache(np, nvap, xidp, 1);
454 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
455 nfs_node_unlock(np);
457 LIST_REMOVE(np, n_hash);
458 np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
459 if (np->n_hflag & NHLOCKWANT) {
460 np->n_hflag &= ~NHLOCKWANT;
461 wakeup(np);
464 if (np->n_parent) {
465 if (!vnode_get(np->n_parent)) {
466 vnode_rele(np->n_parent);
467 vnode_put(np->n_parent);
469 np->n_parent = NULL;
471 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
472 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
473 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
474 if (np->n_fhsize > NFS_SMALLFH)
475 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
476 FREE_ZONE(np, sizeof *np, M_NFSNODE);
481 NFS_CHANGED_UPDATE(nfsvers, np, nvap);
483 NFS_CHANGED_UPDATE_NC(nfsvers, np, nvap);
490 vfsp.vnfs_fsnode = np;
522 if ((nfsvers >= NFS_VER4) && (nvap->nva_type == VDIR) && (np->n_vattr.nva_flags & NFS_FFLAG_TRIGGER)) {
530 error = vnode_create(VNCREATE_TRIGGER, VNCREATE_TRIGGER_SIZE, &vtp, &np->n_vnode);
534 error = vnode_create(VNCREATE_FLAVOR, VCREATESIZE, &vfsp, &np->n_vnode);
537 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
538 nfs_node_unlock(np);
540 LIST_REMOVE(np, n_hash);
541 np->n_hflag &= ~(NHHASHED|NHINIT|NHLOCKED);
542 if (np->n_hflag & NHLOCKWANT) {
543 np->n_hflag &= ~NHLOCKWANT;
544 wakeup(np);
547 if (np->n_parent) {
548 if (!vnode_get(np->n_parent)) {
549 vnode_rele(np->n_parent);
550 vnode_put(np->n_parent);
552 np->n_parent = NULL;
554 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
555 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
556 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
557 if (np->n_fhsize > NFS_SMALLFH)
558 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
559 FREE_ZONE(np, sizeof *np, M_NFSNODE);
564 vp = np->n_vnode;
570 np->n_hflag &= ~(NHINIT|NHLOCKED);
571 if (np->n_hflag & NHLOCKWANT) {
572 np->n_hflag &= ~NHLOCKWANT;
573 wakeup(np);
577 *npp = np;
594 nfsnode_t np;
605 np = VTONFS(vp);
606 if (np == NULL)
607 panic("nfs_vnop_inactive: np == NULL");
609 nmp = NFSTONMP(np);
618 lck_mtx_lock(&np->n_openlock);
619 if (np->n_openrefcnt && !force) {
628 NP(np, "nfs_vnop_inactive: still open: %d", np->n_openrefcnt);
630 lck_mtx_unlock(&np->n_openlock);
634 TAILQ_FOREACH(nofp, &np->n_opens, nof_link) {
638 NP(np, "nfs_vnop_inactive: open file busy");
645 if ((np->n_flag & NREVOKE) || (nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
658 lck_mtx_unlock(&np->n_openlock);
667 lck_mtx_unlock(&np->n_openlock);
668 error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_BOTH, NFS_OPEN_SHARE_DENY_NONE, ctx);
670 NP(np, "nfs_vnop_inactive: create close error: %d", error);
691 lck_mtx_unlock(&np->n_openlock);
700 error = nfs_close(np, nofp, NFS_OPEN_SHARE_ACCESS_READ, NFS_OPEN_SHARE_DENY_NONE, ctx);
702 NP(np, "nfs_vnop_inactive: need close error: %d", error);
713 NP(np, "nfs_vnop_inactive: file still open: %d", nofp->nof_opencnt);
722 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",
738 lck_mtx_unlock(&np->n_openlock);
743 nfs_node_lock_force(np);
746 nsp = np->n_sillyrename;
747 np->n_sillyrename = NULL;
752 FSDBG_TOP(264, vp, np, np->n_flag, nsp);
757 np->n_flag &= (NMODIFIED);
758 nfs_node_unlock(np);
759 FSDBG_BOT(264, vp, np, np->n_flag, 0);
762 nfs_node_unlock(np);
770 attrerr = nfs_getattr(np, &nvattr, ctx, NGA_UNCACHED);
782 busyerror = nfs_node_set_busy2(nsp->nsr_dnp, np, vfs_context_thread(ctx));
786 while (np->n_hflag & NHLOCKED) {
787 np->n_hflag |= NHLOCKWANT;
788 msleep(np, nfs_node_hash_mutex, PINOD, "nfs_inactive", NULL);
790 np->n_hflag |= NHLOCKED;
797 nfs_name_cache_purge(nsp->nsr_dnp, np, &cn, ctx);
799 FSDBG(264, np, np->n_size, np->n_vattr.nva_size, 0xf00d00f1);
805 nfs_node_lock_force(np);
806 np->n_flag &= (NMODIFIED);
807 nfs_node_unlock(np);
810 nfs_node_clear_busy2(nsp->nsr_dnp, np);
815 ubc_setsize(vp, np->n_size);
825 if (np->n_hflag & NHHASHED) {
826 LIST_REMOVE(np, n_hash);
827 np->n_hflag &= ~NHHASHED;
828 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
833 np->n_hflag &= ~NHLOCKED;
834 if (np->n_hflag & NHLOCKWANT) {
835 np->n_hflag &= ~NHLOCKWANT;
836 wakeup(np);
846 FSDBG_BOT(264, vp, np, np->n_flag, 0);
862 nfsnode_t np = VTONFS(vp);
867 struct nfsmount *nmp = np->n_mount ? VFSTONFS(np->n_mount) : NFSTONMP(np);
871 FSDBG_TOP(265, vp, np, np->n_flag, 0);
875 lck_mtx_lock(&np->n_openlock);
879 if (np->n_dreturn.tqe_next != NFSNOLIST) {
882 if (np->n_dreturn.tqe_next != NFSNOLIST) {
883 TAILQ_REMOVE(&nmp->nm_dreturnq, np, n_dreturn);
884 np->n_dreturn.tqe_next = NFSNOLIST;
888 if (np->n_dlink.tqe_next != NFSNOLIST) {
891 if (np->n_dlink.tqe_next != NFSNOLIST) {
892 TAILQ_REMOVE(&nmp->nm_delegations, np, n_dlink);
893 np->n_dlink.tqe_next = NFSNOLIST;
897 if ((np->n_openflags & N_DELEG_MASK) && !force) {
899 np->n_openflags &= ~N_DELEG_MASK;
900 nfs4_delegreturn_rpc(nmp, np->n_fhp, np->n_fhsize, &np->n_dstateid,
903 if (np->n_attrdirfh) {
904 FREE(np->n_attrdirfh, M_TEMP);
905 np->n_attrdirfh = NULL;
910 TAILQ_FOREACH_SAFE(nflp, &np->n_locks, nfl_link, nextnflp) {
912 NP(np, "nfs_vnop_reclaim: lock 0x%llx 0x%llx 0x%x (bc %d)",
918 nmp->nm_funcs->nf_unlock_rpc(np, nflp->nfl_owner, F_WRLCK, nflp->nfl_start, nflp->nfl_end, R_RECOVER,
924 TAILQ_REMOVE(&np->n_locks, nflp, nfl_link);
928 TAILQ_FOREACH_SAFE(nlop, &np->n_lock_owners, nlo_link, nextnlop) {
930 NP(np, "nfs_vnop_reclaim: lock owner with locks");
931 TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link);
935 if (np->n_openrefcnt && !force)
936 NP(np, "nfs_vnop_reclaim: still open: %d", np->n_openrefcnt);
937 TAILQ_FOREACH_SAFE(nofp, &np->n_opens, nof_link, nextnofp) {
939 NP(np, "nfs_vnop_reclaim: open file busy");
940 if (!(np->n_flag & NREVOKE) && !(nofp->nof_flags & NFS_OPEN_FILE_LOST)) {
942 NP(np, "nfs_vnop_reclaim: file still open: %d", nofp->nof_opencnt);
951 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",
967 nfs4_close_rpc(np, nofp, NULL, nofp->nof_owner->noo_cred, R_RECOVER);
970 TAILQ_REMOVE(&np->n_opens, nofp, nof_link);
973 lck_mtx_unlock(&np->n_openlock);
975 if (np->n_monlink.le_next != NFSNOLIST) {
979 while (np->n_mflag & NMMONSCANINPROG) {
981 np->n_mflag |= NMMONSCANWANT;
982 msleep(&np->n_mflag, &nmp->nm_lock, PZERO-1, "nfswaitmonscan", &ts);
984 if (np->n_monlink.le_next != NFSNOLIST) {
985 LIST_REMOVE(np, n_monlink);
986 np->n_monlink.le_next = NFSNOLIST;
992 if (!force && (!LIST_EMPTY(&np->n_dirtyblkhd) || !LIST_EMPTY(&np->n_cleanblkhd)))
993 NP(np, "nfs_reclaim: dropping %s buffers", (!LIST_EMPTY(&np->n_dirtyblkhd) ? "dirty" : "clean"));
999 if ((vnode_vtype(vp) != VDIR) && np->n_sillyrename) {
1001 NP(np, "nfs_reclaim: leaving unlinked file %s", np->n_sillyrename->nsr_name);
1002 if (np->n_sillyrename->nsr_cred != NOCRED)
1003 kauth_cred_unref(&np->n_sillyrename->nsr_cred);
1004 vnode_rele(NFSTOV(np->n_sillyrename->nsr_dnp));
1005 FREE_ZONE(np->n_sillyrename, sizeof(*np->n_sillyrename), M_NFSREQ);
1010 if (np->n_hflag & NHHASHED) {
1011 LIST_REMOVE(np, n_hash);
1012 np->n_hflag &= ~NHHASHED;
1013 FSDBG(266, 0, np, np->n_flag, 0xb1eb1e);
1021 nfs_node_lock_force(np);
1022 if ((vnode_vtype(vp) == VDIR) && np->n_cookiecache)
1023 FREE_ZONE(np->n_cookiecache, sizeof(struct nfsdmap), M_NFSDIROFF);
1024 if (np->n_fhsize > NFS_SMALLFH)
1025 FREE_ZONE(np->n_fhp, np->n_fhsize, M_NFSBIGFH);
1026 if (np->n_vattr.nva_acl)
1027 kauth_acl_free(np->n_vattr.nva_acl);
1028 nfs_node_unlock(np);
1031 if (np->n_parent) {
1032 if (!vnode_get(np->n_parent)) {
1033 vnode_rele(np->n_parent);
1034 vnode_put(np->n_parent);
1036 np->n_parent = NULL;
1039 lck_mtx_destroy(&np->n_lock, nfs_node_lck_grp);
1040 lck_rw_destroy(&np->n_datalock, nfs_data_lck_grp);
1041 lck_mtx_destroy(&np->n_openlock, nfs_open_grp);
1043 FSDBG_BOT(265, vp, np, np->n_flag, 0xd1ed1e);
1044 FREE_ZONE(np, sizeof(struct nfsnode), M_NFSNODE);
1053 nfs_node_lock_internal(nfsnode_t np, int force)
1055 FSDBG_TOP(268, np, force, 0, 0);
1056 lck_mtx_lock(&np->n_lock);
1057 if (!force && !(np->n_hflag && NHHASHED)) {
1058 FSDBG_BOT(268, np, 0xdead, 0, 0);
1059 lck_mtx_unlock(&np->n_lock);
1062 FSDBG_BOT(268, np, force, 0, 0);
1067 nfs_node_lock(nfsnode_t np)
1069 return nfs_node_lock_internal(np, 0);
1073 nfs_node_lock_force(nfsnode_t np)
1075 nfs_node_lock_internal(np, 1);
1082 nfs_node_unlock(nfsnode_t np)
1084 FSDBG(269, np, current_thread(), 0, 0);
1085 lck_mtx_unlock(&np->n_lock);
1124 nfs_node_set_busy(nfsnode_t np, thread_t thd)
1129 if ((error = nfs_node_lock(np)))
1131 while (ISSET(np->n_flag, NBUSY)) {
1132 SET(np->n_flag, NBUSYWANT);
1133 msleep(np, &np->n_lock, PZERO-1, "nfsbusywant", &ts);
1134 if ((error = nfs_sigintr(NFSTONMP(np), NULL, thd, 0)))
1138 SET(np->n_flag, NBUSY);
1139 nfs_node_unlock(np);
1144 nfs_node_clear_busy(nfsnode_t np)
1148 nfs_node_lock_force(np);
1149 wanted = ISSET(np->n_flag, NBUSYWANT);
1150 CLR(np->n_flag, NBUSY|NBUSYWANT);
1151 nfs_node_unlock(np);
1153 wakeup(np);
1242 nfs_data_lock(nfsnode_t np, int locktype)
1244 nfs_data_lock_internal(np, locktype, 1);
1247 nfs_data_lock_noupdate(nfsnode_t np, int locktype)
1249 nfs_data_lock_internal(np, locktype, 0);
1252 nfs_data_lock_internal(nfsnode_t np, int locktype, int updatesize)
1254 FSDBG_TOP(270, np, locktype, np->n_datalockowner, 0);
1256 if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
1257 nfs_data_update_size(np, 0);
1258 lck_rw_lock_shared(&np->n_datalock);
1260 lck_rw_lock_exclusive(&np->n_datalock);
1261 np->n_datalockowner = current_thread();
1262 if (updatesize && ISSET(np->n_flag, NUPDATESIZE))
1263 nfs_data_update_size(np, 1);
1265 FSDBG_BOT(270, np, locktype, np->n_datalockowner, 0);
1272 nfs_data_unlock(nfsnode_t np)
1274 nfs_data_unlock_internal(np, 1);
1277 nfs_data_unlock_noupdate(nfsnode_t np)
1279 nfs_data_unlock_internal(np, 0);
1282 nfs_data_unlock_internal(nfsnode_t np, int updatesize)
1284 int mine = (np->n_datalockowner == current_thread());
1285 FSDBG_TOP(271, np, np->n_datalockowner, current_thread(), 0);
1286 if (updatesize && mine && ISSET(np->n_flag, NUPDATESIZE))
1287 nfs_data_update_size(np, 1);
1288 np->n_datalockowner = NULL;
1289 lck_rw_done(&np->n_datalock);
1290 if (updatesize && !mine && ISSET(np->n_flag, NUPDATESIZE))
1291 nfs_data_update_size(np, 0);
1292 FSDBG_BOT(271, np, np->n_datalockowner, current_thread(), 0);
1300 nfs_data_update_size(nfsnode_t np, int datalocked)
1304 FSDBG_TOP(272, np, np->n_flag, np->n_size, np->n_newsize);
1306 nfs_data_lock(np, NFS_DATA_LOCK_EXCLUSIVE);
1308 nfs_data_unlock(np);
1309 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1312 error = nfs_node_lock(np);
1313 if (error || !ISSET(np->n_flag, NUPDATESIZE)) {
1315 nfs_node_unlock(np);
1316 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1319 CLR(np->n_flag, NUPDATESIZE);
1320 np->n_size = np->n_newsize;
1322 SET(np->n_flag, NNEEDINVALIDATE);
1323 nfs_node_unlock(np);
1324 ubc_setsize(NFSTOV(np), (off_t)np->n_size); /* XXX error? */
1325 FSDBG_BOT(272, np, np->n_flag, np->n_size, np->n_newsize);
1334 nfsnode_t np;
1342 LIST_FOREACH(np, &nfsnodehashtbl[i], n_hash) {
1346 if (np->n_mount == mp && !LIST_EMPTY(&np->n_dirtyblkhd))