usr.sbin/dconschat/dconschat.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-4-Clause
   3  *
   4  * Copyright (C) 2003
   5  *      Hidetoshi Shimokawa. All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  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:
  17  *
  18  *      This product includes software developed by Hidetoshi Shimokawa.
  19  *
  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.
  23  *
  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
  34  * SUCH DAMAGE.
  35  *
  36  * $Id: dconschat.c,v 1.76 2003/10/23 06:21:13 simokawa Exp $
  37  * $FreeBSD$
  38  */
  39
  40 #include <sys/param.h>
  41 #include <sys/types.h>
  42 #include <sys/uio.h>
  43 #include <sys/wait.h>
  44 #include <unistd.h>
  45 #include <fcntl.h>
  46 #include <signal.h>
  47 #include <stdint.h>
  48 #include <stdio.h>
  49 #include <stdlib.h>
  50 #include <termios.h>
  51 #include <dev/dcons/dcons.h>
  52
  53 #include <sys/socket.h>
  54 #include <netinet/in.h>
  55 #include <netdb.h>
  56 #include <err.h>
  57 #include <string.h>
  58 #include <sys/eui64.h>
  59 #include <sys/event.h>
  60 #include <sys/time.h>
  61 #include <arpa/telnet.h>
  62
  63 #include <sys/ioccom.h>
  64 #include <dev/firewire/firewire.h>
  65 #include <dev/firewire/iec13213.h>
  66
  67 #include <kvm.h>
  68 #include <nlist.h>
  69
  70 #include <sys/errno.h>
  71
  72 #define DCONS_POLL_HZ           100
  73 #define DCONS_POLL_OFFLINE      2       /* sec */
  74
  75 #define RETRY 3
  76
  77 #ifdef CSRVAL_VENDOR_PRIVATE
  78 #define USE_CROM 1
  79 #else
  80 #define USE_CROM 0
  81 #endif
  82
  83 int verbose = 0;
  84 int tc_set = 0;
  85 int poll_hz = DCONS_POLL_HZ;
  86 static u_char abreak[3] = {13 /* CR */, 126 /* ~ */, 2 /* ^B */};
  87
  88 #define IS_CONSOLE(p)   ((p)->port == DCONS_CON)
  89 #define IS_GDB(p)       ((p)->port == DCONS_GDB)
  90
  91 static struct dcons_state {
  92         int fd;
  93         kvm_t *kd;
  94         int kq;
  95         off_t paddr;
  96         off_t reset;
  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)
 104         int flags;
 105         enum {
 106                 TYPE_KVM,
 107                 TYPE_FW
 108         } type;
 109         int escape_state;
 110         struct dcons_port {
 111                 int port;
 112                 int sport;
 113                 struct dcons_ch o;
 114                 struct dcons_ch i;
 115                 u_int32_t optr;
 116                 u_int32_t iptr;
 117                 int s;
 118                 int infd;
 119                 int outfd;
 120                 struct addrinfo *res;
 121                 int skip_read;
 122         } port[DCONS_NPORT];
 123         struct timespec to;
 124         struct timespec zero;
 125         struct termios tsave;
 126         struct termios traw;
 127         char escape;
 128 } sc;
 129
 130 static int dconschat_write_dcons(struct dcons_state *, int, char *, int);
 131
 132 static int
 133 dread(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 134 {
 135         switch (dc->type) {
 136         case TYPE_FW:
 137                 return (pread(dc->fd, buf, n, offset));
 138         case TYPE_KVM:
 139                 return (kvm_read(dc->kd, offset, buf, n));
 140         }
 141         return (-1);
 142 }
 143
 144 static int
 145 dwrite(struct dcons_state *dc, void *buf, size_t n, off_t offset)
 146 {
 147         if ((dc->flags & F_RD_ONLY) != 0)
 148                 return (n);
 149
 150         switch (dc->type) {
 151         case TYPE_FW:
 152                 return (pwrite(dc->fd, buf, n, offset));
 153         case TYPE_KVM:
 154                 return (kvm_write(dc->kd, offset, buf, n));
 155         }
 156         return (-1);
 157 }
 158
 159 static void
 160 dconschat_reset_target(struct dcons_state *dc, struct dcons_port *p)
 161 {
 162         char buf[PAGE_SIZE];
 163         if (dc->reset == 0)
 164                 return;
 165
 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);
 172 }
 173
 174
 175 static void
 176 dconschat_suspend(struct dcons_state *dc, struct dcons_port *p)
 177 {
 178         if (p->sport != 0)
 179                 return;
 180
 181         if (tc_set)
 182                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 183
 184         printf("\n[dconschat suspend]\n");
 185         kill(getpid(), SIGTSTP);
 186
 187         if (tc_set)
 188                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 189 }
 190
 191 static void
 192 dconschat_sigchld(int s)
 193 {
 194         struct kevent kev;
 195         struct dcons_port *p;
 196         char buf[256];
 197
 198         p = &sc.port[DCONS_CON];
 199
 200         snprintf(buf, 256, "\r\n[child exit]\r\n");
 201         write(p->outfd, buf, strlen(buf));
 202
 203         if (tc_set)
 204                 tcsetattr(STDIN_FILENO, TCSADRAIN, &sc.traw);
 205
 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);
 208 }
 209
 210 static void
 211 dconschat_fork_gdb(struct dcons_state *dc, struct dcons_port *p)
 212 {
 213         pid_t pid;
 214         char buf[256], com[256];
 215         struct kevent kev;
 216
 217         pid = fork();
 218         if (pid < 0) {
 219                 snprintf(buf, 256, "\r\n[%s: fork failed]\r\n", __FUNCTION__);
 220                 write(p->outfd, buf, strlen(buf));
 221         }
 222
 223
 224         if (pid == 0) {
 225                 /* child */
 226                 if (tc_set)
 227                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 228
 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));
 233
 234                 execl("/bin/sh", "/bin/sh", "-c", com, NULL);
 235
 236                 snprintf(buf, 256, "\n[fork failed]\n");
 237                 write(p->outfd, buf, strlen(buf));
 238
 239                 if (tc_set)
 240                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 241
 242                 exit(0);
 243         } else {
 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);
 247         }
 248 }
 249
 250
 251 static void
 252 dconschat_cleanup(int sig)
 253 {
 254         struct dcons_state *dc;
 255         int status;
 256
 257         dc = &sc;
 258         if (tc_set != 0)
 259                 tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->tsave);
 260
 261         if (sig > 0)
 262                 printf("\n[dconschat exiting with signal %d ...]\n", sig);
 263         else
 264                 printf("\n[dconschat exiting...]\n");
 265         wait(&status);
 266         exit(0);
 267 }
 268
 269 #if USE_CROM
 270 static int
 271 dconschat_get_crom(struct dcons_state *dc)
 272 {
 273         off_t addr;
 274         int i, state = 0;
 275         u_int32_t buf, hi = 0, lo = 0, reset_hi = 0, reset_lo = 0;
 276         struct csrreg *reg;
 277
 278         reg = (struct csrreg *)&buf;
 279         addr = 0xffff;
 280         addr = (addr << 32) | 0xf0000400;
 281         for (i = 20; i < 0x400; i += 4) {
 282                 if (dread(dc, &buf, 4, addr + i) < 0) {
 283                         if (verbose)
 284                                 warn("crom read faild");
 285                         goto out;
 286                 }
 287                 buf = ntohl(buf);
 288                 if (verbose)
 289                         printf("%d %02x %06x\n", state, reg->key, reg->val);
 290                 switch (state) {
 291                 case 0:
 292                         if (reg->key == CSRKEY_SPEC &&
 293                                         reg->val == CSRVAL_VENDOR_PRIVATE)
 294                                 state = 1;
 295                         break;
 296                 case 1:
 297                         if (reg->key == CSRKEY_VER &&
 298                                         reg->val == DCONS_CSR_VAL_VER)
 299                                 state = 2;
 300                         break;
 301                 case 2:
 302                         switch (reg->key) {
 303                         case DCONS_CSR_KEY_HI:
 304                                 hi = reg->val;
 305                                 break;
 306                         case DCONS_CSR_KEY_LO:
 307                                 lo = reg->val;
 308                                 break;
 309                         case DCONS_CSR_KEY_RESET_HI:
 310                                 reset_hi = reg->val;
 311                                 break;
 312                         case DCONS_CSR_KEY_RESET_LO:
 313                                 reset_lo = reg->val;
 314                                 goto out;
 315                                 break;
 316                         case 0x81:
 317                                 break;
 318                         default:
 319                                 state = 0;
 320                         }
 321                         break;
 322                 }
 323         }
 324 out:
 325         if (verbose)
 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;
 329         if (dc->paddr == 0)
 330                 return (-1);
 331         return (0);
 332 }
 333 #endif
 334
 335 static void
 336 dconschat_ready(struct dcons_state *dc, int ready, char *reason)
 337 {
 338         static char oldreason[64] = "";
 339         int old;
 340
 341         old = (dc->flags & F_READY) ? 1 : 0;
 342
 343         if (ready) {
 344                 dc->flags |= F_READY;
 345                 if (ready != old)
 346                         printf("[dcons connected]\r\n");
 347                 oldreason[0] = 0;
 348         } else {
 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));
 353                 }
 354         }
 355 }
 356
 357 static int
 358 dconschat_fetch_header(struct dcons_state *dc)
 359 {
 360         char ebuf[64];
 361         struct dcons_buf dbuf;
 362         int j;
 363
 364 #if USE_CROM
 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");
 368                         return (-1);
 369                 }
 370         }
 371 #endif
 372
 373         if (dread(dc, &dbuf, DCONS_HEADER_SIZE, dc->paddr) < 0) {
 374                 dconschat_ready(dc, 0, "read header failed");
 375                 return (-1);
 376         }
 377         if (dbuf.magic != htonl(DCONS_MAGIC)) {
 378                 if ((dc->flags & F_USE_CROM) !=0)
 379                         dc->paddr = 0;
 380                 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", dbuf.magic);
 381                 dconschat_ready(dc, 0, ebuf);
 382                 return (-1);
 383         }
 384         if (ntohl(dbuf.version) != DCONS_VERSION) {
 385                 snprintf(ebuf, sizeof(ebuf),
 386 #if __FreeBSD_version < 500000
 387                     "wrong version %ld,%d",
 388 #else
 389                     "wrong version %d,%d",
 390 #endif
 391                     ntohl(dbuf.version), DCONS_VERSION);
 392                 /* XXX exit? */
 393                 dconschat_ready(dc, 0, ebuf);
 394                 return (-1);
 395         }
 396
 397         for (j = 0; j < DCONS_NPORT; j++) {
 398                 struct dcons_ch *o, *i;
 399                 off_t newbuf;
 400                 int new = 0;
 401
 402                 o = &dc->port[j].o;
 403                 newbuf = dc->paddr + ntohl(dbuf.ooffset[j]);
 404                 o->size = ntohl(dbuf.osize[j]);
 405
 406                 if (newbuf != o->buf) {
 407                         /* buffer address has changes */
 408                         new = 1;
 409                         o->gen = ntohl(dbuf.optr[j]) >> DCONS_GEN_SHIFT;
 410                         o->pos = ntohl(dbuf.optr[j]) & DCONS_POS_MASK;
 411                         o->buf = newbuf;
 412                 }
 413
 414                 i = &dc->port[j].i;
 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]);
 419
 420                 if (verbose) {
 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",
 425 #else
 426                         printf("output: %5d %6d %5d %5d\n"
 427                                 "input : %5d %6d %5d %5d\n",
 428 #endif
 429                         o->size, ntohl(dbuf.ooffset[j]), o->gen, o->pos,
 430                         i->size, ntohl(dbuf.ioffset[j]), i->gen, i->pos);
 431                 }
 432
 433                 if (IS_CONSOLE(&dc->port[j]) && new &&
 434                     (dc->flags & F_REPLAY) !=0) {
 435                         if (o->gen > 0)
 436                                 o->gen --;
 437                         else
 438                                 o->pos = 0;
 439                 }
 440         }
 441         dconschat_ready(dc, 1, NULL);
 442         return(0);
 443 }
 444
 445 static int
 446 dconschat_get_ptr (struct dcons_state *dc) {
 447         int dlen, i;
 448         u_int32_t ptr[DCONS_NPORT*2+1];
 449         static int retry = RETRY;
 450         char ebuf[64];
 451
 452 again:
 453         dlen = dread(dc, &ptr, sizeof(ptr),
 454                 dc->paddr + __offsetof(struct dcons_buf, magic));
 455
 456         if (dlen < 0) {
 457                 if (errno == ETIMEDOUT)
 458                         if (retry -- > 0)
 459                                 goto again;
 460                 dconschat_ready(dc, 0, "get ptr failed");
 461                 return(-1);
 462         }
 463         if (ptr[0] != htonl(DCONS_MAGIC)) {
 464                 if ((dc->flags & F_USE_CROM) !=0)
 465                         dc->paddr = 0;
 466                 snprintf(ebuf, sizeof(ebuf), "wrong magic 0x%08x", ptr[0]);
 467                 dconschat_ready(dc, 0, ebuf);
 468                 return(-1);
 469         }
 470         retry = RETRY;
 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]);
 474         }
 475         return(0);
 476 }
 477
 478 #define MAX_XFER 2048
 479 static int
 480 dconschat_read_dcons(struct dcons_state *dc, int port, char *buf, int len)
 481 {
 482         struct dcons_ch *ch;
 483         u_int32_t ptr, pos, gen, next_gen;
 484         int rlen, dlen, lost;
 485         int retry = RETRY;
 486
 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)
 492                 return (-1);
 493
 494         next_gen = DCONS_NEXT_GEN(ch->gen);
 495         /* XXX sanity check */
 496         if (gen == ch->gen) {
 497                 if (pos > ch->pos)
 498                         goto ok;
 499                 lost = ch->size * DCONS_GEN_MASK - ch->pos;
 500                 ch->pos = 0;
 501         } else if (gen == next_gen) {
 502                 if (pos <= ch->pos)
 503                         goto ok;
 504                 lost = pos - ch->pos;
 505                 ch->pos = pos;
 506         } else {
 507                 lost = gen - ch->gen;
 508                 if (lost < 0)
 509                         lost += DCONS_GEN_MASK;
 510                 if (verbose)
 511                         printf("[genskip %d]", lost);
 512                 lost = lost * ch->size - ch->pos;
 513                 ch->pos = 0;
 514                 ch->gen = gen;
 515         }
 516         /* generation skipped !! */
 517         /* XXX discard */
 518         if (verbose)
 519                 printf("[lost %d]", lost);
 520 ok:
 521         if (gen == ch->gen)
 522                 rlen = pos - ch->pos;
 523         else
 524                 rlen = ch->size - ch->pos;
 525
 526         if (rlen > MAX_XFER)
 527                 rlen = MAX_XFER;
 528         if (rlen > len)
 529                 rlen = len;
 530
 531 #if 1
 532         if (verbose == 1)
 533                 printf("[%d]", rlen); fflush(stdout);
 534 #endif
 535
 536 again:
 537         dlen = dread(dc, buf, rlen, ch->buf + ch->pos);
 538         if (dlen < 0) {
 539                 if (errno == ETIMEDOUT)
 540                         if (retry -- > 0)
 541                                 goto again;
 542                 dconschat_ready(dc, 0, "read buffer failed");
 543                 return(-1);
 544         }
 545         if (dlen != rlen)
 546                 warnx("dlen(%d) != rlen(%d)\n", dlen, rlen);
 547         ch->pos += dlen;
 548         if (ch->pos >= ch->size) {
 549                 ch->gen = next_gen;
 550                 ch->pos = 0;
 551                 if (verbose)
 552                         printf("read_dcons: gen=%d", ch->gen);
 553         }
 554         return (dlen);
 555 }
 556
 557 static int
 558 dconschat_write_dcons(struct dcons_state *dc, int port, char *buf, int blen)
 559 {
 560         struct dcons_ch *ch;
 561         u_int32_t ptr;
 562         int len, wlen;
 563         int retry = RETRY;
 564
 565         ch = &dc->port[port].i;
 566         ptr = dc->port[port].iptr;
 567
 568         /* the others may advance the pointer sync with it */
 569         ch->gen = ptr >> DCONS_GEN_SHIFT;
 570         ch->pos = ptr & DCONS_POS_MASK;
 571
 572         while(blen > 0) {
 573                 wlen = MIN(blen, ch->size - ch->pos);
 574                 wlen = MIN(wlen, MAX_XFER);
 575                 len = dwrite(dc, buf, wlen, ch->buf + ch->pos);
 576                 if (len < 0) {
 577                         if (errno == ETIMEDOUT)
 578                                 if (retry -- > 0)
 579                                         continue; /* try again */
 580                         dconschat_ready(dc, 0, "write buffer failed");
 581                         return(-1);
 582                 }
 583                 ch->pos += len;
 584                 buf += len;
 585                 blen -= len;
 586                 if (ch->pos >= ch->size) {
 587                         ch->gen = DCONS_NEXT_GEN(ch->gen);
 588                         ch->pos = 0;
 589                         if (verbose)
 590                                 printf("write_dcons: gen=%d", ch->gen);
 591
 592                 }
 593         }
 594
 595         ptr = DCONS_MAKE_PTR(ch);
 596         dc->port[port].iptr = ptr;
 597
 598         if (verbose > 2)
 599                 printf("(iptr: 0x%x)", ptr);
 600 again:
 601         len = dwrite(dc, &ptr, sizeof(u_int32_t),
 602                 dc->paddr + __offsetof(struct dcons_buf, iptr[port]));
 603         if (len < 0) {
 604                 if (errno == ETIMEDOUT)
 605                         if (retry -- > 0)
 606                                 goto again;
 607                 dconschat_ready(dc, 0, "write ptr failed");
 608                 return(-1);
 609         }
 610         return(0);
 611 }
 612
 613
 614 static int
 615 dconschat_write_socket(int fd, char *buf, int len)
 616 {
 617         write(fd, buf, len);
 618         if (verbose > 1) {
 619                 buf[len] = 0;
 620                 printf("<- %s\n", buf);
 621         }
 622         return (0);
 623 }
 624
 625 static void
 626 dconschat_init_socket(struct dcons_state *dc, int port, char *host, int sport)
 627 {
 628         struct addrinfo hints, *res;
 629         int on = 1, error;
 630         char service[10];
 631         struct kevent kev;
 632         struct dcons_port *p;
 633
 634         p = &dc->port[port];
 635         p->port = port;
 636         p->sport = sport;
 637         p->infd = p->outfd = -1;
 638
 639         if (sport < 0)
 640                 return;
 641
 642         if (sport == 0) {
 643
 644                 /* Use stdin and stdout */
 645                 p->infd = STDIN_FILENO;
 646                 p->outfd = STDOUT_FILENO;
 647                 p->s = -1;
 648                 if (tc_set == 0 &&
 649                     tcgetattr(STDIN_FILENO, &dc->tsave) == 0) {
 650                         dc->traw = dc->tsave;
 651                         cfmakeraw(&dc->traw);
 652                         tcsetattr(STDIN_FILENO, TCSADRAIN, &dc->traw);
 653                         tc_set = 1;
 654                 }
 655                 EV_SET(&kev, p->infd, EVFILT_READ, EV_ADD, NOTE_LOWAT, 1,
 656                     (void *)p);
 657                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 658                 return;
 659         }
 660
 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;
 665 #else
 666         hints.ai_family = PF_UNSPEC;
 667 #endif
 668         hints.ai_socktype = SOCK_STREAM;
 669         hints.ai_protocol = 0;
 670
 671         if (verbose)
 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);
 676         if (error)
 677                 errx(1, "tcp/%s: %s\n", service, gai_strerror(error));
 678         p->res = res;
 679         p->s = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 680         if (p->s < 0)
 681                 err(1, "socket");
 682         setsockopt(p->s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
 683
 684         if (bind(p->s, p->res->ai_addr, p->res->ai_addrlen) < 0) {
 685                 err(1, "bind");
 686         }
 687         if (listen(p->s, 1) < 0)
 688                 err(1, "listen");
 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);
 691         if (error < 0)
 692                 err(1, "kevent");
 693         return;
 694 }
 695
 696 static int
 697 dconschat_accept_socket(struct dcons_state *dc, struct dcons_port *p)
 698 {
 699         socklen_t addrlen;
 700         int ns, flags;
 701         struct kevent kev;
 702
 703         /* accept connection */
 704         addrlen = p->res->ai_addrlen;
 705         ns = accept(p->s, p->res->ai_addr, &addrlen);
 706         if (ns < 0)
 707                 err(1, "accept");
 708         if (verbose)
 709                 printf("port%d accepted\n", p->port);
 710
 711         flags = fcntl(ns, F_GETFL, 0);
 712         flags |= O_NDELAY;
 713         fcntl(ns, F_SETFL, flags);
 714 #if 1
 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};
 720
 721                 write(ns, sga, sizeof(sga));
 722                 write(ns, linemode, sizeof(linemode));
 723                 write(ns, echo, sizeof(echo));
 724                 write(ns, bin, sizeof(bin));
 725                 p->skip_read = 0;
 726         }
 727 #endif
 728         /* discard backlog on GDB port */
 729         if (IS_GDB(p)) {
 730                 char buf[2048];
 731                 int len;
 732
 733                 while ((len = dconschat_read_dcons(dc, DCONS_GDB, &buf[0],
 734                                  2048)) > 0)
 735                         if (verbose)
 736                                 printf("discard %d chars on GDB port\n", len);
 737         }
 738
 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);
 742         return(0);
 743 }
 744
 745 static int
 746 dconschat_read_filter(struct dcons_state *dc, struct dcons_port *p,
 747     u_char *sp, int slen, u_char *dp, int *dlen)
 748 {
 749         int skip;
 750         char *buf;
 751
 752         while (slen > 0) {
 753                 skip = 0;
 754                 if (IS_CONSOLE(p)) {
 755                         if ((dc->flags & F_TELNET) != 0) {
 756                                 /* XXX Telnet workarounds */
 757                                 if (p->skip_read -- > 0) {
 758                                         sp ++;
 759                                         slen --;
 760                                         continue;
 761                                 }
 762                                 if (*sp == IAC) {
 763                                         if (verbose)
 764                                                 printf("(IAC)");
 765                                         p->skip_read = 2;
 766                                         sp ++;
 767                                         slen --;
 768                                         continue;
 769                                 }
 770                                 if (*sp == 0) {
 771                                         if (verbose)
 772                                                 printf("(0 stripped)");
 773                                         sp ++;
 774                                         slen --;
 775                                         continue;
 776                                 }
 777                         }
 778                         switch (dc->escape_state) {
 779                         case STATE1:
 780                                 if (*sp == dc->escape) {
 781                                         skip = 1;
 782                                         dc->escape_state = STATE2;
 783                                 } else
 784                                         dc->escape_state = STATE0;
 785                                 break;
 786                         case STATE2:
 787                                 dc->escape_state = STATE0;
 788                                 skip = 1;
 789                                 if (*sp == '.')
 790                                         dconschat_cleanup(0);
 791                                 else if (*sp == CTRL('B')) {
 792                                         bcopy(abreak, dp, 3);
 793                                         dp += 3;
 794                                         *dlen += 3;
 795                                 }
 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);
 805                                 else {
 806                                         skip = 0;
 807                                         *dp++ = dc->escape;
 808                                         (*dlen) ++;
 809                                 }
 810                                 break;
 811                         case STATE3:
 812                                 dc->escape_state = STATE0;
 813                                 skip = 1;
 814                                 if (*sp == 'y')
 815                                         dconschat_reset_target(dc, p);
 816                                 else {
 817                                         write(p->outfd, sp, 1);
 818                                         write(p->outfd, "\r\n", 2);
 819                                 }
 820                                 break;
 821                         }
 822                         if (*sp == KEY_CR)
 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);
 828                                 dp += 3;
 829                                 sp ++;
 830                                 *dlen += 3;
 831                                 /* discard rest of the packet */
 832                                 slen = 0;
 833                                 break;
 834                         }
 835                 }
 836                 if (!skip) {
 837                         *dp++ = *sp;
 838                         (*dlen) ++;
 839                 }
 840                 sp ++;
 841                 slen --;
 842         }
 843         return (*dlen);
 844
 845 }
 846
 847 static int
 848 dconschat_read_socket(struct dcons_state *dc, struct dcons_port *p)
 849 {
 850         struct kevent kev;
 851         int len, wlen;
 852         char rbuf[MAX_XFER], wbuf[MAX_XFER+2];
 853
 854         if ((len = read(p->infd, rbuf, sizeof(rbuf))) > 0) {
 855                 wlen = 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);
 860                         if (verbose > 1) {
 861                                 wbuf[wlen] = 0;
 862                                 printf("-> %s\n", wbuf);
 863                         } else if (verbose == 1) {
 864                                 printf("(%d)", wlen);
 865                                 fflush(stdout);
 866                         }
 867                 }
 868         } else {
 869                 if (verbose) {
 870                         if (len == 0)
 871                                 warnx("port%d: closed", p->port);
 872                         else
 873                                 warn("port%d: read", p->port);
 874                 }
 875                 EV_SET(&kev, p->infd, EVFILT_READ,
 876                         EV_DELETE, 0, 0, NULL);
 877                 kevent(dc->kq, &kev, 1, NULL, 0, &dc->zero);
 878                 close(p->infd);
 879                 close(p->outfd);
 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;
 885         }
 886         return(0);
 887 }
 888 #define NEVENT 5
 889 static int
 890 dconschat_proc_socket(struct dcons_state *dc)
 891 {
 892         struct kevent elist[NEVENT], *e;
 893         int i, n;
 894         struct dcons_port *p;
 895
 896         n = kevent(dc->kq, NULL, 0, elist, NEVENT, &dc->to);
 897         for (i = 0; i < n; i ++) {
 898                 e = &elist[i];
 899                 p = (struct dcons_port *)e->udata;
 900                 if (e->ident == p->s) {
 901                         dconschat_accept_socket(dc, p);
 902                 } else {
 903                         dconschat_read_socket(dc, p);
 904                 }
 905         }
 906         return(0);
 907 }
 908
 909 static int
 910 dconschat_proc_dcons(struct dcons_state *dc)
 911 {
 912         int port, len, err;
 913         char buf[MAX_XFER];
 914         struct dcons_port *p;
 915
 916         err = dconschat_get_ptr(dc);
 917         if (err) {
 918                 /* XXX we should stop write operation too. */
 919                 return err;
 920         }
 921         for (port = 0; port < DCONS_NPORT; port ++) {
 922                 p = &dc->port[port];
 923                 if (p->infd < 0)
 924                         continue;
 925                 while ((len = dconschat_read_dcons(dc, port, buf,
 926                     sizeof(buf))) > 0) {
 927                         dconschat_write_socket(p->outfd, buf, len);
 928                         if ((err = dconschat_get_ptr(dc)))
 929                                 return (err);
 930                 }
 931                 if ((dc->flags & F_ONE_SHOT) != 0 && len <= 0)
 932                         dconschat_cleanup(0);
 933         }
 934         return 0;
 935 }
 936
 937 static int
 938 dconschat_start_session(struct dcons_state *dc)
 939 {
 940         int counter = 0;
 941         int retry = 0;
 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;
 946
 947         while (1) {
 948                 if (((dc->flags & F_READY) == 0) && ++counter > retry_unit) {
 949                         counter = 0;
 950                         retry ++;
 951                         if (retry > retry_max)
 952                                 retry_unit = retry_unit_offline;
 953                         if (verbose) {
 954                                 printf("%d/%d ", retry, retry_max);
 955                                 fflush(stdout);
 956                         }
 957                         dconschat_fetch_header(dc);
 958                 }
 959                 if ((dc->flags & F_READY) != 0) {
 960                         counter = 0;
 961                         retry = 0;
 962                         retry_unit = retry_unit_init;
 963                         dconschat_proc_dcons(dc);
 964                 }
 965                 dconschat_proc_socket(dc);
 966         }
 967         return (0);
 968 }
 969
 970 static void
 971 usage(void)
 972 {
 973         fprintf(stderr,
 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"
 978             "\t-v       verbose\n"
 979             "\t-w       listen on wildcard address rather than localhost\n"
 980             "\t-r       replay old buffer on connection\n"
 981             "\t-R       read-only\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"
 987             "\t(for KVM)\n"
 988             "\t-M       core file\n"
 989             "\t-N       system file\n"
 990             "\t(for FireWire)\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"
 994         );
 995         exit(0);
 996 }
 997 int
 998 main(int argc, char **argv)
 999 {
1000         struct dcons_state *dc;
1001         struct fw_eui64 eui;
1002         struct eui64 target;
1003         char devname[256], *core = NULL, *system = NULL;
1004         int i, ch, error;
1005         int unit=0, wildcard=0;
1006         int port[DCONS_NPORT];
1007
1008         bzero(&sc, sizeof(sc));
1009         dc = &sc;
1010         dc->flags |= USE_CROM ? F_USE_CROM : 0;
1011
1012         /* default ports */
1013         port[0] = 0;    /* stdin/out for console */
1014         port[1] = -1;   /* disable gdb port */
1015
1016         /* default escape char */
1017         dc->escape = KEY_TILDE;
1018
1019         while ((ch = getopt(argc, argv, "a:be:h:rt:u:vwC:G:M:N:RT1")) != -1) {
1020                 switch(ch) {
1021                 case 'a':
1022                         dc->paddr = strtoull(optarg, NULL, 0);
1023                         dc->flags &= ~F_USE_CROM;
1024                         break;
1025                 case 'b':
1026                         dc->flags |= F_ALT_BREAK;
1027                         break;
1028                 case 'e':
1029                         dc->escape = optarg[0];
1030                         break;
1031                 case 'h':
1032                         poll_hz = strtoul(optarg, NULL, 0);
1033                         if (poll_hz == 0)
1034                                 poll_hz = DCONS_POLL_HZ;
1035                         break;
1036                 case 'r':
1037                         dc->flags |= F_REPLAY;
1038                         break;
1039                 case 't':
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]));
1045                         dc->type = TYPE_FW;
1046                         break;
1047                 case 'u':
1048                         unit = strtol(optarg, NULL, 0);
1049                         break;
1050                 case 'v':
1051                         verbose ++;
1052                         break;
1053                 case 'w':
1054                         wildcard = 1;
1055                         break;
1056                 case 'C':
1057                         port[0] = strtol(optarg, NULL, 0);
1058                         break;
1059                 case 'G':
1060                         port[1] = strtol(optarg, NULL, 0);
1061                         break;
1062                 case 'M':
1063                         core = optarg;
1064                         break;
1065                 case 'N':
1066                         system = optarg;
1067                         break;
1068                 case 'R':
1069                         dc->flags |= F_RD_ONLY;
1070                         break;
1071                 case 'T':
1072                         dc->flags |= F_TELNET;
1073                         break;
1074                 case '1':
1075                         dc->flags |= F_ONE_SHOT | F_REPLAY;
1076                         break;
1077                 default:
1078                         usage();
1079                 }
1080         }
1081         if (dc->paddr == 0 && (dc->flags & F_USE_CROM) == 0) {
1082                 warnx("no address specified");
1083                 usage();
1084         }
1085
1086         if (port[0] < 0 && port[1] < 0) {
1087                 warnx("no port specified");
1088                 usage();
1089         }
1090
1091         /* set signal handler */
1092         signal(SIGHUP, dconschat_cleanup);
1093         signal(SIGINT, dconschat_cleanup);
1094         signal(SIGPIPE, dconschat_cleanup);
1095         signal(SIGTERM, dconschat_cleanup);
1096
1097         /* init firewire */
1098         switch (dc->type) {
1099         case TYPE_FW:
1100 #define MAXDEV 10
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);
1105                         if (dc->fd >= 0)
1106                                 goto found;
1107                 }
1108                 err(1, "open");
1109 found:
1110                 error = ioctl(dc->fd, FW_SDEUI64, &eui);
1111                 if (error)
1112                         err(1, "ioctl");
1113                 break;
1114         case TYPE_KVM:
1115         {
1116                 struct nlist nl[] = {{"dcons_buf"}, {""}};
1117                 void *dcons_buf;
1118
1119                 dc->kd = kvm_open(system, core, NULL,
1120                     (dc->flags & F_RD_ONLY) ? O_RDONLY : O_RDWR, "dconschat");
1121                 if (dc->kd == NULL)
1122                         errx(1, "kvm_open");
1123
1124                 if (kvm_nlist(dc->kd, nl) < 0)
1125                         errx(1, "kvm_nlist: %s", kvm_geterr(dc->kd));
1126
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;
1131                 if (verbose)
1132                         printf("dcons_buf: 0x%x\n", (uint)dc->paddr);
1133                 break;
1134         }
1135         }
1136         dconschat_fetch_header(dc);
1137
1138         /* init sockets */
1139         dc->kq = kqueue();
1140         if (poll_hz == 1) {
1141                 dc->to.tv_sec = 1;
1142                 dc->to.tv_nsec = 0;
1143         } else {
1144                 dc->to.tv_sec = 0;
1145                 dc->to.tv_nsec = 1000 * 1000 * 1000 / poll_hz;
1146         }
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]);
1152
1153         dconschat_start_session(dc);
1154
1155         for (i = 0; i < DCONS_NPORT; i++) {
1156                 freeaddrinfo(dc->port[i].res);
1157         }
1158         return (0);
1159 }