bsd/nfs/nfs4_vnops.c

1954 nfs_owner_seqid_increment(struct nfs_open_owner *noop, struct nfs_lock_owner *nlop, int error)
1970 	if (nlop)
1971 		nlop->nlo_seqid++;
2428 	struct nfs_lock_owner *nlop = NULL;
2435 			nlop = nfs_lock_owner_find(np, p, 0);
2436 		if (nlop && !TAILQ_EMPTY(&nlop->nlo_locks)) {
2438 			s = &nlop->nlo_stateid;
2462 	if (nlop)
2463 		nfs_lock_owner_rele(nlop);
2953 	struct nfs_lock_owner *nlop, *newnlop = NULL;
2957 	TAILQ_FOREACH(nlop, &np->n_lock_owners, nlo_link) {
2958 		if (nlop->nlo_pid != pid)
2960 		if (timevalcmp(&nlop->nlo_pid_start, &p->p_start, ==))
2963 		if (nlop->nlo_refcnt) {
2964 			TAILQ_REMOVE(&np->n_lock_owners, nlop, nlo_link);
2965 			nlop->nlo_flags &= ~NFS_LOCK_OWNER_LINK;
2969 		nlop->nlo_pid_start = p->p_start;
2970 		nlop->nlo_seqid = 0;
2971 		nlop->nlo_stategenid = 0;
2975 	if (!nlop && !newnlop && alloc) {
2988 	if (!nlop && newnlop) {
2991 		nlop = newnlop;
2995 	if (newnlop && (nlop != newnlop))
2998 	if (nlop)
2999 		nfs_lock_owner_ref(nlop);
3001 	return (nlop);
3008 nfs_lock_owner_destroy(struct nfs_lock_owner *nlop)
3010 	if (nlop->nlo_open_owner) {
3011 		nfs_open_owner_rele(nlop->nlo_open_owner);
3012 		nlop->nlo_open_owner = NULL;
3014 	lck_mtx_destroy(&nlop->nlo_lock, nfs_open_grp);
3015 	FREE(nlop, M_TEMP);
3022 nfs_lock_owner_ref(struct nfs_lock_owner *nlop)
3024 	lck_mtx_lock(&nlop->nlo_lock);
3025 	nlop->nlo_refcnt++;
3026 	lck_mtx_unlock(&nlop->nlo_lock);
3034 nfs_lock_owner_rele(struct nfs_lock_owner *nlop)
3036 	lck_mtx_lock(&nlop->nlo_lock);
3037 	if (nlop->nlo_refcnt < 1)
3039 	nlop->nlo_refcnt--;
3040 	if (!nlop->nlo_refcnt && (nlop->nlo_flags & NFS_LOCK_OWNER_BUSY))
3043 	if (nlop->nlo_refcnt || (nlop->nlo_flags & NFS_LOCK_OWNER_LINK)) {
3044 		lck_mtx_unlock(&nlop->nlo_lock);
3048 	lck_mtx_unlock(&nlop->nlo_lock);
3049 	nfs_lock_owner_destroy(nlop);
3057 nfs_lock_owner_set_busy(struct nfs_lock_owner *nlop, thread_t thd)
3063 	nmp = nlop->nlo_open_owner->noo_mount;
3068 	lck_mtx_lock(&nlop->nlo_lock);
3069 	while (nlop->nlo_flags & NFS_LOCK_OWNER_BUSY) {
3072 		nlop->nlo_flags |= NFS_LOCK_OWNER_WANT;
3073 		msleep(nlop, &nlop->nlo_lock, slpflag, "nfs_lock_owner_set_busy", &ts);
3077 		nlop->nlo_flags |= NFS_LOCK_OWNER_BUSY;
3078 	lck_mtx_unlock(&nlop->nlo_lock);
3088 nfs_lock_owner_clear_busy(struct nfs_lock_owner *nlop)
3092 	lck_mtx_lock(&nlop->nlo_lock);
3093 	if (!(nlop->nlo_flags & NFS_LOCK_OWNER_BUSY))
3095 	wanted = (nlop->nlo_flags & NFS_LOCK_OWNER_WANT);
3096 	nlop->nlo_flags &= ~(NFS_LOCK_OWNER_BUSY|NFS_LOCK_OWNER_WANT);
3097 	lck_mtx_unlock(&nlop->nlo_lock);
3099 		wakeup(nlop);
3107 nfs_lock_owner_insert_held_lock(struct nfs_lock_owner *nlop, struct nfs_file_lock *newnflp)
3112 	lck_mtx_lock(&nlop->nlo_lock);
3114 		TAILQ_INSERT_HEAD(&nlop->nlo_locks, newnflp, nfl_lolink);
3116 		TAILQ_FOREACH(nflp, &nlop->nlo_locks, nfl_lolink) {
3123 			TAILQ_INSERT_TAIL(&nlop->nlo_locks, newnflp, nfl_lolink);
3125 	lck_mtx_unlock(&nlop->nlo_lock);
3132 nfs_file_lock_alloc(struct nfs_lock_owner *nlop)
3136 	lck_mtx_lock(&nlop->nlo_lock);
3137 	if (!nlop->nlo_alock.nfl_owner) {
3138 		nflp = &nlop->nlo_alock;
3139 		nflp->nfl_owner = nlop;
3141 	lck_mtx_unlock(&nlop->nlo_lock);
3148 		nflp->nfl_owner = nlop;
3150 	nfs_lock_owner_ref(nlop);
3160 	struct nfs_lock_owner *nlop = nflp->nfl_owner;
3166 		lck_mtx_lock(&nlop->nlo_lock);
3168 		lck_mtx_unlock(&nlop->nlo_lock);
3170 	nfs_lock_owner_rele(nlop);
3215 	struct nfs_lock_owner *nlop = nflp->nfl_owner;
3229 	newlocker = (nlop->nlo_stategenid != nmp->nm_stategenid);
3246 		if (!nlop->nlo_open_owner) {
3248 			nlop->nlo_open_owner = nofp->nof_owner;
3251 	error = nfs_lock_owner_set_busy(nlop, thd);
3284 		nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3285 		nfsm_chain_add_lock_owner4(error, &nmreq, nmp, nlop);
3287 		nfsm_chain_add_stateid(error, &nmreq, &nlop->nlo_stateid);
3288 		nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3306 	nfs_owner_seqid_increment(newlocker ? nofp->nof_owner : NULL, nlop, error);
3307 	nfsm_chain_get_stateid(error, &nmrep, &nlop->nlo_stateid);
3312 		nlop->nlo_stategenid = nmp->nm_stategenid;
3316 	nfs_lock_owner_clear_busy(nlop);
3332 	struct nfs_lock_owner *nlop,
3352 	error = nfs_lock_owner_set_busy(nlop, NULL);
3373 	nfsm_chain_add_32(error, &nmreq, nlop->nlo_seqid);
3374 	nfsm_chain_add_stateid(error, &nmreq, &nlop->nlo_stateid);
3393 	nfs_owner_seqid_increment(NULL, nlop, error);
3394 	nfsm_chain_get_stateid(error, &nmrep, &nlop->nlo_stateid);
3398 	nfs_lock_owner_clear_busy(nlop);
3410 	struct nfs_lock_owner *nlop,
3449 	nfsm_chain_add_lock_owner4(error, &nmreq, nmp, nlop);
3497 	struct nfs_lock_owner *nlop,
3547 	error = nmp->nm_funcs->nf_getlock_rpc(np, nlop, fl, start, end, ctx);
3569 	struct nfs_lock_owner *nlop,
3592 	newnflp = nfs_file_lock_alloc(nlop);
3610 		nflp = TAILQ_FIRST(&nlop->nlo_locks);
3668 				error = nfs_advlock_unlock(np, nofp, nlop, 0, UINT64_MAX, NFS_FILE_LOCK_STYLE_FLOCK, ctx);
3720 		nflp2 = nfs_file_lock_alloc(nlop);
3740 				if (!nlop->nlo_open_owner) {
3742 					nlop->nlo_open_owner = nofp->nof_owner;
3781 			error2 = nfs_advlock_unlock(np, nofp, nlop, 0, UINT64_MAX, NFS_FILE_LOCK_STYLE_FLOCK, ctx);
3870 		if (nflp->nfl_owner != nlop)
3880 			lck_mtx_lock(&nlop->nlo_lock);
3881 			TAILQ_REMOVE(&nlop->nlo_locks, nflp, nfl_lolink);
3882 			lck_mtx_unlock(&nlop->nlo_lock);
3894 			nfs_lock_owner_insert_held_lock(nlop, nflp2);
3914 	nfs_lock_owner_insert_held_lock(nlop, newnflp);
3933 			if (nflp->nfl_owner != nlop)
3943 				lck_mtx_lock(&nlop->nlo_lock);
3944 				TAILQ_REMOVE(&nlop->nlo_locks, nflp, nfl_lolink);
3945 				lck_mtx_unlock(&nlop->nlo_lock);
3952 				lck_mtx_lock(&nlop->nlo_lock);
3953 				TAILQ_REMOVE(&nlop->nlo_locks, nflp, nfl_lolink);
3954 				lck_mtx_unlock(&nlop->nlo_lock);
3985 	struct nfs_lock_owner *nlop,
4024 			if (nflp->nfl_owner != nlop)
4039 			newnflp = nfs_file_lock_alloc(nlop);
4063 	    ((nflp = TAILQ_FIRST(&nlop->nlo_locks))) &&
4067 	    ((nflp = TAILQ_FIRST(&nlop->nlo_locks))) &&
4072 		int type = TAILQ_FIRST(&nlop->nlo_locks)->nfl_type;
4073 		int delegated = (TAILQ_FIRST(&nlop->nlo_locks)->nfl_flags & NFS_FILE_LOCK_DELEGATED);
4078 				error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, nflp->nfl_start-1, 0,
4094 			error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, type, s, end, 0,
4111 		if (nflp->nfl_owner != nlop)
4122 				error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, nflp->nfl_end, 0,
4135 			lck_mtx_lock(&nlop->nlo_lock);
4136 			TAILQ_REMOVE(&nlop->nlo_locks, nflp, nfl_lolink);
4137 			lck_mtx_unlock(&nlop->nlo_lock);
4144 				error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, end, 0,
4162 			nfs_lock_owner_insert_held_lock(nlop, newnflp);
4169 				error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, start, nflp->nfl_end, 0,
4186 				error = nmp->nm_funcs->nf_unlock_rpc(np, nlop, nflp->nfl_type, nflp->nfl_start, end, 0,
4243 	struct nfs_lock_owner *nlop = NULL;
4324 	nlop = nfs_lock_owner_find(np, vfs_context_proc(ctx), (op != F_UNLCK));
4325 	if (!nlop) {
4333 		error = nfs_advlock_getlock(np, nlop, fl, start, end, ctx);
4362 			error = nfs_advlock_unlock(np, nofp, nlop, start, end, style, ctx);
4366 			error = nfs_advlock_setlock(np, nofp, nlop, op, start, end, style, fl->l_type, ctx);
4374 	if (nlop)
4375 		nfs_lock_owner_rele(nlop);
4387 	struct nfs_lock_owner *nlop;
4389 	TAILQ_FOREACH(nlop, &nofp->nof_np->n_lock_owners, nlo_link) {
4390 		if (nlop->nlo_open_owner != noop)
4392 		if (!TAILQ_EMPTY(&nlop->nlo_locks))
4395 	return (nlop ? 1 : 0);
5566 	struct nfs_lock_owner *nlop;
5695 		TAILQ_FOREACH(nlop, &nofp->nof_np->n_lock_owners, nlo_link) {
5696 			if (nlop->nlo_open_owner != noop)
5698 			TAILQ_FOREACH_SAFE(nflp, &nlop->nlo_locks, nfl_lolink, nextnflp) {