[apple/xnu.git] / bsd / netat / atp_misc.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *	Copyright (c) 1996-1998 Apple Computer, Inc.
 *	All Rights Reserved.
 */

/*    Modified for MP, 1996 by Tuyen Nguyen
 *   Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
 */
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/param.h>
#include <machine/spl.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/proc.h>
#include <sys/filedesc.h>
#include <sys/fcntl.h>
#include <sys/mbuf.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/socket.h>

#include <netat/sysglue.h>
#include <netat/appletalk.h>
#include <netat/ddp.h>
#include <netat/at_pcb.h>
#include <netat/atp.h>
#include <netat/debug.h>

extern atlock_t atpgen_lock;
void atp_free();
void atp_send(struct atp_trans *);

/*
 *	The request timer retries a request, if all retries are used up
 *		it returns a NAK
 */

void
atp_req_timeout(trp)
register struct atp_trans *trp;
{
	int s;
	register gbuf_t *m;
	gref_t *gref;
	struct atp_state *atp;
	struct atp_trans *ctrp;

	if ((atp = trp->tr_queue) == 0)
		return;
	ATDISABLE(s, atp->atp_lock);
	if (atp->atp_flags & ATP_CLOSING) {
		ATENABLE(s, atp->atp_lock);
		return;
	}
	for (ctrp = atp->atp_trans_wait.head; ctrp; ctrp = ctrp->tr_list.next) {
		if (ctrp == trp)
			break;
	}
	if (ctrp != trp) {
		ATENABLE(s, atp->atp_lock);
		return;
	}

	if ((m = gbuf_cont(trp->tr_xmt)) == NULL)
	        m = trp->tr_xmt;               /* issued via the new interface */

	if (trp->tr_retry == 0) {
		trp->tr_state = TRANS_FAILED;
		if (m == trp->tr_xmt) {
			trp->tr_xmt = NULL;
l_notify:
				gbuf_wset(m,1);
				*gbuf_rptr(m) = 99;
				gbuf_set_type(m, MSG_DATA);
				gref = trp->tr_queue->atp_gref;
				ATENABLE(s, atp->atp_lock);
				atalk_putnext(gref, m);

			return;
		}
		dPrintf(D_M_ATP_LOW,D_L_INFO, ("atp_req_timeout: skt=%d\n",
			trp->tr_local_socket));
		m = trp->tr_xmt;
		switch(((ioc_t *)(gbuf_rptr(trp->tr_xmt)))->ioc_cmd) {
		case AT_ATP_ISSUE_REQUEST:
			trp->tr_xmt = NULL;
			if (trp->tr_queue->dflag)
				((ioc_t *)gbuf_rptr(m))->ioc_cmd = AT_ATP_REQUEST_COMPLETE;
			else if (trp->tr_bdsp == NULL) {
				ATENABLE(s, atp->atp_lock);
				gbuf_freem(m);
				if (trp->tr_rsp_wait)
					thread_wakeup(&trp->tr_event);
				break;
			}
			ATENABLE(s, atp->atp_lock);
			atp_iocnak(trp->tr_queue, m, ETIMEDOUT);
			atp_free(trp);
			return;

		case AT_ATP_ISSUE_REQUEST_NOTE:
		case AT_ATP_ISSUE_REQUEST_TICKLE:
			trp->tr_xmt = gbuf_cont(m);
			gbuf_cont(m) = NULL;
			goto l_notify;
		}
	} else {
		(AT_ATP_HDR(m))->bitmap = trp->tr_bitmap;

		if (trp->tr_retry != (unsigned int) ATP_INFINITE_RETRIES)
			trp->tr_retry--;
		ATENABLE(s, atp->atp_lock);
		atp_send(trp);
	}
}


/*
 *	atp_free frees up a request, cleaning up the queues and freeing
 *		the request packet
 *      always called at 'lock'
 */

