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