/* * Copyright (C) 2003 * Hidetoshi Shimokawa. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * * This product includes software developed by Hidetoshi Shimokawa. * * 4. Neither the name of the author nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: dconschat.c,v 1.76 2003/10/23 06:21:13 simokawa Exp $ * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DCONS_POLL_HZ 100 #define DCONS_POLL_OFFLINE 2 /* sec */ #define RETRY 3 #ifdef CSRVAL_VENDOR_PRIVATE #define USE_CROM 1 #else #define USE_CROM 0 #endif int verbose = 0; int tc_set = 0; int poll_hz = DCONS_POLL_HZ; static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */}; #define IS_CONSOLE(p) ((p)->port == DCONS_CON) #define IS_GDB(p) ((p)->port == DCONS_GDB) static struct dcons_state { int fd; kvm_t *kd; int kq; off_t paddr; off_t reset; #define F_READY (1 << 1) #define F_RD_ONLY (1 << 2) #define F_ALT_BREAK (1 << 3) #define F_TELNET (1 << 4) #define F_USE_CROM (1 << 5) #define F_ONE_SHOT (1 << 6) #define F_REPLAY (1 << 7) int flags; enum { TYPE_KVM, TYPE_FW } type; int escape_state; struct dcons_port { int port; int sport; struct dcons_ch o; struct dcons_ch i; u_int32_t optr; u_int32_t iptr; int s; int infd; int outfd; struct addrinfo *res; int skip_read; } port[DCONS_NPORT]; struct timespec to; struct timespec zero; struct termios tsave; struct termios traw; char escape; } sc; static int dconschat_write_dcons(struct dcons_state *, int, char *, int); static int dread(struct dcons_state *dc, void *buf, size_t n, off_t offset) { switch (dc->type) { case TYPE_FW: return (pread(dc->fd, buf, n, offset)); case TYPE_KVM: return (kvm_read(dc->kd, offset, buf, n)); } return (-1); } static int dwrite(struct dcons_state *dc, void *buf, size_t n, off_t offset) { if ((dc->flags & F_RD_ONLY) != 0) return (n); switch (dc->type) { case TYPE_FW: return (pwrite(dc->fd, buf, n, offset)); case TYPE_KVM: return (kvm_write(dc->kd, offset, buf, n)); } return (-1); } static void dconschat_reset_target(struct dcons_state *dc, struct dcons_port *p) { char buf[PAGE_SIZE]; if (dc->reset == 0) return; snprintf(buf, PAGE_SIZE, "\r\n[dconschat reset target(addr=0x%jx)...]\r\n", (intmax_t)dc->reset); write(p->outfd, buf, strlen(buf)); bzero(&buf[0], PAGE_SIZE); dwrite(dc, (void *)buf, PAGE_SIZE, dc->reset); } static void dconschat_suspend(struct dcons_state *dc, struct dcons_port *p) { if (p->sport != 0) return; if (tc_set) tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave); printf("\n[dconschat suspend]\n"); kill(getpid(), SIGTSTP); if (tc_set) tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw); } static void dconschat_sigchld(int s) { struct kevent kev; struct dcons_port *p; char buf[256]; p = &sc.port[DCONS_CON]; snprintf(buf, 256, "\r\n[child exit]\r\n"); write(p->outfd, buf, strlen(buf)); if (tc_set) tcsetattr(STDIN_FILENO, TCSADRAIN, &sc.traw); EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p); kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero); } static void dconschat_fork_gdb(struct dcons_state *dc, struct dcons_port *p) { pid_t pid; char buf[256], com[256]; struct kevent kev; pid = fork(); if (pid < 0) { snprintf(buf, 256, "\r\n[%s: fork failed]\r\n", __FUNCTION__); write(p->outfd, buf, strlen(buf)); } if (pid == 0) { /* child */ if (tc_set) tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave); snprintf(com, sizeof(buf), "kgdb -r :%d kernel", dc->port[DCONS_GDB].sport); snprintf(buf, 256, "\n[fork %s]\n", com); write(p->outfd, buf, strlen(buf)); execl("/bin/sh", "/bin/sh", "-c", com, 0); snprintf(buf, 256, "\n[fork failed]\n"); write(p->outfd, buf, strlen(buf)); if (tc_set) tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw); exit(0); } else { signal(SIGCHLD, dconschat_sigchld); EV_SET(&kev, p->infd, EVFILT_READ, EV_DELETE, 0, 0, NULL); kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero); } } static void dconschat_cleanup(int sig) { struct dcons_state *dc; int status; dc = ≻ if (tc_set != 0) tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave); if (sig > 0) printf("\n[dconschat exiting with signal %d ...]\n", sig); else printf("\n[dconschat exiting...]\n"); wait(&status); exit(0); } #if USE_CROM static int dconschat_get_crom(struct dcons_state *dc) { off_t addr; int i, state = 0; u_int32_t buf, hi = 0, lo = 0, reset_hi = 0, reset_lo = 0; struct csrreg *reg; reg = (struct csrreg *)&buf; addr = 0xffff; addr = (addr << 32) | 0xf0000400; for (i = 20; i < 0x400; i += 4) { if (dread(dc, &buf, 4, addr + i) < 0) { if (verbose) warn("crom read faild"); goto out; } buf = ntohl(buf); if (verbose) printf("%d %02x %06x\n", state, reg->key, reg->val); switch (state) { case 0: if (reg->key == CSRKEY_SPEC && reg->val == CSRVAL_VENDOR_PRIVATE) state = 1; break; case 1: if (reg->key == CSRKEY_VER && reg->val == DCONS_CSR_VAL_VER) state = 2; break; case 2: switch (reg->key) { case DCONS_CSR_KEY_HI: hi = reg->val; break; case DCONS_CSR_KEY_LO: lo = reg->val; break; case DCONS_CSR_KEY_RESET_HI: reset_hi = reg->val; break; case DCONS_CSR_KEY_RESET_LO: reset_lo = reg->val; goto out; break; case 0x81: break; default: state = 0; } break; } } out: if (verbose) printf("addr: %06x %06x\n", hi, lo); dc->paddr = ((off_t)hi << 24) | lo; dc->reset = ((off_t)reset_hi << 24) | reset_lo; if (dc->paddr == 0) return (-1); return (0); } #endif static void dconschat_ready(struct dcons_state *dc, int ready, char *reason) { static char oldreason[64] = ""; int old; old = (dc->flags & F_READY) ? 1 : 0; if (ready) { dc->flags |= F_READY; if (ready != old) printf("[dcons connected]\r\n"); oldreason[0] = 0; } else { dc->flags &= ~F_READY; if (strncmp(oldreason, reason, sizeof(oldreason)) != 0) { printf("[dcons disconnected (%s)]\r\n", reason); strlcpy(oldreason, reason, sizeof(oldreason)); } } } static int dconschat_fetch_header(struct dcons_state *dc) { char ebuf[64]; struct dcons_buf dbuf; int j; #if USE_CROM if (dc->paddr == 0 && (dc->flags & F_USE_CROM) != 0) { if (dconschat_get_crom(dc)) { dconschat_ready(dc, 0, "get crom failed"); return (-1); } } #endif if (dread(dc, &dbuf, DCONS_HEADER_SIZE, dc->paddr) < 0) { dconschat_ready(dc, 0, "read header failed"); return (-1); } if (dbuf.magic != htonl(DCONS_MAGIC)) { if ((dc->flags & F_USE_CROM) !=0) dc->paddr = 0; snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", dbuf.magic); dconschat_ready(dc, 0, ebuf); return (-1); } if (ntohl(dbuf.version) != DCONS_VERSION) { snprintf(ebuf, sizeof(ebuf), #if __FreeBSD_version < 500000 "wrong version %ld,%d", #else "wrong version %d,%d", #endif ntohl(dbuf.version), DCONS_VERSION); /* XXX exit? */ dconschat_ready(dc, 0, ebuf); return (-1); } for (j = 0; j < DCONS_NPORT; j++) { struct dcons_ch *o, *i; off_t newbuf; int new = 0; o = &dc->port[j].o; newbuf = dc->paddr + ntohl(dbuf.ooffset[j]); o->size = ntohl(dbuf.osize[j]); if (newbuf != o->buf) { /* buffer address has changes */ new = 1; o->gen = ntohl(dbuf.optr[j]) >> DCONS_GEN_SHIFT; o->pos = ntohl(dbuf.optr[j]) & DCONS_POS_MASK; o->buf = newbuf; } i = &dc->port[j].i; i->size = ntohl(dbuf.isize[j]); i->gen = ntohl(dbuf.iptr[j]) >> DCONS_GEN_SHIFT; i->pos = ntohl(dbuf.iptr[j]) & DCONS_POS_MASK; i->buf = dc->paddr + ntohl(dbuf.ioffset[j]); if (verbose) { printf("port %d size offset gen pos\n", j); #if __FreeBSD_version < 500000 printf("output: %5d %6ld %5d %5d\n" "input : %5d %6ld %5d %5d\n", #else printf("output: %5d %6d %5d %5d\n" "input : %5d %6d %5d %5d\n", #endif o->size, ntohl(dbuf.ooffset[j]), o->gen, o->pos, i->size, ntohl(dbuf.ioffset[j]), i->gen, i->pos); } if (IS_CONSOLE(&dc->port[j]) && new && (dc->flags & F_REPLAY) !=0) { if (o->gen > 0) o->gen --; else o->pos = 0; } } dconschat_ready(dc, 1, NULL); return(0); } static int dconschat_get_ptr (struct dcons_state *dc) { int dlen, i; u_int32_t ptr[DCONS_NPORT*2+1]; static int retry = RETRY; char ebuf[64]; again: dlen = dread(dc, &ptr, sizeof(ptr), dc->paddr + __offsetof(struct dcons_buf, magic)); if (dlen < 0) { if (errno == ETIMEDOUT) if (retry -- > 0) goto again; dconschat_ready(dc, 0, "get ptr failed"); return(-1); } if (ptr[0] != htonl(DCONS_MAGIC)) { if ((dc->flags & F_USE_CROM) !=0) dc->paddr = 0; snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", ptr[0]); dconschat_ready(dc, 0, ebuf); return(-1); } retry = RETRY; for (i = 0; i < DCONS_NPORT; i ++) { dc->port[i].optr = ntohl(ptr[i + 1]); dc->port[i].iptr = ntohl(ptr[DCONS_NPORT + i + 1]); } return(0); } #define MAX_XFER 2048 static int dconschat_read_dcons(struct dcons_state *dc, int port, char *buf, int len) { struct dcons_ch *ch; u_int32_t ptr, pos, gen, next_gen; int rlen, dlen, lost; int retry = RETRY; ch = &dc->port[port].o; ptr = dc->port[port].optr; gen = ptr >> DCONS_GEN_SHIFT; pos = ptr & DCONS_POS_MASK; if (gen == ch->gen && pos == ch->pos) return (-1); next_gen = DCONS_NEXT_GEN(ch->gen); /* XXX sanity check */ if (gen == ch->gen) { if (pos > ch->pos) goto ok; lost = ch->size * DCONS_GEN_MASK - ch->pos; ch->pos = 0; } else if (gen == next_gen) { if (pos <= ch->pos) goto ok; lost = pos - ch->pos; ch->pos = pos; } else { lost = gen - ch->gen; if (lost < 0) lost += DCONS_GEN_MASK; if (verbose) printf("[genskip %d]", lost); lost = lost * ch->size - ch->pos; ch->pos = 0; ch->gen = gen; } /* generation skipped !! */ /* XXX discard */ if (verbose) printf("[lost %d]", lost); ok: if (gen == ch->gen) rlen = pos - ch->pos; else rlen = ch->size - ch->pos; if (rlen > MAX_XFER) rlen = MAX_XFER; if (rlen > len) rlen = len; #if 1 if (verbose == 1) printf("[%d]", rlen); fflush(stdout); #endif again: dlen = dread(dc, buf, rlen, ch->buf + ch->pos); if (dlen < 0) { if (errno == ETIMEDOUT) if (retry -- > 0) goto again; dconschat_ready(dc, 0, "read buffer failed"); return(-1); } if (dlen != rlen) warnx("dlen(%d) != rlen(%d)\n", dlen, rlen); ch->pos += dlen; if (ch->pos >= ch->size) { ch->gen = next_gen; ch->pos = 0; if (verbose) printf("read_dcons: gen=%d", ch->gen); } return (dlen); } static int dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen) { struct dcons_ch *ch; u_int32_t ptr; int len, wlen; int retry = RETRY; ch = &dc->port[port].i; ptr = dc->port[port].iptr; /* the others may advance the pointer sync with it */ ch->gen = ptr >> DCONS_GEN_SHIFT; ch->pos = ptr & DCONS_POS_MASK; while(blen > 0) { wlen = MIN(blen, ch->size - ch->pos); wlen = MIN(wlen, MAX_XFER); len = dwrite(dc, buf, wlen, ch->buf + ch->pos); if (len < 0) { if (errno == ETIMEDOUT) if (retry -- > 0) continue; /* try again */ dconschat_ready(dc, 0, "write buffer failed"); return(-1); } ch->pos += len; buf += len; blen -= len; if (ch->pos >= ch->size) { ch->gen = DCONS_NEXT_GEN(ch->gen); ch->pos = 0; if (verbose) printf("write_dcons: gen=%d", ch->gen); } } ptr = DCONS_MAKE_PTR(ch); dc->port[port].iptr = ptr; if (verbose > 2) printf("(iptr: 0x%x)", ptr); again: len = dwrite(dc, &ptr, sizeof(u_int32_t), dc->paddr + __offsetof(struct dcons_buf, iptr[port])); if (len < 0) { if (errno == ETIMEDOUT) if (retry -- > 0) goto again; dconschat_ready(dc, 0, "write ptr failed"); return(-1); } return(0); } static int dconschat_write_socket(int fd, char *buf, int len) { write(fd, buf, len); if (verbose > 1) { buf[len] = 0; printf("<- %s\n", buf); } return (0); } static void dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport) { struct addrinfo hints, *res; int on = 1, error; char service[10]; struct kevent kev; struct dcons_port *p; p = &dc->port[port]; p->port = port; p->sport = sport; p->infd = p->outfd = -1; if (sport < 0) return; if (sport == 0) { /* Use stdin and stdout */ p->infd = STDIN_FILENO; p->outfd = STDOUT_FILENO; p->s = -1; if (tc_set == 0 && tcgetattr(STDIN_FILENO, &dc->tsave) == 0) { dc->traw = dc->tsave; cfmakeraw(&dc->traw); tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw); tc_set = 1; } EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p); kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero); return; } memset(&hints, 0, sizeof(hints)); hints.ai_flags = AI_PASSIVE; #if 1 /* gdb can talk v4 only */ hints.ai_family = PF_INET; #else hints.ai_family = PF_UNSPEC; #endif hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = 0; if (verbose) printf("%s:%d for port %d\n", host == NULL ? "*" : host, sport, port); snprintf(service, sizeof(service), "%d", sport); error = getaddrinfo(host, service, &hints, &res); if (error) errx(1, "tcp/%s: %s\n", service, gai_strerror(error)); p->res = res; p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol); if (p->s < 0) err(1, "socket"); setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) { err(1, "bind"); } if (listen(p->s, 1) < 0) err(1, "listen"); EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *)p); error = kevent(dc->kq, &kev, 1, NULL, 0, &dc->to); if (error < 0) err(1, "kevent"); return; } static int dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p) { socklen_t addrlen; int ns, flags; struct kevent kev; /* accept connection */ addrlen = p->res->ai_addrlen; ns = accept(p->s, p->res->ai_addr, &addrlen); if (ns < 0) err(1, "accept"); if (verbose) printf("port%d accepted\n", p->port); flags = fcntl(ns, F_GETFL, 0); flags |= O_NDELAY; fcntl(ns, F_SETFL, flags); #if 1 if (IS_CONSOLE(p) && (dc->flags & F_TELNET) != 0) { char sga[] = {IAC, WILL, TELOPT_SGA}; char linemode[] = {IAC, DONT, TELOPT_LINEMODE}; char echo[] = {IAC, WILL, TELOPT_ECHO}; char bin[] = {IAC, DO, TELOPT_BINARY}; write(ns, sga, sizeof(sga)); write(ns, linemode, sizeof(linemode)); write(ns, echo, sizeof(echo)); write(ns, bin, sizeof(bin)); p->skip_read = 0; } #endif /* discard backlog on GDB port */ if (IS_GDB(p)) { char buf[2048]; int len; while ((len = dconschat_read_dcons(dc, DCONS_GDB, &buf[0], 2048)) > 0) if (verbose) printf("discard %d chars on GDB port\n", len); } p->infd = p->outfd = ns; EV_SET(&kev, ns, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p); kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero); return(0); } static int dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p, u_char *sp, int slen, u_char *dp, int *dlen) { int skip; char *buf; while (slen > 0) { skip = 0; if (IS_CONSOLE(p)) { if ((dc->flags & F_TELNET) != 0) { /* XXX Telnet workarounds */ if (p->skip_read -- > 0) { sp ++; slen --; continue; } if (*sp == IAC) { if (verbose) printf("(IAC)"); p->skip_read = 2; sp ++; slen --; continue; } if (*sp == 0) { if (verbose) printf("(0 stripped)"); sp ++; slen --; continue; } } switch (dc->escape_state) { case STATE1: if (*sp == dc->escape) { skip = 1; dc->escape_state = STATE2; } else dc->escape_state = STATE0; break; case STATE2: dc->escape_state = STATE0; skip = 1; if (*sp == '.') dconschat_cleanup(0); else if (*sp == CTRL('B')) { bcopy(abreak, dp, 3); dp += 3; *dlen += 3; } else if (*sp == CTRL('G')) dconschat_fork_gdb(dc, p); else if ((*sp == CTRL('R')) && (dc->reset != 0)) { dc->escape_state = STATE3; buf = "\r\n[Are you sure to reset target? (y/N)]"; write(p->outfd, buf, strlen(buf)); } else if (*sp == CTRL('Z')) dconschat_suspend(dc, p); else { skip = 0; *dp++ = dc->escape; (*dlen) ++; } break; case STATE3: dc->escape_state = STATE0; skip = 1; if (*sp == 'y') dconschat_reset_target(dc, p); else { write(p->outfd, sp, 1); write(p->outfd, "\r\n", 2); } break; } if (*sp == KEY_CR) dc->escape_state = STATE1; } else if (IS_GDB(p)) { /* GDB: ^C -> CR+~+^B */ if (*sp == CTRL('C') && (dc->flags & F_ALT_BREAK) != 0) { bcopy(abreak, dp, 3); dp += 3; sp ++; *dlen += 3; /* discard rest of the packet */ slen = 0; break; } } if (!skip) { *dp++ = *sp; (*dlen) ++; } sp ++; slen --; } return (*dlen); } static int dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p) { struct kevent kev; int len, wlen; char rbuf[MAX_XFER], wbuf[MAX_XFER+2]; if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) { wlen = 0; dconschat_read_filter(dc, p, rbuf, len, wbuf, &wlen); /* XXX discard if not ready*/ if (wlen > 0 && (dc->flags & F_READY) != 0) { dconschat_write_dcons(dc, p->port, wbuf, wlen); if (verbose > 1) { wbuf[wlen] = 0; printf("-> %s\n", wbuf); } else if (verbose == 1) { printf("(%d)", wlen); fflush(stdout); } } } else { if (verbose) { if (len == 0) warnx("port%d: closed", p->port); else warn("port%d: read", p->port); } EV_SET(&kev, p->infd, EVFILT_READ, EV_DELETE, 0, 0, NULL); kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero); close(p->infd); close(p->outfd); /* XXX exit for pipe case XXX */ EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *) p); kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero); p->infd = p->outfd = -1; } return(0); } #define NEVENT 5 static int dconschat_proc_socket(struct dcons_state *dc) { struct kevent elist[NEVENT], *e; int i, n; struct dcons_port *p; n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to); for (i = 0; i < n; i ++) { e = &elist[i]; p = (struct dcons_port *)e->udata; if (e->ident == p->s) { dconschat_accept_socket(dc, p); } else { dconschat_read_socket(dc, p); } } return(0); } static int dconschat_proc_dcons(struct dcons_state *dc) { int port, len, err; char buf[MAX_XFER]; struct dcons_port *p; err = dconschat_get_ptr(dc); if (err) { /* XXX we should stop write operation too. */ return err; } for (port = 0; port < DCONS_NPORT; port ++) { p = &dc->port[port]; if (p->infd < 0) continue; while ((len = dconschat_read_dcons(dc, port, buf, sizeof(buf))) > 0) { dconschat_write_socket(p->outfd, buf, len); if ((err = dconschat_get_ptr(dc))) return (err); } if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0) dconschat_cleanup(0); } return 0; } static int dconschat_start_session(struct dcons_state *dc) { int counter = 0; int retry = 0; int retry_unit_init = MAX(1, poll_hz / 10); int retry_unit_offline = poll_hz * DCONS_POLL_OFFLINE; int retry_unit = retry_unit_init; int retry_max = retry_unit_offline / retry_unit; while (1) { if (((dc->flags & F_READY) == 0) && ++counter > retry_unit) { counter = 0; retry ++; if (retry > retry_max) retry_unit = retry_unit_offline; if (verbose) { printf("%d/%d ", retry, retry_max); fflush(stdout); } dconschat_fetch_header(dc); } if ((dc->flags & F_READY) != 0) { counter = 0; retry = 0; retry_unit = retry_unit_init; dconschat_proc_dcons(dc); } dconschat_proc_socket(dc); } return (0); } static void usage(void) { fprintf(stderr, "usage: dconschat [-brvwRT1] [-h hz] [-C port] [-G port]\n" "\t\t\t[-M core] [-N system]\n" "\t\t\t[-u unit] [-a address] [-t target_eui64]\n" "\t-b translate ctrl-C to CR+~+ctrl-B on gdb port\n" "\t-v verbose\n" "\t-w listen on wildcard address rather than localhost\n" "\t-r replay old buffer on connection\n" "\t-R read-only\n" "\t-T enable Telnet protocol workaround on console port\n" "\t-1 one shot: read buffer and exit\n" "\t-h polling rate\n" "\t-C port number for console port\n" "\t-G port number for gdb port\n" "\t(for KVM)\n" "\t-M core file\n" "\t-N system file\n" "\t(for FireWire)\n" "\t-u specify unit number of the bus\n" "\t-t EUI64 of target host (must be specified)\n" "\t-a physical address of dcons buffer on target host\n" ); exit(0); } int main(int argc, char **argv) { struct dcons_state *dc; struct fw_eui64 eui; struct eui64 target; char devname[256], *core = NULL, *system = NULL; int i, ch, error; int unit=0, wildcard=0; int port[DCONS_NPORT]; bzero(&sc, sizeof(sc)); dc = ≻ dc->flags |= USE_CROM ? F_USE_CROM : 0; /* default ports */ port[0] = 0; /* stdin/out for console */ port[1] = -1; /* disable gdb port */ /* default escape char */ dc->escape = KEY_TILDE; while ((ch = getopt(argc, argv, "a:be:h:rt:u:vwC:G:M:N:RT1")) != -1) { switch(ch) { case 'a': dc->paddr = strtoull(optarg, NULL, 0); dc->flags &= ~F_USE_CROM; break; case 'b': dc->flags |= F_ALT_BREAK; break; case 'e': dc->escape = optarg[0]; break; case 'h': poll_hz = strtoul(optarg, NULL, 0); if (poll_hz == 0) poll_hz = DCONS_POLL_HZ; break; case 'r': dc->flags |= F_REPLAY; break; case 't': if (eui64_hostton(optarg, &target) != 0 && eui64_aton(optarg, &target) != 0) errx(1, "invalid target: %s", optarg); eui.hi = ntohl(*(u_int32_t*)&(target.octet[0])); eui.lo = ntohl(*(u_int32_t*)&(target.octet[4])); dc->type = TYPE_FW; break; case 'u': unit = strtol(optarg, NULL, 0); break; case 'v': verbose ++; break; case 'w': wildcard = 1; break; case 'C': port[0] = strtol(optarg, NULL, 0); break; case 'G': port[1] = strtol(optarg, NULL, 0); break; case 'M': core = optarg; break; case 'N': system = optarg; break; case 'R': dc->flags |= F_RD_ONLY; break; case 'T': dc->flags |= F_TELNET; break; case '1': dc->flags |= F_ONE_SHOT | F_REPLAY; break; default: usage(); } } if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) { warnx("no address specified"); usage(); } if (port[0] < 0 && port[1] < 0) { warnx("no port specified"); usage(); } /* set signal handler */ signal(SIGHUP, dconschat_cleanup); signal(SIGINT, dconschat_cleanup); signal(SIGPIPE, dconschat_cleanup); signal(SIGTERM, dconschat_cleanup); /* init firewire */ switch (dc->type) { case TYPE_FW: #define MAXDEV 10 for (i = 0; i < MAXDEV; i ++) { snprintf(devname, sizeof(devname), "/dev/fwmem%d.%d", unit, i); dc->fd = open(devname, O_RDWR); if (dc->fd >= 0) goto found; } err(1, "open"); found: error = ioctl(dc->fd, FW_SDEUI64, &eui); if (error) err(1, "ioctl"); break; case TYPE_KVM: { struct nlist nl[] = {{"dcons_buf"}, {""}}; void *dcons_buf; dc->kd = kvm_open(system, core, NULL, (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat"); if (dc->kd == NULL) errx(1, "kvm_open"); if (kvm_nlist(dc->kd, nl) < 0) errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd)); if (kvm_read(dc->kd, nl[0].n_value, &dcons_buf, sizeof(void *)) < 0) errx(1, "kvm_read: %s", kvm_geterr(dc->kd)); dc->paddr = (uintptr_t)dcons_buf; if (verbose) printf("dcons_buf: 0x%x\n", (uint)dc->paddr); break; } } dconschat_fetch_header(dc); /* init sockets */ dc->kq = kqueue(); if (poll_hz == 1) { dc->to.tv_sec = 1; dc->to.tv_nsec = 0; } else { dc->to.tv_sec = 0; dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz; } dc->zero.tv_sec = 0; dc->zero.tv_nsec = 0; for (i = 0; i < DCONS_NPORT; i++) dconschat_init_socket(dc, i, wildcard ? NULL : "localhost", port[i]); dconschat_start_session(dc); for (i = 0; i < DCONS_NPORT; i++) { freeaddrinfo(dc->port[i].res); } return (0); }