2 * SPDX-License-Identifier: BSD-4-Clause
5 * Hidetoshi Shimokawa. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 * must display the following acknowledgement:
18 * This product includes software developed by Hidetoshi Shimokawa.
20 * 4. Neither the name of the author nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * $Id: dconschat.c,v 1.76 2003/10/23 06:21:13 simokawa Exp $
40 #include <sys/param.h>
41 #include <sys/types.h>
51 #include <dev/dcons/dcons.h>
53 #include <sys/socket.h>
54 #include <netinet/in.h>
58 #include <sys/eui64.h>
59 #include <sys/event.h>
61 #include <arpa/telnet.h>
63 #include <sys/ioccom.h>
64 #include <dev/firewire/firewire.h>
65 #include <dev/firewire/iec13213.h>
70 #include <sys/errno.h>
72 #define DCONS_POLL_HZ 100
73 #define DCONS_POLL_OFFLINE 2 /* sec */
77 #ifdef CSRVAL_VENDOR_PRIVATE
85 int poll_hz = DCONS_POLL_HZ;
86 static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */};
88 #define IS_CONSOLE(p) ((p)->port == DCONS_CON)
89 #define IS_GDB(p) ((p)->port == DCONS_GDB)
91 static struct dcons_state {
97 #define F_READY (1 << 1)
98 #define F_RD_ONLY (1 << 2)
99 #define F_ALT_BREAK (1 << 3)
100 #define F_TELNET (1 << 4)
101 #define F_USE_CROM (1 << 5)
102 #define F_ONE_SHOT (1 << 6)
103 #define F_REPLAY (1 << 7)
120 struct addrinfo *res;
124 struct timespec zero;
125 struct termios tsave;
130 static int dconschat_write_dcons(struct dcons_state *, int, char *, int);
133 dread(struct dcons_state *dc, void *buf, size_t n, off_t offset)
137 return (pread(dc->fd, buf, n, offset));
139 return (kvm_read(dc->kd, offset, buf, n));
145 dwrite(struct dcons_state *dc, void *buf, size_t n, off_t offset)
147 if ((dc->flags & F_RD_ONLY) != 0)
152 return (pwrite(dc->fd, buf, n, offset));
154 return (kvm_write(dc->kd, offset, buf, n));
160 dconschat_reset_target(struct dcons_state *dc, struct dcons_port *p)
166 snprintf(buf, PAGE_SIZE,
167 "\r\n[dconschat reset target(addr=0x%jx)...]\r\n",
168 (intmax_t)dc->reset);
169 write(p->outfd, buf, strlen(buf));
170 bzero(&buf[0], PAGE_SIZE);
171 dwrite(dc, (void *)buf, PAGE_SIZE, dc->reset);
176 dconschat_suspend(struct dcons_state *dc, struct dcons_port *p)
182 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
184 printf("\n[dconschat suspend]\n");
185 kill(getpid(), SIGTSTP);
188 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
192 dconschat_sigchld(int s)
195 struct dcons_port *p;
198 p = &sc.port[DCONS_CON];
200 snprintf(buf, 256, "\r\n[child exit]\r\n");
201 write(p->outfd, buf, strlen(buf));
204 tcsetattr(STDIN_FILENO, TCSADRAIN, &sc.traw);
206 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
207 kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero);
211 dconschat_fork_gdb(struct dcons_state *dc, struct dcons_port *p)
214 char buf[256], com[256];
219 snprintf(buf, 256, "\r\n[%s: fork failed]\r\n", __FUNCTION__);
220 write(p->outfd, buf, strlen(buf));
227 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
229 snprintf(com, sizeof(buf), "kgdb -r :%d kernel",
230 dc->port[DCONS_GDB].sport);
231 snprintf(buf, 256, "\n[fork %s]\n", com);
232 write(p->outfd, buf, strlen(buf));
234 execl("/bin/sh", "/bin/sh", "-c", com, NULL);
236 snprintf(buf, 256, "\n[fork failed]\n");
237 write(p->outfd, buf, strlen(buf));
240 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
244 signal(SIGCHLD, dconschat_sigchld);
245 EV_SET(&kev, p->infd, EVFILT_READ, EV_DELETE, 0, 0, NULL);
246 kevent(sc.kq, &kev, 1, NULL, 0, &sc.zero);
252 dconschat_cleanup(int sig)
254 struct dcons_state *dc;
259 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
262 printf("\n[dconschat exiting with signal %d ...]\n", sig);
264 printf("\n[dconschat exiting...]\n");
271 dconschat_get_crom(struct dcons_state *dc)
275 u_int32_t buf, hi = 0, lo = 0, reset_hi = 0, reset_lo = 0;
278 reg = (struct csrreg *)&buf;
280 addr = (addr << 32) | 0xf0000400;
281 for (i = 20; i < 0x400; i += 4) {
282 if (dread(dc, &buf, 4, addr + i) < 0) {
284 warn("crom read faild");
289 printf("%d %02x %06x\n", state, reg->key, reg->val);
292 if (reg->key == CSRKEY_SPEC &&
293 reg->val == CSRVAL_VENDOR_PRIVATE)
297 if (reg->key == CSRKEY_VER &&
298 reg->val == DCONS_CSR_VAL_VER)
303 case DCONS_CSR_KEY_HI:
306 case DCONS_CSR_KEY_LO:
309 case DCONS_CSR_KEY_RESET_HI:
312 case DCONS_CSR_KEY_RESET_LO:
326 printf("addr: %06x %06x\n", hi, lo);
327 dc->paddr = ((off_t)hi << 24) | lo;
328 dc->reset = ((off_t)reset_hi << 24) | reset_lo;
336 dconschat_ready(struct dcons_state *dc, int ready, char *reason)
338 static char oldreason[64] = "";
341 old = (dc->flags & F_READY) ? 1 : 0;
344 dc->flags |= F_READY;
346 printf("[dcons connected]\r\n");
349 dc->flags &= ~F_READY;
350 if (strncmp(oldreason, reason, sizeof(oldreason)) != 0) {
351 printf("[dcons disconnected (%s)]\r\n", reason);
352 strlcpy(oldreason, reason, sizeof(oldreason));
358 dconschat_fetch_header(struct dcons_state *dc)
361 struct dcons_buf dbuf;
365 if (dc->paddr == 0 && (dc->flags & F_USE_CROM) != 0) {
366 if (dconschat_get_crom(dc)) {
367 dconschat_ready(dc, 0, "get crom failed");
373 if (dread(dc, &dbuf, DCONS_HEADER_SIZE, dc->paddr) < 0) {
374 dconschat_ready(dc, 0, "read header failed");
377 if (dbuf.magic != htonl(DCONS_MAGIC)) {
378 if ((dc->flags & F_USE_CROM) !=0)
380 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", dbuf.magic);
381 dconschat_ready(dc, 0, ebuf);
384 if (ntohl(dbuf.version) != DCONS_VERSION) {
385 snprintf(ebuf, sizeof(ebuf),
386 #if __FreeBSD_version < 500000
387 "wrong version %ld,%d",
389 "wrong version %d,%d",
391 ntohl(dbuf.version), DCONS_VERSION);
393 dconschat_ready(dc, 0, ebuf);
397 for (j = 0; j < DCONS_NPORT; j++) {
398 struct dcons_ch *o, *i;
403 newbuf = dc->paddr + ntohl(dbuf.ooffset[j]);
404 o->size = ntohl(dbuf.osize[j]);
406 if (newbuf != o->buf) {
407 /* buffer address has changes */
409 o->gen = ntohl(dbuf.optr[j]) >> DCONS_GEN_SHIFT;
410 o->pos = ntohl(dbuf.optr[j]) & DCONS_POS_MASK;
415 i->size = ntohl(dbuf.isize[j]);
416 i->gen = ntohl(dbuf.iptr[j]) >> DCONS_GEN_SHIFT;
417 i->pos = ntohl(dbuf.iptr[j]) & DCONS_POS_MASK;
418 i->buf = dc->paddr + ntohl(dbuf.ioffset[j]);
421 printf("port %d size offset gen pos\n", j);
422 #if __FreeBSD_version < 500000
423 printf("output: %5d %6ld %5d %5d\n"
424 "input : %5d %6ld %5d %5d\n",
426 printf("output: %5d %6d %5d %5d\n"
427 "input : %5d %6d %5d %5d\n",
429 o->size, ntohl(dbuf.ooffset[j]), o->gen, o->pos,
430 i->size, ntohl(dbuf.ioffset[j]), i->gen, i->pos);
433 if (IS_CONSOLE(&dc->port[j]) && new &&
434 (dc->flags & F_REPLAY) !=0) {
441 dconschat_ready(dc, 1, NULL);
446 dconschat_get_ptr (struct dcons_state *dc) {
448 u_int32_t ptr[DCONS_NPORT*2+1];
449 static int retry = RETRY;
453 dlen = dread(dc, &ptr, sizeof(ptr),
454 dc->paddr + __offsetof(struct dcons_buf, magic));
457 if (errno == ETIMEDOUT)
460 dconschat_ready(dc, 0, "get ptr failed");
463 if (ptr[0] != htonl(DCONS_MAGIC)) {
464 if ((dc->flags & F_USE_CROM) !=0)
466 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", ptr[0]);
467 dconschat_ready(dc, 0, ebuf);
471 for (i = 0; i < DCONS_NPORT; i ++) {
472 dc->port[i].optr = ntohl(ptr[i + 1]);
473 dc->port[i].iptr = ntohl(ptr[DCONS_NPORT + i + 1]);
478 #define MAX_XFER 2048
480 dconschat_read_dcons(struct dcons_state *dc, int port, char *buf, int len)
483 u_int32_t ptr, pos, gen, next_gen;
484 int rlen, dlen, lost;
487 ch = &dc->port[port].o;
488 ptr = dc->port[port].optr;
489 gen = ptr >> DCONS_GEN_SHIFT;
490 pos = ptr & DCONS_POS_MASK;
491 if (gen == ch->gen && pos == ch->pos)
494 next_gen = DCONS_NEXT_GEN(ch->gen);
495 /* XXX sanity check */
496 if (gen == ch->gen) {
499 lost = ch->size * DCONS_GEN_MASK - ch->pos;
501 } else if (gen == next_gen) {
504 lost = pos - ch->pos;
507 lost = gen - ch->gen;
509 lost += DCONS_GEN_MASK;
511 printf("[genskip %d]", lost);
512 lost = lost * ch->size - ch->pos;
516 /* generation skipped !! */
519 printf("[lost %d]", lost);
522 rlen = pos - ch->pos;
524 rlen = ch->size - ch->pos;
533 printf("[%d]", rlen); fflush(stdout);
537 dlen = dread(dc, buf, rlen, ch->buf + ch->pos);
539 if (errno == ETIMEDOUT)
542 dconschat_ready(dc, 0, "read buffer failed");
546 warnx("dlen(%d) != rlen(%d)\n", dlen, rlen);
548 if (ch->pos >= ch->size) {
552 printf("read_dcons: gen=%d", ch->gen);
558 dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen)
565 ch = &dc->port[port].i;
566 ptr = dc->port[port].iptr;
568 /* the others may advance the pointer sync with it */
569 ch->gen = ptr >> DCONS_GEN_SHIFT;
570 ch->pos = ptr & DCONS_POS_MASK;
573 wlen = MIN(blen, ch->size - ch->pos);
574 wlen = MIN(wlen, MAX_XFER);
575 len = dwrite(dc, buf, wlen, ch->buf + ch->pos);
577 if (errno == ETIMEDOUT)
579 continue; /* try again */
580 dconschat_ready(dc, 0, "write buffer failed");
586 if (ch->pos >= ch->size) {
587 ch->gen = DCONS_NEXT_GEN(ch->gen);
590 printf("write_dcons: gen=%d", ch->gen);
595 ptr = DCONS_MAKE_PTR(ch);
596 dc->port[port].iptr = ptr;
599 printf("(iptr: 0x%x)", ptr);
601 len = dwrite(dc, &ptr, sizeof(u_int32_t),
602 dc->paddr + __offsetof(struct dcons_buf, iptr[port]));
604 if (errno == ETIMEDOUT)
607 dconschat_ready(dc, 0, "write ptr failed");
615 dconschat_write_socket(int fd, char *buf, int len)
620 printf("<- %s\n", buf);
626 dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport)
628 struct addrinfo hints, *res;
632 struct dcons_port *p;
637 p->infd = p->outfd = -1;
644 /* Use stdin and stdout */
645 p->infd = STDIN_FILENO;
646 p->outfd = STDOUT_FILENO;
649 tcgetattr(STDIN_FILENO, &dc->tsave) == 0) {
650 dc->traw = dc->tsave;
651 cfmakeraw(&dc->traw);
652 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
655 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1,
657 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
661 memset(&hints, 0, sizeof(hints));
662 hints.ai_flags = AI_PASSIVE;
663 #if 1 /* gdb can talk v4 only */
664 hints.ai_family = PF_INET;
666 hints.ai_family = PF_UNSPEC;
668 hints.ai_socktype = SOCK_STREAM;
669 hints.ai_protocol = 0;
672 printf("%s:%d for port %d\n",
673 host == NULL ? "*" : host, sport, port);
674 snprintf(service, sizeof(service), "%d", sport);
675 error = getaddrinfo(host, service, &hints, &res);
677 errx(1, "tcp/%s: %s\n", service, gai_strerror(error));
679 p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
682 setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
684 if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) {
687 if (listen(p->s, 1) < 0)
689 EV_SET(&kev, p->s, EVFILT_READ, EV_ADD | EV_ONESHOT, 0, 0, (void *)p);
690 error = kevent(dc->kq, &kev, 1, NULL, 0, &dc->to);
697 dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p)
703 /* accept connection */
704 addrlen = p->res->ai_addrlen;
705 ns = accept(p->s, p->res->ai_addr, &addrlen);
709 printf("port%d accepted\n", p->port);
711 flags = fcntl(ns, F_GETFL, 0);
713 fcntl(ns, F_SETFL, flags);
715 if (IS_CONSOLE(p) && (dc->flags & F_TELNET) != 0) {
716 char sga[] = {IAC, WILL, TELOPT_SGA};
717 char linemode[] = {IAC, DONT, TELOPT_LINEMODE};
718 char echo[] = {IAC, WILL, TELOPT_ECHO};
719 char bin[] = {IAC, DO, TELOPT_BINARY};
721 write(ns, sga, sizeof(sga));
722 write(ns, linemode, sizeof(linemode));
723 write(ns, echo, sizeof(echo));
724 write(ns, bin, sizeof(bin));
728 /* discard backlog on GDB port */
733 while ((len = dconschat_read_dcons(dc, DCONS_GDB, &buf[0],
736 printf("discard %d chars on GDB port\n", len);
739 p->infd = p->outfd = ns;
740 EV_SET(&kev, ns, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1, (void *)p);
741 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
746 dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p,
747 u_char *sp, int slen, u_char *dp, int *dlen)
755 if ((dc->flags & F_TELNET) != 0) {
756 /* XXX Telnet workarounds */
757 if (p->skip_read -- > 0) {
772 printf("(0 stripped)");
778 switch (dc->escape_state) {
780 if (*sp == dc->escape) {
782 dc->escape_state = STATE2;
784 dc->escape_state = STATE0;
787 dc->escape_state = STATE0;
790 dconschat_cleanup(0);
791 else if (*sp == CTRL('B')) {
792 bcopy(abreak, dp, 3);
796 else if (*sp == CTRL('G'))
797 dconschat_fork_gdb(dc, p);
798 else if ((*sp == CTRL('R'))
799 && (dc->reset != 0)) {
800 dc->escape_state = STATE3;
801 buf = "\r\n[Are you sure to reset target? (y/N)]";
802 write(p->outfd, buf, strlen(buf));
803 } else if (*sp == CTRL('Z'))
804 dconschat_suspend(dc, p);
812 dc->escape_state = STATE0;
815 dconschat_reset_target(dc, p);
817 write(p->outfd, sp, 1);
818 write(p->outfd, "\r\n", 2);
823 dc->escape_state = STATE1;
824 } else if (IS_GDB(p)) {
825 /* GDB: ^C -> CR+~+^B */
826 if (*sp == CTRL('C') && (dc->flags & F_ALT_BREAK) != 0) {
827 bcopy(abreak, dp, 3);
831 /* discard rest of the packet */
848 dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p)
852 char rbuf[MAX_XFER], wbuf[MAX_XFER+2];
854 if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) {
856 dconschat_read_filter(dc, p, rbuf, len, wbuf, &wlen);
857 /* XXX discard if not ready*/
858 if (wlen > 0 && (dc->flags & F_READY) != 0) {
859 dconschat_write_dcons(dc, p->port, wbuf, wlen);
862 printf("-> %s\n", wbuf);
863 } else if (verbose == 1) {
864 printf("(%d)", wlen);
871 warnx("port%d: closed", p->port);
873 warn("port%d: read", p->port);
875 EV_SET(&kev, p->infd, EVFILT_READ,
876 EV_DELETE, 0, 0, NULL);
877 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
880 /* XXX exit for pipe case XXX */
881 EV_SET(&kev, p->s, EVFILT_READ,
882 EV_ADD | EV_ONESHOT, 0, 0, (void *) p);
883 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
884 p->infd = p->outfd = -1;
890 dconschat_proc_socket(struct dcons_state *dc)
892 struct kevent elist[NEVENT], *e;
894 struct dcons_port *p;
896 n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to);
897 for (i = 0; i < n; i ++) {
899 p = (struct dcons_port *)e->udata;
900 if (e->ident == p->s) {
901 dconschat_accept_socket(dc, p);
903 dconschat_read_socket(dc, p);
910 dconschat_proc_dcons(struct dcons_state *dc)
914 struct dcons_port *p;
916 err = dconschat_get_ptr(dc);
918 /* XXX we should stop write operation too. */
921 for (port = 0; port < DCONS_NPORT; port ++) {
925 while ((len = dconschat_read_dcons(dc, port, buf,
927 dconschat_write_socket(p->outfd, buf, len);
928 if ((err = dconschat_get_ptr(dc)))
931 if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0)
932 dconschat_cleanup(0);
938 dconschat_start_session(struct dcons_state *dc)
942 int retry_unit_init = MAX(1, poll_hz / 10);
943 int retry_unit_offline = poll_hz * DCONS_POLL_OFFLINE;
944 int retry_unit = retry_unit_init;
945 int retry_max = retry_unit_offline / retry_unit;
948 if (((dc->flags & F_READY) == 0) && ++counter > retry_unit) {
951 if (retry > retry_max)
952 retry_unit = retry_unit_offline;
954 printf("%d/%d ", retry, retry_max);
957 dconschat_fetch_header(dc);
959 if ((dc->flags & F_READY) != 0) {
962 retry_unit = retry_unit_init;
963 dconschat_proc_dcons(dc);
965 dconschat_proc_socket(dc);
974 "usage: dconschat [-brvwRT1] [-h hz] [-C port] [-G port]\n"
975 "\t\t\t[-M core] [-N system]\n"
976 "\t\t\t[-u unit] [-a address] [-t target_eui64]\n"
977 "\t-b translate ctrl-C to CR+~+ctrl-B on gdb port\n"
979 "\t-w listen on wildcard address rather than localhost\n"
980 "\t-r replay old buffer on connection\n"
982 "\t-T enable Telnet protocol workaround on console port\n"
983 "\t-1 one shot: read buffer and exit\n"
984 "\t-h polling rate\n"
985 "\t-C port number for console port\n"
986 "\t-G port number for gdb port\n"
991 "\t-u specify unit number of the bus\n"
992 "\t-t EUI64 of target host (must be specified)\n"
993 "\t-a physical address of dcons buffer on target host\n"
998 main(int argc, char **argv)
1000 struct dcons_state *dc;
1001 struct fw_eui64 eui;
1002 struct eui64 target;
1003 char devname[256], *core = NULL, *system = NULL;
1005 int unit=0, wildcard=0;
1006 int port[DCONS_NPORT];
1008 bzero(&sc, sizeof(sc));
1010 dc->flags |= USE_CROM ? F_USE_CROM : 0;
1013 port[0] = 0; /* stdin/out for console */
1014 port[1] = -1; /* disable gdb port */
1016 /* default escape char */
1017 dc->escape = KEY_TILDE;
1019 while ((ch = getopt(argc, argv, "a:be:h:rt:u:vwC:G:M:N:RT1")) != -1) {
1022 dc->paddr = strtoull(optarg, NULL, 0);
1023 dc->flags &= ~F_USE_CROM;
1026 dc->flags |= F_ALT_BREAK;
1029 dc->escape = optarg[0];
1032 poll_hz = strtoul(optarg, NULL, 0);
1034 poll_hz = DCONS_POLL_HZ;
1037 dc->flags |= F_REPLAY;
1040 if (eui64_hostton(optarg, &target) != 0 &&
1041 eui64_aton(optarg, &target) != 0)
1042 errx(1, "invalid target: %s", optarg);
1043 eui.hi = ntohl(*(u_int32_t*)&(target.octet[0]));
1044 eui.lo = ntohl(*(u_int32_t*)&(target.octet[4]));
1048 unit = strtol(optarg, NULL, 0);
1057 port[0] = strtol(optarg, NULL, 0);
1060 port[1] = strtol(optarg, NULL, 0);
1069 dc->flags |= F_RD_ONLY;
1072 dc->flags |= F_TELNET;
1075 dc->flags |= F_ONE_SHOT | F_REPLAY;
1081 if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) {
1082 warnx("no address specified");
1086 if (port[0] < 0 && port[1] < 0) {
1087 warnx("no port specified");
1091 /* set signal handler */
1092 signal(SIGHUP, dconschat_cleanup);
1093 signal(SIGINT, dconschat_cleanup);
1094 signal(SIGPIPE, dconschat_cleanup);
1095 signal(SIGTERM, dconschat_cleanup);
1101 for (i = 0; i < MAXDEV; i ++) {
1102 snprintf(devname, sizeof(devname),
1103 "/dev/fwmem%d.%d", unit, i);
1104 dc->fd = open(devname, O_RDWR);
1110 error = ioctl(dc->fd, FW_SDEUI64, &eui);
1116 struct nlist nl[] = {{"dcons_buf"}, {""}};
1119 dc->kd = kvm_open(system, core, NULL,
1120 (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat");
1122 errx(1, "kvm_open");
1124 if (kvm_nlist(dc->kd, nl) < 0)
1125 errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd));
1127 if (kvm_read(dc->kd, nl[0].n_value, &dcons_buf,
1128 sizeof(void *)) < 0)
1129 errx(1, "kvm_read: %s", kvm_geterr(dc->kd));
1130 dc->paddr = (uintptr_t)dcons_buf;
1132 printf("dcons_buf: 0x%x\n", (uint)dc->paddr);
1136 dconschat_fetch_header(dc);
1145 dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz;
1147 dc->zero.tv_sec = 0;
1148 dc->zero.tv_nsec = 0;
1149 for (i = 0; i < DCONS_NPORT; i++)
1150 dconschat_init_socket(dc, i,
1151 wildcard ? NULL : "localhost", port[i]);
1153 dconschat_start_session(dc);
1155 for (i = 0; i < DCONS_NPORT; i++) {
1156 freeaddrinfo(dc->port[i].res);