![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_dep.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 sys_dep.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: * ! 28: * The information contained herein is subject to change without ! 29: * notice and should not be construed as a commitment by Apple ! 30: * Computer, Inc. Apple Computer, Inc. assumes no responsibility ! 31: * for any errors that may appear. ! 32: * ! 33: * Confidential and Proprietary to Apple Computer, Inc. ! 34: * ! 35: */ ! 36: #include <h/sysglue.h> ! 37: #include <h/debug.h> ! 38: #include <sys/malloc.h> ! 39: #ifdef _AIX ! 40: #include <sys/device.h> ! 41: #else ! 42: #include <sys/file.h> ! 43: #endif ! 44: ! 45: int (*sys_ATsocket)() = 0; ! 46: int (*sys_ATgetmsg)() = 0; ! 47: int (*sys_ATputmsg)() = 0; ! 48: int (*sys_ATPsndreq)() = 0; ! 49: int (*sys_ATPsndrsp)() = 0; ! 50: int (*sys_ATPgetreq)() = 0; ! 51: int (*sys_ATPgetrsp)() = 0; ! 52: ! 53: #ifndef _AIX ! 54: ! 55: int ATsocket(proc, uap, retval) ! 56: void *proc; ! 57: struct { ! 58: int proto; ! 59: } *uap; ! 60: int *retval; ! 61: { ! 62: int err; ! 63: ! 64: if (sys_ATsocket) ! 65: *retval = (*sys_ATsocket)(uap->proto, &err, proc); ! 66: else { ! 67: *retval = -1; ! 68: err = ENXIO; ! 69: } ! 70: return err; ! 71: } ! 72: ! 73: int ATgetmsg(proc, uap, retval) ! 74: void *proc; ! 75: struct { ! 76: int fd; ! 77: void *ctlptr; ! 78: void *datptr; ! 79: int *flags; ! 80: } *uap; ! 81: int *retval; ! 82: { ! 83: int err; ! 84: ! 85: if (sys_ATgetmsg) ! 86: *retval = (*sys_ATgetmsg)(uap->fd, ! 87: uap->ctlptr, uap->datptr, uap->flags, &err, proc); ! 88: else { ! 89: *retval = -1; ! 90: err = ENXIO; ! 91: } ! 92: return err; ! 93: } ! 94: ! 95: int ATputmsg(proc, uap, retval) ! 96: void *proc; ! 97: struct { ! 98: int fd; ! 99: void *ctlptr; ! 100: void *datptr; ! 101: int flags; ! 102: } *uap; ! 103: int *retval; ! 104: { ! 105: int err; ! 106: ! 107: if (sys_ATputmsg) ! 108: *retval = (*sys_ATputmsg)(uap->fd, ! 109: uap->ctlptr, uap->datptr, uap->flags, &err, proc); ! 110: else { ! 111: *retval = -1; ! 112: err = ENXIO; ! 113: } ! 114: return err; ! 115: } ! 116: ! 117: int ATPsndreq(proc, uap, retval) ! 118: void *proc; ! 119: struct { ! 120: int fd; ! 121: unsigned char *buf; ! 122: int len; ! 123: int nowait; ! 124: } *uap; ! 125: int *retval; ! 126: { ! 127: int err; ! 128: ! 129: if (sys_ATPsndreq) ! 130: *retval = (*sys_ATPsndreq)(uap->fd, ! 131: uap->buf, uap->len, uap->nowait, &err, proc); ! 132: else { ! 133: *retval = -1; ! 134: err= ENXIO; ! 135: } ! 136: return err; ! 137: } ! 138: ! 139: int ATPsndrsp(proc, uap, retval) ! 140: void *proc; ! 141: struct { ! 142: int fd; ! 143: unsigned char *respbuff; ! 144: int resplen; ! 145: int datalen; ! 146: } *uap; ! 147: int *retval; ! 148: { ! 149: int err; ! 150: ! 151: if (sys_ATPsndrsp) ! 152: *retval = (*sys_ATPsndrsp)(uap->fd, ! 153: uap->respbuff, uap->resplen, uap->datalen, &err, proc); ! 154: else { ! 155: *retval = -1; ! 156: err = ENXIO; ! 157: } ! 158: return err; ! 159: } ! 160: ! 161: int ATPgetreq(proc, uap, retval) ! 162: void *proc; ! 163: struct { ! 164: int fd; ! 165: unsigned char *buf; ! 166: int buflen; ! 167: } *uap; ! 168: int *retval; ! 169: { ! 170: int err; ! 171: ! 172: if (sys_ATPgetreq) ! 173: *retval = (*sys_ATPgetreq)(uap->fd, ! 174: uap->buf, uap->buflen, &err, proc); ! 175: else { ! 176: *retval = -1; ! 177: err = ENXIO; ! 178: } ! 179: return err; ! 180: } ! 181: ! 182: int ATPgetrsp(proc, uap, retval) ! 183: void *proc; ! 184: struct { ! 185: int fd; ! 186: unsigned char *bdsp; ! 187: } *uap; ! 188: int *retval; ! 189: { ! 190: int err; ! 191: ! 192: if (sys_ATPgetrsp) ! 193: *retval = (*sys_ATPgetrsp)(uap->fd, uap->bdsp, &err, proc); ! 194: else { ! 195: *retval = -1; ! 196: err = ENXIO; ! 197: } ! 198: return err; ! 199: } ! 200: ! 201: void *at_cl_alloc(size, wait) ! 202: int size; /* in bytes */ ! 203: int wait; ! 204: { ! 205: return((void *)_MALLOC(size, M_MCLUST, (wait)? M_WAITOK: M_NOWAIT)); ! 206: } ! 207: ! 208: void at_cl_free(buf) ! 209: void *buf; ! 210: { ! 211: FREE(buf, M_MCLUST); ! 212: } ! 213: ! 214: int atalk_closeref(fp, grefp) ! 215: struct file *fp; ! 216: gref_t **grefp; ! 217: { ! 218: *grefp = (gref_t *)fp->f_data; ! 219: fp->f_data = 0; ! 220: return 0; ! 221: } ! 222: ! 223: int atalk_openref(gref, retfd, proc) ! 224: gref_t *gref; ! 225: int *retfd; ! 226: struct proc *proc; ! 227: { ! 228: extern int _ATread(), _ATwrite(),_ATioctl(), _ATselect(), _ATclose(); ! 229: static struct fileops fileops = {_ATread, _ATwrite, _ATioctl, _ATselect, _ATclose}; ! 230: int err, fd; ! 231: struct file *fp; ! 232: ! 233: if ((err = falloc(proc, &fp, &fd)) != 0) ! 234: return err; ! 235: fp->f_flag = FREAD|FWRITE; ! 236: /*##### LD 5/7/96 Warning: we don't have a "DTYPE_OTHER" for ! 237: * Rhapsody, so defines DTYPE_ATALK as DTYPE_SOCKET... ! 238: */ ! 239: fp->f_type = DTYPE_ATALK+1; ! 240: fp->f_ops = &fileops; ! 241: *fdflags(proc, fd) &= ~UF_RESERVED; ! 242: *retfd = fd; ! 243: fp->f_data = (void *)gref; ! 244: gref->next = (void *)fp; ! 245: return 0; ! 246: } ! 247: ! 248: int atalk_getref(fp, fd, grefp, proc) ! 249: struct file *fp; ! 250: int fd; ! 251: gref_t **grefp; ! 252: struct proc *proc; ! 253: { ! 254: if (fp == 0) { ! 255: int error = fdgetf(proc, fd, &fp); ! 256: ! 257: if (error) { ! 258: ! 259: *grefp = (gref_t *)0; ! 260: return EBADF; ! 261: } ! 262: } ! 263: if ((*grefp = (gref_t *)fp->f_data) == 0) ! 264: return EBADF; ! 265: return 0; ! 266: } ! 267: ! 268: gbuf_t *gbuf_alloc_wait(size, wait) ! 269: int size; ! 270: int wait; ! 271: { ! 272: gbuf_t *m; ! 273: /* ! 274: * ### LD 5/12/97 Allocate only a mbuf if size is ok, ! 275: * otherwise add a cluster. ! 276: */ ! 277: if (size > MCLBYTES) { ! 278: void *buf; ! 279: if ((buf = at_cl_alloc(size, wait)) == 0) { ! 280: #ifdef APPLETALK_DEBUG ! 281: kprintf("gbuf_alloc: size =%d at_cl_alloc failed\n", ! 282: size); ! 283: #endif ! 284: return NULL; ! 285: } ! 286: if ((m = (gbuf_t *)gbuf_attach( buf, at_cl_free, size, 0)) == 0) { ! 287: #ifdef APPLETALK_DEBUG ! 288: kprintf("gbuf_alloc: size =%d gbuf_attach failed\n", ! 289: size); ! 290: #endif ! 291: at_cl_free(buf); ! 292: return NULL; ! 293: } ! 294: /* ! 295: kprintf("gbuf_alloc: allocated with MALLOC m=%x size =%d \n", ! 296: m, size); ! 297: */ ! 298: } ! 299: else { ! 300: if (!(m = ! 301: (gbuf_t *)m_gethdr((wait)? M_WAIT: M_DONTWAIT, MSG_DATA))) ! 302: return(NULL); ! 303: if (size > MHLEN) { ! 304: MCLGET(m, (wait)? M_WAIT: M_DONTWAIT); ! 305: if (!(m->m_flags & M_EXT)) { ! 306: (void)m_free(m); ! 307: return(NULL); ! 308: } ! 309: } ! 310: } ! 311: gbuf_next(m) = 0; ! 312: gbuf_cont(m) = 0; ! 313: gbuf_wset(m,0); ! 314: return m; ! 315: } /* gbuf_alloc_wait */ ! 316: ! 317: gbuf_t *gbuf_alloc(size, pri) ! 318: int size; ! 319: int pri; ! 320: { ! 321: return(gbuf_alloc_wait(size, FALSE)); ! 322: } ! 323: ! 324: void gbuf_set_type(m, mtype) ! 325: gbuf_t *m; ! 326: short mtype; ! 327: { ! 328: MBUF_LOCK(); ! 329: mbstat.m_mtypes[m->m_type]--; ! 330: m->m_type = mtype; ! 331: mbstat.m_mtypes[mtype]++; ! 332: MBUF_UNLOCK(); ! 333: } ! 334: ! 335: void gbuf_freeb(m) ! 336: gbuf_t *m; ! 337: { ! 338: if (m) { ! 339: /* ! 340: kprintf("gbuf_freeb: calling m_free for m=%x\n", m); ! 341: */ ! 342: (void)m_free((struct mbuf *)m); ! 343: } ! 344: } ! 345: ! 346: /* ! 347: * LD 5/12/97 Added for Rhapsody, defines a m_clattach function that: ! 348: * "Allocates an mbuf structure and attaches an external cluster." ! 349: */ ! 350: ! 351: struct mbuf *m_clattach(extbuf, extfree, extsize, extarg, wait) ! 352: caddr_t extbuf; ! 353: int (*extfree)(); ! 354: int extsize; ! 355: int extarg; ! 356: int wait; ! 357: { ! 358: struct mbuf *m; ! 359: ! 360: m = m_gethdr(wait, MSG_DATA); ! 361: /* ! 362: kprintf("m_clattach: for mbuf = %x of extbuf =%x extsize=%d extfree=%x\n", ! 363: m, extbuf, extsize, extfree); ! 364: */ ! 365: if (m == NULL) ! 366: return (NULL); ! 367: m->m_ext.ext_buf = extbuf; ! 368: m->m_ext.ext_free = extfree; ! 369: m->m_ext.ext_size = extsize; ! 370: m->m_ext.ext_arg = extarg; ! 371: m->m_ext.ext_refs.forward = m->m_ext.ext_refs.backward = ! 372: &m->m_ext.ext_refs; ! 373: m->m_data = extbuf; ! 374: m->m_flags |= M_EXT; ! 375: m->m_pkthdr.len = extsize; ! 376: m->m_len = extsize; ! 377: ! 378: return (m); ! 379: ! 380: } ! 381: void *atalk_timeout(func, arg, ticks) ! 382: void (*func)(); ! 383: void *arg; ! 384: int ticks; ! 385: { ! 386: /* ! 387: dPrintf(D_M_ATP,D_L_VERBOSE, ! 388: "atalk_timeout: func=%x,arg=%x,time=%d\n", func,arg,ticks, 0, 0); ! 389: */ ! 390: timeout(func, arg, ticks); ! 391: return arg; ! 392: } ! 393: ! 394: void atalk_untimeout(func, arg, trb) ! 395: void (*func)(); ! 396: void *arg; ! 397: void *trb; ! 398: { ! 399: /* ! 400: dPrintf(D_M_ATP,D_L_VERBOSE, ! 401: "atalk_untimeout: func=%x,arg=%x, trb=%d\n", func,arg,trb, 0, 0); ! 402: */ ! 403: untimeout(func, arg); ! 404: } ! 405: ! 406: #else /* This AIX code (to the end of this file) is no longer supported. */ ! 407: ! 408: int ATsocket(proto) /* AIX version */ ! 409: int proto; ! 410: { ! 411: int err, rc = -1; ! 412: ! 413: if (sys_ATsocket) ! 414: rc = (*sys_ATsocket)(proto, &err, 0); ! 415: else ! 416: err = ENXIO; ! 417: if (err) ! 418: setuerror(err); ! 419: return rc; ! 420: } ! 421: ! 422: int ATgetmsg(fd, ctlptr, datptr, flags) /* AIX version */ ! 423: int fd; ! 424: void *ctlptr; ! 425: void *datptr; ! 426: int *flags; ! 427: { ! 428: int err, rc = -1; ! 429: ! 430: if (sys_ATgetmsg) ! 431: rc = (*sys_ATgetmsg)(fd, ctlptr, datptr, flags, &err, 0); ! 432: else ! 433: err = ENXIO; ! 434: if (err) ! 435: setuerror(err); ! 436: return rc; ! 437: } ! 438: ! 439: int ATputmsg(fd, ctlptr, datptr, flags) /* AIX version */ ! 440: int fd; ! 441: void *ctlptr; ! 442: void *datptr; ! 443: int flags; ! 444: { ! 445: int err, rc = -1; ! 446: ! 447: if (sys_ATputmsg) ! 448: rc = (*sys_ATputmsg)(fd, ctlptr, datptr, flags, &err, 0); ! 449: else ! 450: err = ENXIO; ! 451: if (err) ! 452: setuerror(err); ! 453: return rc; ! 454: } ! 455: ! 456: int ATPsndreq(fd, buf, len, nowait) /* AIX version */ ! 457: int fd; ! 458: unsigned char *buf; ! 459: int len; ! 460: int nowait; ! 461: { ! 462: int err, rc = -1; ! 463: ! 464: if (sys_ATPsndreq) ! 465: rc = (*sys_ATPsndreq)(fd, buf, len, nowait, &err, 0); ! 466: else ! 467: err = ENXIO; ! 468: if (err) ! 469: setuerror(err); ! 470: return rc; ! 471: } ! 472: ! 473: int ATPsndrsp(fd, respbuff, resplen, datalen) /* AIX version */ ! 474: int fd; ! 475: unsigned char *respbuff; ! 476: int resplen; ! 477: int datalen; ! 478: { ! 479: int err, rc = -1; ! 480: ! 481: if (sys_ATPsndrsp) ! 482: rc = (*sys_ATPsndrsp)(fd, respbuff, resplen, datalen, &err, 0); ! 483: else ! 484: err = ENXIO; ! 485: if (err) ! 486: setuerror(err); ! 487: return rc; ! 488: } ! 489: ! 490: int ATPgetreq(fd, buf, buflen) /* AIX version */ ! 491: int fd; ! 492: unsigned char *buf; ! 493: int buflen; ! 494: { ! 495: int err, rc = -1; ! 496: ! 497: if (sys_ATPgetreq) ! 498: rc = (*sys_ATPgetreq)(fd, buf, buflen, &err, 0); ! 499: else ! 500: err = ENXIO; ! 501: if (err) ! 502: setuerror(err); ! 503: return rc; ! 504: } ! 505: ! 506: int ATPgetrsp(fd, bdsp) /* AIX version */ ! 507: int fd; ! 508: unsigned char *bdsp; ! 509: { ! 510: int err, rc = -1; ! 511: ! 512: if (sys_ATPgetrsp) ! 513: rc = (*sys_ATPgetrsp)(fd, bdsp, &err, 0); ! 514: else ! 515: err = ENXIO; ! 516: if (err) ! 517: setuerror(err); ! 518: return rc; ! 519: } ! 520: ! 521: void *atalk_kalloc(size) /* AIX version */ ! 522: int size; ! 523: { ! 524: return (void *)xmalloc(size, 2, pinned_heap); ! 525: } ! 526: ! 527: void atalk_kfree(buf) /* AIX version */ ! 528: void *buf; ! 529: { ! 530: xmfree(buf, pinned_heap); ! 531: } ! 532: ! 533: int atalk_closeref(fp, grefp) /* AIX version */ ! 534: struct file *fp; ! 535: gref_t **grefp; ! 536: { ! 537: *grefp = (gref_t *)fp->f_data; ! 538: fp->f_data = 0; ! 539: return 0; ! 540: } ! 541: ! 542: int atalk_openref(gref, retfd, proc) /* AIX version */ ! 543: gref_t *gref; ! 544: int *retfd; ! 545: void *proc; ! 546: { ! 547: extern int _ATrw(), _ATioctl(), _ATselect(), _ATclose(), _ATstat(); ! 548: static struct fileops fileops = {_ATrw, _ATioctl, _ATselect, _ATclose, _ATstat}; ! 549: int err, fd; ! 550: struct file *fp; ! 551: void *crp; ! 552: ! 553: crp = (void *)crref(); ! 554: #ifdef _AIX ! 555: if ((err = ufdcreate(FREAD|FWRITE, ! 556: &fileops, 0, DTYPE_OTHER, &fd, crp)) != 0) ! 557: #else ! 558: if ((err = ufdcreate(FREAD|FWRITE, ! 559: &fileops, 0, DTYPE_ATALK, &fd, crp)) != 0) ! 560: #endif ! 561: return err; ! 562: *retfd = fd; ! 563: fp = U.U_ufd[fd].fp; ! 564: fp->f_data = (void *)gref; ! 565: gref->next = (void *)fp; ! 566: return 0; ! 567: } ! 568: ! 569: int atalk_getref(fp, fd, grefp, proc) /* AIX version */ ! 570: struct file *fp; ! 571: int fd; ! 572: gref_t **grefp; ! 573: struct proc *proc; ! 574: { ! 575: if (fp == 0) { ! 576: if ((fd < 0) || (fd > U.U_maxofile) || ((fp = U.U_ufd[fd].fp) == 0)) { ! 577: *grefp = (gref_t *)0; ! 578: return EBADF; ! 579: } ! 580: } ! 581: if ((*grefp = (gref_t *)fp->f_data) == 0) ! 582: return EBADF; ! 583: return 0; ! 584: } ! 585: ! 586: gbuf_t *gbuf_alloc(size, pri) /* AIX version */ ! 587: int size; ! 588: int pri; ! 589: { ! 590: gbuf_t *m; ! 591: ! 592: m = (size > MHLEN) ? (gbuf_t *)m_getclustm(M_DONTWAIT, MSG_DATA, size) ! 593: : (gbuf_t *)m_gethdr(M_DONTWAIT, MSG_DATA); ! 594: #ifdef APPLETALK_DEBUG ! 595: kprintf("gbuf_alloc: for size = %d m=%x\n", size, m); ! 596: #endif ! 597: gbuf_next(m) = 0; ! 598: gbuf_cont(m) = 0; ! 599: gbuf_wset(m,0); ! 600: return m; ! 601: } ! 602: ! 603: void gbuf_freeb(m) /* AIX version */ ! 604: gbuf_t *m; ! 605: { ! 606: if (m) ! 607: m_free(m); ! 608: } ! 609: ! 610: static struct trb *trb_freehead = 0; ! 611: static struct trb *trb_freetail = 0; ! 612: static struct trb *trb_pendhead = 0; ! 613: static int trb_cnt = 0; ! 614: static atlock_t trb_lock; ! 615: ! 616: static void atalk_rem_timeoutcf() /* AIX version */ ! 617: { ! 618: register int s; ! 619: register struct trb *trb; ! 620: register struct trb *tmp_freehead, *tmp_pendhead; ! 621: ! 622: ATDISABLE(s, trb_lock); ! 623: tmp_freehead = trb_freehead; ! 624: trb_freehead = 0; ! 625: tmp_pendhead = trb_pendhead; ! 626: trb_pendhead = 0; ! 627: trb_cnt = 0; ! 628: ATENABLE(s, trb_lock); ! 629: while ((trb = tmp_pendhead) != 0) { ! 630: tmp_pendhead = trb->to_next; ! 631: while (tstop(trb)); ! 632: tfree(trb); ! 633: } ! 634: while ((trb = tmp_freehead) != 0) { ! 635: tmp_freehead = trb->to_next; ! 636: tfree(trb); ! 637: } ! 638: dPrintf(D_M_ATP,D_L_ERROR, "atalk: timer stopped!\n",0,0,0,0,0); ! 639: } ! 640: ! 641: static void atalk_timeoutcf(cnt) /* AIX version */ ! 642: int cnt; ! 643: { ! 644: register int i; ! 645: register struct trb *trb; ! 646: ! 647: if (trb_freehead == 0) { ! 648: for (i=0; i < cnt-1; i++) { ! 649: trb = (struct trb *)talloc(); ! 650: trb->to_next = trb_freehead; ! 651: trb_freehead = trb; ! 652: if (!i) trb_freetail = trb; ! 653: trb_cnt++; ! 654: } ! 655: } ! 656: ATLOCKINIT(trb_lock); ! 657: } ! 658: ! 659: static void atalk_clock(trb) /* AIX version */ ! 660: register struct trb *trb; ! 661: { ! 662: register int s; ! 663: register struct trb *next; ! 664: void (*tof)(); ! 665: void *arg; ! 666: ! 667: ATDISABLE(s, trb_lock); ! 668: if (trb_pendhead && trb->func) { ! 669: /* ! 670: * remove the timeout from the pending queue ! 671: */ ! 672: if (trb_pendhead == trb) ! 673: trb_pendhead = trb->to_next; ! 674: else { ! 675: for (next=trb_pendhead; next->to_next; next=next->to_next) { ! 676: if (next->to_next == trb) { ! 677: next->to_next = trb->to_next; ! 678: trb->func = 0; ! 679: break; ! 680: } ! 681: } ! 682: if (trb->func) { ! 683: dPrintf(D_M_ATP,D_L_WARNING, ! 684: "atalk_clock: %d,%x,%x\n", trb_cnt,trb,trb_pendhead,0,0); ! 685: /* ! 686: * we have not found the trb in the pending list - something ! 687: * has gone wrong here. maybe the trb has been returned to ! 688: * the free list; in which case, we should simply ignore ! 689: * this timeout event! ! 690: */ ! 691: for (next=trb_freehead; next; next=next->to_next) { ! 692: if (next == trb) ! 693: { ! 694: ATENABLE(s, trb_lock); ! 695: return; ! 696: } ! 697: } ! 698: /* ! 699: * the trb is not in the free list either - something has ! 700: * really gone wacky here! all we can do now is put the ! 701: * trb back into the free list and hope that it will be ok. ! 702: */ ! 703: trb->to_next = 0; ! 704: if (trb_freehead) ! 705: trb_freetail->to_next = trb; ! 706: else ! 707: trb_freehead = trb; ! 708: trb_freetail = trb; ! 709: trb_cnt++; ! 710: ATENABLE(s, trb_lock); ! 711: return; ! 712: } ! 713: } ! 714: ! 715: /* ! 716: * process the timeout ! 717: */ ! 718: trb->func = 0; ! 719: trb->to_next = 0; ! 720: tof = trb->tof; ! 721: trb->tof = 0; ! 722: arg = (void *)trb->func_data; ! 723: trb->func_data = 999; ! 724: if (trb_freehead) ! 725: trb_freetail->to_next = trb; ! 726: else ! 727: trb_freehead = trb; ! 728: trb_freetail = trb; ! 729: trb_cnt++; ! 730: ATENABLE(s, trb_lock); ! 731: if (tof) { ! 732: dPrintf(D_M_ATP,D_L_VERBOSE, "atalk_clock: func=%x, arg=%x, %d\n", ! 733: tof,arg,trb_cnt,0,0); ! 734: (*tof)(arg); ! 735: } else { ! 736: dPrintf(D_M_ATP,D_L_ERROR, "atalk_clock: func=%x, arg=%x, %d\n", ! 737: tof,arg,trb_cnt,0,0); ! 738: } ! 739: } else ! 740: ATENABLE(s, trb_lock); ! 741: } ! 742: ! 743: void *atalk_timeout(func, arg, ticks) /* AIX version */ ! 744: void (*func)(); ! 745: void *arg; ! 746: int ticks; ! 747: { ! 748: register int s; ! 749: register struct trb *trb; ! 750: ! 751: dPrintf(D_M_ATP,D_L_VERBOSE, ! 752: "atalk_timeout: func=%x,arg=%x,time=%d, %d,%x\n", func,arg,ticks,trb_cnt,trb_pendhead); ! 753: /* ! 754: * set up the timeout request ! 755: */ ! 756: ATDISABLE(s, trb_lock); ! 757: if ((trb = trb_freehead) == 0) { ! 758: ATENABLE(s, trb_lock); ! 759: dPrintf(D_M_ATP,D_L_WARNING, ! 760: "atalk_timeout: NO TRB! time=%d, %d\n", ticks,trb_cnt,0,0,0); ! 761: return 0; ! 762: } ! 763: trb_freehead = trb->to_next; ! 764: trb->to_next = trb_pendhead; ! 765: trb_pendhead = trb; ! 766: trb_cnt--; ! 767: trb->timeout.it_value.tv_sec = ticks / HZ; ! 768: trb->timeout.it_value.tv_nsec = (ticks % HZ) * (NS_PER_SEC / HZ); ! 769: trb->knext = 0; ! 770: trb->kprev = 0; ! 771: trb->flags = 0; ! 772: trb->tof = func; ! 773: trb->func = (void (*)())atalk_clock; ! 774: trb->func_data = (ulong)arg; ! 775: trb->ipri = PL_IMP; ! 776: trb->id = -1; ! 777: ! 778: /* ! 779: * start the timeout ! 780: */ ! 781: ATENABLE(s, trb_lock); ! 782: tstart(trb); ! 783: return (void *)trb; ! 784: } ! 785: ! 786: void atalk_untimeout(func, arg, trb) /* AIX version */ ! 787: void (*func)(); ! 788: void *arg; ! 789: register struct trb *trb; ! 790: { ! 791: register int s; ! 792: register struct trb *next; ! 793: ! 794: dPrintf(D_M_ATP,D_L_VERBOSE, ! 795: "atalk_untimeout: func=%x,arg=%x, %d\n", func,arg,trb_cnt,0,0); ! 796: ! 797: ATDISABLE(s, trb_lock); ! 798: if (trb == 0) { ! 799: for (trb=trb_pendhead; trb; trb=trb->to_next) { ! 800: if ((func == trb->tof) && (arg == (void *)trb->func_data)) ! 801: break; ! 802: } ! 803: } ! 804: if (trb && (trb->func == (void (*)())atalk_clock) ! 805: && (func == trb->tof) && (arg == (void *)trb->func_data)) { ! 806: trb->func_data = 999; ! 807: if (!(trb->flags & T_PENDING)) ! 808: { ! 809: trb->tof = 0; ! 810: ATENABLE(s, trb_lock); ! 811: return; ! 812: } ! 813: trb->func = 0; ! 814: while (tstop(trb)); ! 815: if (trb_pendhead == trb) ! 816: trb_pendhead = trb->to_next; ! 817: else { ! 818: for (next=trb_pendhead; next->to_next != trb; next=next->to_next) { ! 819: if (next->to_next == 0) { ! 820: ATENABLE(s, trb_lock); ! 821: dPrintf(D_M_ATP,D_L_WARNING, ! 822: "atalk_untimeout: UNKNOWN TRB %x...\n",trb,0,0,0,0); ! 823: return; ! 824: } ! 825: } ! 826: next->to_next = trb->to_next; ! 827: } ! 828: trb->to_next = 0; ! 829: trb_freetail->to_next = trb; ! 830: trb_freetail = trb; ! 831: trb_cnt++; ! 832: } ! 833: ATENABLE(s, trb_lock); ! 834: } ! 835: ! 836: int config_atalk(dev, cmd, uiop) /* AIX only */ ! 837: dev_t dev; ! 838: int cmd; ! 839: void *uiop; ! 840: { ! 841: static int loaded = 0; ! 842: int err, nest; ! 843: ! 844: err = 0; ! 845: nest = lockl(&kernel_lock, LOCK_SHORT); ! 846: ! 847: if (cmd == CFG_INIT) { ! 848: if (loaded) ! 849: goto out; ! 850: vm_protect(0, 4096, 3); ! 851: atalk_timeoutcf(256); ! 852: atalk_load(); ! 853: loaded = 1; ! 854: ! 855: } else if (cmd == CFG_TERM) { ! 856: if (!loaded) ! 857: goto out; ! 858: atalk_rem_timeoutcf(); ! 859: atalk_unload(); ! 860: loaded = 0; ! 861: ! 862: } else ! 863: err = EINVAL; ! 864: ! 865: out: ! 866: if (nest != LOCK_NEST) ! 867: unlockl(&kernel_lock); ! 868: return(err); ! 869: } ! 870: ! 871: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.