linux/arch/um/drivers/line.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   3 * Licensed under the GPL
   4 */
   5
   6#include "linux/irqreturn.h"
   7#include "linux/kd.h"
   8#include "linux/sched.h"
   9#include "linux/slab.h"
  10#include "chan.h"
  11#include "irq_kern.h"
  12#include "irq_user.h"
  13#include "kern_util.h"
  14#include "os.h"
  15
  16#define LINE_BUFSIZE 4096
  17
  18static irqreturn_t line_interrupt(int irq, void *data)
  19{
  20        struct chan *chan = data;
  21        struct line *line = chan->line;
  22
  23        if (line)
  24                chan_interrupt(line, line->tty, irq);
  25        return IRQ_HANDLED;
  26}
  27
  28/*
  29 * Returns the free space inside the ring buffer of this line.
  30 *
  31 * Should be called while holding line->lock (this does not modify data).
  32 */
  33static int write_room(struct line *line)
  34{
  35        int n;
  36
  37        if (line->buffer == NULL)
  38                return LINE_BUFSIZE - 1;
  39
  40        /* This is for the case where the buffer is wrapped! */
  41        n = line->head - line->tail;
  42
  43        if (n <= 0)
  44                n += LINE_BUFSIZE; /* The other case */
  45        return n - 1;
  46}
  47
  48int line_write_room(struct tty_struct *tty)
  49{
  50        struct line *line = tty->driver_data;
  51        unsigned long flags;
  52        int room;
  53
  54        spin_lock_irqsave(&line->lock, flags);
  55        room = write_room(line);
  56        spin_unlock_irqrestore(&line->lock, flags);
  57
  58        return room;
  59}
  60
  61int line_chars_in_buffer(struct tty_struct *tty)
  62{
  63        struct line *line = tty->driver_data;
  64        unsigned long flags;
  65        int ret;
  66
  67        spin_lock_irqsave(&line->lock, flags);
  68        /* write_room subtracts 1 for the needed NULL, so we readd it.*/
  69        ret = LINE_BUFSIZE - (write_room(line) + 1);
  70        spin_unlock_irqrestore(&line->lock, flags);
  71
  72        return ret;
  73}
  74
  75/*
  76 * This copies the content of buf into the circular buffer associated with
  77 * this line.
  78 * The return value is the number of characters actually copied, i.e. the ones
  79 * for which there was space: this function is not supposed to ever flush out
  80 * the circular buffer.
  81 *
  82 * Must be called while holding line->lock!
  83 */
  84static int buffer_data(struct line *line, const char *buf, int len)
  85{
  86        int end, room;
  87
  88        if (line->buffer == NULL) {
  89                line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC);
  90                if (line->buffer == NULL) {
  91                        printk(KERN_ERR "buffer_data - atomic allocation "
  92                               "failed\n");
  93                        return 0;
  94                }
  95                line->head = line->buffer;
  96                line->tail = line->buffer;
  97        }
  98
  99        room = write_room(line);
 100        len = (len > room) ? room : len;
 101
 102        end = line->buffer + LINE_BUFSIZE - line->tail;
 103
 104        if (len < end) {
 105                memcpy(line->tail, buf, len);
 106                line->tail += len;
 107        }
 108        else {
 109                /* The circular buffer is wrapping */
 110                memcpy(line->tail, buf, end);
 111                buf += end;
 112                memcpy(line->buffer, buf, len - end);
 113                line->tail = line->buffer + len - end;
 114        }
 115
 116        return len;
 117}
 118
 119/*
 120 * Flushes the ring buffer to the output channels. That is, write_chan is
 121 * called, passing it line->head as buffer, and an appropriate count.
 122 *
 123 * On exit, returns 1 when the buffer is empty,
 124 * 0 when the buffer is not empty on exit,
 125 * and -errno when an error occurred.
 126 *
 127 * Must be called while holding line->lock!*/
 128static int flush_buffer(struct line *line)
 129{
 130        int n, count;
 131
 132        if ((line->buffer == NULL) || (line->head == line->tail))
 133                return 1;
 134
 135        if (line->tail < line->head) {
 136                /* line->buffer + LINE_BUFSIZE is the end of the buffer! */
 137                count = line->buffer + LINE_BUFSIZE - line->head;
 138
 139                n = write_chan(line->chan_out, line->head, count,
 140                               line->driver->write_irq);
 141                if (n < 0)
 142                        return n;
 143                if (n == count) {
 144                        /*
 145                         * We have flushed from ->head to buffer end, now we
 146                         * must flush only from the beginning to ->tail.
 147                         */
 148                        line->head = line->buffer;
 149                } else {
 150                        line->head += n;
 151                        return 0;
 152                }
 153        }
 154
 155        count = line->tail - line->head;
 156        n = write_chan(line->chan_out, line->head, count,
 157                       line->driver->write_irq);
 158
 159        if (n < 0)
 160                return n;
 161
 162        line->head += n;
 163        return line->head == line->tail;
 164}
 165
 166void line_flush_buffer(struct tty_struct *tty)
 167{
 168        struct line *line = tty->driver_data;
 169        unsigned long flags;
 170
 171        spin_lock_irqsave(&line->lock, flags);
 172        flush_buffer(line);
 173        spin_unlock_irqrestore(&line->lock, flags);
 174}
 175
 176/*
 177 * We map both ->flush_chars and ->put_char (which go in pair) onto
 178 * ->flush_buffer and ->write. Hope it's not that bad.
 179 */
 180void line_flush_chars(struct tty_struct *tty)
 181{
 182        line_flush_buffer(tty);
 183}
 184
 185int line_put_char(struct tty_struct *tty, unsigned char ch)
 186{
 187        return line_write(tty, &ch, sizeof(ch));
 188}
 189
 190int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
 191{
 192        struct line *line = tty->driver_data;
 193        unsigned long flags;
 194        int n, ret = 0;
 195
 196        spin_lock_irqsave(&line->lock, flags);
 197        if (line->head != line->tail)
 198                ret = buffer_data(line, buf, len);
 199        else {
 200                n = write_chan(line->chan_out, buf, len,
 201                               line->driver->write_irq);
 202                if (n < 0) {
 203                        ret = n;
 204                        goto out_up;
 205                }
 206
 207                len -= n;
 208                ret += n;
 209                if (len > 0)
 210                        ret += buffer_data(line, buf + n, len);
 211        }
 212out_up:
 213        spin_unlock_irqrestore(&line->lock, flags);
 214        return ret;
 215}
 216
 217void line_set_termios(struct tty_struct *tty, struct ktermios * old)
 218{
 219        /* nothing */
 220}
 221
 222static const struct {
 223        int  cmd;
 224        char *level;
 225        char *name;
 226} tty_ioctls[] = {
 227        /* don't print these, they flood the log ... */
 228        { TCGETS,      NULL,       "TCGETS"      },
 229        { TCSETS,      NULL,       "TCSETS"      },
 230        { TCSETSW,     NULL,       "TCSETSW"     },
 231        { TCFLSH,      NULL,       "TCFLSH"      },
 232        { TCSBRK,      NULL,       "TCSBRK"      },
 233
 234        /* general tty stuff */
 235        { TCSETSF,     KERN_DEBUG, "TCSETSF"     },
 236        { TCGETA,      KERN_DEBUG, "TCGETA"      },
 237        { TIOCMGET,    KERN_DEBUG, "TIOCMGET"    },
 238        { TCSBRKP,     KERN_DEBUG, "TCSBRKP"     },
 239        { TIOCMSET,    KERN_DEBUG, "TIOCMSET"    },
 240
 241        /* linux-specific ones */
 242        { TIOCLINUX,   KERN_INFO,  "TIOCLINUX"   },
 243        { KDGKBMODE,   KERN_INFO,  "KDGKBMODE"   },
 244        { KDGKBTYPE,   KERN_INFO,  "KDGKBTYPE"   },
 245        { KDSIGACCEPT, KERN_INFO,  "KDSIGACCEPT" },
 246};
 247
 248int line_ioctl(struct tty_struct *tty, unsigned int cmd,
 249                                unsigned long arg)
 250{
 251        int ret;
 252        int i;
 253
 254        ret = 0;
 255        switch(cmd) {
 256#ifdef TIOCGETP
 257        case TIOCGETP:
 258        case TIOCSETP:
 259        case TIOCSETN:
 260#endif
 261#ifdef TIOCGETC
 262        case TIOCGETC:
 263        case TIOCSETC:
 264#endif
 265#ifdef TIOCGLTC
 266        case TIOCGLTC:
 267        case TIOCSLTC:
 268#endif
 269        /* Note: these are out of date as we now have TCGETS2 etc but this
 270           whole lot should probably go away */
 271        case TCGETS:
 272        case TCSETSF:
 273        case TCSETSW:
 274        case TCSETS:
 275        case TCGETA:
 276        case TCSETAF:
 277        case TCSETAW:
 278        case TCSETA:
 279        case TCXONC:
 280        case TCFLSH:
 281        case TIOCOUTQ:
 282        case TIOCINQ:
 283        case TIOCGLCKTRMIOS:
 284        case TIOCSLCKTRMIOS:
 285        case TIOCPKT:
 286        case TIOCGSOFTCAR:
 287        case TIOCSSOFTCAR:
 288                return -ENOIOCTLCMD;
 289#if 0
 290        case TCwhatever:
 291                /* do something */
 292                break;
 293#endif
 294        default:
 295                for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++)
 296                        if (cmd == tty_ioctls[i].cmd)
 297                                break;
 298                if (i == ARRAY_SIZE(tty_ioctls)) {
 299                        printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n",
 300                               __func__, tty->name, cmd);
 301                }
 302                ret = -ENOIOCTLCMD;
 303                break;
 304        }
 305        return ret;
 306}
 307
 308void line_throttle(struct tty_struct *tty)
 309{
 310        struct line *line = tty->driver_data;
 311
 312        deactivate_chan(line->chan_in, line->driver->read_irq);
 313        line->throttled = 1;
 314}
 315
 316void line_unthrottle(struct tty_struct *tty)
 317{
 318        struct line *line = tty->driver_data;
 319
 320        line->throttled = 0;
 321        chan_interrupt(line, tty, line->driver->read_irq);
 322
 323        /*
 324         * Maybe there is enough stuff pending that calling the interrupt
 325         * throttles us again.  In this case, line->throttled will be 1
 326         * again and we shouldn't turn the interrupt back on.
 327         */
 328        if (!line->throttled)
 329                reactivate_chan(line->chan_in, line->driver->read_irq);
 330}
 331
 332static irqreturn_t line_write_interrupt(int irq, void *data)
 333{
 334        struct chan *chan = data;
 335        struct line *line = chan->line;
 336        struct tty_struct *tty = line->tty;
 337        int err;
 338
 339        /*
 340         * Interrupts are disabled here because genirq keep irqs disabled when
 341         * calling the action handler.
 342         */
 343
 344        spin_lock(&line->lock);
 345        err = flush_buffer(line);
 346        if (err == 0) {
 347                spin_unlock(&line->lock);
 348                return IRQ_NONE;
 349        } else if (err < 0) {
 350                line->head = line->buffer;
 351                line->tail = line->buffer;
 352        }
 353        spin_unlock(&line->lock);
 354
 355        if (tty == NULL)
 356                return IRQ_NONE;
 357
 358        tty_wakeup(tty);
 359        return IRQ_HANDLED;
 360}
 361
 362int line_setup_irq(int fd, int input, int output, struct line *line, void *data)
 363{
 364        const struct line_driver *driver = line->driver;
 365        int err = 0, flags = IRQF_SHARED | IRQF_SAMPLE_RANDOM;
 366
 367        if (input)
 368                err = um_request_irq(driver->read_irq, fd, IRQ_READ,
 369                                       line_interrupt, flags,
 370                                       driver->read_irq_name, data);
 371        if (err)
 372                return err;
 373        if (output)
 374                err = um_request_irq(driver->write_irq, fd, IRQ_WRITE,
 375                                        line_write_interrupt, flags,
 376                                        driver->write_irq_name, data);
 377        return err;
 378}
 379
 380/*
 381 * Normally, a driver like this can rely mostly on the tty layer
 382 * locking, particularly when it comes to the driver structure.
 383 * However, in this case, mconsole requests can come in "from the
 384 * side", and race with opens and closes.
 385 *
 386 * mconsole config requests will want to be sure the device isn't in
 387 * use, and get_config, open, and close will want a stable
 388 * configuration.  The checking and modification of the configuration
 389 * is done under a spinlock.  Checking whether the device is in use is
 390 * line->tty->count > 1, also under the spinlock.
 391 *
 392 * line->count serves to decide whether the device should be enabled or
 393 * disabled on the host.  If it's equal to 0, then we are doing the
 394 * first open or last close.  Otherwise, open and close just return.
 395 */
 396
 397int line_open(struct line *lines, struct tty_struct *tty)
 398{
 399        struct line *line = &lines[tty->index];
 400        int err = -ENODEV;
 401
 402        mutex_lock(&line->count_lock);
 403        if (!line->valid)
 404                goto out_unlock;
 405
 406        err = 0;
 407        if (line->count++)
 408                goto out_unlock;
 409
 410        BUG_ON(tty->driver_data);
 411        tty->driver_data = line;
 412        line->tty = tty;
 413
 414        err = enable_chan(line);
 415        if (err) /* line_close() will be called by our caller */
 416                goto out_unlock;
 417
 418        if (!line->sigio) {
 419                chan_enable_winch(line->chan_out, tty);
 420                line->sigio = 1;
 421        }
 422
 423        chan_window_size(line, &tty->winsize.ws_row,
 424                         &tty->winsize.ws_col);
 425out_unlock:
 426        mutex_unlock(&line->count_lock);
 427        return err;
 428}
 429
 430static void unregister_winch(struct tty_struct *tty);
 431
 432void line_close(struct tty_struct *tty, struct file * filp)
 433{
 434        struct line *line = tty->driver_data;
 435
 436        /*
 437         * If line_open fails (and tty->driver_data is never set),
 438         * tty_open will call line_close.  So just return in this case.
 439         */
 440        if (line == NULL)
 441                return;
 442
 443        /* We ignore the error anyway! */
 444        flush_buffer(line);
 445
 446        mutex_lock(&line->count_lock);
 447        BUG_ON(!line->valid);
 448
 449        if (--line->count)
 450                goto out_unlock;
 451
 452        line->tty = NULL;
 453        tty->driver_data = NULL;
 454
 455        if (line->sigio) {
 456                unregister_winch(tty);
 457                line->sigio = 0;
 458        }
 459
 460out_unlock:
 461        mutex_unlock(&line->count_lock);
 462}
 463
 464void close_lines(struct line *lines, int nlines)
 465{
 466        int i;
 467
 468        for(i = 0; i < nlines; i++)
 469                close_chan(&lines[i]);
 470}
 471
 472int setup_one_line(struct line *lines, int n, char *init,
 473                   const struct chan_opts *opts, char **error_out)
 474{
 475        struct line *line = &lines[n];
 476        struct tty_driver *driver = line->driver->driver;
 477        int err = -EINVAL;
 478
 479        mutex_lock(&line->count_lock);
 480
 481        if (line->count) {
 482                *error_out = "Device is already open";
 483                goto out;
 484        }
 485
 486        if (!strcmp(init, "none")) {
 487                if (line->valid) {
 488                        line->valid = 0;
 489                        kfree(line->init_str);
 490                        tty_unregister_device(driver, n);
 491                        parse_chan_pair(NULL, line, n, opts, error_out);
 492                        err = 0;
 493                }
 494        } else {
 495                char *new = kstrdup(init, GFP_KERNEL);
 496                if (!new) {
 497                        *error_out = "Failed to allocate memory";
 498                        return -ENOMEM;
 499                }
 500                if (line->valid) {
 501                        tty_unregister_device(driver, n);
 502                        kfree(line->init_str);
 503                }
 504                line->init_str = new;
 505                line->valid = 1;
 506                err = parse_chan_pair(new, line, n, opts, error_out);
 507                if (!err) {
 508                        struct device *d = tty_register_device(driver, n, NULL);
 509                        if (IS_ERR(d)) {
 510                                *error_out = "Failed to register device";
 511                                err = PTR_ERR(d);
 512                                parse_chan_pair(NULL, line, n, opts, error_out);
 513                        }
 514                }
 515                if (err) {
 516                        line->init_str = NULL;
 517                        line->valid = 0;
 518                        kfree(new);
 519                }
 520        }
 521out:
 522        mutex_unlock(&line->count_lock);
 523        return err;
 524}
 525
 526/*
 527 * Common setup code for both startup command line and mconsole initialization.
 528 * @lines contains the array (of size @num) to modify;
 529 * @init is the setup string;
 530 * @error_out is an error string in the case of failure;
 531 */
 532
 533int line_setup(char **conf, unsigned int num, char **def,
 534               char *init, char *name)
 535{
 536        char *error;
 537
 538        if (*init == '=') {
 539                /*
 540                 * We said con=/ssl= instead of con#=, so we are configuring all
 541                 * consoles at once.
 542                 */
 543                *def = init + 1;
 544        } else {
 545                char *end;
 546                unsigned n = simple_strtoul(init, &end, 0);
 547
 548                if (*end != '=') {
 549                        error = "Couldn't parse device number";
 550                        goto out;
 551                }
 552                if (n >= num) {
 553                        error = "Device number out of range";
 554                        goto out;
 555                }
 556                conf[n] = end + 1;
 557        }
 558        return 0;
 559
 560out:
 561        printk(KERN_ERR "Failed to set up %s with "
 562               "configuration string \"%s\" : %s\n", name, init, error);
 563        return -EINVAL;
 564}
 565
 566int line_config(struct line *lines, unsigned int num, char *str,
 567                const struct chan_opts *opts, char **error_out)
 568{
 569        char *end;
 570        int n;
 571
 572        if (*str == '=') {
 573                *error_out = "Can't configure all devices from mconsole";
 574                return -EINVAL;
 575        }
 576
 577        n = simple_strtoul(str, &end, 0);
 578        if (*end++ != '=') {
 579                *error_out = "Couldn't parse device number";
 580                return -EINVAL;
 581        }
 582        if (n >= num) {
 583                *error_out = "Device number out of range";
 584                return -EINVAL;
 585        }
 586
 587        return setup_one_line(lines, n, end, opts, error_out);
 588}
 589
 590int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
 591                    int size, char **error_out)
 592{
 593        struct line *line;
 594        char *end;
 595        int dev, n = 0;
 596
 597        dev = simple_strtoul(name, &end, 0);
 598        if ((*end != '\0') || (end == name)) {
 599                *error_out = "line_get_config failed to parse device number";
 600                return 0;
 601        }
 602
 603        if ((dev < 0) || (dev >= num)) {
 604                *error_out = "device number out of range";
 605                return 0;
 606        }
 607
 608        line = &lines[dev];
 609
 610        mutex_lock(&line->count_lock);
 611        if (!line->valid)
 612                CONFIG_CHUNK(str, size, n, "none", 1);
 613        else if (line->tty == NULL)
 614                CONFIG_CHUNK(str, size, n, line->init_str, 1);
 615        else n = chan_config_string(line, str, size, error_out);
 616        mutex_unlock(&line->count_lock);
 617
 618        return n;
 619}
 620
 621int line_id(char **str, int *start_out, int *end_out)
 622{
 623        char *end;
 624        int n;
 625
 626        n = simple_strtoul(*str, &end, 0);
 627        if ((*end != '\0') || (end == *str))
 628                return -1;
 629
 630        *str = end;
 631        *start_out = n;
 632        *end_out = n;
 633        return n;
 634}
 635
 636int line_remove(struct line *lines, unsigned int num, int n, char **error_out)
 637{
 638        if (n >= num) {
 639                *error_out = "Device number out of range";
 640                return -EINVAL;
 641        }
 642        return setup_one_line(lines, n, "none", NULL, error_out);
 643}
 644
 645int register_lines(struct line_driver *line_driver,
 646                   const struct tty_operations *ops,
 647                   struct line *lines, int nlines)
 648{
 649        struct tty_driver *driver = alloc_tty_driver(nlines);
 650        int err;
 651        int i;
 652
 653        if (!driver)
 654                return -ENOMEM;
 655
 656        driver->driver_name = line_driver->name;
 657        driver->name = line_driver->device_name;
 658        driver->major = line_driver->major;
 659        driver->minor_start = line_driver->minor_start;
 660        driver->type = line_driver->type;
 661        driver->subtype = line_driver->subtype;
 662        driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 663        driver->init_termios = tty_std_termios;
 664        
 665        for (i = 0; i < nlines; i++) {
 666                spin_lock_init(&lines[i].lock);
 667                mutex_init(&lines[i].count_lock);
 668                lines[i].driver = line_driver;
 669                INIT_LIST_HEAD(&lines[i].chan_list);
 670        }
 671        tty_set_operations(driver, ops);
 672
 673        err = tty_register_driver(driver);
 674        if (err) {
 675                printk(KERN_ERR "register_lines : can't register %s driver\n",
 676                       line_driver->name);
 677                put_tty_driver(driver);
 678                return err;
 679        }
 680
 681        line_driver->driver = driver;
 682        mconsole_register_dev(&line_driver->mc);
 683        return 0;
 684}
 685
 686static DEFINE_SPINLOCK(winch_handler_lock);
 687static LIST_HEAD(winch_handlers);
 688
 689struct winch {
 690        struct list_head list;
 691        int fd;
 692        int tty_fd;
 693        int pid;
 694        struct tty_struct *tty;
 695        unsigned long stack;
 696        struct work_struct work;
 697};
 698
 699static void __free_winch(struct work_struct *work)
 700{
 701        struct winch *winch = container_of(work, struct winch, work);
 702        free_irq(WINCH_IRQ, winch);
 703
 704        if (winch->pid != -1)
 705                os_kill_process(winch->pid, 1);
 706        if (winch->stack != 0)
 707                free_stack(winch->stack, 0);
 708        kfree(winch);
 709}
 710
 711static void free_winch(struct winch *winch)
 712{
 713        int fd = winch->fd;
 714        winch->fd = -1;
 715        if (fd != -1)
 716                os_close_file(fd);
 717        list_del(&winch->list);
 718        __free_winch(&winch->work);
 719}
 720
 721static irqreturn_t winch_interrupt(int irq, void *data)
 722{
 723        struct winch *winch = data;
 724        struct tty_struct *tty;
 725        struct line *line;
 726        int fd = winch->fd;
 727        int err;
 728        char c;
 729
 730        if (fd != -1) {
 731                err = generic_read(fd, &c, NULL);
 732                if (err < 0) {
 733                        if (err != -EAGAIN) {
 734                                winch->fd = -1;
 735                                list_del(&winch->list);
 736                                os_close_file(fd);
 737                                printk(KERN_ERR "winch_interrupt : "
 738                                       "read failed, errno = %d\n", -err);
 739                                printk(KERN_ERR "fd %d is losing SIGWINCH "
 740                                       "support\n", winch->tty_fd);
 741                                INIT_WORK(&winch->work, __free_winch);
 742                                schedule_work(&winch->work);
 743                                return IRQ_HANDLED;
 744                        }
 745                        goto out;
 746                }
 747        }
 748        tty = winch->tty;
 749        if (tty != NULL) {
 750                line = tty->driver_data;
 751                if (line != NULL) {
 752                        chan_window_size(line, &tty->winsize.ws_row,
 753                                         &tty->winsize.ws_col);
 754                        kill_pgrp(tty->pgrp, SIGWINCH, 1);
 755                }
 756        }
 757 out:
 758        if (winch->fd != -1)
 759                reactivate_fd(winch->fd, WINCH_IRQ);
 760        return IRQ_HANDLED;
 761}
 762
 763void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty,
 764                        unsigned long stack)
 765{
 766        struct winch *winch;
 767
 768        winch = kmalloc(sizeof(*winch), GFP_KERNEL);
 769        if (winch == NULL) {
 770                printk(KERN_ERR "register_winch_irq - kmalloc failed\n");
 771                goto cleanup;
 772        }
 773
 774        *winch = ((struct winch) { .list        = LIST_HEAD_INIT(winch->list),
 775                                   .fd          = fd,
 776                                   .tty_fd      = tty_fd,
 777                                   .pid         = pid,
 778                                   .tty         = tty,
 779                                   .stack       = stack });
 780
 781        if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
 782                           IRQF_SHARED | IRQF_SAMPLE_RANDOM,
 783                           "winch", winch) < 0) {
 784                printk(KERN_ERR "register_winch_irq - failed to register "
 785                       "IRQ\n");
 786                goto out_free;
 787        }
 788
 789        spin_lock(&winch_handler_lock);
 790        list_add(&winch->list, &winch_handlers);
 791        spin_unlock(&winch_handler_lock);
 792
 793        return;
 794
 795 out_free:
 796        kfree(winch);
 797 cleanup:
 798        os_kill_process(pid, 1);
 799        os_close_file(fd);
 800        if (stack != 0)
 801                free_stack(stack, 0);
 802}
 803
 804static void unregister_winch(struct tty_struct *tty)
 805{
 806        struct list_head *ele, *next;
 807        struct winch *winch;
 808
 809        spin_lock(&winch_handler_lock);
 810
 811        list_for_each_safe(ele, next, &winch_handlers) {
 812                winch = list_entry(ele, struct winch, list);
 813                if (winch->tty == tty) {
 814                        free_winch(winch);
 815                        break;
 816                }
 817        }
 818        spin_unlock(&winch_handler_lock);
 819}
 820
 821static void winch_cleanup(void)
 822{
 823        struct list_head *ele, *next;
 824        struct winch *winch;
 825
 826        spin_lock(&winch_handler_lock);
 827
 828        list_for_each_safe(ele, next, &winch_handlers) {
 829                winch = list_entry(ele, struct winch, list);
 830                free_winch(winch);
 831        }
 832
 833        spin_unlock(&winch_handler_lock);
 834}
 835__uml_exitcall(winch_cleanup);
 836
 837char *add_xterm_umid(char *base)
 838{
 839        char *umid, *title;
 840        int len;
 841
 842        umid = get_umid();
 843        if (*umid == '\0')
 844                return base;
 845
 846        len = strlen(base) + strlen(" ()") + strlen(umid) + 1;
 847        title = kmalloc(len, GFP_KERNEL);
 848        if (title == NULL) {
 849                printk(KERN_ERR "Failed to allocate buffer for xterm title\n");
 850                return base;
 851        }
 852
 853        snprintf(title, len, "%s (%s)", base, umid);
 854        return title;
 855}
 856
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.