void atp_free(trp)
register struct atp_trans *trp;
{
	register struct atp_state *atp;
	register int i;
	int s;
	
	dPrintf(D_M_ATP_LOW, D_L_TRACE,
		("atp_free: freeing trp 0x%x\n", (u_int) trp));
	ATDISABLE(s, atpgen_lock);
	if (trp->tr_tmo_func)
	        atp_untimout(atp_req_timeout, trp);
	atp = trp->tr_queue;

	ATP_Q_REMOVE(atp->atp_trans_wait, trp, tr_list);

	if (trp->tr_xmt) {
	  	gbuf_freem(trp->tr_xmt);
		trp->tr_xmt = NULL;
	}
	for (i = 0; i < 8; i++) {
	        if (trp->tr_rcv[i]) {
		        gbuf_freem(trp->tr_rcv[i]);
			trp->tr_rcv[i] = NULL;
		}
	}
	if (trp->tr_bdsp) {
		gbuf_freem(trp->tr_bdsp);
		trp->tr_bdsp = NULL;
	}

	ATENABLE(s, atpgen_lock);
	atp_trans_free(trp);

} /* atp_free */


/*
 *	atp_send transmits a request packet by queuing it (if it isn't already) and
 *		scheduling the queue
 */

void atp_send(trp)
register struct atp_trans *trp;
{
	gbuf_t *m;
	struct atp_state *atp;

	dPrintf(D_M_ATP_LOW, D_L_OUTPUT, ("atp_send: trp=0x%x, loc=%d\n",
		(u_int) trp->tr_queue, trp->tr_local_socket));

	if ((atp = trp->tr_queue) != 0) {
	  if (trp->tr_state == TRANS_TIMEOUT) {
	    if ((m = gbuf_cont(trp->tr_xmt)) == NULL)
	        m = trp->tr_xmt;

	    /*
	     *	Now either release the transaction or start the timer
	     */
	    if (!trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo) {
		m = (gbuf_t *)gbuf_copym(m);
		atp_x_done(trp);
	    } else {
		m = (gbuf_t *)gbuf_dupm(m);

		atp_timout(atp_req_timeout, trp, trp->tr_timeout);
	    }

	    if (m) {	
	        trace_mbufs(D_M_ATP_LOW, "  m", m);
		DDP_OUTPUT(m);
	    }
	}
  }
}


/*
 *	atp_reply sends all the available messages in the bitmap again
 *		by queueing us to the write service routine
 */

void atp_reply(rcbp)
register struct atp_rcb *rcbp;
{
	register struct atp_state *atp;
	register int i;
	int s;

  if ((atp = rcbp->rc_queue) != 0) {
	ATDISABLE(s, atp->atp_lock);
	for (i = 0; i < rcbp->rc_pktcnt; i++) {
		if (rcbp->rc_bitmap&atp_mask[i])
			rcbp->rc_snd[i] = 1;
		else
			rcbp->rc_snd[i] = 0;
	}
        if (rcbp->rc_rep_waiting == 0) {
	        rcbp->rc_state = RCB_SENDING;
	        rcbp->rc_rep_waiting = 1;
	        ATENABLE(s, atp->atp_lock);
	        atp_send_replies(atp, rcbp);
	} else
	ATENABLE(s, atp->atp_lock);
  }
}


/*
 *	The rcb timer just frees the rcb, this happens when we missed a release for XO
 */

void atp_rcb_timer()
{  
	int s;
        register struct atp_rcb *rcbp;
	register struct atp_rcb *next_rcbp;
	extern   struct atp_rcb_qhead atp_need_rel;
	extern struct atp_trans *trp_tmo_rcb;

l_again:
	ATDISABLE(s, atpgen_lock);
	for (rcbp = atp_need_rel.head; rcbp; rcbp = next_rcbp) {
	        next_rcbp = rcbp->rc_tlist.next;

	        if (abs(time.tv_sec - rcbp->rc_timestamp) > 30) {
		        ATENABLE(s, atpgen_lock);
		        atp_rcb_free(rcbp);
		        goto l_again;
		}
	}
	ATENABLE(s, atpgen_lock);
	atp_timout(atp_rcb_timer, trp_tmo_rcb, 10 * HZ);
}

atp_iocack(atp, m)
struct   atp_state *atp;
register gbuf_t *m;
{
	if (gbuf_type(m) == MSG_IOCTL)
		gbuf_set_type(m, MSG_IOCACK);
	if (gbuf_cont(m))
		((ioc_t *)gbuf_rptr(m))->ioc_count = gbuf_msgsize(gbuf_cont(m));
	else
		((ioc_t *)gbuf_rptr(m))->ioc_count = 0;

	if (atp->dflag)
		asp_ack_reply(atp->atp_gref, m);
	else
		atalk_putnext(atp->atp_gref, m);
}

