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