• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
line_interrupt(int irq,void * data)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  */
write_room(struct line * line)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 
line_write_room(struct tty_struct * tty)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 
line_chars_in_buffer(struct tty_struct * tty)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  */
buffer_data(struct line * line,const char * buf,int len)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!*/
flush_buffer(struct line * line)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 
line_flush_buffer(struct tty_struct * tty)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  */
line_flush_chars(struct tty_struct * tty)180 void line_flush_chars(struct tty_struct *tty)
181 {
182 	line_flush_buffer(tty);
183 }
184 
line_put_char(struct tty_struct * tty,unsigned char ch)185 int line_put_char(struct tty_struct *tty, unsigned char ch)
186 {
187 	return line_write(tty, &ch, sizeof(ch));
188 }
189 
line_write(struct tty_struct * tty,const unsigned char * buf,int len)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 
line_set_termios(struct tty_struct * tty,struct ktermios * old)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 
line_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)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 
line_throttle(struct tty_struct * tty)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 
line_unthrottle(struct tty_struct * tty)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 
line_write_interrupt(int irq,void * data)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 
line_setup_irq(int fd,int input,int output,struct line * line,void * data)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 
line_open(struct line * lines,struct tty_struct * tty)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 
line_close(struct tty_struct * tty,struct file * filp)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 
close_lines(struct line * lines,int nlines)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 
setup_one_line(struct line * lines,int n,char * init,const struct chan_opts * opts,char ** error_out)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 
line_setup(char ** conf,unsigned int num,char ** def,char * init,char * name)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 
line_config(struct line * lines,unsigned int num,char * str,const struct chan_opts * opts,char ** error_out)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 
line_get_config(char * name,struct line * lines,unsigned int num,char * str,int size,char ** error_out)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 
line_id(char ** str,int * start_out,int * end_out)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 
line_remove(struct line * lines,unsigned int num,int n,char ** error_out)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 
register_lines(struct line_driver * line_driver,const struct tty_operations * ops,struct line * lines,int nlines)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 
__free_winch(struct work_struct * work)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 
free_winch(struct winch * winch)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 
winch_interrupt(int irq,void * data)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 
register_winch_irq(int fd,int tty_fd,int pid,struct tty_struct * tty,unsigned long stack)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 
unregister_winch(struct tty_struct * tty)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 
winch_cleanup(void)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 
add_xterm_umid(char * base)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 }
856