bsd/nfs/nfs4_vnops.c

1733  * Does the error mean we probably lost a delegation?
2409  * Get the current (delegation, lock, open, default) stateid for this node.
2410  * If node has a delegation, use that stateid.
2464  * When we have a delegation, we may be able to perform the OPEN locally.
2465  * Perform the OPEN by checking the delegation ACE and/or checking via ACCESS.
2549  * If we have a delegation, we may be able to handle the open locally.
2574 	 * We can handle the OPEN ourselves if we have a delegation,
2575 	 * unless it's a read delegation and the open is asking for
2577 	 * use the delegation if it's being returned.
3528 		 * If we have a write delegation, we know there can't be other
3727 		/* do we have a delegation? (that we're not returning?) */
3730 				/* with a write delegation, just take the lock delegated */
4642 	uint32_t rflags, delegation, recall;
4684 	rflags = delegation = recall = 0;
4771 	nfsm_chain_get_32(error, &nmrep, delegation);
4773 		switch (delegation) {
4780 			if (delegation == NFS_OPEN_DELEGATE_WRITE) // space (skip) XXX
4884 	if ((delegation == NFS_OPEN_DELEGATE_READ) || (delegation == NFS_OPEN_DELEGATE_WRITE)) {
4888 			/* stuff the delegation state in the node */
4891 			np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
4902 			/* give the delegation back */
4905 					/* update delegation state and return it */
4908 					np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
4921 				/* return np's current delegation */
4924 			if (fh.fh_len) /* return fh's delegation if it wasn't for np */
4978 	uint32_t rflags = 0, delegation, recall = 0;
5047 	delegation = NFS_OPEN_DELEGATE_NONE;
5101 	nfsm_chain_get_32(error, &nmrep, delegation);
5103 		switch (delegation) {
5105 			// if (!(np->n_openflags & N_DELEG_RETURN)) /* don't warn if delegation is being returned */
5106 			// 	printf("nfs: open delegated claim didn't return a delegation %s\n", filename ? filename : "???");
5111 			     (delegation == NFS_OPEN_DELEGATE_WRITE)) ||
5113 			     (delegation == NFS_OPEN_DELEGATE_READ)))
5114 				printf("nfs: open delegated claim returned a different delegation type! have %s got %s %s\n",
5116 				     (delegation == NFS_OPEN_DELEGATE_WRITE) ? "W" : "R", filename ? filename : "???");
5119 			if (delegation == NFS_OPEN_DELEGATE_WRITE) // space (skip) XXX
5151 				/* stuff the latest delegation state in the node */
5154 				np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
5196 	if ((delegation == NFS_OPEN_DELEGATE_READ) || (delegation == NFS_OPEN_DELEGATE_WRITE)) {
5200 			 * Don't return the delegation here in case we have more to claim.
5236 	uint32_t rflags = 0, delegation, recall = 0;
5253 	delegation = NFS_OPEN_DELEGATE_NONE;
5280 	delegation = (np->n_openflags & N_DELEG_READ) ? NFS_OPEN_DELEGATE_READ :
5283 	nfsm_chain_add_32(error, &nmreq, delegation);
5284 	delegation = NFS_OPEN_DELEGATE_NONE;
5310 	nfsm_chain_get_32(error, &nmrep, delegation);
5312 		switch (delegation) {
5316 				 * Hey!  We were supposed to get our delegation back even
5319 				 * Just try to return the existing delegation.
5321 				// NP(np, "nfs: open reclaim didn't return delegation?");
5322 				delegation = (np->n_openflags & N_DELEG_WRITE) ? NFS_OPEN_DELEGATE_WRITE : NFS_OPEN_DELEGATE_READ;
5330 			if (delegation == NFS_OPEN_DELEGATE_WRITE) // space (skip) XXX
5362 				/* stuff the delegation state in the node */
5365 				np->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
5411 	if ((delegation == NFS_OPEN_DELEGATE_READ) || (delegation == NFS_OPEN_DELEGATE_WRITE)) {
5664 		 * Any problems with the delegation probably indicates that we
5665 		 * should review/return all of our current delegation state.
5718 	/* restart if it looks like a problem more than just losing the delegation */
5731 	 * Any problems with the delegation probably indicates that we
5732 	 * should review/return all of our current delegation state.
5867  * Mark a node as needed to have its delegation returned.
5868  * Queue it up on the delegation return queue.
5892  * return any delegation we may have for the given node
5906 	/* first, make sure the node's marked for delegation return */
5911 	/* make sure nobody else is using the delegation state */
5919 	/* return the delegation */
5926 	/* assume delegation is gone for all errors except ETIMEDOUT, NFSERR_*MOVED */
5969  * RPC to return a delegation for a file handle
6923 	uint32_t denyMode, rflags, delegation, recall, eof, rlen, retlen;
6940 	rflags = delegation = recall = eof = rlen = retlen = 0;
7091 			 * it - which we may be able to do with a delegation.
7281 		nfsm_chain_get_32(error, &nmrep, delegation);
7283 			switch (delegation) {
7290 				if (delegation == NFS_OPEN_DELEGATE_WRITE) // space (skip) XXX
7434 	if (open && ((delegation == NFS_OPEN_DELEGATE_READ) || (delegation == NFS_OPEN_DELEGATE_WRITE))) {
7436 			/* stuff the delegation state in the node */
7439 			anp->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
7450 			/* give the delegation back */
7453 					/* update delegation state and return it */
7456 					anp->n_openflags |= ((delegation == NFS_OPEN_DELEGATE_READ) ? N_DELEG_READ : N_DELEG_WRITE);
7469 				/* return anp's current delegation */
7472 			if (fh.fh_len) /* return fh's delegation if it wasn't for anp */
7489 			rflags = delegation = recall = eof = rlen = retlen = 0;