[PATCH] uml: Move mconsole support out of generic code
[linux-2.6] / arch / um / drivers / line.c
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         }
128         else {
129                 /* The circular buffer is wrapping */
130                 memcpy(line->tail, buf, end);
131                 buf += end;
132                 memcpy(line->buffer, buf, len - end);
133                 line->tail = line->buffer + len - end;
134         }
135
136         return len;
137 }
138
139 /*
140  * Flushes the ring buffer to the output channels. That is, write_chan is
141  * called, passing it line->head as buffer, and an appropriate count.
142  *
143  * On exit, returns 1 when the buffer is empty,
144  * 0 when the buffer is not empty on exit,
145  * and -errno when an error occurred.
146  *
147  * Must be called while holding line->lock!*/
148 static int flush_buffer(struct line *line)
149 {
150         int n, count;
151
152         if ((line->buffer == NULL) || (line->head == line->tail))
153                 return 1;
154
155         if (line->tail < line->head) {
156                 /* line->buffer + LINE_BUFSIZE is the end of the buffer! */
157                 count = line->buffer + LINE_BUFSIZE - line->head;
158
159                 n = write_chan(&line->chan_list, line->head, count,
160                                line->driver->write_irq);
161                 if (n < 0)
162                         return n;
163                 if (n == count) {
164                         /* We have flushed from ->head to buffer end, now we
165                          * must flush only from the beginning to ->tail.*/
166                         line->head = line->buffer;
167                 } else {
168                         line->head += n;
169                         return 0;
170                 }
171         }
172
173         count = line->tail - line->head;
174         n = write_chan(&line->chan_list, line->head, count,
175                        line->driver->write_irq);
176
177         if(n < 0)
178                 return n;
179
180         line->head += n;
181         return line->head == line->tail;
182 }
183
184 void line_flush_buffer(struct tty_struct *tty)
185 {
186         struct line *line = tty->driver_data;
187         unsigned long flags;
188         int err;
189
190         /*XXX: copied from line_write, verify if it is correct!*/
191         if(tty->stopped)
192                 return;
193                 //return 0;
194
195         spin_lock_irqsave(&line->lock, flags);
196         err = flush_buffer(line);
197         /*if (err == 1)
198                 err = 0;*/
199         spin_unlock_irqrestore(&line->lock, flags);
200         //return err;
201 }
202
203 /* We map both ->flush_chars and ->put_char (which go in pair) onto ->flush_buffer
204  * and ->write. Hope it's not that bad.*/
205 void line_flush_chars(struct tty_struct *tty)
206 {
207         line_flush_buffer(tty);
208 }
209
210 void line_put_char(struct tty_struct *tty, unsigned char ch)
211 {
212         line_write(tty, &ch, sizeof(ch));
213 }
214
215 int line_write(struct tty_struct *tty, const unsigned char *buf, int len)
216 {
217         struct line *line = tty->driver_data;
218         unsigned long flags;
219         int n, err, ret = 0;
220
221         if(tty->stopped)
222                 return 0;
223
224         spin_lock_irqsave(&line->lock, flags);
225         if (line->head != line->tail) {
226                 ret = buffer_data(line, buf, len);
227                 err = flush_buffer(line);
228                 if (err <= 0 && (err != -EAGAIN || !ret))
229                         ret = err;
230         } else {
231                 n = write_chan(&line->chan_list, buf, len,
232                                line->driver->write_irq);
233                 if (n < 0) {
234                         ret = n;
235                         goto out_up;
236                 }
237
238                 len -= n;
239                 ret += n;
240                 if (len > 0)
241                         ret += buffer_data(line, buf + n, len);
242         }
243 out_up:
244         spin_unlock_irqrestore(&line->lock, flags);
245         return ret;
246 }
247
248 void line_set_termios(struct tty_struct *tty, struct termios * old)
249 {
250         /* nothing */
251 }
252
253 static struct {
254         int  cmd;
255         char *level;
256         char *name;
257 } tty_ioctls[] = {
258         /* don't print these, they flood the log ... */
259         { TCGETS,      NULL,       "TCGETS"      },
260         { TCSETS,      NULL,       "TCSETS"      },
261         { TCSETSW,     NULL,       "TCSETSW"     },
262         { TCFLSH,      NULL,       "TCFLSH"      },
263         { TCSBRK,      NULL,       "TCSBRK"      },
264
265         /* general tty stuff */
266         { TCSETSF,     KERN_DEBUG, "TCSETSF"     },
267         { TCGETA,      KERN_DEBUG, "TCGETA"      },
268         { TIOCMGET,    KERN_DEBUG, "TIOCMGET"    },
269         { TCSBRKP,     KERN_DEBUG, "TCSBRKP"     },
270         { TIOCMSET,    KERN_DEBUG, "TIOCMSET"    },
271
272         /* linux-specific ones */
273         { TIOCLINUX,   KERN_INFO,  "TIOCLINUX"   },
274         { KDGKBMODE,   KERN_INFO,  "KDGKBMODE"   },
275         { KDGKBTYPE,   KERN_INFO,  "KDGKBTYPE"   },
276         { KDSIGACCEPT, KERN_INFO,  "KDSIGACCEPT" },
277 };
278
279 int line_ioctl(struct tty_struct *tty, struct file * file,
280                unsigned int cmd, unsigned long arg)
281 {
282         int ret;
283         int i;
284
285         ret = 0;
286         switch(cmd) {
287 #ifdef TIOCGETP
288         case TIOCGETP:
289         case TIOCSETP:
290         case TIOCSETN:
291 #endif
292 #ifdef TIOCGETC
293         case TIOCGETC:
294         case TIOCSETC:
295 #endif
296 #ifdef TIOCGLTC
297         case TIOCGLTC:
298         case TIOCSLTC:
299 #endif
300         case TCGETS:
301         case TCSETSF:
302         case TCSETSW:
303         case TCSETS:
304         case TCGETA:
305         case TCSETAF:
306         case TCSETAW:
307         case TCSETA:
308         case TCXONC:
309         case TCFLSH:
310         case TIOCOUTQ:
311         case TIOCINQ:
312         case TIOCGLCKTRMIOS:
313         case TIOCSLCKTRMIOS:
314         case TIOCPKT:
315         case TIOCGSOFTCAR:
316         case TIOCSSOFTCAR:
317                 return -ENOIOCTLCMD;
318 #if 0
319         case TCwhatever:
320                 /* do something */
321                 break;
322 #endif
323         default:
324                 for (i = 0; i < ARRAY_SIZE(tty_ioctls); i++)
325                         if (cmd == tty_ioctls[i].cmd)
326                                 break;
327                 if (i < ARRAY_SIZE(tty_ioctls)) {
328                         if (NULL != tty_ioctls[i].level)
329                                 printk("%s%s: %s: ioctl %s called\n",
330                                        tty_ioctls[i].level, __FUNCTION__,
331                                        tty->name, tty_ioctls[i].name);
332                 } else {
333                         printk(KERN_ERR "%s: %s: unknown ioctl: 0x%x\n",
334                                __FUNCTION__, tty->name, cmd);
335                 }
336                 ret = -ENOIOCTLCMD;
337                 break;
338         }
339         return ret;
340 }
341
342 static irqreturn_t line_write_interrupt(int irq, void *data,
343                                         struct pt_regs *unused)
344 {
345         struct tty_struct *tty = data;
346         struct line *line = tty->driver_data;
347         int err;
348
349         /* Interrupts are enabled here because we registered the interrupt with
350          * SA_INTERRUPT (see line_setup_irq).*/
351
352         spin_lock_irq(&line->lock);
353         err = flush_buffer(line);
354         if (err == 0) {
355                 return IRQ_NONE;
356         } else if(err < 0) {
357                 line->head = line->buffer;
358                 line->tail = line->buffer;
359         }
360         spin_unlock_irq(&line->lock);
361
362         if(tty == NULL)
363                 return IRQ_NONE;
364
365         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags) &&
366            (tty->ldisc.write_wakeup != NULL))
367                 (tty->ldisc.write_wakeup)(tty);
368         
369         /* BLOCKING mode
370          * In blocking mode, everything sleeps on tty->write_wait.
371          * Sleeping in the console driver would break non-blocking
372          * writes.
373          */
374
375         if (waitqueue_active(&tty->write_wait))
376                 wake_up_interruptible(&tty->write_wait);
377         return IRQ_HANDLED;
378 }
379
380 int line_setup_irq(int fd, int input, int output, struct tty_struct *tty)
381 {
382         struct line *line = tty->driver_data;
383         struct line_driver *driver = line->driver;
384         int err = 0, flags = SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM;
385
386         if (input)
387                 err = um_request_irq(driver->read_irq, fd, IRQ_READ,
388                                        line_interrupt, flags,
389                                        driver->read_irq_name, tty);
390         if (err)
391                 return err;
392         if (output)
393                 err = um_request_irq(driver->write_irq, fd, IRQ_WRITE,
394                                         line_write_interrupt, flags,
395                                         driver->write_irq_name, tty);
396         line->have_irq = 1;
397         return err;
398 }
399
400 void line_disable(struct tty_struct *tty, int current_irq)
401 {
402         struct line *line = tty->driver_data;
403
404         if(!line->have_irq)
405                 return;
406
407         if(line->driver->read_irq == current_irq)
408                 free_irq_later(line->driver->read_irq, tty);
409         else {
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(line->driver->write_irq, tty);
417         }
418
419         line->have_irq = 0;
420 }
421
422 int line_open(struct line *lines, struct tty_struct *tty,
423               struct chan_opts *opts)
424 {
425         struct line *line;
426         int err = 0;
427
428         line = &lines[tty->index];
429         tty->driver_data = line;
430
431         /* The IRQ which takes this lock is not yet enabled and won't be run
432          * before the end, so we don't need to use spin_lock_irq.*/
433         spin_lock(&line->lock);
434         if (tty->count == 1) {
435                 if (!line->valid) {
436                         err = -ENODEV;
437                         goto out;
438                 }
439                 if (list_empty(&line->chan_list)) {
440                         err = parse_chan_pair(line->init_str, &line->chan_list,
441                                               tty->index, opts);
442                         if(err) goto out;
443                         err = open_chan(&line->chan_list);
444                         if(err) goto out;
445                 }
446                 /* Here the interrupt is registered.*/
447                 enable_chan(&line->chan_list, tty);
448                 INIT_WORK(&line->task, line_timer_cb, tty);
449         }
450
451         if(!line->sigio){
452                 chan_enable_winch(&line->chan_list, tty);
453                 line->sigio = 1;
454         }
455         chan_window_size(&line->chan_list, &tty->winsize.ws_row,
456                          &tty->winsize.ws_col);
457         line->count++;
458
459 out:
460         spin_unlock(&line->lock);
461         return err;
462 }
463
464 static void unregister_winch(struct tty_struct *tty);
465
466 void line_close(struct tty_struct *tty, struct file * filp)
467 {
468         struct line *line = tty->driver_data;
469
470         /* XXX: I assume this should be called in process context, not with
471          *  interrupts disabled!
472          */
473         spin_lock_irq(&line->lock);
474
475         /* We ignore the error anyway! */
476         flush_buffer(line);
477
478         line->count--;
479         if (tty->count == 1) {
480                 line_disable(tty, -1);
481                 tty->driver_data = NULL;
482         }
483
484         if((line->count == 0) && line->sigio){
485                 unregister_winch(tty);
486                 line->sigio = 0;
487         }
488
489         spin_unlock_irq(&line->lock);
490 }
491
492 void close_lines(struct line *lines, int nlines)
493 {
494         int i;
495
496         for(i = 0; i < nlines; i++)
497                 close_chan(&lines[i].chan_list);
498 }
499
500 /* Common setup code for both startup command line and mconsole initialization.
501  * @lines contains the the array (of size @num) to modify;
502  * @init is the setup string;
503  */
504
505 int line_setup(struct line *lines, unsigned int num, char *init)
506 {
507         int i, n;
508         char *end;
509
510         if(*init == '=') {
511                 /* We said con=/ssl= instead of con#=, so we are configuring all
512                  * consoles at once.*/
513                 n = -1;
514         }
515         else {
516                 n = simple_strtoul(init, &end, 0);
517                 if(*end != '='){
518                         printk(KERN_ERR "line_setup failed to parse \"%s\"\n",
519                                init);
520                         return 0;
521                 }
522                 init = end;
523         }
524         init++;
525
526         if (n >= (signed int) num) {
527                 printk("line_setup - %d out of range ((0 ... %d) allowed)\n",
528                        n, num - 1);
529                 return 0;
530         }
531         else if (n >= 0){
532                 if (lines[n].count > 0) {
533                         printk("line_setup - device %d is open\n", n);
534                         return 0;
535                 }
536                 if (lines[n].init_pri <= INIT_ONE){
537                         lines[n].init_pri = INIT_ONE;
538                         if (!strcmp(init, "none"))
539                                 lines[n].valid = 0;
540                         else {
541                                 lines[n].init_str = init;
542                                 lines[n].valid = 1;
543                         }       
544                 }
545         }
546         else {
547                 for(i = 0; i < num; i++){
548                         if(lines[i].init_pri <= INIT_ALL){
549                                 lines[i].init_pri = INIT_ALL;
550                                 if(!strcmp(init, "none")) lines[i].valid = 0;
551                                 else {
552                                         lines[i].init_str = init;
553                                         lines[i].valid = 1;
554                                 }
555                         }
556                 }
557         }
558         return 1;
559 }
560
561 int line_config(struct line *lines, unsigned int num, char *str)
562 {
563         char *new;
564
565         if(*str == '='){
566                 printk("line_config - can't configure all devices from "
567                        "mconsole\n");
568                 return 1;
569         }
570
571         new = kstrdup(str, GFP_KERNEL);
572         if(new == NULL){
573                 printk("line_config - kstrdup failed\n");
574                 return -ENOMEM;
575         }
576         return !line_setup(lines, num, new);
577 }
578
579 int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
580                     int size, char **error_out)
581 {
582         struct line *line;
583         char *end;
584         int dev, n = 0;
585
586         dev = simple_strtoul(name, &end, 0);
587         if((*end != '\0') || (end == name)){
588                 *error_out = "line_get_config failed to parse device number";
589                 return 0;
590         }
591
592         if((dev < 0) || (dev >= num)){
593                 *error_out = "device number out of range";
594                 return 0;
595         }
596
597         line = &lines[dev];
598
599         spin_lock(&line->lock);
600         if(!line->valid)
601                 CONFIG_CHUNK(str, size, n, "none", 1);
602         else if(line->count == 0)
603                 CONFIG_CHUNK(str, size, n, line->init_str, 1);
604         else n = chan_config_string(&line->chan_list, str, size, error_out);
605         spin_unlock(&line->lock);
606
607         return n;
608 }
609
610 int line_id(char **str, int *start_out, int *end_out)
611 {
612         char *end;
613         int n;
614
615         n = simple_strtoul(*str, &end, 0);
616         if((*end != '\0') || (end == *str))
617                 return -1;
618
619         *str = end;
620         *start_out = n;
621         *end_out = n;
622         return n;
623 }
624
625 int line_remove(struct line *lines, unsigned int num, int n)
626 {
627         char config[sizeof("conxxxx=none\0")];
628
629         sprintf(config, "%d=none", n);
630         return !line_setup(lines, num, config);
631 }
632
633 struct tty_driver *line_register_devfs(struct lines *set,
634                          struct line_driver *line_driver,
635                          struct tty_operations *ops, struct line *lines,
636                          int nlines)
637 {
638         int i;
639         struct tty_driver *driver = alloc_tty_driver(nlines);
640
641         if (!driver)
642                 return NULL;
643
644         driver->driver_name = line_driver->name;
645         driver->name = line_driver->device_name;
646         driver->devfs_name = line_driver->devfs_name;
647         driver->major = line_driver->major;
648         driver->minor_start = line_driver->minor_start;
649         driver->type = line_driver->type;
650         driver->subtype = line_driver->subtype;
651         driver->flags = TTY_DRIVER_REAL_RAW;
652         driver->init_termios = tty_std_termios;
653         tty_set_operations(driver, ops);
654
655         if (tty_register_driver(driver)) {
656                 printk("%s: can't register %s driver\n",
657                        __FUNCTION__,line_driver->name);
658                 put_tty_driver(driver);
659                 return NULL;
660         }
661
662         for(i = 0; i < nlines; i++){
663                 if(!lines[i].valid)
664                         tty_unregister_device(driver, i);
665         }
666
667         mconsole_register_dev(&line_driver->mc);
668         return driver;
669 }
670
671 static spinlock_t winch_handler_lock;
672 LIST_HEAD(winch_handlers);
673
674 void lines_init(struct line *lines, int nlines)
675 {
676         struct line *line;
677         int i;
678
679         spin_lock_init(&winch_handler_lock);
680         for(i = 0; i < nlines; i++){
681                 line = &lines[i];
682                 INIT_LIST_HEAD(&line->chan_list);
683                 spin_lock_init(&line->lock);
684                 if(line->init_str == NULL)
685                         continue;
686
687                 line->init_str = kstrdup(line->init_str, GFP_KERNEL);
688                 if(line->init_str == NULL)
689                         printk("lines_init - kstrdup returned NULL\n");
690         }
691 }
692
693 struct winch {
694         struct list_head list;
695         int fd;
696         int tty_fd;
697         int pid;
698         struct tty_struct *tty;
699 };
700
701 irqreturn_t winch_interrupt(int irq, void *data, struct pt_regs *unused)
702 {
703         struct winch *winch = data;
704         struct tty_struct *tty;
705         struct line *line;
706         int err;
707         char c;
708
709         if(winch->fd != -1){
710                 err = generic_read(winch->fd, &c, NULL);
711                 if(err < 0){
712                         if(err != -EAGAIN){
713                                 printk("winch_interrupt : read failed, "
714                                        "errno = %d\n", -err);
715                                 printk("fd %d is losing SIGWINCH support\n",
716                                        winch->tty_fd);
717                                 return IRQ_HANDLED;
718                         }
719                         goto out;
720                 }
721         }
722         tty  = winch->tty;
723         if (tty != NULL) {
724                 line = tty->driver_data;
725                 chan_window_size(&line->chan_list, &tty->winsize.ws_row,
726                                  &tty->winsize.ws_col);
727                 kill_pg(tty->pgrp, SIGWINCH, 1);
728         }
729  out:
730         if(winch->fd != -1)
731                 reactivate_fd(winch->fd, WINCH_IRQ);
732         return IRQ_HANDLED;
733 }
734
735 void register_winch_irq(int fd, int tty_fd, int pid, struct tty_struct *tty)
736 {
737         struct winch *winch;
738
739         winch = kmalloc(sizeof(*winch), GFP_KERNEL);
740         if (winch == NULL) {
741                 printk("register_winch_irq - kmalloc failed\n");
742                 return;
743         }
744
745         *winch = ((struct winch) { .list        = LIST_HEAD_INIT(winch->list),
746                                    .fd          = fd,
747                                    .tty_fd      = tty_fd,
748                                    .pid         = pid,
749                                    .tty         = tty });
750
751         spin_lock(&winch_handler_lock);
752         list_add(&winch->list, &winch_handlers);
753         spin_unlock(&winch_handler_lock);
754
755         if(um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
756                           SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
757                           "winch", winch) < 0)
758                 printk("register_winch_irq - failed to register IRQ\n");
759 }
760
761 static void unregister_winch(struct tty_struct *tty)
762 {
763         struct list_head *ele;
764         struct winch *winch, *found = NULL;
765
766         spin_lock(&winch_handler_lock);
767         list_for_each(ele, &winch_handlers){
768                 winch = list_entry(ele, struct winch, list);
769                 if(winch->tty == tty){
770                         found = winch;
771                         break;
772                 }
773         }
774         if(found == NULL)
775                 goto err;
776
777         list_del(&winch->list);
778         spin_unlock(&winch_handler_lock);
779
780         if(winch->pid != -1)
781                 os_kill_process(winch->pid, 1);
782
783         free_irq(WINCH_IRQ, winch);
784         kfree(winch);
785
786         return;
787 err:
788         spin_unlock(&winch_handler_lock);
789 }
790
791 /* XXX: No lock as it's an exitcall... is this valid? Depending on cleanup
792  * order... are we sure that nothing else is done on the list? */
793 static void winch_cleanup(void)
794 {
795         struct list_head *ele;
796         struct winch *winch;
797
798         list_for_each(ele, &winch_handlers){
799                 winch = list_entry(ele, struct winch, list);
800                 if(winch->fd != -1){
801                         /* Why is this different from the above free_irq(),
802                          * which deactivates SIGIO? This searches the FD
803                          * somewhere else and removes it from the list... */
804                         deactivate_fd(winch->fd, WINCH_IRQ);
805                         os_close_file(winch->fd);
806                 }
807                 if(winch->pid != -1)
808                         os_kill_process(winch->pid, 1);
809         }
810 }
811 __uml_exitcall(winch_cleanup);
812
813 char *add_xterm_umid(char *base)
814 {
815         char *umid, *title;
816         int len;
817
818         umid = get_umid(1);
819         if(umid == NULL)
820                 return base;
821         
822         len = strlen(base) + strlen(" ()") + strlen(umid) + 1;
823         title = kmalloc(len, GFP_KERNEL);
824         if(title == NULL){
825                 printk("Failed to allocate buffer for xterm title\n");
826                 return base;
827         }
828
829         snprintf(title, len, "%s (%s)", base, umid);
830         return title;
831 }