/* temporary */ void sys_write(int fd, const char *buf, size_t nbytes) { unsigned int i; for (i = 0; i < nbytes; i++) { if (buf[i] == '\n') prom_write(fd, "\r", 1); prom_write(fd, &buf[i], 1); } }
/* * PROM console output putchar. */ static void prom_cnputc(dev_t dev, int c) { int s; char c0 = (c & 0x7f); s = splhigh(); prom_write(prom_stdout(), &c0, 1); splx(s); }
void notrace prom_printf(const char *fmt, ...) { va_list args; int i; va_start(args, fmt); i = vscnprintf(ppbuf, sizeof(ppbuf), fmt, args); va_end(args); prom_write(ppbuf, i); }
/* * Write string to PROM's notion of stdout. */ void prom_writestr(const char *buf, size_t len) { size_t written = 0; ihandle_t istdin; ssize_t i; istdin = prom_stdout_ihandle(); while (written < len) { if ((i = prom_write(istdin, (char *)buf, len - written, 0, BYTE)) == -1) continue; written += i; } }
/* * Send a packet. The ether header is already there. * Return the length sent (or -1 on error). */ ssize_t netif_put(struct iodesc *desc, void *pkt, size_t len) { struct of_dev *op; ssize_t rv; size_t sendlen; op = ((struct netif *)desc->io_netif)->nif_devdata; #ifdef NETIF_DEBUG { struct ether_header *eh; printf("netif_put: desc=0x%x pkt=0x%x len=%d\n", desc, pkt, len); eh = pkt; printf("dst: %s ", ether_sprintf(eh->ether_dhost)); printf("src: %s ", ether_sprintf(eh->ether_shost)); printf("type: 0x%x\n", eh->ether_type & 0xFFFF); } #endif sendlen = len; if (sendlen < 60) { sendlen = 60; #ifdef NETIF_DEBUG printf("netif_put: length padded to %d\n", sendlen); #endif } rv = prom_write(op->handle, pkt, sendlen); #ifdef NETIF_DEBUG printf("netif_put: xmit returned %d\n", rv); #endif if (rv > len) rv = len; return rv; }
static void prom_console_write(struct console *con, const char *s, unsigned n) { prom_write(s, n); }
ssize_t kmdb_prom_obp_writer(caddr_t buf, size_t len) { return (prom_write(prom_stdout_ihandle(), buf, len, 0, 0)); }
int write(int fd, const void *buf, size_t count) { return prom_write((void *)fd, (void *)buf, count); }
/* ARGSUSED */ static int ibd_output(int index, struct inetgram *ogp) { int header_len, result; ipoib_ptxhdr_t eh; struct ip *ip; struct in_addr tmpip, ipdst; int broadcast = FALSE; int size; mblk_t *mp; if (!initialized) prom_panic("IPoIB device is not initialized."); if (ogp->igm_level != MEDIA_LVL) { dprintf("ibd_output: frame type wrong: socket: %d\n", index * SOCKETTYPE); errno = EINVAL; return (-1); } header_len = IPOIB_HDRSIZE + IPOIB_ADDRL; mp = ogp->igm_mp; size = mp->b_wptr - mp->b_rptr; if (size > (mac_state.mac_mtu - IPOIB_ADDRL)) { dprintf("ibd_output: frame size too big: %d\n", size); errno = E2BIG; return (-1); } size += header_len; ip = (struct ip *)(mp->b_rptr); eh.ipoib_rhdr.ipoib_type = htons(ETHERTYPE_IP); eh.ipoib_rhdr.ipoib_mbz = 0; bcopy((caddr_t)&ip->ip_dst, (caddr_t)&ipdst, sizeof (ipdst)); if (ipdst.s_addr == htonl(INADDR_BROADCAST)) broadcast = TRUE; /* limited broadcast */ if (!broadcast) { struct in_addr mask; ipv4_getnetmask(&mask); mask.s_addr = htonl(mask.s_addr); if (mask.s_addr != htonl(INADDR_BROADCAST) && (ipdst.s_addr & ~mask.s_addr) == 0) { broadcast = TRUE; /* directed broadcast */ } else { if (ogp->igm_router.s_addr != htonl(INADDR_ANY)) tmpip.s_addr = ogp->igm_router.s_addr; else tmpip.s_addr = ipdst.s_addr; result = mac_get_arp(&tmpip, (void *)&eh.ipoib_dest, IPOIB_ADDRL, mac_state.mac_arp_timeout); if (!result) { errno = ETIMEDOUT; dprintf("ibd_output: ARP request for %s " "timed out.\n", inet_ntoa(tmpip)); return (-1); } } } if (broadcast) bcopy((caddr_t)&ibdbroadcastaddr, (caddr_t)&eh.ipoib_dest, IPOIB_ADDRL); /* add the ibd header */ mp->b_rptr -= sizeof (eh); bcopy((caddr_t)&eh, mp->b_rptr, sizeof (eh)); #ifdef DEBUG printf("ibd_output(%d): level(%d) frame(0x%x) len(%d)\n", index, ogp->igm_level, mp->b_rptr, size); #endif /* DEBUG */ return (prom_write(mac_state.mac_dev, (char *)mp->b_rptr, size, 0, NETWORK)); }
/* * Handle a IP datagram addressed to our MAC address or to the link * layer broadcast address. Also respond to ARP requests. Generates * inetgrams as long as there's data and the mac level IP timeout timer * hasn't expired. As soon as there is no data, we try for * IBD_INPUT_ATTEMPTS for more, then exit the loop, even if there is time * left, since we expect to have data waiting for us when we're called, we just * don't know how much. * * We workaround slow proms (some proms have hard sleeps for as much as 3msec) * even though there are is data waiting. * * Returns the total number of MEDIA_LVL frames placed on the socket. * Caller is expected to free up the inetgram resources. */ static int ibd_input(int index) { struct inetgram *inp; ipoib_ptxhdr_t *eh; int frames = 0; /* successful frames */ int attempts = 0; /* failed attempts after success */ int16_t len = 0, data_len; uint32_t timeout, reltime; uint32_t pre_pr, post_pr; /* prom_read interval */ #ifdef DEBUG int failures = 0; /* total failures */ int total_attempts = 0; /* total prom_read */ int no_data = 0; /* no data in prom */ int arps = 0; /* arp requests processed */ uint32_t tot_pr = 0; /* prom_read time */ uint32_t tot_pc = 0; /* inetgram creation time */ uint32_t pre_pc; uint32_t now; #endif /* DEBUG */ if (!initialized) prom_panic("IPoIB device is not initialized."); if ((reltime = sockets[index].in_timeout) == 0) reltime = mac_state.mac_in_timeout; timeout = prom_gettime() + reltime; do { if (frames > IBD_MAX_FRAMES) { /* someone is trying a denial of service attack */ break; } /* * The following is being paranoid about possible bugs * where prom_read() returns a nonzero length, even when * it's not read a packet; it zeroes out the header to * compensate. Paranoia from calvin prom (V2) days. */ bzero(mac_state.mac_buf, sizeof (ipoib_ptxhdr_t)); /* * Prom_read() will return 0 or -2 if no data is present. A * return value of -1 means an error has occurred. We adjust * the timeout by calling the time spent in prom_read() "free". * prom_read() returns the number of bytes actually read, but * will only copy "len" bytes into our buffer. Adjust in * case the MTU is wrong. */ pre_pr = prom_gettime(); len = prom_read(mac_state.mac_dev, mac_state.mac_buf, mac_state.mac_mtu, 0, NETWORK); post_pr = prom_gettime(); timeout += (post_pr - pre_pr); #ifdef DEBUG tot_pr += (post_pr - pre_pr); total_attempts++; #endif /* DEBUG */ if (len > mac_state.mac_mtu) { dprintf("ibd_input: adjusting MTU %d -> %d\n", mac_state.mac_mtu, len); bkmem_free(mac_state.mac_buf, mac_state.mac_mtu); mac_state.mac_mtu = len; mac_state.mac_buf = bkmem_alloc(mac_state.mac_mtu); if (mac_state.mac_buf == NULL) { prom_panic("ibd_input: Cannot reallocate " "netbuf memory."); } len = 0; /* pretend there was no data */ } if (len == -1) { #ifdef DEBUG failures++; #endif /* DEBUG */ break; } if (len == 0 || len == -2) { if (frames != 0) attempts++; #ifdef DEBUG no_data++; #endif /* DEBUG */ continue; } eh = (ipoib_ptxhdr_t *)mac_state.mac_buf; if (eh->ipoib_rhdr.ipoib_type == ntohs(ETHERTYPE_IP) && len >= (sizeof (ipoib_ptxhdr_t) + sizeof (struct ip))) { int offset; #ifdef DEBUG pre_pc = prom_gettime(); #endif /* DEBUG */ inp = (struct inetgram *)bkmem_zalloc( sizeof (struct inetgram)); if (inp == NULL) { errno = ENOMEM; return (frames == 0 ? -1 : frames); } offset = sizeof (ipoib_ptxhdr_t); data_len = len - offset; inp->igm_mp = allocb(data_len, 0); if (inp->igm_mp == NULL) { errno = ENOMEM; bkmem_free((caddr_t)inp, sizeof (struct inetgram)); return (frames == 0 ? -1 : frames); } bcopy((caddr_t)(mac_state.mac_buf + offset), inp->igm_mp->b_rptr, data_len); inp->igm_mp->b_wptr += data_len; inp->igm_level = NETWORK_LVL; add_grams(&sockets[index].inq, inp); frames++; attempts = 0; #ifdef DEBUG tot_pc += prom_gettime() - pre_pc; #endif /* DEBUG */ continue; } if (eh->ipoib_rhdr.ipoib_type == ntohs(ETHERTYPE_ARP) && len >= sizeof (struct arp_packet)) { struct in_addr ip; struct ibd_arp *ea; #ifdef DEBUG printf("ibd_input: ARP message received\n"); arps++; #endif /* DEBUG */ ea = (struct ibd_arp *)(mac_state.mac_buf + sizeof (ipoib_ptxhdr_t)); if (ea->arp_pro != ntohs(ETHERTYPE_IP)) continue; ipv4_getipaddr(&ip); ip.s_addr = ntohl(ip.s_addr); if (ea->arp_op == ntohs(ARPOP_REQUEST) && ip.s_addr != INADDR_ANY && (bcmp((caddr_t)ea->arp_tpa, (caddr_t)&ip, sizeof (struct in_addr)) == 0)) { ea->arp_op = htons(ARPOP_REPLY); bcopy((caddr_t)&ea->arp_sha, (caddr_t)&eh->ipoib_dest, IPOIB_ADDRL); bcopy((caddr_t)&ea->arp_sha, (caddr_t)&ea->arp_tha, IPOIB_ADDRL); bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa, sizeof (struct in_addr)); bcopy(mac_state.mac_addr_buf, (caddr_t)&ea->arp_sha, mac_state.mac_addr_len); bcopy((caddr_t)&ip, (caddr_t)ea->arp_spa, sizeof (struct in_addr)); (void) prom_write(mac_state.mac_dev, mac_state.mac_buf, sizeof (struct arp_packet), 0, NETWORK); /* don't charge for ARP replies */ timeout += reltime; } } } while (attempts < IBD_INPUT_ATTEMPTS && #ifdef DEBUG (now = prom_gettime()) < timeout); #else prom_gettime() < timeout); #endif /* DEBUG */ #ifdef DEBUG printf("ibd_input(%d): T/S/N/A/F/P/M: %d/%d/%d/%d/%d/%d/%d " "T/O: %d < %d = %s\n", index, total_attempts, frames, no_data, arps, failures, tot_pr, tot_pc, now, timeout, (now < timeout) ? "TRUE" : "FALSE"); #endif /* DEBUG */ return (frames); }
/* * Common ARP code. Broadcast the packet and wait for the right response. * * If arp is called for, caller expects a hardware address in the * source hardware address (sha) field of the "out" argument. * * IPoIB does not support RARP (see ibd_revarp()). * * Returns TRUE if transaction succeeded, FALSE otherwise. * * The timeout argument is the number of milliseconds to wait for a * response. An infinite timeout can be specified as 0xffffffff. */ static int ibd_comarp(struct arp_packet *out, uint32_t timeout) { struct arp_packet *in = (struct arp_packet *)mac_state.mac_buf; int count, time, feedback, len, delay = 2; char *ind = "-\\|/"; struct in_addr tmp_ia; uint32_t wait_time; bcopy((caddr_t)&ibdbroadcastaddr, (caddr_t)&out->arp_eh.ipoib_dest, IPOIB_ADDRL); out->arp_ea.arp_hrd = htons(ARPHRD_IB); out->arp_ea.arp_pro = htons(ETHERTYPE_IP); out->arp_ea.arp_hln = IPOIB_ADDRL; out->arp_ea.arp_pln = sizeof (struct in_addr); bcopy(mac_state.mac_addr_buf, (caddr_t)&out->arp_ea.arp_sha, IPOIB_ADDRL); ipv4_getipaddr(&tmp_ia); tmp_ia.s_addr = htonl(tmp_ia.s_addr); bcopy((caddr_t)&tmp_ia, (caddr_t)out->arp_ea.arp_spa, sizeof (struct in_addr)); feedback = 0; wait_time = prom_gettime() + timeout; for (count = 0; timeout == ~0U || prom_gettime() < wait_time; count++) { if (count == IBD_WAITCNT) { /* * Since IPoIB does not support RARP (see ibd_revarp), * we know that out->arp_ea.arp_op == ARPOP_REQUEST. */ bcopy((caddr_t)out->arp_ea.arp_tpa, (caddr_t)&tmp_ia, sizeof (struct in_addr)); printf("\nRequesting MAC address for: %s\n", inet_ntoa(tmp_ia)); } (void) prom_write(mac_state.mac_dev, (caddr_t)out, sizeof (*out), 0, NETWORK); if (count >= IBD_WAITCNT) printf("%c\b", ind[feedback++ % 4]); /* activity */ time = prom_gettime() + (delay * 1000); /* broadcast delay */ while (prom_gettime() <= time) { len = prom_read(mac_state.mac_dev, mac_state.mac_buf, mac_state.mac_mtu, 0, NETWORK); if (len < sizeof (struct arp_packet)) continue; if (in->arp_ea.arp_pro != ntohs(ETHERTYPE_IP)) continue; /* * Since IPoIB does not support RARP (see ibd_revarp), * we know that out->arp_ea.arp_op == ARPOP_REQUEST. */ if (in->arp_eh.ipoib_rhdr.ipoib_type != ntohs(ETHERTYPE_ARP)) continue; if (in->arp_ea.arp_op != ntohs(ARPOP_REPLY)) continue; if (bcmp((caddr_t)in->arp_ea.arp_spa, (caddr_t)out->arp_ea.arp_tpa, sizeof (struct in_addr)) != 0) continue; if (boothowto & RB_VERBOSE) { bcopy((caddr_t)in->arp_ea.arp_spa, (caddr_t)&tmp_ia, sizeof (struct in_addr)); printf("Found %s @ %s\n", inet_ntoa(tmp_ia), ibd_print(&in->arp_ea.arp_sha)); } /* copy hardware addr into "out" for caller */ bcopy((caddr_t)&in->arp_ea.arp_sha, (caddr_t)&out->arp_ea.arp_sha, IPOIB_ADDRL); return (TRUE); } delay = delay * 2; /* Double the request delay */ if (delay > 64) /* maximum delay is 64 seconds */ delay = 64; } return (FALSE); }