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