mirror of
https://git.FreeBSD.org/src.git
synced 2024-11-27 08:00:11 +00:00
1151 lines
25 KiB
C
1151 lines
25 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-4-Clause
|
|
*
|
|
* 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 <sys/param.h>
|
|
#include <sys/types.h>
|
|
#include <sys/uio.h>
|
|
#include <sys/wait.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <termios.h>
|
|
#include <dev/dcons/dcons.h>
|
|
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <netdb.h>
|
|
#include <err.h>
|
|
#include <string.h>
|
|
#include <sys/eui64.h>
|
|
#include <sys/event.h>
|
|
#include <sys/time.h>
|
|
#include <arpa/telnet.h>
|
|
|
|
#include <sys/ioccom.h>
|
|
#include <dev/firewire/firewire.h>
|
|
#include <dev/firewire/iec13213.h>
|
|
|
|
#include <kvm.h>
|
|
#include <nlist.h>
|
|
|
|
#include <sys/errno.h>
|
|
|
|
#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, NULL);
|
|
|
|
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),
|
|
"wrong version %d,%d",
|
|
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);
|
|
printf("output: %5d %6d %5d %5d\n"
|
|
"input : %5d %6d %5d %5d\n",
|
|
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);
|
|
}
|