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