![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to adsp_stream.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 adsp_stream.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) 1995-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 <h/adsp_local.h>
35: #include <h/adsp_ioctl.h>
36: #include <at/ddp.h>
37: #include <h/at_ddp.h>
38: #include <h/atlog.h>
39:
40: void SndMsgUp();
41: void adsp_rput();
42: static void adsp_stop();
43: static void adsp_iocack();
44: static void adsp_iocnak();
45: static void adspgetcfg();
46: void adsp_dequeue_ccb();
47: unsigned char adspAssignSocket();
48: int adspallocate(), adsprelease();
49: static int adspInited = 0;
50:
51: at_ddp_cfg_t ddpcfg;
52: atlock_t adspall_lock;
53: atlock_t adspgen_lock;
54: GLOBAL adspGlobal;
55:
56: /**********/
57:
58: int adsp_pidM[256];
59: char adsp_inputC[256];
60: CCB *adsp_inputQ[256];
61: extern char ddp_off_flag;
62: extern int ot_protoCnt;
63: extern char ot_protoT[];
64: extern char ot_adsp_socketM[];
65:
66: static char adsp_off_flag;
67: static CCB *ccb_used_list;
68:
69: void adsp_input(mp)
70: gbuf_t *mp;
71: {
72: gref_t *gref;
73: CCBPtr sp;
74: at_ddp_t *p;
75: int s, l;
76: gbuf_t *mb;
77:
78: switch (gbuf_type(mp)) {
79: case MSG_DATA:
80: p = (at_ddp_t *)gbuf_rptr(mp);
81: ATDISABLE(s, adspall_lock);
82: sp = adsp_inputQ[p->dst_socket];
83: if ((sp == 0) || adsp_off_flag || (sp->gref==0) || (sp->state==sClosed))
84: {
85: ATENABLE(s, adspall_lock);
86: gbuf_freem(mp);
87: return;
88: }
89: else if (sp->otccbLink != 0) {
90: do {
91: if ((sp->remoteAddress.a.node == p->src_node)
92: && (sp->remoteAddress.a.socket == p->src_socket)
93: && (*(short *)sp->remoteAddress.a.net == *(short *)p->src_net))
94: break;
95: } while ((sp = sp->otccbLink) != 0);
96: if (sp == 0)
97: {
98: ATENABLE(s, adspall_lock);
99: gbuf_freem(mp);
100: return;
101: }
102: }
103: if (sp->lockFlag) {
104: gbuf_next(mp) = 0;
105: if (sp->deferred_mb) {
106: for (mb=sp->deferred_mb; gbuf_next(mb); mb=gbuf_next(mb)) ;
107: gbuf_next(mb) = mp;
108: } else
109: sp->deferred_mb = mp;
110: ATENABLE(s, adspall_lock);
111: return;
112: }
113: ATDISABLE(l, sp->lockRemove);
114: sp->lockFlag = 1;
115: ATENABLE(l, adspall_lock);
116: while (mp) {
117: adsp_rput(sp->gref, mp);
118: if ((mp = sp->deferred_mb) != 0) {
119: sp->deferred_mb = gbuf_next(mp);
120: gbuf_next(mp) = 0;
121: }
122: }
123: sp->lockFlag = 0;
124: ATENABLE(s, sp->lockRemove);
125: return;
126:
127: case MSG_IOCACK:
128: case MSG_IOCNAK:
129: gref = (gref_t *)((ioc_t *)gbuf_rptr(mp))->ioc_private;
130: break;
131:
132: case MSG_IOCTL:
133: adsp_stop(mp, *gbuf_rptr(mp));
134: gbuf_set_type(mp, MSG_IOCACK);
135: DDP_OUTPUT(mp);
136: return;
137:
138: default:
139: gbuf_freem(mp);
140: return;
141: }
142:
143: adsp_rput(gref, mp);
144: }
145:
146: /**********/
147: int adsp_readable(gref)
148: gref_t *gref;
149: {
150: int rc;
151: CCBPtr sp;
152:
153: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
154: rc = sp->rData;
155:
156: return rc;
157: }
158:
159: int adsp_writeable(gref)
160: gref_t *gref;
161: {
162: int s, rc;
163: CCBPtr sp;
164:
165: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
166: ATDISABLE(s, sp->lock);
167: rc = CalcSendQFree(sp);
168: ATENABLE(s, sp->lock);
169:
170: return rc;
171: }
172:
173: void adsp_init()
174: {
175: adspInited++;
176: InitGlobals();
177: ccb_used_list = 0;
178: adsp_off_flag = 0;
179: bzero(adsp_pidM, sizeof(adsp_pidM));
180: bzero(adsp_inputC, sizeof(adsp_inputC));
181: bzero(adsp_inputQ, sizeof(adsp_inputQ));
182: }
183:
184: /*
185: * Description:
186: * ADSP open and close routines. These routines
187: * initalize and release the ADSP structures. They do not
188: * have anything to do with "connections"
189: */
190:
191: int adsp_open(gref)
192: gref_t *gref;
193: {
194: register CCBPtr sp;
195: int s;
196:
197: if (!adspInited)
198: adsp_init();
199: /*
200: * if not ready, return error
201: */
202: if (adsp_off_flag)
203: return ENOTREADY;
204:
205: if (!adspAllocateCCB(gref))
206: return(ENOBUFS); /* can't get buffers */
207:
208: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
209: gref->readable = adsp_readable;
210: gref->writeable = adsp_writeable;
211: ATDISABLE(s, adspall_lock);
212: if ((sp->otccbLink = ccb_used_list) != 0)
213: sp->otccbLink->ccbLink = sp;
214: ccb_used_list = sp;
215: ATENABLE(s, adspall_lock);
216: return 0;
217: }
218:
219: int adsp_close(gref)
220: gref_t *gref;
221: {
222: int s, l;
223: unsigned char localSocket;
224:
225: /* make sure we've not yet removed the CCB (e.g., due to TrashSession) */
226: ATDISABLE(l, adspgen_lock);
227: if (gref->info) {
228: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
229: ATDISABLE(s, sp->lock);
230: ATENABLE(s, adspgen_lock);
231: if (sp->ioDone)
232: {
233: ATENABLE(l, sp->lock);
234: return 0;
235: }
236: localSocket = sp->localSocket;
237: ATENABLE(l, sp->lock);
238: if (localSocket)
239: adspRelease(gref);
240: else
241: {
242: adsp_dequeue_ccb(sp);
243: gbuf_freeb((gbuf_t *)gref->info);
244: }
245: } else
246: ATENABLE(l, adspgen_lock);
247: return 0;
248: }
249:
250:
251: /*
252: * Name:
253: * adsp_rput
254: *
255: * Description:
256: * ADSP streams read put and service routines.
257: */
258:
259: void adsp_rput(gref, mp)
260: gref_t *gref; /* READ queue */
261: gbuf_t *mp;
262: {
263: static first = 1;
264:
265: switch (gbuf_type(mp)) {
266: case MSG_ERROR:
267: case MSG_HANGUP:
268: case MSG_IOCACK:
269: case MSG_IOCNAK:
270:
271: /*
272: * ADSP needs to obtain the network number and node number
273: * for the Host it is running on.
274: * In the AUX implementation it "peeked" inside the ddp
275: * structure pointed to by at_ifDefault;
276: * In a strict streams module implementation "peeking" is
277: * neither kosher, nor permitted.
278: * adspgetcfg() sends a DDP_IOC_GET_CFG ioctl request to DDP.
279: * This code picks up the response from DDP. From this
280: * response, the ADSP streams module obtains the network
281: * and node number.
282: */
283:
284: /*
285: ** Examine the first packet coming from DDP stream.
286: */
287: if (first) {
288: first = 0;
289: if (gbuf_type(mp) == MSG_IOCACK) {
290: ioc_t *iocbp = (ioc_t *) gbuf_rptr(mp);
291:
292: if (iocbp->ioc_cmd == DDP_IOC_GET_CFG) {
293: if (gbuf_rptr(gbuf_cont(mp))) {
294: bcopy((caddr_t) gbuf_rptr(gbuf_cont(mp)),
295: (caddr_t) &ddpcfg,
296: sizeof(at_ddp_cfg_t));
297: dPrintf(D_M_ADSP, D_L_INFO,
298: ("ADSP: Net = 0x%x, Node = 0x%x\n",
299: NET_VALUE(ddpcfg.node_addr.net),
300: ddpcfg.node_addr.node));
301: }
302: gbuf_freem(mp);
303: return;
304: }
305: }
306: }
307: switch (adspReadHandler(gref, mp)) {
308: case STR_PUTNEXT:
309: atalk_putnext(gref, mp);
310: break;
311: case STR_IGNORE:
312: break;
313: }
314: break;
315: default:
316: CheckReadQueue(gbuf_rptr(((gbuf_t *)gref->info)));
317: CheckSend(gbuf_rptr(((gbuf_t *)gref->info)));
318:
319: switch (gbuf_type(mp)) {
320: case MSG_IOCTL:
321: case MSG_DATA:
322: case MSG_PROTO:
323: if (adspReadHandler(gref, mp) == STR_PUTNEXT)
324: atalk_putnext(gref, mp);
325: break;
326: default:
327: atalk_putnext(gref, mp);
328: break;
329: }
330: }
331: }
332:
333: /*
334: * Name:
335: * adsp_wput
336: *
337: * Description:
338: * ADSP streams write put and service routines.
339: *
340: */
341:
342: int adsp_wput(gref, mp)
343: gref_t *gref; /* WRITE queue */
344: gbuf_t *mp;
345: {
346: int rc;
347: int s;
348: gbuf_t *xm;
349: ioc_t *iocbp;
350:
351: if (gbuf_type(mp) == MSG_IOCTL) {
352: iocbp = (ioc_t *)gbuf_rptr(mp);
353: switch (iocbp->ioc_cmd) {
354: case AT_ADSP_LINK:
355: adsp_dequeue_ccb((CCBPtr)gbuf_rptr(((gbuf_t *)gref->info)));
356: ot_protoT[DDP_ADSP] = 1;
357: ot_protoCnt++;
358:
359: iocbp->ioc_rval = 0;
360: adsp_iocack(gref, mp);
361: return 0;
362:
363: case AT_ADSP_UNLINK:
364: ot_protoT[DDP_ADSP] = 0;
365: ot_protoCnt--;
366: ddp_off_flag = 0; /* why do this on an unlink? */
367:
368: if (adspInited) {
369: CleanupGlobals(); /* for 2225395 */
370: adspInited = 0;
371: }
372: iocbp->ioc_rval = 0;
373: adsp_iocack(gref, mp);
374: return 0;
375:
376: case ADSPBINDREQ:
377: {
378: unsigned char v;
379: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
380:
381: if (gbuf_cont(mp) == NULL) {
382: iocbp->ioc_rval = -1;
383: adsp_iocnak(gref, mp, EINVAL);
384: }
385: v = *(unsigned char *)gbuf_rptr(gbuf_cont(mp));
386: ATDISABLE(s, adspall_lock);
387: if ( (v != 0)
388: && ((v > DDP_SOCKET_LAST) || (v < 2)
389: || (adsp_inputQ[v] != 0) || (ot_adsp_socketM[v] != 0)) ) {
390: ATENABLE(s, adspall_lock);
391: iocbp->ioc_rval = -1;
392: adsp_iocnak(gref, mp, EINVAL);
393: }
394: else {
395: if (v == 0) {
396: ATENABLE(s, adspall_lock);
397: if ((v = adspAssignSocket(gref, 0)) == 0) {
398: iocbp->ioc_rval = -1;
399: adsp_iocnak(gref, mp, EINVAL);
400: return 0;
401: }
402: } else {
403: adsp_inputC[v] = 1;
404: adsp_inputQ[v] = sp;
405: adsp_pidM[v] = sp->pid;
406: ATENABLE(s, adspall_lock);
407: adsp_dequeue_ccb(sp);
408: }
409: *(unsigned char *)gbuf_rptr(gbuf_cont(mp)) = v;
410: sp->localSocket = v;
411: iocbp->ioc_rval = 0;
412: adsp_iocack(gref, mp);
413: }
414: return 0;
415: }
416:
417: case ADSPGETSOCK:
418: case ADSPGETPEER:
419: {
420: at_inet_t *addr;
421: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
422:
423: if (((xm = gbuf_cont(mp)) == NULL)
424: && ((xm = gbuf_alloc(sizeof(at_inet_t), PRI_MED)) == NULL)) {
425: iocbp->ioc_rval = -1;
426: adsp_iocnak(gref, mp, ENOSR);
427: return 0;
428: }
429: gbuf_cont(mp) = xm;
430: gbuf_wset(xm,sizeof(at_inet_t));
431: addr = (at_inet_t *)gbuf_rptr(xm);
432: if (iocbp->ioc_cmd == ADSPGETSOCK) {
433: adspgetcfg(gref);
434: *addr = ddpcfg.node_addr;
435: addr->socket = sp->localSocket;
436: } else
437: *addr = sp->remoteAddress.a;
438: iocbp->ioc_rval = 0;
439: adsp_iocack(gref, mp);
440: return 0;
441: }
442: } /* switch */
443: }
444:
445: /* Obtain Network and Node Id's from DDP */
446: adspgetcfg(gref);
447:
448: if (!gref->info)
449: gbuf_freem(mp);
450: else {
451: CCBPtr sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
452: ATDISABLE(s, sp->lockClose);
453: rc = adspWriteHandler(gref, mp);
454: ATENABLE(s, sp->lockClose);
455:
456: switch (rc) {
457: case STR_PUTNEXT:
458: if (gbuf_type(mp) == MSG_IOCTL) {
459: iocbp = (ioc_t *)gbuf_rptr(mp);
460: if (iocbp->ioc_cmd == DDP_IOC_GET_CFG) {
461: if ((xm = gbuf_alloc(sizeof(at_ddp_cfg_t), PRI_MED)) == NULL) {
462: adsp_iocnak(gref, mp, ENOBUFS);
463: break;
464: }
465: if (gbuf_cont(mp) != NULL)
466: gbuf_freem(gbuf_cont(mp));
467: gbuf_cont(mp) = xm;
468: gbuf_wset(xm,sizeof(at_ddp_cfg_t));
469: *(at_ddp_cfg_t *)gbuf_rptr(xm) = ddpcfg;
470: ((at_ddp_cfg_t *)gbuf_rptr(xm))->node_addr.socket =
471: ((CCBPtr)gbuf_rptr(((gbuf_t *)gref->info)))->localSocket;
472: adsp_iocack(gref, mp);
473: break;
474: }
475: iocbp->ioc_private = (void *)gref;
476: }
477: DDP_OUTPUT(mp);
478: break;
479: case STR_IGNORE:
480: case STR_IGNORE+99:
481: break;
482: default:
483: gbuf_freem(mp);
484: break;
485: }
486: }
487:
488: return 0;
489: } /* adsp_wput */
490:
491: void adspioc_ack(errno, m, gref)
492: int errno;
493: gbuf_t *m;
494: gref_t *gref;
495: {
496: ioc_t *iocbp;
497:
498: if (m == NULL)
499: return;
500: iocbp = (ioc_t *) gbuf_rptr(m);
501:
502: iocbp->ioc_error = errno; /* set the errno */
503: iocbp->ioc_count = gbuf_msgsize(gbuf_cont(m));
504: if (gbuf_type(m) == MSG_IOCTL) /* if an ioctl, this is an ack */
505: gbuf_set_type(m, MSG_IOCACK); /* and ALWAYS update the user */
506: /* ioctl structure */
507: SndMsgUp(gref, m);
508: }
509:
510: static void adspgetcfg(gref)
511: gref_t *gref;
512: {
513: static adspgetcfgdone = 0;
514: register gbuf_t *mp;
515: ioc_t *iocbp;
516:
517: if (adspgetcfgdone)
518: return;
519:
520: if (gref && (mp = gbuf_alloc(sizeof(ioc_t), PRI_HI))) {
521: adspgetcfgdone = 1;
522: gbuf_set_type(mp, MSG_IOCTL);
523: gbuf_wset(mp,sizeof(ioc_t));
524: iocbp = (ioc_t *) gbuf_rptr(mp);
525: iocbp->ioc_private = (void *)gref;
526: iocbp->ioc_count = ((CCBPtr)gbuf_rptr(((gbuf_t *)gref->info)))->localSocket;
527: iocbp->ioc_error = 7;
528:
529: iocbp->ioc_cmd = DDP_IOC_GET_CFG;
530: DDP_OUTPUT(mp);
531: }
532: }
533:
534: static void adsp_iocack(gref, m)
535: gref_t *gref;
536: register gbuf_t *m;
537: {
538: if (gbuf_type(m) == MSG_IOCTL)
539: gbuf_set_type(m, MSG_IOCACK);
540:
541: if (gbuf_cont(m))
542: ((ioc_t *)gbuf_rptr(m))->ioc_count = gbuf_msgsize(gbuf_cont(m));
543: else
544: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
545:
546: SndMsgUp(gref, m);
547: }
548:
549:
550: static void adsp_iocnak(gref, m, err)
551: gref_t *gref;
552: register gbuf_t *m;
553: register int err;
554: {
555: if (gbuf_type(m) == MSG_IOCTL)
556: gbuf_set_type(m, MSG_IOCNAK);
557: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
558:
559: if (err == 0)
560: err = ENXIO;
561: ((ioc_t *)gbuf_rptr(m))->ioc_error = err;
562:
563: if (gbuf_cont(m)) {
564: gbuf_freem(gbuf_cont(m));
565: gbuf_cont(m) = NULL;
566: }
567: SndMsgUp(gref, m);
568: }
569:
570: unsigned char
571: adspAssignSocket(gref, flag)
572: gref_t *gref;
573: int flag;
574: {
575: unsigned char sVal, sMax, sMin, sSav, inputC;
576: CCBPtr sp;
577: int s;
578:
579: sMax = flag ? DDP_SOCKET_LAST-46 : DDP_SOCKET_LAST-6;
580: sMin = DDP_SOCKET_1st_DYNAMIC-64;
581:
582: ATDISABLE(s, adspall_lock);
583: for (inputC=255, sVal=sMax; sVal >= sMin; sVal--) {
584: if (!ot_adsp_socketM[sVal]) {
585: if (!adsp_inputQ[sVal])
586: break;
587: else if (flag) {
588: if ((adsp_inputC[sVal] < inputC)
589: && (adsp_inputQ[sVal]->state == sOpen)) {
590: inputC = adsp_inputC[sVal];
591: sSav = sVal;
592: }
593: }
594: }
595: }
596:
597: if (sVal < sMin) {
598: if (!flag || (inputC == 255)) {
599: ATENABLE(s, adspall_lock);
600: return 0;
601: }
602: sVal = sSav;
603: }
604: sp = (CCBPtr)gbuf_rptr(((gbuf_t *)gref->info));
605: ATENABLE(s, adspall_lock);
606: adsp_dequeue_ccb(sp);
607: ATDISABLE(s, adspall_lock);
608: adsp_inputC[sVal]++;
609: sp->otccbLink = adsp_inputQ[sVal];
610: adsp_inputQ[sVal] = sp;
611: if (!flag)
612: adsp_pidM[sVal] = sp->pid;
613: ATENABLE(s, adspall_lock);
614: return sVal;
615: }
616:
617: int
618: adspDeassignSocket(sp)
619: CCBPtr sp;
620: {
621: unsigned char sVal;
622: CCBPtr curr_sp;
623: CCBPtr prev_sp;
624: int pid = 0;
625: int s, l;
626:
627: dPrintf(D_M_ADSP, D_L_TRACE, ("adspDeassignSocket: pid=%d,s=%d\n",
628: sp->pid, sp->localSocket));
629: ATDISABLE(s, adspall_lock);
630: sVal = sp->localSocket;
631: if ((curr_sp = adsp_inputQ[sVal]) != 0) {
632: prev_sp = 0;
633: while (curr_sp != sp) {
634: prev_sp = curr_sp;
635: curr_sp = curr_sp->otccbLink;
636: }
637: if (curr_sp) {
638: ATDISABLE(l, sp->lockRemove);
639: if (prev_sp)
640: prev_sp->otccbLink = sp->otccbLink;
641: else
642: adsp_inputQ[sVal] = sp->otccbLink;
643: ATENABLE(l, sp->lockRemove);
644: if (adsp_inputQ[sVal])
645: adsp_inputC[sVal]--;
646: else {
647: pid = adsp_pidM[sVal];
648: adsp_inputC[sVal] = 0;
649: adsp_pidM[sVal] = 0;
650: }
651: sp->ccbLink = 0;
652: sp->otccbLink = 0;
653: sp->localSocket = 0;
654: ATENABLE(s, adspall_lock);
655: return pid ? 0 : 1;
656: }
657: }
658: ATENABLE(s, adspall_lock);
659:
660: dPrintf(D_M_ADSP, D_L_ERROR,
661: ("adspDeassignSocket: closing, no CCB block, trouble ahead\n"));
662: return -1;
663: }
664:
665: /*
666: * stop ADSP now
667: */
668: static void
669: adsp_stop(m, flag)
670: gbuf_t *m;
671: int flag;
672: {
673: int k, s, *x_wptr;
674: CCB *sp;
675:
676: ATDISABLE(s, adspall_lock);
677: gbuf_rptr(m)[1]++;
678:
679: if (flag)
680: adsp_off_flag = 1;
681:
682: x_wptr = (int *)gbuf_wptr(m);
683: for (sp = ccb_used_list; sp; sp = sp->otccbLink) {
684: if (flag == 2) {
685: sp->ioDone = 1;
686: } else {
687: *(int *)gbuf_wptr(m) = sp->pid;
688: gbuf_winc(m,sizeof(int));
689: }
690: }
691:
692: for (k=0; k < 256; k++) {
693: if ((sp = adsp_inputQ[k]) == 0)
694: continue;
695: do {
696: if (flag == 2) {
697: sp->ioDone = 1;
698: } else {
699: *(int *)gbuf_wptr(m) = sp->pid;
700: gbuf_winc(m,sizeof(int));
701: }
702: } while ((sp = sp->otccbLink) != 0);
703: }
704: ATENABLE(s, adspall_lock);
705:
706: while (x_wptr != (int *)gbuf_wptr(m)) {
707: dPrintf(D_M_ADSP, D_L_TRACE, ("adsp_stop: pid=%d\n", *x_wptr));
708: x_wptr++;
709: }
710: }
711:
712: /*
713: * remove CCB from the use list
714: */
715: void
716: adsp_dequeue_ccb(sp)
717: CCB *sp;
718: {
719: int s;
720:
721: ATDISABLE(s, adspall_lock);
722: if (sp == ccb_used_list) {
723: if ((ccb_used_list = sp->otccbLink) != 0)
724: sp->otccbLink->ccbLink = 0;
725: } else if (sp->ccbLink) {
726: if ((sp->ccbLink->otccbLink = sp->otccbLink) != 0)
727: sp->otccbLink->ccbLink = sp->ccbLink;
728: }
729:
730: sp->otccbLink = 0;
731: sp->ccbLink = 0;
732: ATENABLE(s, adspall_lock);
733: }
734:
735: void SndMsgUp(gref, mp)
736: gref_t *gref; /* WRITE queue */
737: gbuf_t *mp;
738: {
739: atalk_putnext(gref, mp);
740: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.