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