![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sys_glue.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 sys_glue.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) 1995 Apple Computer, Inc. ! 24: * ! 25: * Change Log: ! 26: * Created, March 17, 1997 by Tuyen Nguyen for MacOSX. ! 27: */ ! 28: ! 29: #include <sys/errno.h> ! 30: #include <sys/types.h> ! 31: #include <sys/param.h> ! 32: #include <machine/spl.h> ! 33: #include <sys/systm.h> ! 34: #include <sys/kernel.h> ! 35: #include <sys/proc.h> ! 36: #include <sys/filedesc.h> ! 37: #include <sys/fcntl.h> ! 38: #include <sys/mbuf.h> ! 39: #include <sys/ioctl.h> ! 40: #include <sys/malloc.h> ! 41: #include <sys/socket.h> ! 42: #include <sys/socketvar.h> ! 43: #include <sys/ioccom.h> ! 44: ! 45: #include <sys/sysctl.h> ! 46: ! 47: #include <net/if.h> ! 48: ! 49: #include <netat/sysglue.h> ! 50: #include <netat/appletalk.h> ! 51: #include <netat/ddp.h> ! 52: #include <netat/at_pcb.h> ! 53: #include <netat/at_var.h> ! 54: #include <netat/routing_tables.h> ! 55: #include <netat/debug.h> ! 56: ! 57: extern struct atpcb ddp_head; ! 58: ! 59: extern void ! 60: ddp_putmsg(gref_t *gref, gbuf_t *m), ! 61: elap_wput(gref_t *gref, gbuf_t *m), ! 62: atp_wput(gref_t *gref, gbuf_t *m), ! 63: asp_wput(gref_t *gref, gbuf_t *m), ! 64: #ifdef AURP_SUPPORT ! 65: aurp_wput(gref_t *gref, gbuf_t *m), ! 66: #endif ! 67: adsp_wput(gref_t *gref, gbuf_t *m); ! 68: ! 69: void atalk_putnext(gref_t *gref, gbuf_t *m); ! 70: static int gref_close(gref_t *gref); ! 71: ! 72: SYSCTL_DECL(_net_appletalk); ! 73: dbgBits_t dbgBits; ! 74: SYSCTL_STRUCT(_net_appletalk, OID_AUTO, debug, CTLFLAG_WR, ! 75: &dbgBits, dbgBits, "Appletalk Debug Flags"); ! 76: volatile int RouterMix = RT_MIX_DEFAULT; /* default for nbr of ppsec */ ! 77: SYSCTL_INT(_net_appletalk, OID_AUTO, routermix, CTLFLAG_WR, ! 78: &RouterMix, 0, "Appletalk RouterMix"); ! 79: ! 80: atlock_t refall_lock; ! 81: ! 82: static void gref_wput(gref, m) ! 83: gref_t *gref; ! 84: gbuf_t *m; ! 85: { ! 86: switch (gref->proto) { ! 87: case ATPROTO_DDP: ! 88: ddp_putmsg(gref, m); break; ! 89: case ATPROTO_LAP: ! 90: elap_wput(gref, m); break; ! 91: case ATPROTO_ATP: ! 92: atp_wput(gref, m); break; ! 93: case ATPROTO_ASP: ! 94: asp_wput(gref, m); break; ! 95: #ifdef AURP_SUPPORT ! 96: case ATPROTO_AURP: ! 97: aurp_wput(gref, m); break; ! 98: #endif ! 99: case ATPROTO_ADSP: ! 100: adsp_wput(gref, m); break; ! 101: case ATPROTO_NONE: ! 102: if (gbuf_type(m) == MSG_IOCTL) { ! 103: gbuf_freem(gbuf_cont(m)); ! 104: gbuf_cont(m) = 0; ! 105: ((ioc_t *)gbuf_rptr(m))->ioc_rval = -1; ! 106: ((ioc_t *)gbuf_rptr(m))->ioc_error = EPROTO; ! 107: gbuf_set_type(m, MSG_IOCNAK); ! 108: atalk_putnext(gref, m); ! 109: } else ! 110: gbuf_freem(m); ! 111: break; ! 112: default: ! 113: gbuf_freem(m); ! 114: break; ! 115: } ! 116: } ! 117: ! 118: int _ATsocket(proto, err, proc) ! 119: int proto; ! 120: int *err; ! 121: void *proc; ! 122: { ! 123: int fd; ! 124: gref_t *gref; ! 125: ! 126: /* make sure the specified protocol id is valid */ ! 127: switch (proto) { ! 128: ! 129: /* ATPROTO_DDP and ATPROTO_LAP have been replaced with ! 130: BSD-style socket interface. */ ! 131: ! 132: case ATPROTO_ATP: ! 133: case ATPROTO_ASP: ! 134: case ATPROTO_AURP: ! 135: case ATPROTO_ADSP: ! 136: break; ! 137: default: ! 138: *err = EPROTOTYPE; ! 139: #ifdef APPLETALK_DEBUG ! 140: kprintf("_ATsocket: error EPROTOTYPE =%d\n", *err); ! 141: #endif ! 142: return -1; ! 143: } ! 144: ! 145: /* allocate a protocol channel */ ! 146: if ((*err = gref_alloc(&gref)) != 0) { ! 147: #ifdef APPLETALK_DEBUG ! 148: kprintf("_ATsocket: error gref_open =%d\n", *err); ! 149: #endif ! 150: return -1; ! 151: } ! 152: gref->proto = proto; ! 153: gref->pid = ((struct proc *)proc)->p_pid; ! 154: ! 155: /* open the specified protocol */ ! 156: switch (gref->proto) { ! 157: ! 158: /* ATPROTO_DDP and ATPROTO_LAP have been replaced with ! 159: BSD-style socket interface. */ ! 160: ! 161: case ATPROTO_ATP: ! 162: *err = atp_open(gref, 1); break; ! 163: case ATPROTO_ASP: ! 164: *err = asp_open(gref); break; ! 165: #ifdef AURP_SUPPORT ! 166: case ATPROTO_AURP: ! 167: *err = aurp_open(gref); break; ! 168: #endif ! 169: case ATPROTO_ADSP: ! 170: *err = adsp_open(gref); break; ! 171: } ! 172: ! 173: /* create the descriptor for the channel */ ! 174: if (*err) { ! 175: #ifdef APPLETALK_DEBUG ! 176: kprintf("_ATsocket: open failed for %d proto; err = %d\n", ! 177: gref->proto, *err); ! 178: #endif ! 179: gref->proto = ATPROTO_NONE; ! 180: } ! 181: if (*err || (*err = atalk_openref(gref, &fd, proc))) { ! 182: #ifdef APPLETALK_DEBUG ! 183: kprintf("_ATsocket: error atalk_openref =%d\n", *err); ! 184: #endif ! 185: (void)gref_close(gref); ! 186: return -1; ! 187: } ! 188: /* ! 189: kprintf("_ATsocket: proto=%d return=%d fd=%d\n", proto, *err, fd); ! 190: */ ! 191: return fd; ! 192: } /* _ATsocket */ ! 193: ! 194: int _ATgetmsg(fd, ctlptr, datptr, flags, err, proc) ! 195: int fd; ! 196: strbuf_t *ctlptr; ! 197: strbuf_t *datptr; ! 198: int *flags; ! 199: int *err; ! 200: void *proc; ! 201: { ! 202: int rc = -1; ! 203: gref_t *gref; ! 204: ! 205: if ((*err = atalk_getref(0, fd, &gref, proc)) == 0) { ! 206: switch (gref->proto) { ! 207: case ATPROTO_ASP: ! 208: rc = ASPgetmsg(gref, ctlptr, datptr, flags, err); break; ! 209: case ATPROTO_AURP: ! 210: #ifdef AURP_SUPPORT ! 211: rc = AURPgetmsg(err); break; ! 212: #endif ! 213: default: ! 214: *err = EPROTONOSUPPORT; break; ! 215: } ! 216: } ! 217: ! 218: ! 219: /* kprintf("_ATgetmsg: return=%d\n", *err);*/ ! 220: return rc; ! 221: } ! 222: ! 223: int _ATputmsg(fd, ctlptr, datptr, flags, err, proc) ! 224: int fd; ! 225: strbuf_t *ctlptr; ! 226: strbuf_t *datptr; ! 227: int flags; ! 228: int *err; ! 229: void *proc; ! 230: { ! 231: int rc = -1; ! 232: gref_t *gref; ! 233: ! 234: if ((*err = atalk_getref(0, fd, &gref, proc)) == 0) { ! 235: switch (gref->proto) { ! 236: case ATPROTO_ASP: ! 237: rc = ASPputmsg(gref, ctlptr, datptr, flags, err); break; ! 238: default: ! 239: *err = EPROTONOSUPPORT; break; ! 240: } ! 241: } ! 242: ! 243: /* kprintf("_ATputmsg: return=%d\n", *err); */ ! 244: return rc; ! 245: } ! 246: ! 247: int _ATclose(fp, proc) ! 248: void *fp; ! 249: void *proc; ! 250: { ! 251: int err; ! 252: gref_t *gref; ! 253: ! 254: if ((err = atalk_closeref(fp, &gref)) != 0) ! 255: return err; ! 256: ! 257: (void)gref_close(gref); ! 258: return 0; ! 259: } ! 260: ! 261: int _ATrw(fp, rw, uio, ext) ! 262: void *fp; ! 263: enum uio_rw rw; ! 264: struct uio *uio; ! 265: int ext; ! 266: { ! 267: int s, err, len, clen = 0, res; ! 268: gref_t *gref; ! 269: gbuf_t *m, *mhead, *mprev; ! 270: ! 271: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0) ! 272: return err; ! 273: ! 274: if ((len = uio->uio_resid) == 0) ! 275: return 0; ! 276: ! 277: ATDISABLE(s, gref->lock); ! 278: if (gref->errno) { ! 279: ATENABLE(s, gref->lock); ! 280: return (int)gref->errno; ! 281: } ! 282: ! 283: if (rw == UIO_READ) { ! 284: KERNEL_DEBUG(DBG_ADSP_ATRW, 0, gref, len, gref->rdhead, 0); ! 285: while ((gref->errno == 0) && ((mhead = gref->rdhead) == 0)) { ! 286: gref->sevents |= POLLMSG; ! 287: err = tsleep(&gref->event, PSOCK | PCATCH, "AT read", 0); ! 288: gref->sevents &= ~POLLMSG; ! 289: if (err != 0) { ! 290: ATENABLE(s, gref->lock); ! 291: return err; ! 292: } ! 293: KERNEL_DEBUG(DBG_ADSP_ATRW, 1, gref, gref->rdhead, mhead, gbuf_next(mhead)); ! 294: } ! 295: ! 296: if (gref->errno) { ! 297: ATENABLE(s, gref->lock); ! 298: return EPIPE; ! 299: } ! 300: if ((gref->rdhead = gbuf_next(mhead)) == 0) ! 301: gref->rdtail = 0; ! 302: ! 303: KERNEL_DEBUG(DBG_ADSP_ATRW, 2, gref, gref->rdhead, mhead, gbuf_next(mhead)); ! 304: ! 305: ATENABLE(s, gref->lock); ! 306: ! 307: //##### LD TEST 08/05 ! 308: // simple_lock(&gref->lock); ! 309: ! 310: gbuf_next(mhead) = 0; ! 311: ! 312: for (mprev=0, m=mhead; m && len; len-=clen) { ! 313: if ((clen = gbuf_len(m)) > 0) { ! 314: if (clen > len) ! 315: clen = len; ! 316: uio->uio_rw = UIO_READ; ! 317: if ((res = uiomove((caddr_t)gbuf_rptr(m), ! 318: clen, uio))) { ! 319: KERNEL_DEBUG(DBG_ADSP_ATRW, 3, m, clen, ! 320: len, gbuf_cont(m)); ! 321: break; ! 322: } ! 323: if (gbuf_len(m) > len) { ! 324: gbuf_rinc(m,clen); ! 325: break; ! 326: } ! 327: } ! 328: mprev = m; ! 329: m = gbuf_cont(m); ! 330: } ! 331: if (m) { ! 332: KERNEL_DEBUG(DBG_ADSP_ATRW, 4, m, gbuf_len(m), mprev, gref->rdhead); ! 333: if (mprev) ! 334: gbuf_cont(mprev) = 0; ! 335: else ! 336: mhead = 0; ! 337: ATDISABLE(s, gref->lock); ! 338: if (gref->rdhead == 0) ! 339: gref->rdtail = m; ! 340: gbuf_next(m) = gref->rdhead; ! 341: gref->rdhead = m; ! 342: ATENABLE(s, gref->lock); ! 343: } ! 344: if (mhead) ! 345: gbuf_freem(mhead); ! 346: //### LD TEST ! 347: // simple_unlock(&gref->lock); ! 348: } else { ! 349: if (gref->writeable) { ! 350: while (!(*gref->writeable)(gref)) { ! 351: /* flow control on, wait to be enabled to write */ ! 352: gref->sevents |= POLLSYNC; ! 353: err = tsleep(&gref->event, PSOCK | PCATCH, "AT write", 0); ! 354: gref->sevents &= ~POLLSYNC; ! 355: if (err != 0) { ! 356: ATENABLE(s, gref->lock); ! 357: return err; ! 358: } ! 359: } ! 360: } ! 361: ! 362: ATENABLE(s, gref->lock); ! 363: ! 364: /* allocate a buffer to copy in the write data */ ! 365: if ((m = gbuf_alloc(AT_WR_OFFSET+len, PRI_MED)) == 0) ! 366: return ENOBUFS; ! 367: gbuf_rinc(m,AT_WR_OFFSET); ! 368: gbuf_wset(m,len); ! 369: ! 370: /* copy in the write data */ ! 371: uio->uio_rw = UIO_WRITE; ! 372: if ((res = uiomove((caddr_t)gbuf_rptr(m), len, uio))) { ! 373: #ifdef APPLETALK_DEBUG ! 374: kprintf("_ATrw: UIO_WRITE: res=%d\n", res); ! 375: #endif ! 376: gbuf_freeb(m); ! 377: return EIO; ! 378: } ! 379: ! 380: /* forward the write data to the appropriate protocol module */ ! 381: gref_wput(gref, m); ! 382: } ! 383: ! 384: return 0; ! 385: } /* _ATrw */ ! 386: ! 387: int _ATread(fp, uio, cred) ! 388: void *fp; ! 389: struct uio *uio; ! 390: void *cred; ! 391: { ! 392: return _ATrw(fp, UIO_READ, uio, 0); ! 393: } ! 394: ! 395: int _ATwrite(fp, uio, cred) ! 396: void *fp; ! 397: struct uio *uio; ! 398: void *cred; ! 399: { ! 400: return _ATrw(fp, UIO_WRITE, uio, 0); ! 401: } ! 402: ! 403: /* Most of the processing from _ATioctl, so that it can be called ! 404: from the new select code */ ! 405: int at_ioctl(gref, cmd, arg) ! 406: gref_t *gref; ! 407: register caddr_t arg; ! 408: { ! 409: int s, err = 0, len; ! 410: gbuf_t *m, *mdata; ! 411: ioc_t *ioc; ! 412: ioccmd_t ioccmd; ! 413: ! 414: /* error if not for us */ ! 415: if ((cmd & 0xffff) != 0xff99) ! 416: return EOPNOTSUPP; ! 417: ! 418: /* copy in ioc command info */ ! 419: /* ! 420: kprintf("at_ioctl: arg ioccmd.ic_cmd=%x ic_len=%x gref->lock=%x, gref->event=%x\n", ! 421: ((ioccmd_t *)arg)->ic_cmd, ((ioccmd_t *)arg)->ic_len, ! 422: gref->lock, gref->event); ! 423: */ ! 424: if ((err = copyin((caddr_t)arg, ! 425: (caddr_t)&ioccmd, sizeof(ioccmd_t))) != 0) { ! 426: #ifdef APPLETALK_DEBUG ! 427: kprintf("at_ioctl: err = %d, copyin(%x, %x, %d)\n", err, ! 428: (caddr_t)arg, (caddr_t)&ioccmd, sizeof(ioccmd_t)); ! 429: #endif ! 430: return err; ! 431: } ! 432: ! 433: /* allocate a buffer to create an ioc command */ ! 434: if ((m = gbuf_alloc(sizeof(ioc_t), PRI_HI)) == 0) ! 435: return ENOBUFS; ! 436: gbuf_wset(m,sizeof(ioc_t)); ! 437: gbuf_set_type(m, MSG_IOCTL); ! 438: ! 439: /* create the ioc command */ ! 440: if (ioccmd.ic_len) { ! 441: if ((gbuf_cont(m) = gbuf_alloc(ioccmd.ic_len, PRI_HI)) == 0) { ! 442: gbuf_freem(m); ! 443: #ifdef APPLETALK_DEBUG ! 444: kprintf("at_ioctl: gbuf_alloc err=%d\n",ENOBUFS); ! 445: #endif ! 446: return ENOBUFS; ! 447: } ! 448: gbuf_wset(gbuf_cont(m),ioccmd.ic_len); ! 449: if ((err = copyin((caddr_t)ioccmd.ic_dp, ! 450: (caddr_t)gbuf_rptr(gbuf_cont(m)), ioccmd.ic_len)) != 0) { ! 451: gbuf_freem(m); ! 452: return err; ! 453: } ! 454: } ! 455: ioc = (ioc_t *)gbuf_rptr(m); ! 456: ioc->ioc_cmd = ioccmd.ic_cmd; ! 457: ioc->ioc_count = ioccmd.ic_len; ! 458: ioc->ioc_error = 0; ! 459: ioc->ioc_rval = 0; ! 460: ! 461: /* send the ioc command to the appropriate recipient */ ! 462: gref_wput(gref, m); ! 463: ! 464: /* wait for the ioc ack */ ! 465: ATDISABLE(s, gref->lock); ! 466: while ((m = gref->ichead) == 0) { ! 467: gref->sevents |= POLLPRI; ! 468: #ifdef APPLETALK_DEBUG ! 469: kprintf("sleep gref = 0x%x\n", (unsigned)gref); ! 470: #endif ! 471: err = tsleep(&gref->iocevent, PSOCK | PCATCH, "AT ioctl", 0); ! 472: gref->sevents &= ~POLLPRI; ! 473: if (err != 0) { ! 474: ATENABLE(s, gref->lock); ! 475: #ifdef APPLETALK_DEBUG ! 476: kprintf("at_ioctl: EINTR\n"); ! 477: #endif ! 478: return err; ! 479: } ! 480: } ! 481: ! 482: /* PR-2224797 */ ! 483: if (gbuf_next(m) == m) /* error case */ ! 484: gbuf_next(m) = 0; ! 485: ! 486: gref->ichead = gbuf_next(m); ! 487: ! 488: ATENABLE(s, gref->lock); ! 489: ! 490: #ifdef APPLETALK_DEBUG ! 491: kprintf("at_ioctl: woke up from ioc sleep gref = 0x%x\n", ! 492: (unsigned)gref); ! 493: #endif ! 494: /* process the ioc response */ ! 495: ioc = (ioc_t *)gbuf_rptr(m); ! 496: if ((err = ioc->ioc_error) == 0) { ! 497: ioccmd.ic_timout = ioc->ioc_rval; ! 498: ioccmd.ic_len = 0; ! 499: mdata = gbuf_cont(m); ! 500: if (mdata && ioccmd.ic_dp) { ! 501: ioccmd.ic_len = gbuf_msgsize(mdata); ! 502: for (len=0; mdata; mdata=gbuf_cont(mdata)) { ! 503: if ((err = copyout((caddr_t)gbuf_rptr(mdata), ! 504: (caddr_t)&ioccmd.ic_dp[len], gbuf_len(mdata))) < 0) { ! 505: #ifdef APPLETALK_DEBUG ! 506: kprintf("at_ioctl: len=%d error copyout=%d from=%x to=%x gbuf_len=%x\n", ! 507: len, err, (caddr_t)gbuf_rptr(mdata), ! 508: (caddr_t)&ioccmd.ic_dp[len], gbuf_len(mdata)); ! 509: #endif ! 510: goto l_done; ! 511: } ! 512: len += gbuf_len(mdata); ! 513: } ! 514: } ! 515: if ((err = copyout((caddr_t)&ioccmd, ! 516: (caddr_t)arg, sizeof(ioccmd_t))) != 0) { ! 517: #ifdef APPLETALK_DEBUG ! 518: kprintf("at_ioctl: error copyout2=%d from=%x to=%x len=%d\n", ! 519: err, &ioccmd, arg, sizeof(ioccmd_t)); ! 520: #endif ! 521: goto l_done; ! 522: } ! 523: } ! 524: ! 525: l_done: ! 526: gbuf_freem(m); ! 527: /*kprintf("at_ioctl: I_done=%d\n", err);*/ ! 528: return err; ! 529: } /* at_ioctl */ ! 530: ! 531: int _ATioctl(fp, cmd, arg, proc) ! 532: void *fp; ! 533: u_long cmd; ! 534: register caddr_t arg; ! 535: void *proc; ! 536: { ! 537: int err; ! 538: gref_t *gref; ! 539: ! 540: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0) { ! 541: #ifdef APPLETALK_DEBUG ! 542: kprintf("_ATioctl: atalk_getref err = %d\n", err); ! 543: #endif ! 544: return err; ! 545: } ! 546: ! 547: return((err = at_ioctl(gref, cmd, arg))); ! 548: } ! 549: ! 550: int _ATselect(fp, which, proc) ! 551: void *fp; ! 552: int which; ! 553: void *proc; ! 554: { ! 555: int s, err, rc = 0; ! 556: gref_t *gref; ! 557: ! 558: if ((err = atalk_getref(fp, 0, &gref, 0)) != 0) ! 559: return err; ! 560: ! 561: ATDISABLE(s, gref->lock); ! 562: if (which == FREAD) { ! 563: if (gref->rdhead || (gref->readable && (*gref->readable)(gref))) ! 564: rc = 1; ! 565: else { ! 566: gref->sevents |= POLLIN; ! 567: selrecord(proc, &gref->si); ! 568: } ! 569: } ! 570: ! 571: else if (which == POLLOUT) { ! 572: if (gref->writeable) { ! 573: if ((*gref->writeable)(gref)) ! 574: rc = 1; ! 575: else { ! 576: gref->sevents |= POLLOUT; ! 577: selrecord(proc, &gref->si); ! 578: } ! 579: } else ! 580: rc = 1; ! 581: } ! 582: ATENABLE(s, gref->lock); ! 583: ! 584: return rc; ! 585: } ! 586: ! 587: void atalk_putnext(gref, m) ! 588: gref_t *gref; ! 589: gbuf_t *m; ! 590: { ! 591: int s; ! 592: ! 593: ATDISABLE(s, gref->lock); ! 594: ! 595: /* *** potential leak? *** */ ! 596: gbuf_next(m) = 0; ! 597: ! 598: switch (gbuf_type(m)) { ! 599: case MSG_IOCACK: ! 600: case MSG_IOCNAK: ! 601: if (gref->ichead) ! 602: gbuf_next(gref->ichead) = m; ! 603: else { ! 604: gref->ichead = m; ! 605: if (gref->sevents & POLLPRI) { ! 606: #ifdef APPLETALK_DEBUG ! 607: kprintf("wakeup gref = 0x%x\n", (unsigned)gref); ! 608: #endif ! 609: thread_wakeup(&gref->iocevent); ! 610: } ! 611: } ! 612: break; ! 613: case MSG_ERROR: ! 614: /* *** this processing was moved to atalk_notify *** */ ! 615: panic("atalk_putnext receved MSG_ERROR"); ! 616: break; ! 617: default: ! 618: if (gref->errno) ! 619: gbuf_freem(m); ! 620: else ! 621: if (gref->rdhead) { ! 622: gbuf_next(gref->rdtail) = m; ! 623: gref->rdtail = m; ! 624: } else { ! 625: gref->rdhead = m; ! 626: if (gref->sevents & POLLMSG) { ! 627: gref->sevents &= ~POLLMSG; ! 628: thread_wakeup(&gref->event); ! 629: } ! 630: if (gref->sevents & POLLIN) { ! 631: gref->sevents &= ~POLLIN; ! 632: selwakeup(&gref->si); ! 633: } ! 634: gref->rdtail = m; ! 635: } ! 636: } /* switch gbuf_type(m) */ ! 637: ! 638: ATENABLE(s, gref->lock); ! 639: } /* atalk_putnext */ ! 640: ! 641: void atalk_enablew(gref) ! 642: gref_t *gref; ! 643: { ! 644: if (gref->sevents & POLLSYNC) ! 645: thread_wakeup(&gref->event); ! 646: } ! 647: ! 648: void atalk_flush(gref) ! 649: gref_t *gref; ! 650: { ! 651: int s; ! 652: ! 653: ATDISABLE(s, gref->lock); ! 654: if (gref->rdhead) { ! 655: gbuf_freel(gref->rdhead); ! 656: gref->rdhead = 0; ! 657: } ! 658: if (gref->ichead) { ! 659: gbuf_freel(gref->ichead); ! 660: gref->ichead = 0; ! 661: } ! 662: ATENABLE(s, gref->lock); ! 663: } ! 664: ! 665: /* ! 666: * Notify an appletalk user of an asynchronous error; ! 667: * just wake up so that he can collect error status. ! 668: */ ! 669: /* *** separate out the error wakeup stuff to eliminate use ! 670: of MSG_ERROR and atalk_putnext(), moving towards ! 671: standard socket code ! 672: *** */ ! 673: void atalk_notify(gref, errno) ! 674: register gref_t *gref; ! 675: int errno; ! 676: { ! 677: /* *** code from udp_notify() in netinet/udp_usrreq.c ! 678: inp->inp_socket->so_error = errno; ! 679: sorwakeup(inp->inp_socket); ! 680: sowwakeup(inp->inp_socket); ! 681: *** */ ! 682: ! 683: int s; ! 684: ATDISABLE(s, gref->lock); ! 685: ! 686: if (gref->errno == 0) { ! 687: gref->errno = errno; ! 688: if (gref->rdhead) { ! 689: gbuf_freel(gref->rdhead); ! 690: gref->rdhead = 0; ! 691: } ! 692: if (gref->sevents & POLLMSG) { ! 693: gref->sevents &= ~POLLMSG; ! 694: thread_wakeup(&gref->event); ! 695: } ! 696: if (gref->sevents & POLLIN) { ! 697: gref->sevents &= ~POLLIN; ! 698: selwakeup(&gref->si); ! 699: } ! 700: } ! 701: ATENABLE(s, gref->lock); ! 702: } /* atalk_notify */ ! 703: ! 704: void atalk_notify_sel(gref) ! 705: gref_t *gref; ! 706: { ! 707: int s; ! 708: ! 709: ATDISABLE(s, gref->lock); ! 710: if (gref->sevents & POLLIN) { ! 711: gref->sevents &= ~POLLIN; ! 712: selwakeup(&gref->si); ! 713: } ! 714: ATENABLE(s, gref->lock); ! 715: } ! 716: ! 717: int atalk_peek(gref, event) ! 718: gref_t *gref; ! 719: unsigned char *event; ! 720: { ! 721: int s, rc; ! 722: ! 723: ATDISABLE(s, gref->lock); ! 724: if (gref->rdhead) { ! 725: *event = *gbuf_rptr(gref->rdhead); ! 726: rc = 0; ! 727: } else ! 728: rc = -1; ! 729: ATENABLE(s, gref->lock); ! 730: ! 731: return rc; ! 732: } ! 733: ! 734: static gbuf_t *trace_msg; ! 735: ! 736: void atalk_settrace(str, p1, p2, p3, p4, p5) ! 737: char *str; ! 738: { ! 739: int len; ! 740: gbuf_t *m, *nextm; ! 741: char trace_buf[256]; ! 742: ! 743: sprintf(trace_buf, str, p1, p2, p3, p4, p5); ! 744: len = strlen(trace_buf); ! 745: #ifdef APPLETALK_DEBUG ! 746: kprintf("atalk_settrace: gbufalloc size=%d\n", len+1); ! 747: #endif ! 748: if ((m = gbuf_alloc(len+1, PRI_MED)) == 0) ! 749: return; ! 750: gbuf_wset(m,len); ! 751: strcpy(gbuf_rptr(m), trace_buf); ! 752: if (trace_msg) { ! 753: for (nextm=trace_msg; gbuf_cont(nextm); nextm=gbuf_cont(nextm)) ; ! 754: gbuf_cont(nextm) = m; ! 755: } else ! 756: trace_msg = m; ! 757: } ! 758: ! 759: void atalk_gettrace(m) ! 760: gbuf_t *m; ! 761: { ! 762: if (trace_msg) { ! 763: gbuf_cont(m) = trace_msg; ! 764: trace_msg = 0; ! 765: } ! 766: } ! 767: ! 768: #define GREF_PER_BLK 32 ! 769: static gref_t *gref_free_list = 0; ! 770: ! 771: int gref_alloc(grefp) ! 772: gref_t **grefp; ! 773: { ! 774: extern gbuf_t *atp_resource_m; ! 775: int i, s; ! 776: gbuf_t *m; ! 777: gref_t *gref, *gref_array; ! 778: ! 779: *grefp = (gref_t *)NULL; ! 780: ! 781: ATDISABLE(s, refall_lock); ! 782: if (gref_free_list == 0) { ! 783: ATENABLE(s, refall_lock); ! 784: #ifdef APPLETALK_DEBUG ! 785: kprintf("gref_alloc: gbufalloc size=%d\n", GREF_PER_BLK*sizeof(gref_t)); ! 786: #endif ! 787: if ((m = gbuf_alloc(GREF_PER_BLK*sizeof(gref_t),PRI_HI)) == 0) ! 788: return ENOBUFS; ! 789: bzero(gbuf_rptr(m), GREF_PER_BLK*sizeof(gref_t)); ! 790: gref_array = (gref_t *)gbuf_rptr(m); ! 791: for (i=0; i < GREF_PER_BLK-1; i++) ! 792: gref_array[i].atpcb_next = (gref_t *)&gref_array[i+1]; ! 793: ATDISABLE(s, refall_lock); ! 794: gbuf_cont(m) = atp_resource_m; ! 795: atp_resource_m = m; ! 796: gref_array[i].atpcb_next = gref_free_list; ! 797: gref_free_list = (gref_t *)&gref_array[0]; ! 798: } ! 799: ! 800: gref = gref_free_list; ! 801: gref_free_list = gref->atpcb_next; ! 802: ATENABLE(s, refall_lock); ! 803: ATLOCKINIT(gref->lock); ! 804: //### LD Test 08/05/98 ! 805: // simple_lock_init(&gref->lock); ! 806: ATEVENTINIT(gref->event); ! 807: ATEVENTINIT(gref->iocevent); ! 808: ! 809: /* *** just for now *** */ ! 810: gref->atpcb_socket = (struct socket *)NULL; ! 811: ! 812: *grefp = gref; ! 813: return 0; ! 814: } /* gref_alloc */ ! 815: ! 816: static int gref_close(gref) ! 817: gref_t *gref; ! 818: { ! 819: int s, rc; ! 820: ! 821: switch (gref->proto) { ! 822: ! 823: /* ATPROTO_DDP and ATPROTO_LAP have been replaced with ! 824: BSD-style socket interface. */ ! 825: ! 826: case ATPROTO_ATP: ! 827: rc = atp_close(gref, 1); break; ! 828: case ATPROTO_ASP: ! 829: rc = asp_close(gref); break; ! 830: #ifdef AURP_SUPPORT ! 831: case ATPROTO_AURP: ! 832: rc = aurp_close(gref); break; ! 833: break; ! 834: #endif ! 835: case ATPROTO_ADSP: ! 836: rc = adsp_close(gref); break; ! 837: default: ! 838: rc = 0; ! 839: break; ! 840: } ! 841: ! 842: if (rc == 0) { ! 843: atalk_flush(gref); ! 844: selthreadclear(&gref->si); ! 845: ! 846: /* from original gref_free() */ ! 847: ATDISABLE(s, refall_lock); ! 848: bzero((char *)gref, sizeof(gref_t)); ! 849: gref->atpcb_next = gref_free_list; ! 850: gref_free_list = gref; ! 851: ATENABLE(s, refall_lock); ! 852: } ! 853: ! 854: return rc; ! 855: } ! 856: ! 857: /* ! 858: Buffer Routines ! 859: ! 860: *** Some to be replaced with mbuf routines, some to be re-written ! 861: as mbuf routines (and moved to kern/uicp_mbuf.c or sys/mbuf.h?). ! 862: *** ! 863: ! 864: */ ! 865: ! 866: /* ! 867: * LD 5/12/97 Added for MacOSX, defines a m_clattach function that: ! 868: * "Allocates an mbuf structure and attaches an external cluster." ! 869: */ ! 870: ! 871: struct mbuf *m_clattach(extbuf, extfree, extsize, extarg, wait) ! 872: caddr_t extbuf; ! 873: int (*extfree)(); ! 874: int extsize; ! 875: int extarg; ! 876: int wait; ! 877: { ! 878: struct mbuf *m; ! 879: ! 880: if ((m = m_gethdr(wait, MSG_DATA)) == NULL) ! 881: return (NULL); ! 882: ! 883: m->m_ext.ext_buf = extbuf; ! 884: m->m_ext.ext_free = extfree; ! 885: m->m_ext.ext_size = extsize; ! 886: m->m_ext.ext_arg = extarg; ! 887: m->m_ext.ext_refs.forward = ! 888: m->m_ext.ext_refs.backward = &m->m_ext.ext_refs; ! 889: m->m_data = extbuf; ! 890: m->m_flags |= M_EXT; ! 891: ! 892: return (m); ! 893: } ! 894: ! 895: /* ! 896: Used as the "free" routine for over-size clusters allocated using ! 897: m_lgbuf_alloc(). ! 898: */ ! 899: ! 900: void m_lgbuf_free(buf, size, arg) ! 901: void *buf; ! 902: int size, arg; /* not needed, but they're in m_free() */ ! 903: { ! 904: FREE(buf, M_MCLUST); ! 905: } ! 906: ! 907: /* ! 908: Used to allocate an mbuf when there is the possibility that it may ! 909: need to be larger than the size of a standard cluster. ! 910: */ ! 911: ! 912: struct mbuf *m_lgbuf_alloc(size, wait) ! 913: int size, wait; ! 914: { ! 915: struct mbuf *m; ! 916: ! 917: /* If size is too large, allocate a cluster, otherwise, use the ! 918: standard mbuf allocation routines.*/ ! 919: if (size > MCLBYTES) { ! 920: void *buf; ! 921: if (NULL == ! 922: (buf = (void *)_MALLOC(size, M_MCLUST, ! 923: (wait)? M_WAITOK: M_NOWAIT))) { ! 924: return(NULL); ! 925: } ! 926: if (NULL == ! 927: (m = m_clattach(buf, m_lgbuf_free, size, 0, ! 928: (wait)? M_WAIT: M_DONTWAIT))) { ! 929: m_lgbuf_free(buf); ! 930: return(NULL); ! 931: } ! 932: } else { ! 933: m = m_gethdr(((wait)? M_WAIT: M_DONTWAIT), MSG_DATA); ! 934: if (m && (size > MHLEN)) { ! 935: MCLGET(m, ((wait)? M_WAIT: M_DONTWAIT)); ! 936: if (!(m->m_flags & M_EXT)) { ! 937: (void)m_free(m); ! 938: return(NULL); ! 939: } ! 940: } ! 941: } ! 942: ! 943: return(m); ! 944: } /* m_lgbuf_alloc */ ! 945: ! 946: /* ! 947: gbuf_alloc() is a wrapper for m_lgbuf_alloc(), which is used to ! 948: allocate an mbuf when there is the possibility that it may need ! 949: to be larger than the size of a standard cluster. ! 950: ! 951: gbuf_alloc() sets the mbuf lengths, unlike the standard mbuf routines. ! 952: */ ! 953: ! 954: gbuf_t *gbuf_alloc_wait(size, wait) ! 955: int size, wait; ! 956: { ! 957: gbuf_t *m = (gbuf_t *)m_lgbuf_alloc(size, wait); ! 958: ! 959: /* Standard mbuf allocation routines assume that the caller ! 960: will set the size. */ ! 961: if (m) { ! 962: (struct mbuf *)m->m_pkthdr.len = size; ! 963: (struct mbuf *)m->m_len = size; ! 964: } ! 965: ! 966: return(m); ! 967: } ! 968: ! 969: int gbuf_msgsize(m) ! 970: gbuf_t *m; ! 971: { ! 972: int size; ! 973: ! 974: for (size=0; m; m=gbuf_cont(m)) ! 975: size += gbuf_len(m); ! 976: return size; ! 977: } ! 978: ! 979: int append_copy(m1, m2, wait) ! 980: struct mbuf *m1, *m2; ! 981: int wait; ! 982: { ! 983: if ((!(m1->m_flags & M_EXT)) && (!(m2->m_flags & M_EXT)) && ! 984: (m_trailingspace(m1) >= m2->m_len)) { ! 985: /* splat the data from one into the other */ ! 986: bcopy(mtod(m2, caddr_t), mtod(m1, caddr_t) + m1->m_len, ! 987: (u_int)m2->m_len); ! 988: m1->m_len += m2->m_len; ! 989: if (m1->m_flags & M_PKTHDR) ! 990: m1->m_pkthdr.len += m2->m_len; ! 991: return 1; ! 992: } ! 993: if ((m1->m_next = m_copym(m2, 0, m2->m_len, ! 994: (wait)? M_WAIT: M_DONTWAIT)) == NULL) ! 995: return 0; ! 996: return 1; ! 997: } /* append_copy */ ! 998: ! 999: /* ! 1000: Copy an mbuf chain, referencing existing external storage, if any. ! 1001: Leave space for a header in the new chain, if the space has been ! 1002: left in the origin chain. ! 1003: */ ! 1004: struct mbuf *copy_pkt(mlist, pad) ! 1005: struct mbuf *mlist; /* the mbuf chain to be copied */ ! 1006: int pad; /* hint as to how long the header might be ! 1007: If pad is < 0, leave the same amount of space ! 1008: as there was in the original. */ ! 1009: { ! 1010: struct mbuf *new_m; ! 1011: int len; ! 1012: ! 1013: if (pad < 0) ! 1014: len = m_leadingspace(mlist); ! 1015: else ! 1016: len = min(pad, m_leadingspace(mlist)); ! 1017: ! 1018: /* preserve space for the header at the beginning of the mbuf */ ! 1019: if (len) { ! 1020: mlist->m_data -= (len); ! 1021: mlist->m_len += (len); ! 1022: if (mlist->m_flags & M_PKTHDR) ! 1023: mlist->m_pkthdr.len += (len); ! 1024: new_m = m_copym(mlist, 0, M_COPYALL, M_DONTWAIT); ! 1025: m_adj(mlist, len); ! 1026: m_adj(new_m, len); ! 1027: } else ! 1028: new_m = m_copym(mlist, 0, M_COPYALL, M_DONTWAIT); ! 1029: ! 1030: return(new_m); ! 1031: } ! 1032: ! 1033: void gbuf_linkb(m1, m2) ! 1034: gbuf_t *m1; ! 1035: gbuf_t *m2; ! 1036: { ! 1037: while (gbuf_cont(m1) != 0) ! 1038: m1 = gbuf_cont(m1); ! 1039: gbuf_cont(m1) = m2; ! 1040: } ! 1041: ! 1042: void gbuf_linkpkt(m1, m2) ! 1043: gbuf_t *m1; ! 1044: gbuf_t *m2; ! 1045: { ! 1046: while (gbuf_next(m1) != 0) ! 1047: m1 = gbuf_next(m1); ! 1048: gbuf_next(m1) = m2; ! 1049: } ! 1050: ! 1051: int gbuf_freel(m) ! 1052: gbuf_t *m; ! 1053: { ! 1054: gbuf_t *tmp_m; ! 1055: ! 1056: while ((tmp_m = m) != 0) { ! 1057: m = gbuf_next(m); ! 1058: gbuf_next(tmp_m) = 0; ! 1059: gbuf_freem(tmp_m); ! 1060: } ! 1061: return (0); ! 1062: } ! 1063: ! 1064: /* free empty mbufs at the front of the chain */ ! 1065: gbuf_t *gbuf_strip(m) ! 1066: gbuf_t *m; ! 1067: { ! 1068: gbuf_t *tmp_m; ! 1069: ! 1070: while (m && gbuf_len(m) == 0) { ! 1071: tmp_m = m; ! 1072: m = gbuf_cont(m); ! 1073: gbuf_freeb(tmp_m); ! 1074: } ! 1075: return(m); ! 1076: } ! 1077: ! 1078: /**************************************/ ! 1079: ! 1080: int ddp_adjmsg(m, len) ! 1081: gbuf_t *m; ! 1082: int len; ! 1083: { ! 1084: int buf_len; ! 1085: gbuf_t *curr_m, *prev_m; ! 1086: ! 1087: if (m == (gbuf_t *)0) ! 1088: return 0; ! 1089: ! 1090: if (len > 0) { ! 1091: for (curr_m=m; curr_m;) { ! 1092: buf_len = gbuf_len(curr_m); ! 1093: if (len < buf_len) { ! 1094: gbuf_rinc(curr_m,len); ! 1095: return 1; ! 1096: } ! 1097: len -= buf_len; ! 1098: gbuf_rinc(curr_m,buf_len); ! 1099: if ((curr_m = gbuf_cont(curr_m)) == 0) { ! 1100: gbuf_freem(m); ! 1101: return 0; ! 1102: } ! 1103: } ! 1104: ! 1105: } else if (len < 0) { ! 1106: len = -len; ! 1107: l_cont: prev_m = 0; ! 1108: for (curr_m=m; gbuf_cont(curr_m); ! 1109: prev_m=curr_m, curr_m=gbuf_cont(curr_m)) ; ! 1110: buf_len = gbuf_len(curr_m); ! 1111: if (len < buf_len) { ! 1112: gbuf_wdec(curr_m,len); ! 1113: return 1; ! 1114: } ! 1115: if (prev_m == 0) ! 1116: return 0; ! 1117: gbuf_cont(prev_m) = 0; ! 1118: gbuf_freeb(curr_m); ! 1119: len -= buf_len; ! 1120: goto l_cont; ! 1121: ! 1122: } else ! 1123: return 1; ! 1124: } ! 1125: ! 1126: /* ! 1127: * The message chain, m is grown in size by len contiguous bytes. ! 1128: * If len is non-negative, len bytes are added to the ! 1129: * end of the gbuf_t chain. If len is negative, the ! 1130: * bytes are added to the front. ddp_growmsg only adds bytes to ! 1131: * message blocks of the same type. ! 1132: * It returns a pointer to the new gbuf_t on sucess, 0 on failure. ! 1133: */ ! 1134: ! 1135: gbuf_t *ddp_growmsg(mp, len) ! 1136: gbuf_t *mp; ! 1137: int len; ! 1138: { ! 1139: gbuf_t *m, *d; ! 1140: ! 1141: if ((m = mp) == (gbuf_t *) 0) ! 1142: return ((gbuf_t *) 0); ! 1143: ! 1144: if (len <= 0) { ! 1145: len = -len; ! 1146: if ((d = gbuf_alloc(len, PRI_MED)) == 0) ! 1147: return ((gbuf_t *) 0); ! 1148: gbuf_set_type(d, gbuf_type(m)); ! 1149: gbuf_wset(d,len); ! 1150: /* link in new gbuf_t */ ! 1151: gbuf_cont(d) = m; ! 1152: return (d); ! 1153: ! 1154: } else { ! 1155: register int count; ! 1156: /* ! 1157: * Add to tail. ! 1158: */ ! 1159: if ((count = gbuf_msgsize(m)) < 0) ! 1160: return ((gbuf_t *) 0); ! 1161: /* find end of chain */ ! 1162: for ( ; m; m = gbuf_cont(m)) { ! 1163: if (gbuf_len(m) >= count) ! 1164: break; ! 1165: count -= gbuf_len(m); ! 1166: } ! 1167: /* m now points to gbuf_t to add to */ ! 1168: if ((d = gbuf_alloc(len, PRI_MED)) == 0) ! 1169: return ((gbuf_t *) 0); ! 1170: gbuf_set_type(d, gbuf_type(m)); ! 1171: /* link in new gbuf_t */ ! 1172: gbuf_cont(d) = gbuf_cont(m); ! 1173: gbuf_cont(m) = d; ! 1174: gbuf_wset(d,len); ! 1175: return (d); ! 1176: } ! 1177: } ! 1178: ! 1179: /* ! 1180: * return the MSG_IOCACK/MSG_IOCNAK. Note that the same message ! 1181: * block is used as the vehicle, and that if there is an error return, ! 1182: * then linked blocks are lopped off. BEWARE of multiple references. ! 1183: * Used by other appletalk modules, so it is not static! ! 1184: */ ! 1185: ! 1186: void ioc_ack(errno, m, gref) ! 1187: int errno; ! 1188: register gbuf_t *m; ! 1189: register gref_t *gref; ! 1190: { ! 1191: ioc_t *iocbp = (ioc_t *)gbuf_rptr(m); ! 1192: ! 1193: /*kprintf("ioc_ack: m=%x gref=%x errno=%d\n", m, gref, errno);*/ ! 1194: if ((iocbp->ioc_error = errno) != 0) ! 1195: { /* errno != 0, then there is an error, get rid of linked blocks! */ ! 1196: ! 1197: if (gbuf_cont(m)) { ! 1198: gbuf_freem(gbuf_cont(m)); ! 1199: gbuf_cont(m) = 0; ! 1200: } ! 1201: gbuf_set_type(m, MSG_IOCNAK); ! 1202: iocbp->ioc_count = 0; /* only make zero length if error */ ! 1203: iocbp->ioc_rval = -1; ! 1204: } else ! 1205: gbuf_set_type(m, MSG_IOCACK); ! 1206: ! 1207: atalk_putnext(gref, m); ! 1208: } ! 1209:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.