arch/um/drivers/line.c

   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
  18 static 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  */
  33 static 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
  48 int 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
  61 int 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  */
  84 static 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!*/
 128 static 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
 166 void 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  */
 180 void line_flush_chars(struct tty_struct *tty)
 181 {
 182         line_flush_buffer(tty);
 183 }
 184
 185 int line_put_char(struct tty_struct *tty, unsigned char ch)
 186 {
 187         return line_write(tty, &ch, sizeof(ch));
 188 }
 189
 190 int 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         }
 212 out_up:
 213         spin_unlock_irqrestore(&line->lock, flags);
 214         return ret;
 215 }
 216
 217 void line_set_termios(struct tty_struct *tty, struct ktermios * old)
 218 {
 219         /* nothing */
 220 }
 221
 222 static 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
 248 int 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
 308 void 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
 316 void 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
 332 static 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
 362 int 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
 397 int 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);
 425 out_unlock:
 426         mutex_unlock(&line->count_lock);
 427         return err;
 428 }
 429
 430 static void unregister_winch(struct tty_struct *tty);
 431
 432 void 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
 460 out_unlock:
 461         mutex_unlock(&line->count_lock);
 462 }
 463
 464 void 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
 472 int 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         }
 521 out:
 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
 533 int 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
 560 out:
 561         printk(KERN_ERR "Failed to set up %s with "
 562                "configuration string \"%s\" : %s\n", name, init, error);
 563         return -EINVAL;
 564 }
 565
 566 int 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
 590 int 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
 621 int 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
 636 int 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
 645 int 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
 686 static DEFINE_SPINLOCK(winch_handler_lock);
 687 static LIST_HEAD(winch_handlers);
 688
 689 struct 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
 699 static 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
 711 static 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
 721 static 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
 763 void 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
 804 static 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
 821 static 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
 837 char *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 }