![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atp_misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to atp_misc.c CVS log | Up to [Apple XNU] / XNU / bsd / netat |
1.1 root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.