![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atp_write.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_write.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: #define RESOLVE_DBG ! 31: ! 32: #include <sys/errno.h> ! 33: #include <sys/types.h> ! 34: #include <sys/param.h> ! 35: #include <machine/spl.h> ! 36: #include <sys/systm.h> ! 37: #include <sys/kernel.h> ! 38: #include <sys/proc.h> ! 39: #include <sys/filedesc.h> ! 40: #include <sys/fcntl.h> ! 41: #include <sys/mbuf.h> ! 42: #include <sys/ioctl.h> ! 43: #include <sys/malloc.h> ! 44: #include <sys/socket.h> ! 45: #include <sys/socketvar.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/atp.h> ! 54: #include <netat/at_var.h> ! 55: #include <netat/asp.h> ! 56: #include <netat/at_pat.h> ! 57: #include <netat/debug.h> ! 58: ! 59: static int loop_cnt; /* for debugging loops */ ! 60: #define CHK_LOOP(str) { \ ! 61: if (loop_cnt++ > 100) { \ ! 62: kprintf("%s", str); \ ! 63: break; \ ! 64: } \ ! 65: } ! 66: ! 67: static void atp_pack_bdsp(struct atp_trans *, struct atpBDS *); ! 68: static int atp_unpack_bdsp(struct atp_state *, gbuf_t *, struct atp_rcb *, ! 69: int, int); ! 70: void atp_retry_req(), atp_trp_clock(), asp_clock(); ! 71: ! 72: extern struct atp_rcb_qhead atp_need_rel; ! 73: extern int atp_inited; ! 74: extern struct atp_state *atp_used_list; ! 75: extern asp_scb_t *scb_free_list; ! 76: extern atlock_t atpgen_lock; ! 77: extern atlock_t atpall_lock; ! 78: extern atlock_t atptmo_lock; ! 79: ! 80: extern gbuf_t *scb_resource_m; ! 81: extern gbuf_t *atp_resource_m; ! 82: extern gref_t *atp_inputQ[]; ! 83: extern int atp_pidM[]; ! 84: extern char ot_atp_socketM[]; ! 85: extern at_ifaddr_t *ifID_home; ! 86: ! 87: static struct atp_trans *trp_tmo_list; ! 88: struct atp_trans *trp_tmo_rcb; ! 89: ! 90: /* first bds entry gives number of bds entries in total (hack) */ ! 91: #define get_bds_entries(m) \ ! 92: ((gbuf_len(m) > TOTAL_ATP_HDR_SIZE)? \ ! 93: (UAS_VALUE(((struct atpBDS *)(AT_ATP_HDR(m)->data))->bdsDataSz)): 0) ! 94: ! 95: #define atpBDSsize (sizeof(struct atpBDS)*ATP_TRESP_MAX) ! 96: ! 97: void atp_link() ! 98: { ! 99: trp_tmo_list = 0; ! 100: trp_tmo_rcb = atp_trans_alloc(0); ! 101: atp_timout(atp_rcb_timer, trp_tmo_rcb, 10 * HZ); ! 102: atp_trp_clock((void *)&atp_inited); ! 103: asp_clock((void *)&atp_inited); ! 104: } ! 105: ! 106: void atp_unlink() ! 107: { ! 108: untimeout(asp_clock, (void *)&atp_inited); ! 109: untimeout(atp_trp_clock, (void *)&atp_inited); ! 110: atp_untimout(atp_rcb_timer, trp_tmo_rcb); ! 111: trp_tmo_list = 0; ! 112: ! 113: #ifdef BAD_IDEA ! 114: /* allocated in asp_scb_alloc(), which is called ! 115: by asp_open() */ ! 116: if (scb_resource_m) { ! 117: gbuf_freem(scb_resource_m); ! 118: scb_resource_m = 0; ! 119: scb_free_list = 0; ! 120: } ! 121: /* allocated in atp_trans_alloc() */ ! 122: if (atp_resource_m) { ! 123: gbuf_freem(atp_resource_m); ! 124: atp_resource_m = 0; ! 125: atp_trans_free_list = 0; ! 126: } ! 127: #endif ! 128: } ! 129: ! 130: /* ! 131: * write queue put routine .... filter out other than IOCTLs ! 132: * Version 1.8 of atp_write.c on 89/02/09 17:53:26 ! 133: */ ! 134: ! 135: void ! 136: atp_wput(gref, m) ! 137: register gref_t *gref; ! 138: register gbuf_t *m; ! 139: { ! 140: register ioc_t *iocbp; ! 141: int i, xcnt, s; ! 142: struct atp_state *atp; ! 143: struct atp_trans *trp; ! 144: struct atp_rcb *rcbp; ! 145: at_socket skt; ! 146: ! 147: atp = (struct atp_state *)gref->info; ! 148: if (atp->dflag) ! 149: atp = (struct atp_state *)atp->atp_msgq; ! 150: ! 151: switch(gbuf_type(m)) { ! 152: case MSG_DATA: ! 153: if (atp->atp_msgq) { ! 154: gbuf_freem(m); ! 155: dPrintf(D_M_ATP, D_L_WARNING, ! 156: ("atp_wput: atp_msgq discarded\n")); ! 157: } else ! 158: atp->atp_msgq = m; ! 159: break; ! 160: ! 161: case MSG_IOCTL: ! 162: /* Need to ensure that all copyin/copyout calls are made at ! 163: * put routine time which should be in the user context. (true when ! 164: * we are the stream head). The service routine can be called on an ! 165: * unpredictable context and copyin/copyout calls will get wrong results ! 166: * or even panic the kernel. ! 167: */ ! 168: iocbp = (ioc_t *)gbuf_rptr(m); ! 169: ! 170: switch (iocbp->ioc_cmd) { ! 171: case AT_ATP_BIND_REQ: ! 172: if (gbuf_cont(m) == NULL) { ! 173: iocbp->ioc_rval = -1; ! 174: atp_iocnak(atp, m, EINVAL); ! 175: return; ! 176: } ! 177: skt = *(at_socket *)gbuf_rptr(gbuf_cont(m)); ! 178: if ((skt = (at_socket)atp_bind(gref, (unsigned int)skt, 0)) == 0) ! 179: atp_iocnak(atp, m, EINVAL); ! 180: else { ! 181: *(at_socket *)gbuf_rptr(gbuf_cont(m)) = skt; ! 182: iocbp->ioc_rval = 0; ! 183: atp_iocack(atp, m); ! 184: atp_dequeue_atp(atp); ! 185: } ! 186: return; ! 187: ! 188: case AT_ATP_GET_CHANID: ! 189: if (gbuf_cont(m) == NULL) { ! 190: iocbp->ioc_rval = -1; ! 191: atp_iocnak(atp, m, EINVAL); ! 192: return; ! 193: } ! 194: *(gref_t **)gbuf_rptr(gbuf_cont(m)) = gref; ! 195: atp_iocack(atp, m); ! 196: return; ! 197: ! 198: /* not the close and not the tickle(?) */ ! 199: case AT_ATP_ISSUE_REQUEST_DEF: ! 200: case AT_ATP_ISSUE_REQUEST_DEF_NOTE: { ! 201: gbuf_t *bds, *tmp, *m2; ! 202: struct atp_rcb *rcbp; ! 203: at_ddp_t *ddp; ! 204: at_atp_t *athp; ! 205: ! 206: if ((tmp = gbuf_cont(m)) != 0) { ! 207: if ((bds = gbuf_dupb(tmp)) == NULL) { ! 208: atp_iocnak(atp, m, ENOBUFS); ! 209: return; ! 210: } ! 211: gbuf_rinc(tmp,atpBDSsize); ! 212: gbuf_wset(bds,atpBDSsize); ! 213: iocbp->ioc_count -= atpBDSsize; ! 214: gbuf_cont(tmp) = bds; ! 215: } ! 216: ! 217: /* ! 218: * send a response to a transaction ! 219: * first check it out ! 220: */ ! 221: if (iocbp->ioc_count < TOTAL_ATP_HDR_SIZE) { ! 222: atp_iocnak(atp, m, EINVAL); ! 223: break; ! 224: } ! 225: ! 226: /* ! 227: * remove the response from the message ! 228: */ ! 229: m2 = gbuf_cont(m); ! 230: gbuf_cont(m) = NULL; ! 231: iocbp->ioc_count = 0; ! 232: ddp = AT_DDP_HDR(m2); ! 233: athp = AT_ATP_HDR(m2); ! 234: if (atp->atp_msgq) { ! 235: gbuf_cont(m2) = atp->atp_msgq; ! 236: atp->atp_msgq = 0; ! 237: } ! 238: ! 239: ATDISABLE(s, atp->atp_lock); ! 240: /* ! 241: * search for the corresponding rcb ! 242: */ ! 243: for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) { ! 244: if (rcbp->rc_tid == UAS_VALUE(athp->tid) && ! 245: rcbp->rc_socket.node == ddp->dst_node && ! 246: rcbp->rc_socket.net == NET_VALUE(ddp->dst_net) && ! 247: rcbp->rc_socket.socket == ddp->dst_socket) ! 248: break; ! 249: } ! 250: ATENABLE(s, atp->atp_lock); ! 251: ! 252: /* ! 253: * If it has already been sent then return an error ! 254: */ ! 255: if ((rcbp && rcbp->rc_state != RCB_NOTIFIED) || ! 256: (rcbp == NULL && athp->xo)) { ! 257: atp_iocnak(atp, m, ENOENT); ! 258: gbuf_freem(m2); ! 259: return; ! 260: } ! 261: if (rcbp == NULL) { /* a response for an ALO transaction */ ! 262: if ((rcbp = atp_rcb_alloc(atp)) == NULL) { ! 263: atp_iocnak(atp, m, ENOBUFS); ! 264: gbuf_freem(m2); ! 265: return; ! 266: } ! 267: rcbp->rc_ioctl = 0; ! 268: rcbp->rc_socket.socket = ddp->dst_socket; ! 269: rcbp->rc_socket.node = ddp->dst_node; ! 270: rcbp->rc_socket.net = NET_VALUE(ddp->dst_net); ! 271: rcbp->rc_tid = UAS_VALUE(athp->tid); ! 272: rcbp->rc_bitmap = 0xff; ! 273: rcbp->rc_xo = 0; ! 274: ATDISABLE(s, atp->atp_lock); ! 275: rcbp->rc_state = RCB_SENDING; ! 276: ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list); ! 277: ATENABLE(s, atp->atp_lock); ! 278: } ! 279: xcnt = get_bds_entries(m2); ! 280: if ((i = atp_unpack_bdsp(atp, m2, rcbp, xcnt, FALSE))) { ! 281: if ( !rcbp->rc_xo) ! 282: atp_rcb_free(rcbp); ! 283: atp_iocnak(atp, m, i); ! 284: return; ! 285: } ! 286: atp_send_replies(atp, rcbp); ! 287: ! 288: /* ! 289: * send the ack back to the responder ! 290: */ ! 291: atp_iocack(atp, m); ! 292: return; ! 293: } ! 294: ! 295: case AT_ATP_GET_POLL: { ! 296: if (gbuf_cont(m)) { ! 297: gbuf_freem(gbuf_cont(m)); ! 298: gbuf_cont(m) = NULL; ! 299: iocbp->ioc_count = 0; ! 300: } ! 301: ! 302: /* ! 303: * search for a waiting request ! 304: */ ! 305: ATDISABLE(s, atp->atp_lock); ! 306: if ((rcbp = atp->atp_attached.head)) { ! 307: /* ! 308: * Got one, move it to the active response Q ! 309: */ ! 310: gbuf_cont(m) = rcbp->rc_ioctl; ! 311: rcbp->rc_ioctl = NULL; ! 312: if (rcbp->rc_xo) { ! 313: ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list); ! 314: rcbp->rc_state = RCB_NOTIFIED; ! 315: ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list); ! 316: } else { ! 317: /* detach rcbp from attached queue, ! 318: * and free any outstanding resources ! 319: */ ! 320: atp_rcb_free(rcbp); ! 321: } ! 322: ATENABLE(s, atp->atp_lock); ! 323: atp_iocack(atp, m); ! 324: } else { ! 325: /* ! 326: * None available - can out ! 327: */ ! 328: ATENABLE(s, atp->atp_lock); ! 329: atp_iocnak(atp, m, EAGAIN); ! 330: } ! 331: break; ! 332: } ! 333: ! 334: case AT_ATP_CANCEL_REQUEST: { ! 335: /* ! 336: * Cancel a pending request ! 337: */ ! 338: if (iocbp->ioc_count != sizeof(int)) { ! 339: atp_iocnak(atp, m, EINVAL); ! 340: break; ! 341: } ! 342: i = *(int *)gbuf_rptr(gbuf_cont(m)); ! 343: gbuf_freem(gbuf_cont(m)); ! 344: gbuf_cont(m) = NULL; ! 345: ATDISABLE(s, atp->atp_lock); ! 346: for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) { ! 347: if (trp->tr_tid == i) ! 348: break; ! 349: } ! 350: if (trp == NULL) { ! 351: ATENABLE(s, atp->atp_lock); ! 352: atp_iocnak(atp, m, ENOENT); ! 353: } else { ! 354: ATENABLE(s, atp->atp_lock); ! 355: atp_free(trp); ! 356: atp_iocack(atp, m); ! 357: } ! 358: break; ! 359: } ! 360: ! 361: case AT_ATP_PEEK: { ! 362: unsigned char event; ! 363: if (atalk_peek(gref, &event) == -1) ! 364: atp_iocnak(atp, m, EAGAIN); ! 365: else { ! 366: *gbuf_rptr(gbuf_cont(m)) = event; ! 367: atp_iocack(atp, m); ! 368: } ! 369: break; ! 370: } ! 371: ! 372: case DDP_IOC_GET_CFG: ! 373: /* *** untested code *** */ ! 374: #ifdef APPLETALK_DEBUG ! 375: kprintf("atp_wput: DDP_IOC_GET_CFG\n"); ! 376: #endif ! 377: if (gbuf_cont(m) == 0) { ! 378: atp_iocnak(atp, m, EINVAL); ! 379: break; ! 380: } ! 381: { ! 382: /* *** was ddp_get_cfg() *** */ ! 383: ddp_addr_t *cfgp = ! 384: (ddp_addr_t *)gbuf_rptr(gbuf_cont(m)); ! 385: cfgp->inet.net = atp->atp_gref->laddr.s_net; ! 386: cfgp->inet.node = atp->atp_gref->laddr.s_node; ! 387: cfgp->inet.socket = atp->atp_gref->lport; ! 388: cfgp->ddptype = atp->atp_gref->ddptype; ! 389: } ! 390: gbuf_wset(gbuf_cont(m), sizeof(ddp_addr_t)); ! 391: atp_iocack(atp, m); ! 392: break; ! 393: ! 394: default: ! 395: /* ! 396: * Otherwise pass it on, if possible ! 397: */ ! 398: iocbp->ioc_private = (void *)gref; ! 399: DDP_OUTPUT(m); ! 400: break; ! 401: } ! 402: break; ! 403: ! 404: default: ! 405: gbuf_freem(m); ! 406: break; ! 407: } ! 408: } /* atp_wput */ ! 409: ! 410: gbuf_t *atp_build_release(trp) ! 411: register struct atp_trans *trp; ! 412: { ! 413: register gbuf_t *m; ! 414: register at_ddp_t *ddp; ! 415: register at_atp_t *athp; ! 416: ! 417: /* ! 418: * Now try and allocate enough space to send the message ! 419: * if none is available the caller will schedule ! 420: * a timeout so we can retry for more space soon ! 421: */ ! 422: if ((m = (gbuf_t *)gbuf_alloc(AT_WR_OFFSET+ATP_HDR_SIZE, PRI_HI)) != NULL) { ! 423: gbuf_rinc(m,AT_WR_OFFSET); ! 424: gbuf_wset(m,TOTAL_ATP_HDR_SIZE); ! 425: ddp = AT_DDP_HDR(m); ! 426: ddp->type = DDP_ATP; ! 427: UAS_ASSIGN(ddp->checksum, 0); ! 428: ddp->dst_socket = trp->tr_socket.socket; ! 429: ddp->dst_node = trp->tr_socket.node; ! 430: NET_ASSIGN(ddp->dst_net, trp->tr_socket.net); ! 431: ddp->src_node = trp->tr_local_node; ! 432: NET_NET(ddp->src_net, trp->tr_local_net); ! 433: ! 434: /* ! 435: * clear the cmd/xo/eom/sts/unused fields ! 436: */ ! 437: athp = AT_ATP_HDR(m); ! 438: ATP_CLEAR_CONTROL(athp); ! 439: athp->cmd = ATP_CMD_TREL; ! 440: UAS_ASSIGN(athp->tid, trp->tr_tid); ! 441: } ! 442: ! 443: return (m); ! 444: } ! 445: ! 446: void atp_send_replies(atp, rcbp) ! 447: register struct atp_state *atp; ! 448: register struct atp_rcb *rcbp; ! 449: { register gbuf_t *m; ! 450: register int i, len; ! 451: int s_gen, s, cnt; ! 452: unsigned char *m0_rptr = NULL, *m0_wptr = NULL; ! 453: register at_atp_t *athp; ! 454: register struct atpBDS *bdsp; ! 455: register gbuf_t *m2, *m1, *m0; ! 456: gbuf_t *mprev, *mlist = 0; ! 457: at_socket src_socket = (at_socket)atp->atp_socket_no; ! 458: gbuf_t *rc_xmt[ATP_TRESP_MAX]; ! 459: struct ddp_atp { ! 460: char ddp_atp_hdr[TOTAL_ATP_HDR_SIZE]; ! 461: }; ! 462: ! 463: ATDISABLE(s, atp->atp_lock); ! 464: if (rcbp->rc_queue != atp) { ! 465: ATENABLE(s, atp->atp_lock); ! 466: return; ! 467: } ! 468: if (rcbp->rc_not_sent_bitmap == 0) ! 469: goto nothing_to_send; ! 470: ! 471: dPrintf(D_M_ATP_LOW, D_L_OUTPUT, ("atp_send_replies\n")); ! 472: /* ! 473: * Do this for each message that hasn't been sent ! 474: */ ! 475: cnt = rcbp->rc_pktcnt; ! 476: for (i = 0; i < cnt; i++) { ! 477: rc_xmt[i] = 0; ! 478: if (rcbp->rc_snd[i]) { ! 479: if ((rc_xmt[i] = ! 480: gbuf_alloc(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE,PRI_MED)) ! 481: == NULL) { ! 482: for (cnt = 0; cnt < i; cnt++) ! 483: if (rc_xmt[cnt]) ! 484: gbuf_freeb(rc_xmt[cnt]); ! 485: goto nothing_to_send; ! 486: } ! 487: } ! 488: } ! 489: ! 490: m = rcbp->rc_xmt; ! 491: m0 = gbuf_cont(m); ! 492: if (m0) { ! 493: m0_rptr = gbuf_rptr(m0); ! 494: m0_wptr = gbuf_wptr(m0); ! 495: } ! 496: if (gbuf_len(m) > TOTAL_ATP_HDR_SIZE) ! 497: bdsp = (struct atpBDS *)(AT_ATP_HDR(m)->data); ! 498: else ! 499: bdsp = 0; ! 500: ! 501: for (i = 0; i < cnt; i++) { ! 502: if (rcbp->rc_snd[i] == 0) { ! 503: if ((len = UAS_VALUE(bdsp->bdsBuffSz))) ! 504: gbuf_rinc(m0,len); ! 505: ! 506: } else { ! 507: m2 = rc_xmt[i]; ! 508: gbuf_rinc(m2,AT_WR_OFFSET); ! 509: gbuf_wset(m2,TOTAL_ATP_HDR_SIZE); ! 510: *(struct ddp_atp *)(gbuf_rptr(m2))= *(struct ddp_atp *)(gbuf_rptr(m)); ! 511: athp = AT_ATP_HDR(m2); ! 512: ATP_CLEAR_CONTROL(athp); ! 513: athp->cmd = ATP_CMD_TRESP; ! 514: athp->bitmap = i; ! 515: if (i == (cnt - 1)) ! 516: athp->eom = 1; /* for the last fragment */ ! 517: if (bdsp) ! 518: UAL_UAL(athp->user_bytes, bdsp->bdsUserData); ! 519: ! 520: if (bdsp) ! 521: if (len = UAS_VALUE(bdsp->bdsBuffSz)) { /* copy in data */ ! 522: if (m0 && gbuf_len(m0)) { ! 523: if ((m1 = gbuf_dupb(m0)) == NULL) { ! 524: for (i = 0; i < cnt; i++) ! 525: if (rc_xmt[i]) ! 526: gbuf_freem(rc_xmt[i]); ! 527: gbuf_rptr(m0) = m0_rptr; ! 528: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 529: goto nothing_to_send; ! 530: } ! 531: gbuf_wset(m1,len); ! 532: gbuf_rinc(m0,len); ! 533: if ((len = gbuf_len(m0)) < 0) { ! 534: gbuf_rdec(m0,len); ! 535: gbuf_wdec(m1,len); ! 536: if (!append_copy((struct mbuf *)m1, ! 537: (struct mbuf *)gbuf_cont(m0), FALSE)) { ! 538: for (i = 0; i < cnt; i++) ! 539: if (rc_xmt[i]) ! 540: gbuf_freem(rc_xmt[i]); ! 541: gbuf_rptr(m0) = m0_rptr; ! 542: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 543: goto nothing_to_send; ! 544: } ! 545: } else ! 546: gbuf_cont(m1) = 0; ! 547: gbuf_cont(m2) = m1; ! 548: } ! 549: } ! 550: ! 551: AT_DDP_HDR(m2)->src_socket = src_socket; ! 552: dPrintf(D_M_ATP_LOW, D_L_OUTPUT, ! 553: ("atp_send_replies: %d, socket=%d, size=%d\n", ! 554: i, atp->atp_socket_no, gbuf_msgsize(gbuf_cont(m2)))); ! 555: ! 556: if (mlist) ! 557: gbuf_next(mprev) = m2; ! 558: else ! 559: mlist = m2; ! 560: mprev = m2; ! 561: ! 562: rcbp->rc_snd[i] = 0; ! 563: rcbp->rc_not_sent_bitmap &= ~atp_mask[i]; ! 564: if (rcbp->rc_not_sent_bitmap == 0) ! 565: break; ! 566: } ! 567: /* ! 568: * on to the next frag ! 569: */ ! 570: bdsp++; ! 571: } ! 572: if (m0) { ! 573: gbuf_rptr(m0) = m0_rptr; ! 574: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 575: } ! 576: ! 577: if (mlist) { ! 578: ATENABLE(s, atp->atp_lock); ! 579: DDP_OUTPUT(mlist); ! 580: ATDISABLE(s, atp->atp_lock); ! 581: } ! 582: ! 583: nothing_to_send: ! 584: /* ! 585: * If all replies from this reply block have been sent then ! 586: * remove it from the queue and mark it so ! 587: */ ! 588: if (rcbp->rc_queue != atp) { ! 589: ATENABLE(s, atp->atp_lock); ! 590: return; ! 591: } ! 592: rcbp->rc_rep_waiting = 0; ! 593: ! 594: /* ! 595: * If we are doing execute once re-set the rcb timeout ! 596: * each time we send back any part of the response. Note ! 597: * that this timer is started when an initial request is ! 598: * received. Each response reprimes the timer. Duplicate ! 599: * requests do not reprime the timer. ! 600: * ! 601: * We have sent all of a response so free the ! 602: * resources. ! 603: */ ! 604: if (rcbp->rc_xo && rcbp->rc_state != RCB_RELEASED) { ! 605: ATDISABLE(s_gen, atpgen_lock); ! 606: if (rcbp->rc_timestamp == 0) { ! 607: rcbp->rc_timestamp = time.tv_sec; ! 608: if (rcbp->rc_timestamp == 0) ! 609: rcbp->rc_timestamp = 1; ! 610: ATP_Q_APPEND(atp_need_rel, rcbp, rc_tlist); ! 611: } ! 612: rcbp->rc_state = RCB_RESPONSE_FULL; ! 613: ATENABLE(s_gen, atpgen_lock); ! 614: } else ! 615: atp_rcb_free(rcbp); ! 616: ATENABLE(s, atp->atp_lock); ! 617: } /* atp_send_replies */ ! 618: ! 619: ! 620: static void ! 621: atp_pack_bdsp(trp, bdsp) ! 622: register struct atp_trans *trp; ! 623: register struct atpBDS *bdsp; ! 624: { ! 625: register gbuf_t *m = NULL; ! 626: register int i, datsize = 0; ! 627: struct atpBDS *bdsbase = bdsp; ! 628: ! 629: dPrintf(D_M_ATP, D_L_INFO, ("atp_pack_bdsp: socket=%d\n", ! 630: trp->tr_queue->atp_socket_no)); ! 631: ! 632: for (i = 0; i < ATP_TRESP_MAX; i++, bdsp++) { ! 633: short bufsize = UAS_VALUE(bdsp->bdsBuffSz); ! 634: long bufaddr = UAL_VALUE(bdsp->bdsBuffAddr); ! 635: ! 636: if ((m = trp->tr_rcv[i]) == NULL) ! 637: break; ! 638: ! 639: /* discard ddp hdr on first packet */ ! 640: if (i == 0) ! 641: gbuf_rinc(m,DDP_X_HDR_SIZE); ! 642: ! 643: /* this field may contain control information even when ! 644: no data is present */ ! 645: UAL_UAL(bdsp->bdsUserData, ! 646: (((at_atp_t *)(gbuf_rptr(m)))->user_bytes)); ! 647: gbuf_rinc(m, ATP_HDR_SIZE); ! 648: ! 649: if ((bufsize != 0) && (bufaddr != 0)) { ! 650: /* user expects data back */ ! 651: short tmp = 0; ! 652: register char *buf = (char *)bufaddr; ! 653: ! 654: while (m) { ! 655: short len = (short)(gbuf_len(m)); ! 656: if (len) { ! 657: if (len > bufsize) ! 658: len = bufsize; ! 659: copyout((caddr_t)gbuf_rptr(m), ! 660: (caddr_t)&buf[tmp], ! 661: len); ! 662: bufsize -= len; ! 663: tmp =+ len; ! 664: } ! 665: m = gbuf_cont(m); ! 666: } ! 667: ! 668: UAS_ASSIGN(bdsp->bdsDataSz, tmp); ! 669: datsize += (int)tmp; ! 670: } ! 671: gbuf_freem(trp->tr_rcv[i]); ! 672: trp->tr_rcv[i] = NULL; ! 673: } ! 674: ! 675: /* report the number of packets */ ! 676: UAS_ASSIGN(((struct atpBDS *)bdsbase)->bdsBuffSz, i); ! 677: ! 678: dPrintf(D_M_ATP, D_L_INFO, (" : size=%d\n", ! 679: datsize)); ! 680: } /* atp_pack_bdsp */ ! 681: ! 682: ! 683: static int ! 684: atp_unpack_bdsp(atp, m, rcbp, cnt, wait) ! 685: struct atp_state *atp; ! 686: gbuf_t *m; /* ddp, atp and bdsp gbuf_t */ ! 687: register struct atp_rcb *rcbp; ! 688: register int cnt, wait; ! 689: { ! 690: register struct atpBDS *bdsp; ! 691: register gbuf_t *m2, *m1, *m0; ! 692: register at_atp_t *athp; ! 693: register int i, len, s_gen; ! 694: at_socket src_socket; ! 695: struct ddp_atp { ! 696: char ddp_atp_hdr[TOTAL_ATP_HDR_SIZE]; ! 697: }; ! 698: gbuf_t *mprev, *mlist = 0; ! 699: gbuf_t *rc_xmt[ATP_TRESP_MAX]; ! 700: unsigned char *m0_rptr, *m0_wptr; ! 701: ! 702: /* ! 703: * get the user data structure pointer ! 704: */ ! 705: bdsp = (struct atpBDS *)(AT_ATP_HDR(m)->data); ! 706: ! 707: /* ! 708: * Guard against bogus count argument. ! 709: */ ! 710: if ((unsigned) cnt > ATP_TRESP_MAX) { ! 711: dPrintf(D_M_ATP, D_L_ERROR, ! 712: ("atp_unpack_bdsp: bad bds count 0x%x\n", cnt)); ! 713: gbuf_freem(m); ! 714: return(EINVAL); ! 715: } ! 716: if ((src_socket = (at_socket)atp->atp_socket_no) == 0xFF) { ! 717: /* comparison was to -1, however src_socket is a u_char */ ! 718: gbuf_freem(m); ! 719: return EPIPE; ! 720: } ! 721: ! 722: m0 = gbuf_cont(m); ! 723: rcbp->rc_xmt = m; ! 724: rcbp->rc_pktcnt = cnt; ! 725: rcbp->rc_state = RCB_SENDING; ! 726: rcbp->rc_not_sent_bitmap = 0; ! 727: ! 728: if (cnt <= 1) { ! 729: /* ! 730: * special case this to ! 731: * improve AFP write transactions to the server ! 732: */ ! 733: rcbp->rc_pktcnt = 1; ! 734: if ((m2 = gbuf_alloc_wait(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE, ! 735: wait)) == NULL) ! 736: return 0; ! 737: gbuf_rinc(m2,AT_WR_OFFSET); ! 738: gbuf_wset(m2,TOTAL_ATP_HDR_SIZE); ! 739: *(struct ddp_atp *)(gbuf_rptr(m2))= *(struct ddp_atp *)(gbuf_rptr(m)); ! 740: athp = AT_ATP_HDR(m2); ! 741: ATP_CLEAR_CONTROL(athp); ! 742: athp->cmd = ATP_CMD_TRESP; ! 743: athp->bitmap = 0; ! 744: athp->eom = 1; /* there's only 1 fragment */ ! 745: ! 746: /* *** why only if cnt > 0? *** */ ! 747: if (cnt > 0) ! 748: UAL_UAL(athp->user_bytes, bdsp->bdsUserData); ! 749: if (m0) ! 750: if (!append_copy((struct mbuf *)m2, ! 751: (struct mbuf *)m0, wait)) { ! 752: gbuf_freeb(m2); ! 753: return 0; ! 754: } ! 755: /* ! 756: * send the message and mark it as sent ! 757: */ ! 758: AT_DDP_HDR(m2)->src_socket = src_socket; ! 759: dPrintf(D_M_ATP_LOW, D_L_INFO, ! 760: ("atp_unpack_bdsp %d, socket=%d, size=%d, cnt=%d\n", ! 761: 0,atp->atp_socket_no,gbuf_msgsize(gbuf_cont(m2)),cnt)); ! 762: mlist = m2; ! 763: goto l_send; ! 764: } ! 765: ! 766: for (i = 0; i < cnt; i++) { ! 767: /* all hdrs, packet data and dst addr storage */ ! 768: if ((rc_xmt[i] = ! 769: gbuf_alloc_wait(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE, ! 770: wait)) == NULL) { ! 771: for (cnt = 0; cnt < i; cnt++) ! 772: if (rc_xmt[cnt]) ! 773: gbuf_freeb(rc_xmt[cnt]); ! 774: return 0; ! 775: } ! 776: } ! 777: if (m0) { ! 778: m0_rptr = gbuf_rptr(m0); ! 779: m0_wptr = gbuf_wptr(m0); ! 780: } ! 781: ! 782: for (i = 0; i < cnt; i++) { ! 783: m2 = rc_xmt[i]; ! 784: gbuf_rinc(m2,AT_WR_OFFSET); ! 785: gbuf_wset(m2,TOTAL_ATP_HDR_SIZE); ! 786: *(struct ddp_atp *)(gbuf_rptr(m2))= *(struct ddp_atp *)(gbuf_rptr(m)); ! 787: athp = AT_ATP_HDR(m2); ! 788: ATP_CLEAR_CONTROL(athp); ! 789: athp->cmd = ATP_CMD_TRESP; ! 790: athp->bitmap = i; ! 791: if (i == (cnt - 1)) ! 792: athp->eom = 1; /* for the last fragment */ ! 793: UAL_UAL(athp->user_bytes, bdsp->bdsUserData); ! 794: ! 795: if ((len = UAS_VALUE(bdsp->bdsBuffSz))) { /* copy in data */ ! 796: if (m0 && gbuf_len(m0)) { ! 797: if ((m1 = gbuf_dupb_wait(m0, wait)) == NULL) { ! 798: for (i = 0; i < cnt; i++) ! 799: if (rc_xmt[i]) ! 800: gbuf_freem(rc_xmt[i]); ! 801: gbuf_rptr(m0) = m0_rptr; ! 802: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 803: return 0; ! 804: } ! 805: gbuf_wset(m1,len); /* *** m1 is first len bytes of m0? *** */ ! 806: gbuf_rinc(m0,len); ! 807: if ((len = gbuf_len(m0)) < 0) { ! 808: gbuf_rdec(m0,len); ! 809: gbuf_wdec(m1,len); ! 810: if (!append_copy((struct mbuf *)m1, ! 811: (struct mbuf *)gbuf_cont(m0), wait)) { ! 812: for (i = 0; i < cnt; i++) ! 813: if (rc_xmt[i]) ! 814: gbuf_freem(rc_xmt[i]); ! 815: gbuf_rptr(m0) = m0_rptr; ! 816: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 817: return 0; ! 818: } ! 819: } else ! 820: gbuf_cont(m1) = 0; ! 821: gbuf_cont(m2) = m1; ! 822: } ! 823: } ! 824: ! 825: AT_DDP_HDR(m2)->src_socket = src_socket; ! 826: dPrintf(D_M_ATP_LOW,D_L_INFO, ! 827: ("atp_unpack_bdsp %d, socket=%d, size=%d, cnt=%d\n", ! 828: i,atp->atp_socket_no,gbuf_msgsize(gbuf_cont(m2)),cnt)); ! 829: if (mlist) ! 830: gbuf_next(mprev) = m2; ! 831: else ! 832: mlist = m2; ! 833: mprev = m2; ! 834: /* ! 835: * on to the next frag ! 836: */ ! 837: bdsp++; ! 838: } ! 839: if (m0) { ! 840: gbuf_rptr(m0) = m0_rptr; ! 841: gbuf_wset(m0,(m0_wptr-m0_rptr)); ! 842: } ! 843: /* ! 844: * send the message ! 845: */ ! 846: l_send: ! 847: if (rcbp->rc_xo) { ! 848: ATDISABLE(s_gen, atpgen_lock); ! 849: if (rcbp->rc_timestamp == 0) { ! 850: if ((rcbp->rc_timestamp = time.tv_sec) == 0) ! 851: rcbp->rc_timestamp = 1; ! 852: ATP_Q_APPEND(atp_need_rel, rcbp, rc_tlist); ! 853: } ! 854: ATENABLE(s_gen, atpgen_lock); ! 855: } ! 856: ! 857: DDP_OUTPUT(mlist); ! 858: return 0; ! 859: } /* atp_unpack_bdsp */ ! 860: ! 861: #define ATP_SOCKET_LAST (DDP_SOCKET_LAST-6) ! 862: #define ATP_SOCKET_FIRST (DDP_SOCKET_1st_DYNAMIC-64) ! 863: static unsigned int sNext = 0; ! 864: ! 865: int atp_bind(gref, sVal, flag) ! 866: gref_t *gref; ! 867: unsigned int sVal; ! 868: unsigned char *flag; ! 869: { ! 870: extern unsigned char asp_inpC[]; ! 871: extern asp_scb_t *asp_scbQ[]; ! 872: unsigned char inpC, sNextUsed = 0; ! 873: unsigned int sMin, sMax, sSav; ! 874: struct atp_state *atp; ! 875: int s; ! 876: ! 877: atp = (struct atp_state *)gref->info; ! 878: if (atp->dflag) ! 879: atp = (struct atp_state *)atp->atp_msgq; ! 880: ! 881: sMax = ATP_SOCKET_LAST; ! 882: sMin = ATP_SOCKET_FIRST; ! 883: ATDISABLE(s, atpgen_lock); ! 884: if (flag && (*flag == 3)) { ! 885: sMin += 40; ! 886: if (sMin < sNext) { ! 887: sMin = sNext; ! 888: sNextUsed = 1; ! 889: } ! 890: } ! 891: ! 892: if ( (sVal != 0) ! 893: && ((sVal > sMax) || (sVal < 2) || (sVal == 6) ! 894: || ((atp_inputQ[sVal] != NULL) && ! 895: (atp_inputQ[sVal] != (gref_t *)1)) ! 896: || (ot_atp_socketM[sVal] != 0)) ) ! 897: { ! 898: ATENABLE(s, atpgen_lock); ! 899: return 0; ! 900: } ! 901: ! 902: if (sVal == 0) { ! 903: inpC = 255; ! 904: again: ! 905: for (sVal=sMin; sVal <= sMax; sVal++) { ! 906: if (ot_atp_socketM[sVal] == 0) { ! 907: if (atp_inputQ[sVal] == NULL || ! 908: atp_inputQ[sVal] == (gref_t *)1) ! 909: break; ! 910: else if (flag && (*flag == 3)) { ! 911: if ((asp_scbQ[sVal]->dflag == *flag) ! 912: && (asp_inpC[sVal] < inpC) ) { ! 913: inpC = asp_inpC[sVal]; ! 914: sSav = sVal; ! 915: } ! 916: } ! 917: } ! 918: } ! 919: if (sVal > sMax) { ! 920: if (flag && (*flag == 3)) { ! 921: if (sNextUsed) { ! 922: sNextUsed = 0; ! 923: sMax = sNext - 1; ! 924: sMin = ATP_SOCKET_FIRST+40; ! 925: goto again; ! 926: } ! 927: sNext = 0; ! 928: *flag = (unsigned char)sSav; ! 929: } ! 930: ATENABLE(s, atpgen_lock); ! 931: return 0; ! 932: } ! 933: } ! 934: atp->atp_socket_no = (short)sVal; ! 935: atp_inputQ[sVal] = gref; ! 936: if (flag == 0) ! 937: atp_pidM[sVal] = atp->atp_pid; ! 938: else if (*flag == 3) { ! 939: sNext = sVal + 1; ! 940: if (sNext > ATP_SOCKET_LAST) ! 941: sNext = 0; ! 942: } ! 943: ! 944: ATENABLE(s, atpgen_lock); ! 945: return (int)sVal; ! 946: } ! 947: ! 948: void atp_req_ind(atp, mioc) ! 949: register struct atp_state *atp; ! 950: register gbuf_t *mioc; ! 951: { ! 952: register struct atp_rcb *rcbp; ! 953: int s; ! 954: ! 955: if ((rcbp = atp->atp_attached.head) != 0) { ! 956: gbuf_cont(mioc) = rcbp->rc_ioctl; ! 957: rcbp->rc_ioctl = NULL; ! 958: ATDISABLE(s, atp->atp_lock); ! 959: if (rcbp->rc_xo) { ! 960: ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list); ! 961: rcbp->rc_state = RCB_NOTIFIED; ! 962: ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list); ! 963: } else ! 964: atp_rcb_free(rcbp); ! 965: ATENABLE(s, atp->atp_lock); ! 966: if (gbuf_cont(mioc)) ! 967: ((ioc_t *)gbuf_rptr(mioc))->ioc_count = gbuf_msgsize(gbuf_cont(mioc)); ! 968: else ! 969: ((ioc_t *)gbuf_rptr(mioc))->ioc_count = 0; ! 970: asp_ack_reply(atp->atp_gref, mioc); ! 971: } else ! 972: gbuf_freeb(mioc); ! 973: } ! 974: ! 975: void atp_rsp_ind(trp, mioc) ! 976: register struct atp_trans *trp; ! 977: register gbuf_t *mioc; ! 978: { ! 979: register struct atp_state *atp = trp->tr_queue; ! 980: register int err; ! 981: gbuf_t *xm = 0; ! 982: ! 983: err = 0; ! 984: { ! 985: switch (trp->tr_state) { ! 986: case TRANS_DONE: ! 987: if (asp_pack_bdsp(trp, &xm) < 0) ! 988: err = EFAULT; ! 989: gbuf_cont(mioc) = trp->tr_xmt; ! 990: trp->tr_xmt = NULL; ! 991: break; ! 992: ! 993: case TRANS_FAILED: ! 994: err = ETIMEDOUT; ! 995: break; ! 996: ! 997: default: ! 998: err = ENOENT; ! 999: break; ! 1000: } ! 1001: atp_free(trp); ! 1002: ! 1003: if (err) { ! 1004: dPrintf(D_M_ATP, D_L_ERROR, ! 1005: ("atp_rsp_ind: TRANSACTION error\n")); ! 1006: atp_iocnak(atp, mioc, err); ! 1007: } else { ! 1008: gbuf_cont(gbuf_cont(mioc)) = xm; ! 1009: atp_iocack(atp, mioc); ! 1010: } ! 1011: } ! 1012: } ! 1013: ! 1014: void atp_cancel_req(gref, tid) ! 1015: gref_t *gref; ! 1016: unsigned short tid; ! 1017: { ! 1018: int s; ! 1019: struct atp_state *atp; ! 1020: struct atp_trans *trp; ! 1021: ! 1022: atp = (struct atp_state *)gref->info; ! 1023: if (atp->dflag) ! 1024: atp = (struct atp_state *)atp->atp_msgq; ! 1025: ! 1026: ATDISABLE(s, atp->atp_lock); ! 1027: for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) { ! 1028: if (trp->tr_tid == tid) ! 1029: break; ! 1030: } ! 1031: ATENABLE(s, atp->atp_lock); ! 1032: if (trp != NULL) ! 1033: atp_free(trp); ! 1034: } ! 1035: ! 1036: /* ! 1037: * remove atp from the use list ! 1038: */ ! 1039: void ! 1040: atp_dequeue_atp(atp) ! 1041: struct atp_state *atp; ! 1042: { ! 1043: int s; ! 1044: ! 1045: ATDISABLE(s, atpall_lock); ! 1046: if (atp == atp_used_list) { ! 1047: if ((atp_used_list = atp->atp_trans_waiting) != 0) ! 1048: atp->atp_trans_waiting->atp_rcb_waiting = 0; ! 1049: } else if (atp->atp_rcb_waiting) { ! 1050: if ((atp->atp_rcb_waiting->atp_trans_waiting ! 1051: = atp->atp_trans_waiting) != 0) ! 1052: atp->atp_trans_waiting->atp_rcb_waiting = atp->atp_rcb_waiting; ! 1053: } ! 1054: ! 1055: atp->atp_trans_waiting = 0; ! 1056: atp->atp_rcb_waiting = 0; ! 1057: ATENABLE(s, atpall_lock); ! 1058: } ! 1059: ! 1060: void ! 1061: atp_timout(func, trp, ticks) ! 1062: void (*func)(); ! 1063: struct atp_trans *trp; ! 1064: int ticks; ! 1065: { ! 1066: int s; ! 1067: unsigned int sum; ! 1068: struct atp_trans *curr_trp, *prev_trp; ! 1069: ! 1070: ATDISABLE(s, atptmo_lock); ! 1071: if (trp->tr_tmo_func) { ! 1072: ATENABLE(s, atptmo_lock); ! 1073: return; ! 1074: } ! 1075: ! 1076: trp->tr_tmo_func = func; ! 1077: trp->tr_tmo_delta = 1+(ticks>>5); ! 1078: ! 1079: if (trp_tmo_list == 0) { ! 1080: trp->tr_tmo_next = trp->tr_tmo_prev = 0; ! 1081: trp_tmo_list = trp; ! 1082: ATENABLE(s, atptmo_lock); ! 1083: return; ! 1084: } ! 1085: ! 1086: prev_trp = 0; ! 1087: curr_trp = trp_tmo_list; ! 1088: sum = 0; ! 1089: ! 1090: while (1) { ! 1091: sum += curr_trp->tr_tmo_delta; ! 1092: if (sum > trp->tr_tmo_delta) { ! 1093: sum -= curr_trp->tr_tmo_delta; ! 1094: trp->tr_tmo_delta -= sum; ! 1095: curr_trp->tr_tmo_delta -= trp->tr_tmo_delta; ! 1096: break; ! 1097: } ! 1098: prev_trp = curr_trp; ! 1099: if ((curr_trp = curr_trp->tr_tmo_next) == 0) { ! 1100: trp->tr_tmo_delta -= sum; ! 1101: break; ! 1102: } ! 1103: } ! 1104: ! 1105: if (prev_trp) { ! 1106: trp->tr_tmo_prev = prev_trp; ! 1107: if ((trp->tr_tmo_next = prev_trp->tr_tmo_next) != 0) ! 1108: prev_trp->tr_tmo_next->tr_tmo_prev = trp; ! 1109: prev_trp->tr_tmo_next = trp; ! 1110: } else { ! 1111: trp->tr_tmo_prev = 0; ! 1112: trp->tr_tmo_next = trp_tmo_list; ! 1113: trp_tmo_list->tr_tmo_prev = trp; ! 1114: trp_tmo_list = trp; ! 1115: } ! 1116: ATENABLE(s, atptmo_lock); ! 1117: } ! 1118: ! 1119: void ! 1120: atp_untimout(func, trp) ! 1121: void (*func)(); ! 1122: struct atp_trans *trp; ! 1123: { ! 1124: int s; ! 1125: ! 1126: ATDISABLE(s, atptmo_lock); ! 1127: if (trp->tr_tmo_func == 0) { ! 1128: ATENABLE(s, atptmo_lock); ! 1129: return; ! 1130: } ! 1131: ! 1132: if (trp_tmo_list == trp) { ! 1133: if ((trp_tmo_list = trp->tr_tmo_next) != 0) { ! 1134: trp_tmo_list->tr_tmo_prev = 0; ! 1135: trp->tr_tmo_next->tr_tmo_delta += trp->tr_tmo_delta; ! 1136: } ! 1137: } else { ! 1138: if ((trp->tr_tmo_prev->tr_tmo_next = trp->tr_tmo_next) != 0) { ! 1139: trp->tr_tmo_next->tr_tmo_prev = trp->tr_tmo_prev; ! 1140: trp->tr_tmo_next->tr_tmo_delta += trp->tr_tmo_delta; ! 1141: } ! 1142: } ! 1143: trp->tr_tmo_func = 0; ! 1144: ATENABLE(s, atptmo_lock); ! 1145: } ! 1146: ! 1147: void ! 1148: atp_trp_clock(arg) ! 1149: void *arg; ! 1150: { ! 1151: int s; ! 1152: struct atp_trans *trp; ! 1153: void (*tr_tmo_func)(); ! 1154: ! 1155: ATDISABLE(s, atptmo_lock); ! 1156: if (trp_tmo_list) ! 1157: trp_tmo_list->tr_tmo_delta--; ! 1158: while (((trp = trp_tmo_list) != 0) && (trp_tmo_list->tr_tmo_delta == 0)) { ! 1159: if ((trp_tmo_list = trp->tr_tmo_next) != 0) ! 1160: trp_tmo_list->tr_tmo_prev = 0; ! 1161: if ((tr_tmo_func = trp->tr_tmo_func) != 0) { ! 1162: trp->tr_tmo_func = 0; ! 1163: ATENABLE(s, atptmo_lock); ! 1164: (*tr_tmo_func)(trp); ! 1165: ATDISABLE(s, atptmo_lock); ! 1166: } ! 1167: } ! 1168: ATENABLE(s, atptmo_lock); ! 1169: ! 1170: timeout(atp_trp_clock, (void *)arg, (1<<5)); ! 1171: } ! 1172: ! 1173: void ! 1174: atp_send_req(gref, mioc) ! 1175: gref_t *gref; ! 1176: gbuf_t *mioc; ! 1177: { ! 1178: register struct atp_state *atp; ! 1179: register struct atp_trans *trp; ! 1180: register ioc_t *iocbp; ! 1181: register at_atp_t *athp; ! 1182: register at_ddp_t *ddp; ! 1183: gbuf_t *m, *m2, *bds; ! 1184: struct atp_set_default *sdb; ! 1185: int s, old; ! 1186: unsigned int timer; ! 1187: ! 1188: atp = (struct atp_state *)((struct atp_state *)gref->info)->atp_msgq; ! 1189: iocbp = (ioc_t *)gbuf_rptr(mioc); ! 1190: ! 1191: if ((trp = atp_trans_alloc(atp)) == NULL) { ! 1192: l_retry: ! 1193: ((asp_scb_t *)gref->info)->stat_msg = mioc; ! 1194: iocbp->ioc_private = (void *)gref; ! 1195: timeout(atp_retry_req, mioc, 10); ! 1196: return; ! 1197: } ! 1198: ! 1199: m2 = gbuf_cont(mioc); ! 1200: if ((bds = gbuf_dupb(m2)) == NULL) { ! 1201: atp_trans_free(trp); ! 1202: goto l_retry; ! 1203: } ! 1204: gbuf_rinc(m2,atpBDSsize); ! 1205: gbuf_wset(bds,atpBDSsize); ! 1206: iocbp->ioc_count -= atpBDSsize; ! 1207: gbuf_cont(m2) = NULL; ! 1208: ! 1209: old = iocbp->ioc_cmd; ! 1210: iocbp->ioc_cmd = AT_ATP_ISSUE_REQUEST; ! 1211: sdb = (struct atp_set_default *)gbuf_rptr(m2); ! 1212: ! 1213: /* ! 1214: * The at_snd_req library routine multiplies seconds by 100. ! 1215: * We need to divide by 100 in order to obtain the timer. ! 1216: */ ! 1217: if ((timer = (sdb->def_rate * HZ)/100) == 0) ! 1218: timer = HZ; ! 1219: iocbp->ioc_count -= sizeof(struct atp_set_default); ! 1220: gbuf_rinc(m2,sizeof(struct atp_set_default)); ! 1221: ! 1222: trp->tr_retry = sdb->def_retries; ! 1223: trp->tr_timeout = timer; ! 1224: trp->tr_bdsp = bds; ! 1225: trp->tr_tid = atp_tid(atp); ! 1226: trp->tr_xmt = mioc; ! 1227: ! 1228: /* ! 1229: * Now fill in the header (and remember the bits ! 1230: * we need to know) ! 1231: */ ! 1232: athp = AT_ATP_HDR(m2); ! 1233: athp->cmd = ATP_CMD_TREQ; ! 1234: UAS_ASSIGN(athp->tid, trp->tr_tid); ! 1235: athp->eom = 0; ! 1236: athp->sts = 0; ! 1237: trp->tr_xo = athp->xo; ! 1238: trp->tr_bitmap = athp->bitmap; ! 1239: ddp = AT_DDP_HDR(m2); ! 1240: ddp->type = DDP_ATP; ! 1241: ddp->src_socket = (at_socket)atp->atp_socket_no; ! 1242: trp->tr_socket.socket = ddp->dst_socket; ! 1243: trp->tr_socket.node = ddp->dst_node; ! 1244: trp->tr_socket.net = NET_VALUE(ddp->dst_net); ! 1245: trp->tr_local_socket = atp->atp_socket_no; ! 1246: trp->tr_local_node = ddp->src_node; ! 1247: NET_NET(trp->tr_local_net, ddp->src_net); ! 1248: ! 1249: /* save the local information in the gref */ ! 1250: atp->atp_gref->laddr.s_net = NET_VALUE(ddp->src_net); ! 1251: atp->atp_gref->laddr.s_node = ddp->src_node; ! 1252: atp->atp_gref->lport = ddp->src_node; ! 1253: atp->atp_gref->ddptype = DDP_ATP; ! 1254: ! 1255: /* ! 1256: * Put us in the transaction waiting queue ! 1257: */ ! 1258: ATDISABLE(s, atp->atp_lock); ! 1259: ATP_Q_APPEND(atp->atp_trans_wait, trp, tr_list); ! 1260: ATENABLE(s, atp->atp_lock); ! 1261: ! 1262: /* ! 1263: * Send the message and set the timer ! 1264: */ ! 1265: m = (gbuf_t *)copy_pkt(m2, sizeof(llc_header_t)); ! 1266: if (!trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo) ! 1267: atp_x_done(trp); /* no reason to tie up resources */ ! 1268: else ! 1269: atp_timout(atp_req_timeout, trp, trp->tr_timeout); ! 1270: if (m) { ! 1271: trace_mbufs(D_M_ATP_LOW, " s", m); ! 1272: DDP_OUTPUT(m); ! 1273: } ! 1274: } /* atp_send_req */ ! 1275: ! 1276: void atp_retry_req(m) ! 1277: gbuf_t *m; ! 1278: { ! 1279: gref_t *gref; ! 1280: ! 1281: gref = (gref_t *)((ioc_t *)gbuf_rptr(m))->ioc_private; ! 1282: if (gref->info) { ! 1283: ((asp_scb_t *)gref->info)->stat_msg = 0; ! 1284: atp_send_req(gref, m); ! 1285: } ! 1286: } ! 1287: ! 1288: void atp_send_rsp(gref, m, wait) ! 1289: gref_t *gref; ! 1290: gbuf_t *m; ! 1291: int wait; ! 1292: { ! 1293: register struct atp_state *atp; ! 1294: register struct atp_rcb *rcbp; ! 1295: register at_atp_t *athp; ! 1296: register at_ddp_t *ddp; ! 1297: int s, xcnt; ! 1298: ! 1299: atp = (struct atp_state *)gref->info; ! 1300: if (atp->dflag) ! 1301: atp = (struct atp_state *)atp->atp_msgq; ! 1302: ddp = AT_DDP_HDR(m); ! 1303: athp = AT_ATP_HDR(m); ! 1304: ! 1305: /* ! 1306: * search for the corresponding rcb ! 1307: */ ! 1308: ATDISABLE(s, atp->atp_lock); ! 1309: for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) { ! 1310: if ( (rcbp->rc_tid == UAS_VALUE(athp->tid)) && ! 1311: (rcbp->rc_socket.node == ddp->dst_node) && ! 1312: (rcbp->rc_socket.net == NET_VALUE(ddp->dst_net)) && ! 1313: (rcbp->rc_socket.socket == ddp->dst_socket) ) ! 1314: break; ! 1315: } ! 1316: ! 1317: /* ! 1318: * If it has already been sent then drop the request ! 1319: */ ! 1320: if ((rcbp && (rcbp->rc_state != RCB_NOTIFIED)) || ! 1321: (rcbp == NULL && athp->xo) ) { ! 1322: ATENABLE(s, atp->atp_lock); ! 1323: gbuf_freem(m); ! 1324: return; ! 1325: } ! 1326: ATENABLE(s, atp->atp_lock); ! 1327: ! 1328: if (rcbp == NULL) { /* a response is being sent for an ALO transaction */ ! 1329: if ((rcbp = atp_rcb_alloc(atp)) == NULL) { ! 1330: gbuf_freem(m); ! 1331: return; ! 1332: } ! 1333: rcbp->rc_ioctl = 0; ! 1334: rcbp->rc_socket.socket = ddp->dst_socket; ! 1335: rcbp->rc_socket.node = ddp->dst_node; ! 1336: rcbp->rc_socket.net = NET_VALUE(ddp->dst_net); ! 1337: rcbp->rc_tid = UAS_VALUE(athp->tid); ! 1338: rcbp->rc_bitmap = 0xff; ! 1339: rcbp->rc_xo = 0; ! 1340: rcbp->rc_state = RCB_RESPONSE_FULL; ! 1341: ATDISABLE(s, atp->atp_lock); ! 1342: ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list); ! 1343: ATENABLE(s, atp->atp_lock); ! 1344: } ! 1345: else if (ddp->src_node == 0) { ! 1346: NET_NET(ddp->src_net, rcbp->rc_local_net); ! 1347: ddp->src_node = rcbp->rc_local_node; ! 1348: } ! 1349: ! 1350: xcnt = get_bds_entries(m); ! 1351: s = atp_unpack_bdsp(atp, m, rcbp, xcnt, wait); ! 1352: if (s == 0) ! 1353: atp_send_replies(atp, rcbp); ! 1354: } /* atp_send_rsp */ ! 1355: ! 1356: int asp_pack_bdsp(trp, xm) ! 1357: register struct atp_trans *trp; ! 1358: gbuf_t **xm; ! 1359: { ! 1360: register struct atpBDS *bdsp; ! 1361: register gbuf_t *m, *m2; ! 1362: register int i; ! 1363: gbuf_t *m_prev, *m_head = 0; ! 1364: ! 1365: dPrintf(D_M_ATP, D_L_INFO, ("asp_pack_bdsp: socket=%d\n", ! 1366: trp->tr_queue->atp_socket_no)); ! 1367: ! 1368: if ((m2 = trp->tr_bdsp) == NULL) ! 1369: return 0; ! 1370: trp->tr_bdsp = NULL; ! 1371: bdsp = (struct atpBDS *)gbuf_rptr(m2); ! 1372: ! 1373: for (i = 0; (i < ATP_TRESP_MAX && ! 1374: bdsp < (struct atpBDS *)(gbuf_wptr(m2))); i++) { ! 1375: if ((m = trp->tr_rcv[i]) == NULL) ! 1376: break; ! 1377: if (i == 0) { ! 1378: /* discard ddp hdr on first packet */ ! 1379: gbuf_rinc(m,DDP_X_HDR_SIZE); ! 1380: } ! 1381: ! 1382: UAL_UAL(bdsp->bdsUserData, (((at_atp_t *)(gbuf_rptr(m)))->user_bytes)); ! 1383: gbuf_rinc(m, ATP_HDR_SIZE); ! 1384: ! 1385: if (UAL_VALUE(bdsp->bdsBuffAddr)) { ! 1386: short tmp; ! 1387: ! 1388: /* user expects data back */ ! 1389: m = gbuf_strip(m); ! 1390: if (m_head == 0) ! 1391: m_head = m; ! 1392: else ! 1393: gbuf_cont(m_prev) = m; ! 1394: if (m) { ! 1395: tmp = (short)gbuf_len(m); ! 1396: while (gbuf_cont(m)) { ! 1397: m = gbuf_cont(m); ! 1398: tmp += (short)(gbuf_len(m)); ! 1399: } ! 1400: m_prev = m; ! 1401: } ! 1402: UAS_ASSIGN(bdsp->bdsDataSz, tmp); ! 1403: } ! 1404: trp->tr_rcv[i] = NULL; ! 1405: bdsp++; ! 1406: ! 1407: } ! 1408: /* ! 1409: * report the number of packets ! 1410: */ ! 1411: UAS_ASSIGN(((struct atpBDS *)gbuf_rptr(m2))->bdsBuffSz, i); ! 1412: ! 1413: if (trp->tr_xmt) /* an ioctl block is still held? */ ! 1414: gbuf_cont(trp->tr_xmt) = m2; ! 1415: else ! 1416: trp->tr_xmt = m2; ! 1417: ! 1418: if (m_head) ! 1419: *xm = m_head; ! 1420: else ! 1421: *xm = 0; ! 1422: ! 1423: dPrintf(D_M_ATP, D_L_INFO, (" : size=%d\n", ! 1424: gbuf_msgsize(*xm))); ! 1425: ! 1426: return 0; ! 1427: } ! 1428: ! 1429: /* ! 1430: * The following routines are direct entries from system ! 1431: * calls to allow fast sending and recving of ATP data. ! 1432: */ ! 1433: ! 1434: int ! 1435: _ATPsndreq(fd, buf, len, nowait, err, proc) ! 1436: int fd; ! 1437: unsigned char *buf; ! 1438: int len; ! 1439: int nowait; ! 1440: int *err; ! 1441: void *proc; ! 1442: { ! 1443: gref_t *gref; ! 1444: int s, rc; ! 1445: unsigned short tid; ! 1446: unsigned int timer; ! 1447: register struct atp_state *atp; ! 1448: register struct atp_trans *trp; ! 1449: register ioc_t *iocbp; ! 1450: register at_atp_t *athp; ! 1451: register at_ddp_t *ddp; ! 1452: struct atp_set_default *sdb; ! 1453: gbuf_t *m2, *m, *mioc; ! 1454: char bds[atpBDSsize]; ! 1455: ! 1456: if ((*err = atalk_getref(0, fd, &gref, proc)) != 0) ! 1457: return -1; ! 1458: ! 1459: if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0) ! 1460: || (atp->atp_flags & ATP_CLOSING)) { ! 1461: dPrintf(D_M_ATP, D_L_ERROR, ("ATPsndreq: stale handle=0x%x, pid=%d\n", ! 1462: (u_int) gref, gref->pid)); ! 1463: ! 1464: *err = EINVAL; ! 1465: return -1; ! 1466: } ! 1467: ! 1468: while ((mioc = gbuf_alloc(sizeof(ioc_t), PRI_MED)) == 0) { ! 1469: ATDISABLE(s, atp->atp_delay_lock); ! 1470: rc = tsleep(&atp->atp_delay_event, PSOCK | PCATCH, "atpmioc", 10); ! 1471: ATENABLE(s, atp->atp_delay_lock); ! 1472: if (rc != 0) { ! 1473: *err = rc; ! 1474: return -1; ! 1475: } ! 1476: ! 1477: } ! 1478: gbuf_wset(mioc,sizeof(ioc_t)); ! 1479: len -= atpBDSsize; ! 1480: while ((m2 = gbuf_alloc(len, PRI_MED)) == 0) { ! 1481: ATDISABLE(s, atp->atp_delay_lock); ! 1482: rc = tsleep(&atp->atp_delay_event, PSOCK | PCATCH, "atpm2", 10); ! 1483: ATENABLE(s, atp->atp_delay_lock); ! 1484: if (rc != 0) { ! 1485: gbuf_freeb(mioc); ! 1486: *err = rc; ! 1487: return -1; ! 1488: } ! 1489: } ! 1490: gbuf_wset(m2, len); ! 1491: gbuf_cont(mioc) = m2; ! 1492: if (((*err = copyin((caddr_t)buf, (caddr_t)bds, atpBDSsize)) != 0) ! 1493: || ((*err = copyin((caddr_t)&buf[atpBDSsize], ! 1494: (caddr_t)gbuf_rptr(m2), len)) != 0)) { ! 1495: gbuf_freem(mioc); ! 1496: return -1; ! 1497: } ! 1498: gbuf_set_type(mioc, MSG_IOCTL); ! 1499: iocbp = (ioc_t *)gbuf_rptr(mioc); ! 1500: iocbp->ioc_count = len; ! 1501: iocbp->ioc_cmd = nowait ? AT_ATP_ISSUE_REQUEST_NOTE : AT_ATP_ISSUE_REQUEST; ! 1502: sdb = (struct atp_set_default *)gbuf_rptr(m2); ! 1503: ! 1504: /* ! 1505: * The at_snd_req library routine multiplies seconds by 100. ! 1506: * We need to divide by 100 in order to obtain the timer. ! 1507: */ ! 1508: if ((timer = (sdb->def_rate * HZ)/100) == 0) ! 1509: timer = HZ; ! 1510: iocbp->ioc_count -= sizeof(struct atp_set_default); ! 1511: gbuf_rinc(m2,sizeof(struct atp_set_default)); ! 1512: ! 1513: /* ! 1514: * allocate and set up the transaction record ! 1515: */ ! 1516: while ((trp = atp_trans_alloc(atp)) == 0) { ! 1517: ATDISABLE(s, atp->atp_delay_lock); ! 1518: rc = tsleep(&atp->atp_delay_event, PSOCK | PCATCH, "atptrp", 10); ! 1519: ATENABLE(s, atp->atp_delay_lock); ! 1520: if (rc != 0) { ! 1521: gbuf_freem(mioc); ! 1522: *err = rc; ! 1523: return -1; ! 1524: } ! 1525: } ! 1526: trp->tr_retry = sdb->def_retries; ! 1527: trp->tr_timeout = timer; ! 1528: trp->tr_bdsp = NULL; ! 1529: trp->tr_tid = atp_tid(atp); ! 1530: tid = trp->tr_tid; ! 1531: ! 1532: /* ! 1533: * remember the IOCTL packet so we can ack it ! 1534: * later ! 1535: */ ! 1536: trp->tr_xmt = mioc; ! 1537: ! 1538: /* ! 1539: * Now fill in the header (and remember the bits ! 1540: * we need to know) ! 1541: */ ! 1542: athp = AT_ATP_HDR(m2); ! 1543: athp->cmd = ATP_CMD_TREQ; ! 1544: UAS_ASSIGN(athp->tid, trp->tr_tid); ! 1545: athp->eom = 0; ! 1546: athp->sts = 0; ! 1547: trp->tr_xo = athp->xo; ! 1548: trp->tr_bitmap = athp->bitmap; ! 1549: ddp = AT_DDP_HDR(m2); ! 1550: ddp->type = DDP_ATP; ! 1551: ddp->src_socket = (at_socket)atp->atp_socket_no; ! 1552: ddp->src_node = 0; ! 1553: trp->tr_socket.socket = ddp->dst_socket; ! 1554: trp->tr_socket.node = ddp->dst_node; ! 1555: trp->tr_socket.net = NET_VALUE(ddp->dst_net); ! 1556: trp->tr_local_socket = atp->atp_socket_no; ! 1557: ! 1558: /* save the local information in the gref */ ! 1559: atp->atp_gref->laddr.s_net = NET_VALUE(ddp->src_net); ! 1560: atp->atp_gref->laddr.s_node = ddp->src_node; ! 1561: atp->atp_gref->lport = ddp->src_node; ! 1562: atp->atp_gref->ddptype = DDP_ATP; ! 1563: ! 1564: /* ! 1565: * Put us in the transaction waiting queue ! 1566: */ ! 1567: ATDISABLE(s, atp->atp_lock); ! 1568: ATP_Q_APPEND(atp->atp_trans_wait, trp, tr_list); ! 1569: ATENABLE(s, atp->atp_lock); ! 1570: ! 1571: /* ! 1572: * Send the message and set the timer ! 1573: */ ! 1574: m = (gbuf_t *)copy_pkt(m2, sizeof(llc_header_t)); ! 1575: if ( !trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo) ! 1576: atp_x_done(trp); /* no reason to tie up resources */ ! 1577: else ! 1578: atp_timout(atp_req_timeout, trp, trp->tr_timeout); ! 1579: if (m) ! 1580: DDP_OUTPUT(m); ! 1581: ! 1582: if (nowait) ! 1583: return (int)tid; ! 1584: ! 1585: /* ! 1586: * wait for the transaction to complete ! 1587: */ ! 1588: ATDISABLE(s, trp->tr_lock); ! 1589: while ((trp->tr_state != TRANS_DONE) && (trp->tr_state != TRANS_FAILED)) { ! 1590: trp->tr_rsp_wait = 1; ! 1591: rc = tsleep(&trp->tr_event, PSOCK | PCATCH, "atpsndreq", 0); ! 1592: if (rc != 0) { ! 1593: trp->tr_rsp_wait = 0; ! 1594: ATENABLE(s, trp->tr_lock); ! 1595: *err = rc; ! 1596: return -1; ! 1597: } ! 1598: } ! 1599: trp->tr_rsp_wait = 0; ! 1600: ATENABLE(s, trp->tr_lock); ! 1601: ! 1602: if (trp->tr_state == TRANS_FAILED) { ! 1603: /* ! 1604: * transaction timed out, return error ! 1605: */ ! 1606: atp_free(trp); ! 1607: *err = ETIMEDOUT; ! 1608: return -1; ! 1609: } ! 1610: ! 1611: /* ! 1612: * copy out the recv data ! 1613: */ ! 1614: atp_pack_bdsp(trp, bds); ! 1615: ! 1616: /* ! 1617: * copyout the result info ! 1618: */ ! 1619: copyout((caddr_t)bds, (caddr_t)buf, atpBDSsize); ! 1620: ! 1621: atp_free(trp); ! 1622: ! 1623: return (int)tid; ! 1624: } /* _ATPsndreq */ ! 1625: ! 1626: int ! 1627: _ATPsndrsp(fd, respbuff, resplen, datalen, err, proc) ! 1628: int fd; ! 1629: unsigned char *respbuff; ! 1630: int resplen; ! 1631: int datalen; ! 1632: int *err; ! 1633: void *proc; ! 1634: { ! 1635: gref_t *gref; ! 1636: int s, rc; ! 1637: long bufaddr; ! 1638: gbuf_t *m, *mdata; ! 1639: register short len; ! 1640: register int size; ! 1641: register struct atp_state *atp; ! 1642: register struct atpBDS *bdsp; ! 1643: register char *buf; ! 1644: ! 1645: if ((*err = atalk_getref(0, fd, &gref, proc)) != 0) ! 1646: return -1; ! 1647: ! 1648: if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0) ! 1649: || (atp->atp_flags & ATP_CLOSING)) { ! 1650: dPrintf(D_M_ATP, D_L_ERROR, ("ATPsndrsp: stale handle=0x%x, pid=%d\n", ! 1651: (u_int) gref, gref->pid)); ! 1652: ! 1653: *err = EINVAL; ! 1654: return -1; ! 1655: } ! 1656: ! 1657: /* ! 1658: * allocate buffer and copy in the response info ! 1659: */ ! 1660: while ((m = gbuf_alloc(resplen, PRI_MED)) == 0) { ! 1661: ATDISABLE(s, atp->atp_delay_lock); ! 1662: rc = tsleep(&atp->atp_delay_event, PSOCK | PCATCH, "atprspinfo", 10); ! 1663: ATENABLE(s, atp->atp_delay_lock); ! 1664: if (rc != 0) { ! 1665: *err = rc; ! 1666: return -1; ! 1667: } ! 1668: } ! 1669: if ((*err = copyin((caddr_t)respbuff, (caddr_t)gbuf_rptr(m), resplen)) != 0) { ! 1670: gbuf_freeb(m); ! 1671: return -1; ! 1672: } ! 1673: gbuf_wset(m,resplen); ! 1674: ((at_ddp_t *)gbuf_rptr(m))->src_node = 0; ! 1675: bdsp = (struct atpBDS *)(gbuf_rptr(m) + TOTAL_ATP_HDR_SIZE); ! 1676: if ((resplen == TOTAL_ATP_HDR_SIZE) || ((len = UAS_VALUE(bdsp->bdsDataSz)) == 1)) ! 1677: len = 0; ! 1678: else ! 1679: len = 16 * sizeof(gbuf_t); ! 1680: ! 1681: /* ! 1682: * allocate buffer and copy in the response data ! 1683: */ ! 1684: while ((mdata = gbuf_alloc(datalen+len, PRI_MED)) == 0) { ! 1685: ATDISABLE(s, atp->atp_delay_lock); ! 1686: rc = tsleep(&atp->atp_delay_event, PSOCK | PCATCH, "atprspdata", 10); ! 1687: ATENABLE(s, atp->atp_delay_lock); ! 1688: if (rc != 0) { ! 1689: gbuf_freem(m); ! 1690: *err = rc; ! 1691: return -1; ! 1692: } ! 1693: } ! 1694: gbuf_cont(m) = mdata; ! 1695: for (size=0; bdsp < (struct atpBDS *)gbuf_wptr(m); bdsp++) { ! 1696: if ((bufaddr = UAL_VALUE(bdsp->bdsBuffAddr)) != 0) { ! 1697: len = UAS_VALUE(bdsp->bdsBuffSz); ! 1698: buf = (char *)bufaddr; ! 1699: if ((*err = copyin((caddr_t)buf, ! 1700: (caddr_t)&gbuf_rptr(mdata)[size], len)) != 0) { ! 1701: gbuf_freem(m); ! 1702: return -1; ! 1703: } ! 1704: size += len; ! 1705: } ! 1706: } ! 1707: gbuf_wset(mdata,size); ! 1708: ! 1709: atp_send_rsp(gref, m, TRUE); ! 1710: return 0; ! 1711: } ! 1712: ! 1713: int ! 1714: _ATPgetreq(fd, buf, buflen, err, proc) ! 1715: int fd; ! 1716: unsigned char *buf; ! 1717: int buflen; ! 1718: int *err; ! 1719: void *proc; ! 1720: { ! 1721: gref_t *gref; ! 1722: register struct atp_state *atp; ! 1723: register struct atp_rcb *rcbp; ! 1724: register gbuf_t *m, *m_head; ! 1725: int s, size, len; ! 1726: ! 1727: if ((*err = atalk_getref(0, fd, &gref, proc)) != 0) ! 1728: return -1; ! 1729: ! 1730: if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0) ! 1731: || (atp->atp_flags & ATP_CLOSING)) { ! 1732: dPrintf(D_M_ATP, D_L_ERROR, ("ATPgetreq: stale handle=0x%x, pid=%d\n", ! 1733: (u_int) gref, gref->pid)); ! 1734: *err = EINVAL; ! 1735: return -1; ! 1736: } ! 1737: ! 1738: ATDISABLE(s, atp->atp_lock); ! 1739: if ((rcbp = atp->atp_attached.head) != NULL) { ! 1740: /* ! 1741: * Got one, move it to the active response Q ! 1742: */ ! 1743: m_head = rcbp->rc_ioctl; ! 1744: rcbp->rc_ioctl = NULL; ! 1745: ! 1746: if (rcbp->rc_xo) { ! 1747: ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list); ! 1748: rcbp->rc_state = RCB_NOTIFIED; ! 1749: ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list); ! 1750: } else { ! 1751: /* detach rcbp from attached queue, ! 1752: * and free any outstanding resources ! 1753: */ ! 1754: atp_rcb_free(rcbp); ! 1755: } ! 1756: ATENABLE(s, atp->atp_lock); ! 1757: ! 1758: /* ! 1759: * copyout the request data, including the protocol header ! 1760: */ ! 1761: for (size=0, m=m_head; m; m = gbuf_cont(m)) { ! 1762: if ((len = gbuf_len(m)) > buflen) ! 1763: len = buflen; ! 1764: copyout((caddr_t)gbuf_rptr(m), (caddr_t)&buf[size], len); ! 1765: size += len; ! 1766: if ((buflen -= len) == 0) ! 1767: break; ! 1768: } ! 1769: gbuf_freem(m_head); ! 1770: ! 1771: return size; ! 1772: } ! 1773: ATENABLE(s, atp->atp_lock); ! 1774: ! 1775: return -1; ! 1776: } ! 1777: ! 1778: int ! 1779: _ATPgetrsp(fd, bdsp, err, proc) ! 1780: int fd; ! 1781: struct atpBDS *bdsp; ! 1782: int *err; ! 1783: void *proc; ! 1784: { ! 1785: gref_t *gref; ! 1786: register struct atp_state *atp; ! 1787: register struct atp_trans *trp; ! 1788: int s, tid; ! 1789: char bds[atpBDSsize]; ! 1790: ! 1791: if ((*err = atalk_getref(0, fd, &gref, proc)) != 0) ! 1792: return -1; ! 1793: ! 1794: if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0) ! 1795: || (atp->atp_flags & ATP_CLOSING)) { ! 1796: dPrintf(D_M_ATP, D_L_ERROR, ("ATPgetrsp: stale handle=0x%x, pid=%d\n", ! 1797: (u_int) gref, gref->pid)); ! 1798: *err = EINVAL; ! 1799: return -1; ! 1800: } ! 1801: ! 1802: ATDISABLE(s, atp->atp_lock); ! 1803: for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) { ! 1804: dPrintf(D_M_ATP, D_L_INFO, ! 1805: ("ATPgetrsp: atp:0x%x, trp:0x%x, state:%d\n", ! 1806: (u_int) atp, (u_int) trp, trp->tr_state)); ! 1807: ! 1808: switch (trp->tr_state) { ! 1809: case TRANS_DONE: ! 1810: ATENABLE(s, atp->atp_lock); ! 1811: if ((*err = copyin((caddr_t)bdsp, ! 1812: (caddr_t)bds, sizeof(bds))) != 0) ! 1813: return -1; ! 1814: atp_pack_bdsp(trp, bds); ! 1815: tid = (int)trp->tr_tid; ! 1816: atp_free(trp); ! 1817: copyout((caddr_t)bds, (caddr_t)bdsp, sizeof(bds)); ! 1818: return tid; ! 1819: ! 1820: case TRANS_FAILED: ! 1821: /* ! 1822: * transaction timed out, return error ! 1823: */ ! 1824: ATENABLE(s, atp->atp_lock); ! 1825: atp_free(trp); ! 1826: *err = ETIMEDOUT; ! 1827: return -1; ! 1828: ! 1829: default: ! 1830: continue; ! 1831: } ! 1832: } ! 1833: ATENABLE(s, atp->atp_lock); ! 1834: ! 1835: *err = EINVAL; ! 1836: return -1; ! 1837: } ! 1838: ! 1839: void ! 1840: atp_drop_req(gref, m) ! 1841: gref_t *gref; ! 1842: gbuf_t *m; ! 1843: { ! 1844: int s; ! 1845: struct atp_state *atp; ! 1846: struct atp_rcb *rcbp; ! 1847: at_atp_t *athp; ! 1848: at_ddp_t *ddp; ! 1849: ! 1850: atp = (struct atp_state *)gref->info; ! 1851: if (atp->dflag) ! 1852: atp = (struct atp_state *)atp->atp_msgq; ! 1853: ddp = AT_DDP_HDR(m); ! 1854: athp = AT_ATP_HDR(m); ! 1855: ! 1856: /* ! 1857: * search for the corresponding rcb ! 1858: */ ! 1859: ATDISABLE(s, atp->atp_lock); ! 1860: for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) { ! 1861: if ( (rcbp->rc_tid == UAS_VALUE(athp->tid)) && ! 1862: (rcbp->rc_socket.node == ddp->src_node) && ! 1863: (rcbp->rc_socket.net == NET_VALUE(ddp->src_net)) && ! 1864: (rcbp->rc_socket.socket == ddp->src_socket) ) ! 1865: break; ! 1866: } ! 1867: ! 1868: /* ! 1869: * drop the request ! 1870: */ ! 1871: if (rcbp) ! 1872: atp_rcb_free(rcbp); ! 1873: ATENABLE(s, atp->atp_lock); ! 1874: ! 1875: gbuf_freem(m); ! 1876: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.