1 /* 2 * Copyright (C) 2001, 2002 Jeff Dike (jdike@karaya.com) 3 * Licensed under the GPL 4 */ 5 6 #include "linux/sched.h" 7 #include "linux/slab.h" 8 #include "linux/list.h" 9 #include "linux/kd.h" 10 #include "linux/interrupt.h" 11 #include "linux/devfs_fs_kernel.h" 12 #include "asm/uaccess.h" 13 #include "chan_kern.h" 14 #include "irq_user.h" 15 #include "line.h" 16 #include "kern.h" 17 #include "user_util.h" 18 #include "kern_util.h" 19 #include "os.h" 20 #include "irq_kern.h" 21 22 #define LINE_BUFSIZE 4096 23 24 static irqreturn_t line_interrupt(int irq, void *data, struct pt_regs *unused) 25 { 26 struct tty_struct *tty = data; 27 struct line *line = tty->driver_data; 28 29 if (line) 30 chan_interrupt(&line->chan_list, &line->task, tty, irq); 31 return IRQ_HANDLED; 32 } 33 34 static void line_timer_cb(void *arg) 35 { 36 struct tty_struct *tty = arg; 37 struct line *line = tty->driver_data; 38 39 line_interrupt(line->driver->read_irq, arg, NULL); 40 } 41 42 /* Returns the free space inside the ring buffer of this line. 43 * 44 * Should be called while holding line->lock (this does not modify datas). 45 */ 46 static int write_room(struct line *line) 47 { 48 int n; 49 50 if (line->buffer == NULL) 51 return LINE_BUFSIZE - 1; 52 53 /* This is for the case where the buffer is wrapped! */ 54 n = line->head - line->tail; 55 56 if (n <= 0) 57 n = LINE_BUFSIZE + n; /* The other case */ 58 return n - 1; 59 } 60 61 int line_write_room(struct tty_struct *tty) 62 { 63 struct line *line = tty->driver_data; 64 unsigned long flags; 65 int room; 66 67 if (tty->stopped) 68 return 0; 69 70 spin_lock_irqsave(&line->lock, flags); 71 room = write_room(line); 72 spin_unlock_irqrestore(&line->lock, flags); 73 74 /*XXX: Warning to remove */ 75 if (0 == room) 76 printk(KERN_DEBUG "%s: %s: no room left in buffer\n", 77 __FUNCTION__,tty->name); 78 return room; 79 } 80 81 int line_chars_in_buffer(struct tty_struct *tty) 82 { 83 struct line *line = tty->driver_data; 84 unsigned long flags; 85 int ret; 86 87 spin_lock_irqsave(&line->lock, flags); 88 89 /*write_room subtracts 1 for the needed NULL, so we readd it.*/ 90 ret = LINE_BUFSIZE - (write_room(line) + 1); 91 spin_unlock_irqrestore(&line->lock, flags); 92 93 return ret; 94 } 95 96 /* 97 * This copies the content of buf into the circular buffer associated with 98 * this line. 99 * The return value is the number of characters actually copied, i.e. the ones 100 * for which there was space: this function is not supposed to ever flush out 101 * the circular buffer. 102 * 103 * Must be called while holding line->lock! 104 */ 105 static int buffer_data(struct line *line, const char *buf, int len) 106 { 107 int end, room; 108 109 if(line->buffer == NULL){ 110 line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC); 111 if (line->buffer == NULL) { 112 printk("buffer_data - atomic allocation failed\n"); 113 return(0); 114 } 115 line->head = line->buffer; 116 line->tail = line->buffer; 117 } 118 119 room = write_room(line); 120 len = (len > room) ? room : len; 121 122 end = line->buffer + LINE_BUFSIZE - line->tail; 123 124 if (len < end){ 125 memcpy(line->tail, buf, len); 126 line->tail += len; 127 } else { 128 /* The circular buffer is wrapping */ 129 memcpy(line->tail, buf, end); 130 buf += end; 131 memcpy(line->buffer, buf, len - end); 132 line->tail = line->buffer + len - end; 133 } 134 135 return len; 136 } 137 138 /* 139 * Flushes the ring buffer to the output channels. That is, write_chan is 140 * called, passing it line->head as buffer, and an appropriate count. 141 * 142 * On exit, returns 1 when the buffer is empty, 143 * 0 when the buffer is not empty on exit, 144 * and -errno when an error occurred. 145 * 146 * Must be called while holding line->lock!*/ 147 static int flush_buffer(struct line *line) 148 { 149 int n, count; 150 151 if ((line->buffer == NULL) || (line->head == line->tail)) 152 return 1; 153 154 if (line->tail < line->head) { 155 /* line->buffer + LINE_BUFSIZE is the end of the buffer! */ 156 count = line->buffer + LINE_BUFSIZE - line->head; 157 158 n = write_chan(&line->chan_list, line->head, count, 159 line->driver->write_irq); 160 if (n < 0) 161 return n; 162 if (n == count) { 163 /* We have flushed from ->head to buffer end, now we 164 * must flush only from the beginning to ->tail.*/ 165 line->head = line->buffer; 166 } else { 167 line->head += n; 168 return 0; 169 } 170 } 171 172 count = line->tail - line->head; 173 n = write_chan(&line->chan_list, line->head, count, 174 line->driver->write_irq); 175 176 if(n < 0) 177 return n; 178 179 line->head += n; 180 return line->head == line->tail; 181 } 182 183 void line_flush_buffer(struct tty_struct *tty) 184 { 185 struct line *line = tty->driver_data; 186 unsigned long flags; 187 int err; 188 189 /*XXX: copied from line_write, verify if it is correct!*/ 190 if(tty->stopped) 191 return; 192 //return 0; 193 194 spin_lock_irqsave(&line->lock, flags); 195 err = flush_buffer(line); 196 /*if (err == 1) 197 err = 0;*/ 198 spin_unlock_irqrestore(&line->lock, flags); 199 //return err; 200 } 201 202 /* We map both ->flush_chars and ->put_char (which go in pair) onto ->flush_buffer 203 * and ->write. Hope it's not that bad.*/ 204 void line_flush_chars(struct tty_struct *tty) 205 { 206 line_flush_buffer(tty); 207 } 208 209 void line_put_char(struct tty_struct *tty, unsigned char ch) 210 { 211 line_write(tty, &ch, sizeof(ch)); 212 } 213 214 int line_write(struct tty_struct *tty, const unsigned char *buf, int len) 215 { 216 struct line *line = tty->driver_data; 217 unsigned long flags; 218 int n, err, ret = 0; 219 220 if(tty->stopped) 221 return 0; 222 223 spin_lock_irqsave(&line->lock, flags); 224 if (line->head != line->tail) { 225 ret = buffer_data(line, buf, len); 226 err = flush_buffer(line); 227 if (err <= 0 && (err != -EAGAIN || !ret)) 228 ret = err; 229 } else { 230 n = write_chan(&line->chan_list, buf, len, 231 line->driver->write_irq); 232 if (n < 0) { 233 ret = n; 234 goto out_up; 235 } 236 237 len -= n; 238 ret += n; 239 if (len > 0) 240 ret += buffer_data(line, buf + n, len); 241 } 242 out_up: 243 spin_unlock_irqrestore(&line->lock, flags); 244 return ret; 245 } 246 247 void line_set_termios(struct tty_struct *tty, struct termios * old) 248 { 249 /* nothing */ 250 } 251 252 static struct { 253 int cmd; 254 char *level; 255 char *name; 256 } tty_ioctls[] = { 257 /* don't print these, they flood the log ... */ 258 { TCGETS, NULL, "TCGETS" }, 259 { TCSETS, NULL, "TCSETS" }, 260 { TCSETSW, NULL, "TCSETSW" }, 261 { TCFLSH, NULL, "TCFLSH" }, 262 { TCSBRK, NULL, "TCSBRK" }, 263 264 /* general tty stuff */ 265 { TCSETSF, KERN_DEBUG, "TCSETSF" }, 266 { TCGETA, KERN_DEBUG, "TCGETA" }, 267 { TIOCMGET, KERN_DEBUG, "TIOCMGET" }, 268 { TCSBRKP, KERN_DEBUG, "TCSBRKP" }, 269 { TIOCMSET, KERN_DEBUG, "TIOCMSET" }, 270 271 /* linux-specific ones */ 272 { TIOCLINUX, KERN_INFO, "TIOCLINUX" }, 273 { KDGKBMODE, KERN_INFO, "KDGKBMODE" }, 274 { KDGKBTYPE, KERN_INFO, "KDGKBTYPE" }, 275 { KDSIGACCEPT, KERN_INFO, "KDSIGACCEPT" }, 276 }; 277 278 int line_ioctl(struct tty_struct *tty, struct file * file, 279 unsigned int cmd, unsigned long arg) 280 { 281 int ret; 282 int i; 283 284 ret = 0; 285 switch(cmd) { 286 #ifdef TIOCGETP 287 case TIOCGETP: 288 case TIOCSETP: 289 case TIOCSETN: 290 #endif 291 #ifdef TIOCGETC 292 case TIOCGETC: 293 case TIOCSETC: 294 #endif 295 #ifdef TIOCGLTC 296 case TIOCGLTC: 297 case TIOCSLTC: 298 #endif 299 case TCGETS: 300 case TCSETSF: 301 case TCSETSW: 302 case TCSETS: 303 case TCGETA: 304 case TCSETAF: 305 case TCSETAW: 306 case TCSETA: 307 case TCXONC: 308 case TCFLSH: 309 case TIOCOUTQ: 310 case TIOCINQ: 311 case TIOCGLCKTRMIOS: 312 case TIOCSLCKTRMIOS: 313 case TIOCPKT: 314 case TIOCGSOFTCAR: 315 case TIOCSSOFTCAR: 316 return -ENOIOCTLCMD; 317 #if 0 318 case TCwhatever: 319 /* do something */ 320 break; 321 #endif 322 default: 323 for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++) 324 if (cmd == tty_ioctls[i].cmd) 325 break; 326 if (i < ARRAY_SIZE(tty_ioctls)) { 327 if (NULL != tty_ioctls[i].level) 328 printk("%s%s: %s: ioctl %s called\n", 329 tty_ioctls[i].level, __FUNCTION__, 330 tty->name, tty_ioctls[i].name); 331 } else { 332 printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n", 333 __FUNCTION__, tty->name, cmd); 334 } 335 ret = -ENOIOCTLCMD; 336 break; 337 } 338 return ret; 339 } 340 341 static irqreturn_t line_write_interrupt(int irq, void *data, 342 struct pt_regs *unused) 343 { 344 struct tty_struct *tty = data; 345 struct line *line = tty->driver_data; 346 int err; 347 348 /* Interrupts are enabled here because we registered the interrupt with 349 * SA_INTERRUPT (see line_setup_irq).*/ 350 351 spin_lock_irq(&line->lock); 352 err = flush_buffer(line); 353 if (err == 0) { 354 return IRQ_NONE; 355 } else if(err < 0) { 356 line->head = line->buffer; 357 line->tail = line->buffer; 358 } 359 spin_unlock_irq(&line->lock); 360 361 if(tty == NULL) 362 return IRQ_NONE; 363 364 if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) && 365 (tty->ldisc.write_wakeup != NULL)) 366 (tty->ldisc.write_wakeup)(tty); 367 368 /* BLOCKING mode 369 * In blocking mode, everything sleeps on tty->write_wait. 370 * Sleeping in the console driver would break non-blocking 371 * writes. 372 */ 373 374 if (waitqueue_active(&tty->write_wait)) 375 wake_up_interruptible(&tty->write_wait); 376 return IRQ_HANDLED; 377 } 378 379 int line_setup_irq(int fd, int input, int output, struct tty_struct *tty) 380 { 381 struct line *line = tty->driver_data; 382 struct line_driver *driver = line->driver; 383 int err = 0, flags = SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM; 384 385 if (input) 386 err = um_request_irq(driver->read_irq, fd, IRQ_READ, 387 line_interrupt, flags, 388 driver->read_irq_name, tty); 389 if (err) 390 return err; 391 if (output) 392 err = um_request_irq(driver->write_irq, fd, IRQ_WRITE, 393 line_write_interrupt, flags, 394 driver->write_irq_name, tty); 395 line->have_irq = 1; 396 return err; 397 } 398 399 void line_disable(struct tty_struct *tty, int current_irq) 400 { 401 struct line *line = tty->driver_data; 402 403 if(!line->have_irq) 404 return; 405 406 if(line->driver->read_irq == current_irq) 407 free_irq_later(line->driver->read_irq, tty); 408 else { 409 free_irq_by_irq_and_dev(line->driver->read_irq, tty); 410 free_irq(line->driver->read_irq, tty); 411 } 412 413 if(line->driver->write_irq == current_irq) 414 free_irq_later(line->driver->write_irq, tty); 415 else { 416 free_irq_by_irq_and_dev(line->driver->write_irq, tty); 417 free_irq(line->driver->write_irq, tty); 418 } 419 420 line->have_irq = 0; 421 } 422 423 int line_open(struct line *lines, struct tty_struct *tty, 424 struct chan_opts *opts) 425 { 426 struct line *line; 427 int err = 0; 428 429 line = &lines[tty->index]; 430 tty->driver_data = line; 431 432 /* The IRQ which takes this lock is not yet enabled and won't be run 433 * before the end, so we don't need to use spin_lock_irq.*/ 434 spin_lock(&line->lock); 435 if (tty->count == 1) { 436 if (!line->valid) { 437 err = -ENODEV; 438 goto out; 439 } 440 if (list_empty(&line->chan_list)) { 441 err = parse_chan_pair(line->init_str, &line->chan_list, 442 line->init_pri, tty->index, opts); 443 if(err) goto out; 444 err = open_chan(&line->chan_list); 445 if(err) goto out; 446 } 447 /* Here the interrupt is registered.*/ 448 enable_chan(&line->chan_list, tty); 449 INIT_WORK(&line->task, line_timer_cb, tty); 450 } 451 452 if(!line->sigio){ 453 chan_enable_winch(&line->chan_list, tty); 454 line->sigio = 1; 455 } 456 chan_window_size(&line->chan_list, &tty->winsize.ws_row, 457 &tty->winsize.ws_col); 458 line->count++; 459 460 out: 461 spin_unlock(&line->lock); 462 return err; 463 } 464 465 void line_close(struct tty_struct *tty, struct file * filp) 466 { 467 struct line *line = tty->driver_data; 468 469 /* XXX: I assume this should be called in process context, not with interrupt 470 * disabled!*/ 471 spin_lock_irq(&line->lock); 472 473 /* We ignore the error anyway! */ 474 flush_buffer(line); 475 476 line->count--; 477 if (tty->count == 1) { 478 line_disable(tty, -1); 479 tty->driver_data = NULL; 480 } 481 spin_unlock_irq(&line->lock); 482 } 483 484 void close_lines(struct line *lines, int nlines) 485 { 486 int i; 487 488 for(i = 0; i < nlines; i++) 489 close_chan(&lines[i].chan_list); 490 } 491 492 /* Common setup code for both startup command line and mconsole initialization. 493 * @lines contains the the array (of size @num) to modify; 494 * @init is the setup string; 495 * @all_allowed is a boolean saying if we can setup the whole @lines 496 * at once. For instance, it will be usually true for startup init. (where we 497 * can use con=xterm) and false for mconsole.*/ 498 499 int line_setup(struct line *lines, unsigned int num, char *init, int all_allowed) 500 { 501 int i, n; 502 char *end; 503 504 if(*init == '=') { 505 /* We said con=/ssl= instead of con#=, so we are configuring all 506 * consoles at once.*/ 507 n = -1; 508 } else { 509 n = simple_strtoul(init, &end, 0); 510 if(*end != '='){ 511 printk(KERN_ERR "line_setup failed to parse \"%s\"\n", 512 init); 513 return 0; 514 } 515 init = end; 516 } 517 init++; 518 519 if (n >= (signed int) num) { 520 printk("line_setup - %d out of range ((0 ... %d) allowed)\n", 521 n, num - 1); 522 return 0; 523 } else if (n >= 0){ 524 if (lines[n].count > 0) { 525 printk("line_setup - device %d is open\n", n); 526 return 0; 527 } 528 if (lines[n].init_pri <= INIT_ONE){ 529 lines[n].init_pri = INIT_ONE; 530 if (!strcmp(init, "none")) 531 lines[n].valid = 0; 532 else { 533 lines[n].init_str = init; 534 lines[n].valid = 1; 535 } 536 } 537 } else if(!all_allowed){ 538 printk("line_setup - can't configure all devices from " 539 "mconsole\n"); 540 return 0; 541 } else { 542 for(i = 0; i < num; i++){ 543 if(lines[i].init_pri <= INIT_ALL){ 544 lines[i].init_pri = INIT_ALL; 545 if(!strcmp(init, "none")) lines[i].valid = 0; 546 else { 547 lines[i].init_str = init; 548 lines[i].valid = 1; 549 } 550 } 551 } 552 } 553 return 1; 554 } 555 556 int line_config(struct line *lines, unsigned int num, char *str) 557 { 558 char *new = uml_strdup(str); 559 560 if(new == NULL){ 561 printk("line_config - uml_strdup failed\n"); 562 return -ENOMEM; 563 } 564 return !line_setup(lines, num, new, 0); 565 } 566 567 int line_get_config(char *name, struct line *lines, unsigned int num, char *str, 568 int size, char **error_out) 569 { 570 struct line *line; 571 char *end; 572 int dev, n = 0; 573 574 dev = simple_strtoul(name, &end, 0); 575 if((*end != '\0') || (end == name)){ 576 *error_out = "line_get_config failed to parse device number"; 577 return 0; 578 } 579 580 if((dev < 0) || (dev >= num)){ 581 *error_out = "device number out of range"; 582 return 0; 583 } 584 585 line = &lines[dev]; 586 587 spin_lock(&line->lock); 588 if(!line->valid) 589 CONFIG_CHUNK(str, size, n, "none", 1); 590 else if(line->count == 0) 591 CONFIG_CHUNK(str, size, n, line->init_str, 1); 592 else n = chan_config_string(&line->chan_list, str, size, error_out); 593 spin_unlock(&line->lock); 594 595 return n; 596 } 597 598 int line_remove(struct line *lines, unsigned int num, char *str) 599 { 600 char config[sizeof("conxxxx=none\0")]; 601 602 sprintf(config, "%s=none", str); 603 return !line_setup(lines, num, config, 0); 604 } 605 606 struct tty_driver *line_register_devfs(struct lines *set, 607 struct line_driver *line_driver, 608 struct tty_operations *ops, struct line *lines, 609 int nlines) 610 { 611 int i; 612 struct tty_driver *driver = alloc_tty_driver(nlines); 613 614 if (!driver) 615 return NULL; 616 617 driver->driver_name = line_driver->name; 618 driver->name = line_driver->device_name; 619 driver->devfs_name = line_driver->devfs_name; 620 driver->major = line_driver->major; 621 driver->minor_start = line_driver->minor_start; 622 driver->type = line_driver->type; 623 driver->subtype = line_driver->subtype; 624 driver->flags = TTY_DRIVER_REAL_RAW; 625 driver->init_termios = tty_std_termios; 626 tty_set_operations(driver, ops); 627 628 if (tty_register_driver(driver)) { 629 printk("%s: can't register %s driver\n", 630 __FUNCTION__,line_driver->name); 631 put_tty_driver(driver); 632 return NULL; 633 } 634 635 for(i = 0; i < nlines; i++){ 636 if(!lines[i].valid) 637 tty_unregister_device(driver, i); 638 } 639 640 mconsole_register_dev(&line_driver->mc); 641 return driver; 642 } 643 644 void lines_init(struct line *lines, int nlines) 645 { 646 struct line *line; 647 int i; 648 649 for(i = 0; i < nlines; i++){ 650 line = &lines[i]; 651 INIT_LIST_HEAD(&line->chan_list); 652 spin_lock_init(&line->lock); 653 if(line->init_str != NULL){ 654 line->init_str = uml_strdup(line->init_str); 655 if(line->init_str == NULL) 656 printk("lines_init - uml_strdup returned " 657 "NULL\n"); 658 } 659 } 660 } 661 662 struct winch { 663 struct list_head list; 664 int fd; 665 int tty_fd; 666 int pid; 667 struct tty_struct *tty; 668 }; 669 670 irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused) 671 { 672 struct winch *winch = data; 673 struct tty_struct *tty; 674 struct line *line; 675 int err; 676 char c; 677 678 if(winch->fd != -1){ 679 err = generic_read(winch->fd, &c, NULL); 680 if(err < 0){ 681 if(err != -EAGAIN){ 682 printk("winch_interrupt : read failed, " 683 "errno = %d\n", -err); 684 printk("fd %d is losing SIGWINCH support\n", 685 winch->tty_fd); 686 return IRQ_HANDLED; 687 } 688 goto out; 689 } 690 } 691 tty = winch->tty; 692 if (tty != NULL) { 693 line = tty->driver_data; 694 chan_window_size(&line->chan_list, 695 &tty->winsize.ws_row, 696 &tty->winsize.ws_col); 697 kill_pg(tty->pgrp, SIGWINCH, 1); 698 } 699 out: 700 if(winch->fd != -1) 701 reactivate_fd(winch->fd, WINCH_IRQ); 702 return IRQ_HANDLED; 703 } 704 705 DECLARE_MUTEX(winch_handler_sem); 706 LIST_HEAD(winch_handlers); 707 708 void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty) 709 { 710 struct winch *winch; 711 712 down(&winch_handler_sem); 713 winch = kmalloc(sizeof(*winch), GFP_KERNEL); 714 if (winch == NULL) { 715 printk("register_winch_irq - kmalloc failed\n"); 716 goto out; 717 } 718 *winch = ((struct winch) { .list = LIST_HEAD_INIT(winch->list), 719 .fd = fd, 720 .tty_fd = tty_fd, 721 .pid = pid, 722 .tty = tty }); 723 list_add(&winch->list, &winch_handlers); 724 if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt, 725 SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM, 726 "winch", winch) < 0) 727 printk("register_winch_irq - failed to register IRQ\n"); 728 out: 729 up(&winch_handler_sem); 730 } 731 732 static void winch_cleanup(void) 733 { 734 struct list_head *ele; 735 struct winch *winch; 736 737 list_for_each(ele, &winch_handlers){ 738 winch = list_entry(ele, struct winch, list); 739 if(winch->fd != -1){ 740 deactivate_fd(winch->fd, WINCH_IRQ); 741 os_close_file(winch->fd); 742 } 743 if(winch->pid != -1) 744 os_kill_process(winch->pid, 1); 745 } 746 } 747 __uml_exitcall(winch_cleanup); 748 749 char *add_xterm_umid(char *base) 750 { 751 char *umid, *title; 752 int len; 753 754 umid = get_umid(1); 755 if(umid == NULL) 756 return base; 757 758 len = strlen(base) + strlen(" ()") + strlen(umid) + 1; 759 title = kmalloc(len, GFP_KERNEL); 760 if(title == NULL){ 761 printk("Failed to allocate buffer for xterm title\n"); 762 return base; 763 } 764 765 snprintf(title, len, "%s (%s)", base, umid); 766 return title; 767 } 768