1 /** 2 * Console server process for OpenBMC 3 * 4 * Copyright © 2016 IBM Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 19 #define _GNU_SOURCE 20 21 #include <assert.h> 22 #include <errno.h> 23 #include <signal.h> 24 #include <stdint.h> 25 #include <stdbool.h> 26 #include <stdlib.h> 27 #include <stdio.h> 28 #include <fcntl.h> 29 #include <unistd.h> 30 #include <err.h> 31 #include <string.h> 32 #include <getopt.h> 33 #include <limits.h> 34 #include <termios.h> 35 36 #include <sys/types.h> 37 #include <sys/poll.h> 38 39 #include "console-server.h" 40 41 struct console { 42 const char *tty_kname; 43 char *tty_sysfs_devnode; 44 char *tty_dev; 45 int tty_sirq; 46 int tty_lpc_addr; 47 int tty_fd; 48 49 struct handler **handlers; 50 int n_handlers; 51 52 struct poller **pollers; 53 int n_pollers; 54 55 struct pollfd *pollfds; 56 }; 57 58 struct poller { 59 struct handler *handler; 60 void *data; 61 poller_fn_t fn; 62 bool remove; 63 }; 64 65 /* we have one extra entry in the pollfds array for the VUART tty */ 66 static const int n_internal_pollfds = 1; 67 68 /* state shared with the signal handler */ 69 static bool sigint; 70 71 static void usage(const char *progname) 72 { 73 fprintf(stderr, 74 "usage: %s [options]\n" 75 "\n" 76 "Options:\n" 77 " --config <FILE> Use FILE for configuration\n" 78 "", 79 progname); 80 } 81 82 /* populates tty_dev and tty_sysfs_devnode, using the tty kernel name */ 83 static int tty_find_device(struct console *console) 84 { 85 char *tty_class_device_link; 86 char *tty_device_tty_dir; 87 char *tty_device_reldir; 88 int rc; 89 90 tty_class_device_link = NULL; 91 tty_device_tty_dir = NULL; 92 tty_device_reldir = NULL; 93 94 rc = asprintf(&tty_class_device_link, 95 "/sys/class/tty/%s", console->tty_kname); 96 if (rc < 0) 97 return -1; 98 99 tty_device_tty_dir = realpath(tty_class_device_link, NULL); 100 if (rc < 0) { 101 warn("Can't query sysfs for device %s", console->tty_kname); 102 goto out_free; 103 } 104 105 rc = asprintf(&tty_device_reldir, "%s/../../", tty_device_tty_dir); 106 if (rc < 0) 107 goto out_free; 108 109 console->tty_sysfs_devnode = realpath(tty_device_reldir, NULL); 110 if (!console->tty_sysfs_devnode) 111 warn("Can't find parent device for %s", console->tty_kname); 112 113 114 /* todo: lookup from major/minor info in sysfs, in case udev has 115 * renamed us */ 116 rc = asprintf(&console->tty_dev, "/dev/%s", console->tty_kname); 117 if (rc < 0) 118 goto out_free; 119 120 rc = 0; 121 122 out_free: 123 free(tty_class_device_link); 124 free(tty_device_tty_dir); 125 free(tty_device_reldir); 126 return rc; 127 } 128 129 static int tty_set_sysfs_attr(struct console *console, const char *name, 130 int value) 131 { 132 char *path; 133 FILE *fp; 134 int rc; 135 136 rc = asprintf(&path, "%s/%s", console->tty_sysfs_devnode, name); 137 if (rc < 0) 138 return -1; 139 140 fp = fopen(path, "w"); 141 if (!fp) { 142 warn("Can't access attribute %s on device %s", 143 name, console->tty_kname); 144 rc = -1; 145 goto out_free; 146 } 147 setvbuf(fp, NULL, _IONBF, 0); 148 149 rc = fprintf(fp, "0x%x", value); 150 if (rc < 0) 151 warn("Error writing to %s attribute of device %s", 152 name, console->tty_kname); 153 fclose(fp); 154 155 156 157 out_free: 158 free(path); 159 return rc; 160 } 161 162 /** 163 * Set console to raw mode: we don't want any processing to occur on 164 * the underlying terminal input/output. 165 */ 166 static void tty_init_termios(struct console *console) 167 { 168 struct termios termios; 169 int rc; 170 171 rc = tcgetattr(console->tty_fd, &termios); 172 if (rc) { 173 warn("Can't read tty termios"); 174 return; 175 } 176 177 cfmakeraw(&termios); 178 rc = tcsetattr(console->tty_fd, TCSANOW, &termios); 179 if (rc) 180 warn("Can't set terminal raw mode for tty"); 181 } 182 183 /** 184 * Open and initialise the serial device 185 */ 186 static int tty_init_io(struct console *console) 187 { 188 if (console->tty_sirq) 189 tty_set_sysfs_attr(console, "sirq", console->tty_sirq); 190 if (console->tty_lpc_addr) 191 tty_set_sysfs_attr(console, "lpc_address", 192 console->tty_lpc_addr); 193 194 console->tty_fd = open(console->tty_dev, O_RDWR); 195 if (console->tty_fd <= 0) { 196 warn("Can't open tty %s", console->tty_dev); 197 return -1; 198 } 199 200 /* Disable character delay. We may want to later enable this when 201 * we detect larger amounts of data 202 */ 203 fcntl(console->tty_fd, F_SETFL, FNDELAY); 204 205 tty_init_termios(console); 206 207 console->pollfds[console->n_pollers].fd = console->tty_fd; 208 console->pollfds[console->n_pollers].events = POLLIN; 209 210 return 0; 211 } 212 213 static int tty_init(struct console *console, struct config *config) 214 { 215 const char *val; 216 char *endp; 217 int rc; 218 219 console->tty_kname = config_get_value(config, "device"); 220 221 val = config_get_value(config, "lpc-address"); 222 if (val) { 223 console->tty_lpc_addr = strtoul(val, &endp, 0); 224 if (endp == optarg) { 225 warn("Invalid LPC address: '%s'", val); 226 return -1; 227 } 228 } 229 230 val = config_get_value(config, "sirq"); 231 if (val) { 232 console->tty_sirq = strtoul(val, &endp, 0); 233 if (endp == optarg) 234 warn("Invalid sirq: '%s'", val); 235 } 236 237 if (!console->tty_kname) { 238 warnx("Error: No TTY device specified"); 239 return -1; 240 } 241 242 rc = tty_find_device(console); 243 if (rc) 244 return rc; 245 246 rc = tty_init_io(console); 247 return rc; 248 } 249 250 251 int console_data_out(struct console *console, const uint8_t *data, size_t len) 252 { 253 return write_buf_to_fd(console->tty_fd, data, len); 254 } 255 256 static void handlers_init(struct console *console, struct config *config) 257 { 258 extern struct handler *__start_handlers, *__stop_handlers; 259 struct handler *handler; 260 int i, rc; 261 262 console->n_handlers = &__stop_handlers - &__start_handlers; 263 console->handlers = &__start_handlers; 264 265 printf("%d handler%s\n", console->n_handlers, 266 console->n_handlers == 1 ? "" : "s"); 267 268 for (i = 0; i < console->n_handlers; i++) { 269 handler = console->handlers[i]; 270 271 rc = 0; 272 if (handler->init) 273 rc = handler->init(handler, console, config); 274 275 handler->active = rc == 0; 276 277 printf(" %s [%sactive]\n", handler->name, 278 handler->active ? "" : "in"); 279 } 280 } 281 282 static void handlers_fini(struct console *console) 283 { 284 struct handler *handler; 285 int i; 286 287 for (i = 0; i < console->n_handlers; i++) { 288 handler = console->handlers[i]; 289 if (handler->fini && handler->active) 290 handler->fini(handler); 291 } 292 } 293 294 static int handlers_data_in(struct console *console, uint8_t *buf, size_t len) 295 { 296 struct handler *handler; 297 int i, rc, tmp; 298 299 rc = 0; 300 301 for (i = 0; i < console->n_handlers; i++) { 302 handler = console->handlers[i]; 303 304 if (!handler->active) 305 continue; 306 307 if (!handler->data_in) 308 continue; 309 310 tmp = handler->data_in(handler, buf, len); 311 if (tmp == HANDLER_EXIT) 312 rc = 1; 313 } 314 315 return rc; 316 317 } 318 319 struct poller *console_register_poller(struct console *console, 320 struct handler *handler, poller_fn_t poller_fn, 321 int fd, int events, void *data) 322 { 323 struct poller *poller; 324 int n; 325 326 poller = malloc(sizeof(*poller)); 327 poller->remove = false; 328 poller->handler = handler; 329 poller->fn = poller_fn; 330 poller->data = data; 331 332 /* add one to our pollers array */ 333 n = console->n_pollers++; 334 console->pollers = realloc(console->pollers, 335 sizeof(*console->pollers) * console->n_pollers); 336 337 console->pollers[n] = poller; 338 339 /* increase pollfds array too */ 340 console->pollfds = realloc(console->pollfds, 341 sizeof(*console->pollfds) * 342 (n_internal_pollfds + console->n_pollers)); 343 344 /* shift the end pollfds up by one */ 345 memcpy(&console->pollfds[n+n_internal_pollfds], 346 &console->pollfds[n], 347 sizeof(*console->pollfds) * n_internal_pollfds); 348 349 console->pollfds[n].fd = fd; 350 console->pollfds[n].events = events; 351 352 return poller; 353 } 354 355 void console_unregister_poller(struct console *console, 356 struct poller *poller) 357 { 358 int i; 359 360 /* find the entry in our pollers array */ 361 for (i = 0; i < console->n_pollers; i++) 362 if (console->pollers[i] == poller) 363 break; 364 365 assert(i < console->n_pollers); 366 367 console->n_pollers--; 368 369 /* remove the item from the pollers array... */ 370 memmove(&console->pollers[i], &console->pollers[i+1], 371 sizeof(*console->pollers) 372 * (console->n_pollers - i)); 373 374 console->pollers = realloc(console->pollers, 375 sizeof(*console->pollers) * console->n_pollers); 376 377 /* ... and the pollfds array */ 378 memmove(&console->pollfds[i], &console->pollfds[i+1], 379 sizeof(*console->pollfds) * 380 (n_internal_pollfds + console->n_pollers - i)); 381 382 console->pollfds = realloc(console->pollfds, 383 sizeof(*console->pollfds) * 384 (n_internal_pollfds + console->n_pollers)); 385 386 387 free(poller); 388 } 389 390 static int call_pollers(struct console *console) 391 { 392 struct poller *poller; 393 struct pollfd *pollfd; 394 enum poller_ret prc; 395 int i, rc; 396 397 rc = 0; 398 399 /* 400 * Process poll events by iterating through the pollers and pollfds 401 * in-step, calling any pollers that we've found revents for. 402 */ 403 for (i = 0; i < console->n_pollers; i++) { 404 poller = console->pollers[i]; 405 pollfd = &console->pollfds[i]; 406 407 if (!pollfd->revents) 408 continue; 409 410 prc = poller->fn(poller->handler, pollfd->revents, 411 poller->data); 412 if (prc == POLLER_EXIT) 413 rc = -1; 414 else if (prc == POLLER_REMOVE) 415 poller->remove = true; 416 } 417 418 /** 419 * Process deferred removals; restarting each time we unregister, as 420 * the array will have changed 421 */ 422 for (;;) { 423 bool removed = false; 424 425 for (i = 0; i < console->n_pollers; i++) { 426 poller = console->pollers[i]; 427 if (poller->remove) { 428 console_unregister_poller(console, poller); 429 removed = true; 430 break; 431 } 432 } 433 if (!removed) 434 break; 435 } 436 437 return rc; 438 } 439 440 static void sighandler(int signal) 441 { 442 if (signal == SIGINT) 443 sigint = true; 444 } 445 446 int run_console(struct console *console) 447 { 448 sighandler_t sighandler_save; 449 int rc; 450 451 sighandler_save = signal(SIGINT, sighandler); 452 453 rc = 0; 454 455 for (;;) { 456 uint8_t buf[4096]; 457 458 if (sigint) { 459 fprintf(stderr, "Received interrupt, exiting\n"); 460 break; 461 } 462 463 rc = poll(console->pollfds, 464 console->n_pollers + n_internal_pollfds, -1); 465 if (rc < 0) { 466 if (errno == EINTR) { 467 continue; 468 } else { 469 warn("poll error"); 470 break; 471 } 472 } 473 474 /* process internal fd first */ 475 BUILD_ASSERT(n_internal_pollfds == 1); 476 477 if (console->pollfds[console->n_pollers].revents) { 478 rc = read(console->tty_fd, buf, sizeof(buf)); 479 if (rc <= 0) { 480 warn("Error reading from tty device"); 481 rc = -1; 482 break; 483 } 484 rc = handlers_data_in(console, buf, rc); 485 if (rc) 486 break; 487 } 488 489 /* ... and then the pollers */ 490 rc = call_pollers(console); 491 if (rc) 492 break; 493 } 494 495 signal(SIGINT, sighandler_save); 496 497 return rc ? -1 : 0; 498 } 499 static const struct option options[] = { 500 { "config", required_argument, 0, 'c'}, 501 { 0, 0, 0, 0}, 502 }; 503 504 int main(int argc, char **argv) 505 { 506 const char *config_filename = NULL; 507 struct console *console; 508 struct config *config; 509 int rc; 510 511 rc = -1; 512 513 for (;;) { 514 int c, idx; 515 516 c = getopt_long(argc, argv, "c:", options, &idx); 517 if (c == -1) 518 break; 519 520 switch (c) { 521 case 'c': 522 config_filename = optarg; 523 break; 524 case 'h': 525 case '?': 526 usage(argv[0]); 527 return EXIT_SUCCESS; 528 } 529 } 530 531 console = malloc(sizeof(struct console)); 532 memset(console, 0, sizeof(*console)); 533 console->pollfds = calloc(n_internal_pollfds, 534 sizeof(*console->pollfds)); 535 536 config = config_init(config_filename); 537 if (!config) { 538 warnx("Can't read configuration, exiting."); 539 goto out_free; 540 } 541 542 rc = tty_init(console, config); 543 if (rc) 544 goto out_config_fini; 545 546 handlers_init(console, config); 547 548 rc = run_console(console); 549 550 handlers_fini(console); 551 552 out_config_fini: 553 config_fini(config); 554 555 out_free: 556 free(console->pollers); 557 free(console->pollfds); 558 free(console->tty_sysfs_devnode); 559 free(console->tty_dev); 560 free(console); 561 562 return rc == 0 ? EXIT_SUCCESS : EXIT_FAILURE; 563 } 564