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