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