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