atp_iocnak(atp, m, err)
struct   atp_state *atp;
register gbuf_t *m;
register int err;
{
	if (gbuf_type(m) == MSG_IOCTL)
		gbuf_set_type(m, MSG_IOCNAK);
	((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
	((ioc_t *)gbuf_rptr(m))->ioc_error = err ? err : ENXIO;
	((ioc_t *)gbuf_rptr(m))->ioc_rval = -1;
	if (gbuf_cont(m)) {
		gbuf_freem(gbuf_cont(m));
		gbuf_cont(m) = NULL;
	}

	if (atp->dflag)
		asp_nak_reply(atp->atp_gref, m);
	else
		atalk_putnext(atp->atp_gref, m);
}

/*
 *	Generate a transaction id for a socket
 */
static int lasttid;
atp_tid(atp)
register struct atp_state *atp;
{
	register int i;
	register struct atp_trans *trp;
	int s;

	ATDISABLE(s, atpgen_lock);
	for (i = lasttid;;) {
		i = (i+1)&0xffff;

		for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
		        if (trp->tr_tid == i)
			        break;
		}
		if (trp == NULL) {
			lasttid = i;
			ATENABLE(s, atpgen_lock);
			return(i);
		}
	}
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* Copyright (c) 1996-1998 Apple Computer, Inc.
	24	* All Rights Reserved.
	25	*/
	26
	27	/* Modified for MP, 1996 by Tuyen Nguyen
	28	* Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
	29	*/
	30	#include <sys/errno.h>
	31	#include <sys/types.h>
	32	#include <sys/param.h>
	33	#include <machine/spl.h>
	34	#include <sys/systm.h>
	35	#include <sys/kernel.h>
	36	#include <sys/proc.h>
	37	#include <sys/filedesc.h>
	38	#include <sys/fcntl.h>
	39	#include <sys/mbuf.h>
	40	#include <sys/ioctl.h>
	41	#include <sys/malloc.h>
	42	#include <sys/socket.h>
	43
	44	#include <netat/sysglue.h>
	45	#include <netat/appletalk.h>
	46	#include <netat/ddp.h>
	47	#include <netat/at_pcb.h>
	48	#include <netat/atp.h>
	49	#include <netat/debug.h>
	50
	51	extern atlock_t atpgen_lock;
	52	void atp_free();
	53	void atp_send(struct atp_trans *);
	54
	55	/*
	56	* The request timer retries a request, if all retries are used up
	57	* it returns a NAK
	58	*/
	59
	60	void
	61	atp_req_timeout(trp)
	62	register struct atp_trans *trp;
	63	{
	64	int s;
65	register gbuf_t *m;
66	gref_t *gref;
67	struct atp_state *atp;
68	struct atp_trans *ctrp;
69
70	if ((atp = trp->tr_queue) == 0)
71	return;
72	ATDISABLE(s, atp->atp_lock);
73	if (atp->atp_flags & ATP_CLOSING) {
74	ATENABLE(s, atp->atp_lock);
75	return;
76	}
77	for (ctrp = atp->atp_trans_wait.head; ctrp; ctrp = ctrp->tr_list.next) {
78	if (ctrp == trp)
79	break;
80	}
81	if (ctrp != trp) {
82	ATENABLE(s, atp->atp_lock);
83	return;
84	}
85
86	if ((m = gbuf_cont(trp->tr_xmt)) == NULL)
87	m = trp->tr_xmt; /* issued via the new interface */
88
89	if (trp->tr_retry == 0) {
90	trp->tr_state = TRANS_FAILED;
91	if (m == trp->tr_xmt) {
92	trp->tr_xmt = NULL;
93	l_notify:
94	gbuf_wset(m,1);
95	*gbuf_rptr(m) = 99;
96	gbuf_set_type(m, MSG_DATA);
97	gref = trp->tr_queue->atp_gref;
98	ATENABLE(s, atp->atp_lock);
99	atalk_putnext(gref, m);
100
101	return;
102	}
103	dPrintf(D_M_ATP_LOW,D_L_INFO, ("atp_req_timeout: skt=%d\n",
104	trp->tr_local_socket));
105	m = trp->tr_xmt;
106	switch(((ioc_t *)(gbuf_rptr(trp->tr_xmt)))->ioc_cmd) {
107	case AT_ATP_ISSUE_REQUEST:
108	trp->tr_xmt = NULL;
109	if (trp->tr_queue->dflag)
110	((ioc_t *)gbuf_rptr(m))->ioc_cmd = AT_ATP_REQUEST_COMPLETE;
111	else if (trp->tr_bdsp == NULL) {
112	ATENABLE(s, atp->atp_lock);
113	gbuf_freem(m);
114	if (trp->tr_rsp_wait)
115	thread_wakeup(&trp->tr_event);
116	break;
117	}
118	ATENABLE(s, atp->atp_lock);
119	atp_iocnak(trp->tr_queue, m, ETIMEDOUT);
120	atp_free(trp);
121	return;
122
123	case AT_ATP_ISSUE_REQUEST_NOTE:
124	case AT_ATP_ISSUE_REQUEST_TICKLE:
125	trp->tr_xmt = gbuf_cont(m);
126	gbuf_cont(m) = NULL;
127	goto l_notify;
128	}
129	} else {
130	(AT_ATP_HDR(m))->bitmap = trp->tr_bitmap;
131
132	if (trp->tr_retry != (unsigned int) ATP_INFINITE_RETRIES)
133	trp->tr_retry--;
134	ATENABLE(s, atp->atp_lock);
135	atp_send(trp);
136	}
137	}
138
139
140	/*
141	* atp_free frees up a request, cleaning up the queues and freeing
142	* the request packet
143	* always called at 'lock'
144	*/
145
146	void atp_free(trp)
147	register struct atp_trans *trp;
148	{
149	register struct atp_state *atp;
150	register int i;
151	int s;
152
153	dPrintf(D_M_ATP_LOW, D_L_TRACE,
154	("atp_free: freeing trp 0x%x\n", (u_int) trp));
155	ATDISABLE(s, atpgen_lock);
156	if (trp->tr_tmo_func)
157	atp_untimout(atp_req_timeout, trp);
158	atp = trp->tr_queue;
159
160	ATP_Q_REMOVE(atp->atp_trans_wait, trp, tr_list);
161
162	if (trp->tr_xmt) {
163	gbuf_freem(trp->tr_xmt);
164	trp->tr_xmt = NULL;
165	}
166	for (i = 0; i < 8; i++) {
167	if (trp->tr_rcv[i]) {
168	gbuf_freem(trp->tr_rcv[i]);
169	trp->tr_rcv[i] = NULL;
170	}
171	}
172	if (trp->tr_bdsp) {
173	gbuf_freem(trp->tr_bdsp);
174	trp->tr_bdsp = NULL;
175	}
176
177	ATENABLE(s, atpgen_lock);
178	atp_trans_free(trp);
179
180	} /* atp_free */
181
182
183	/*
184	* atp_send transmits a request packet by queuing it (if it isn't already) and
185	* scheduling the queue
186	*/
187
188	void atp_send(trp)
189	register struct atp_trans *trp;
190	{
191	gbuf_t *m;
192	struct atp_state *atp;
193
194	dPrintf(D_M_ATP_LOW, D_L_OUTPUT, ("atp_send: trp=0x%x, loc=%d\n",
195	(u_int) trp->tr_queue, trp->tr_local_socket));
196
197	if ((atp = trp->tr_queue) != 0) {
198	if (trp->tr_state == TRANS_TIMEOUT) {
199	if ((m = gbuf_cont(trp->tr_xmt)) == NULL)
200	m = trp->tr_xmt;
201
202	/*
203	* Now either release the transaction or start the timer
204	*/
205	if (!trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo) {
206	m = (gbuf_t *)gbuf_copym(m);
207	atp_x_done(trp);
208	} else {
209	m = (gbuf_t *)gbuf_dupm(m);
210
211	atp_timout(atp_req_timeout, trp, trp->tr_timeout);
212	}
213
214	if (m) {
215	trace_mbufs(D_M_ATP_LOW, " m", m);
216	DDP_OUTPUT(m);
217	}
218	}
219	}
220	}
221
222
223	/*
224	* atp_reply sends all the available messages in the bitmap again
225	* by queueing us to the write service routine
226	*/
227
228	void atp_reply(rcbp)
229	register struct atp_rcb *rcbp;
230	{
231	register struct atp_state *atp;
232	register int i;
233	int s;
234
235	if ((atp = rcbp->rc_queue) != 0) {
236	ATDISABLE(s, atp->atp_lock);
237	for (i = 0; i < rcbp->rc_pktcnt; i++) {
238	if (rcbp->rc_bitmap&atp_mask[i])
239	rcbp->rc_snd[i] = 1;
240	else
241	rcbp->rc_snd[i] = 0;
242	}
243	if (rcbp->rc_rep_waiting == 0) {
244	rcbp->rc_state = RCB_SENDING;
245	rcbp->rc_rep_waiting = 1;
246	ATENABLE(s, atp->atp_lock);
247	atp_send_replies(atp, rcbp);
248	} else
249	ATENABLE(s, atp->atp_lock);
250	}
251	}
252
253
254	/*
255	* The rcb timer just frees the rcb, this happens when we missed a release for XO
256	*/
257
258	void atp_rcb_timer()
259	{
260	int s;
261	register struct atp_rcb *rcbp;
262	register struct atp_rcb *next_rcbp;
263	extern struct atp_rcb_qhead atp_need_rel;
264	extern struct atp_trans *trp_tmo_rcb;
265
266	l_again:
267	ATDISABLE(s, atpgen_lock);
268	for (rcbp = atp_need_rel.head; rcbp; rcbp = next_rcbp) {
269	next_rcbp = rcbp->rc_tlist.next;
270
271	if (abs(time.tv_sec - rcbp->rc_timestamp) > 30) {
272	ATENABLE(s, atpgen_lock);
273	atp_rcb_free(rcbp);
274	goto l_again;
275	}
276	}
277	ATENABLE(s, atpgen_lock);
278	atp_timout(atp_rcb_timer, trp_tmo_rcb, 10 * HZ);
279	}
280
281	atp_iocack(atp, m)
282	struct atp_state *atp;
283	register gbuf_t *m;
284	{
285	if (gbuf_type(m) == MSG_IOCTL)
286	gbuf_set_type(m, MSG_IOCACK);
287	if (gbuf_cont(m))
288	((ioc_t *)gbuf_rptr(m))->ioc_count = gbuf_msgsize(gbuf_cont(m));
289	else
290	((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
291
292	if (atp->dflag)
293	asp_ack_reply(atp->atp_gref, m);
294	else
295	atalk_putnext(atp->atp_gref, m);
296	}
297
298	atp_iocnak(atp, m, err)
299	struct atp_state *atp;
300	register gbuf_t *m;
301	register int err;
302	{
303	if (gbuf_type(m) == MSG_IOCTL)
304	gbuf_set_type(m, MSG_IOCNAK);
305	((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
306	((ioc_t *)gbuf_rptr(m))->ioc_error = err ? err : ENXIO;
307	((ioc_t *)gbuf_rptr(m))->ioc_rval = -1;
308	if (gbuf_cont(m)) {
309	gbuf_freem(gbuf_cont(m));
310	gbuf_cont(m) = NULL;
311	}
312
313	if (atp->dflag)
314	asp_nak_reply(atp->atp_gref, m);
315	else
316	atalk_putnext(atp->atp_gref, m);
317	}
318
319	/*
320	* Generate a transaction id for a socket
321	*/
322	static int lasttid;
323	atp_tid(atp)
324	register struct atp_state *atp;
325	{
326	register int i;
327	register struct atp_trans *trp;
328	int s;
329
330	ATDISABLE(s, atpgen_lock);
331	for (i = lasttid;;) {
332	i = (i+1)&0xffff;
333
334	for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
335	if (trp->tr_tid == i)
336	break;
337	}
338	if (trp == NULL) {
339	lasttid = i;
340	ATENABLE(s, atpgen_lock);
341	return(i);
342	}
343	}
344	}