1dbddf429SAlex Dewar // SPDX-License-Identifier: GPL-2.0
21da177e4SLinus Torvalds /*
32f8a2dc2SJeff Dike * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
41da177e4SLinus Torvalds */
51da177e4SLinus Torvalds
637185b33SAl Viro #include <linux/irqreturn.h>
737185b33SAl Viro #include <linux/kd.h>
83f07c014SIngo Molnar #include <linux/sched/signal.h>
937185b33SAl Viro #include <linux/slab.h>
103f07c014SIngo Molnar
11510c72a3SAl Viro #include "chan.h"
1237185b33SAl Viro #include <irq_kern.h>
1337185b33SAl Viro #include <irq_user.h>
1437185b33SAl Viro #include <kern_util.h>
1537185b33SAl Viro #include <os.h>
161da177e4SLinus Torvalds
171da177e4SLinus Torvalds #define LINE_BUFSIZE 4096
181da177e4SLinus Torvalds
line_interrupt(int irq,void * data)197bea96fdSAl Viro static irqreturn_t line_interrupt(int irq, void *data)
201da177e4SLinus Torvalds {
21165dc591SJeff Dike struct chan *chan = data;
22165dc591SJeff Dike struct line *line = chan->line;
231da177e4SLinus Torvalds
241da177e4SLinus Torvalds if (line)
252e124b4aSJiri Slaby chan_interrupt(line, irq);
262e124b4aSJiri Slaby
271da177e4SLinus Torvalds return IRQ_HANDLED;
281da177e4SLinus Torvalds }
291da177e4SLinus Torvalds
302f8a2dc2SJeff Dike /*
312f8a2dc2SJeff Dike * Returns the free space inside the ring buffer of this line.
32b97b77ccSPaolo 'Blaisorblade' Giarrusso *
33b60745b9SSimon Arlott * Should be called while holding line->lock (this does not modify data).
34b97b77ccSPaolo 'Blaisorblade' Giarrusso */
write_room(struct line * line)3503b3b1a2SJiri Slaby static unsigned int write_room(struct line *line)
361da177e4SLinus Torvalds {
371da177e4SLinus Torvalds int n;
381da177e4SLinus Torvalds
39b97b77ccSPaolo 'Blaisorblade' Giarrusso if (line->buffer == NULL)
40b97b77ccSPaolo 'Blaisorblade' Giarrusso return LINE_BUFSIZE - 1;
411da177e4SLinus Torvalds
42b97b77ccSPaolo 'Blaisorblade' Giarrusso /* This is for the case where the buffer is wrapped! */
43b97b77ccSPaolo 'Blaisorblade' Giarrusso n = line->head - line->tail;
44b97b77ccSPaolo 'Blaisorblade' Giarrusso
451da177e4SLinus Torvalds if (n <= 0)
46acb2cf34SJeff Dike n += LINE_BUFSIZE; /* The other case */
47b97b77ccSPaolo 'Blaisorblade' Giarrusso return n - 1;
481da177e4SLinus Torvalds }
491da177e4SLinus Torvalds
line_write_room(struct tty_struct * tty)5003b3b1a2SJiri Slaby unsigned int line_write_room(struct tty_struct *tty)
51b97b77ccSPaolo 'Blaisorblade' Giarrusso {
52b97b77ccSPaolo 'Blaisorblade' Giarrusso struct line *line = tty->driver_data;
53b97b77ccSPaolo 'Blaisorblade' Giarrusso unsigned long flags;
5403b3b1a2SJiri Slaby unsigned int room;
55b97b77ccSPaolo 'Blaisorblade' Giarrusso
56b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_lock_irqsave(&line->lock, flags);
57b97b77ccSPaolo 'Blaisorblade' Giarrusso room = write_room(line);
58b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_unlock_irqrestore(&line->lock, flags);
59b97b77ccSPaolo 'Blaisorblade' Giarrusso
60b97b77ccSPaolo 'Blaisorblade' Giarrusso return room;
61b97b77ccSPaolo 'Blaisorblade' Giarrusso }
62b97b77ccSPaolo 'Blaisorblade' Giarrusso
line_chars_in_buffer(struct tty_struct * tty)63fff4ef17SJiri Slaby unsigned int line_chars_in_buffer(struct tty_struct *tty)
64b97b77ccSPaolo 'Blaisorblade' Giarrusso {
65b97b77ccSPaolo 'Blaisorblade' Giarrusso struct line *line = tty->driver_data;
66b97b77ccSPaolo 'Blaisorblade' Giarrusso unsigned long flags;
67fff4ef17SJiri Slaby unsigned int ret;
68b97b77ccSPaolo 'Blaisorblade' Giarrusso
69b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_lock_irqsave(&line->lock, flags);
70b97b77ccSPaolo 'Blaisorblade' Giarrusso /* write_room subtracts 1 for the needed NULL, so we readd it.*/
71b97b77ccSPaolo 'Blaisorblade' Giarrusso ret = LINE_BUFSIZE - (write_room(line) + 1);
72b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_unlock_irqrestore(&line->lock, flags);
73b97b77ccSPaolo 'Blaisorblade' Giarrusso
74b97b77ccSPaolo 'Blaisorblade' Giarrusso return ret;
75b97b77ccSPaolo 'Blaisorblade' Giarrusso }
76b97b77ccSPaolo 'Blaisorblade' Giarrusso
77b97b77ccSPaolo 'Blaisorblade' Giarrusso /*
78b97b77ccSPaolo 'Blaisorblade' Giarrusso * This copies the content of buf into the circular buffer associated with
79b97b77ccSPaolo 'Blaisorblade' Giarrusso * this line.
80b97b77ccSPaolo 'Blaisorblade' Giarrusso * The return value is the number of characters actually copied, i.e. the ones
81b97b77ccSPaolo 'Blaisorblade' Giarrusso * for which there was space: this function is not supposed to ever flush out
82b97b77ccSPaolo 'Blaisorblade' Giarrusso * the circular buffer.
83b97b77ccSPaolo 'Blaisorblade' Giarrusso *
84b97b77ccSPaolo 'Blaisorblade' Giarrusso * Must be called while holding line->lock!
85b97b77ccSPaolo 'Blaisorblade' Giarrusso */
buffer_data(struct line * line,const char * buf,int len)861da177e4SLinus Torvalds static int buffer_data(struct line *line, const char *buf, int len)
871da177e4SLinus Torvalds {
881da177e4SLinus Torvalds int end, room;
891da177e4SLinus Torvalds
901da177e4SLinus Torvalds if (line->buffer == NULL) {
911da177e4SLinus Torvalds line->buffer = kmalloc(LINE_BUFSIZE, GFP_ATOMIC);
921da177e4SLinus Torvalds if (line->buffer == NULL) {
932f8a2dc2SJeff Dike printk(KERN_ERR "buffer_data - atomic allocation "
942f8a2dc2SJeff Dike "failed\n");
952f8a2dc2SJeff Dike return 0;
961da177e4SLinus Torvalds }
971da177e4SLinus Torvalds line->head = line->buffer;
981da177e4SLinus Torvalds line->tail = line->buffer;
991da177e4SLinus Torvalds }
1001da177e4SLinus Torvalds
1011da177e4SLinus Torvalds room = write_room(line);
1021da177e4SLinus Torvalds len = (len > room) ? room : len;
1031da177e4SLinus Torvalds
1041da177e4SLinus Torvalds end = line->buffer + LINE_BUFSIZE - line->tail;
105b97b77ccSPaolo 'Blaisorblade' Giarrusso
1061da177e4SLinus Torvalds if (len < end) {
1071da177e4SLinus Torvalds memcpy(line->tail, buf, len);
1081da177e4SLinus Torvalds line->tail += len;
109d50084a2SJeff Dike }
110d50084a2SJeff Dike else {
111b97b77ccSPaolo 'Blaisorblade' Giarrusso /* The circular buffer is wrapping */
1121da177e4SLinus Torvalds memcpy(line->tail, buf, end);
1131da177e4SLinus Torvalds buf += end;
1141da177e4SLinus Torvalds memcpy(line->buffer, buf, len - end);
1151da177e4SLinus Torvalds line->tail = line->buffer + len - end;
1161da177e4SLinus Torvalds }
1171da177e4SLinus Torvalds
118b97b77ccSPaolo 'Blaisorblade' Giarrusso return len;
1191da177e4SLinus Torvalds }
1201da177e4SLinus Torvalds
121b97b77ccSPaolo 'Blaisorblade' Giarrusso /*
122b97b77ccSPaolo 'Blaisorblade' Giarrusso * Flushes the ring buffer to the output channels. That is, write_chan is
123b97b77ccSPaolo 'Blaisorblade' Giarrusso * called, passing it line->head as buffer, and an appropriate count.
124b97b77ccSPaolo 'Blaisorblade' Giarrusso *
125b97b77ccSPaolo 'Blaisorblade' Giarrusso * On exit, returns 1 when the buffer is empty,
126b97b77ccSPaolo 'Blaisorblade' Giarrusso * 0 when the buffer is not empty on exit,
127b97b77ccSPaolo 'Blaisorblade' Giarrusso * and -errno when an error occurred.
128b97b77ccSPaolo 'Blaisorblade' Giarrusso *
129b97b77ccSPaolo 'Blaisorblade' Giarrusso * Must be called while holding line->lock!*/
flush_buffer(struct line * line)1301da177e4SLinus Torvalds static int flush_buffer(struct line *line)
1311da177e4SLinus Torvalds {
1321da177e4SLinus Torvalds int n, count;
1331da177e4SLinus Torvalds
1341da177e4SLinus Torvalds if ((line->buffer == NULL) || (line->head == line->tail))
135b97b77ccSPaolo 'Blaisorblade' Giarrusso return 1;
1361da177e4SLinus Torvalds
1371da177e4SLinus Torvalds if (line->tail < line->head) {
138b97b77ccSPaolo 'Blaisorblade' Giarrusso /* line->buffer + LINE_BUFSIZE is the end of the buffer! */
1391da177e4SLinus Torvalds count = line->buffer + LINE_BUFSIZE - line->head;
140b97b77ccSPaolo 'Blaisorblade' Giarrusso
141bed5e39cSAl Viro n = write_chan(line->chan_out, line->head, count,
142d5a9597dSJohannes Berg line->write_irq);
1431da177e4SLinus Torvalds if (n < 0)
144b97b77ccSPaolo 'Blaisorblade' Giarrusso return n;
145b97b77ccSPaolo 'Blaisorblade' Giarrusso if (n == count) {
1462f8a2dc2SJeff Dike /*
1472f8a2dc2SJeff Dike * We have flushed from ->head to buffer end, now we
1482f8a2dc2SJeff Dike * must flush only from the beginning to ->tail.
1492f8a2dc2SJeff Dike */
1501da177e4SLinus Torvalds line->head = line->buffer;
151b97b77ccSPaolo 'Blaisorblade' Giarrusso } else {
1521da177e4SLinus Torvalds line->head += n;
153b97b77ccSPaolo 'Blaisorblade' Giarrusso return 0;
1541da177e4SLinus Torvalds }
1551da177e4SLinus Torvalds }
1561da177e4SLinus Torvalds
1571da177e4SLinus Torvalds count = line->tail - line->head;
158bed5e39cSAl Viro n = write_chan(line->chan_out, line->head, count,
159d5a9597dSJohannes Berg line->write_irq);
160b97b77ccSPaolo 'Blaisorblade' Giarrusso
161b97b77ccSPaolo 'Blaisorblade' Giarrusso if (n < 0)
162b97b77ccSPaolo 'Blaisorblade' Giarrusso return n;
1631da177e4SLinus Torvalds
1641da177e4SLinus Torvalds line->head += n;
165b97b77ccSPaolo 'Blaisorblade' Giarrusso return line->head == line->tail;
166b97b77ccSPaolo 'Blaisorblade' Giarrusso }
167b97b77ccSPaolo 'Blaisorblade' Giarrusso
line_flush_buffer(struct tty_struct * tty)168b97b77ccSPaolo 'Blaisorblade' Giarrusso void line_flush_buffer(struct tty_struct *tty)
169b97b77ccSPaolo 'Blaisorblade' Giarrusso {
170b97b77ccSPaolo 'Blaisorblade' Giarrusso struct line *line = tty->driver_data;
171b97b77ccSPaolo 'Blaisorblade' Giarrusso unsigned long flags;
172b97b77ccSPaolo 'Blaisorblade' Giarrusso
173b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_lock_irqsave(&line->lock, flags);
174f1c93e49SRichard Weinberger flush_buffer(line);
175b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_unlock_irqrestore(&line->lock, flags);
176b97b77ccSPaolo 'Blaisorblade' Giarrusso }
177b97b77ccSPaolo 'Blaisorblade' Giarrusso
1782f8a2dc2SJeff Dike /*
1792f8a2dc2SJeff Dike * We map both ->flush_chars and ->put_char (which go in pair) onto
1802f8a2dc2SJeff Dike * ->flush_buffer and ->write. Hope it's not that bad.
1812f8a2dc2SJeff Dike */
line_flush_chars(struct tty_struct * tty)182b97b77ccSPaolo 'Blaisorblade' Giarrusso void line_flush_chars(struct tty_struct *tty)
183b97b77ccSPaolo 'Blaisorblade' Giarrusso {
184b97b77ccSPaolo 'Blaisorblade' Giarrusso line_flush_buffer(tty);
185b97b77ccSPaolo 'Blaisorblade' Giarrusso }
186b97b77ccSPaolo 'Blaisorblade' Giarrusso
line_write(struct tty_struct * tty,const u8 * buf,size_t len)187*95713967SJiri Slaby (SUSE) ssize_t line_write(struct tty_struct *tty, const u8 *buf, size_t len)
1881da177e4SLinus Torvalds {
1891da177e4SLinus Torvalds struct line *line = tty->driver_data;
1901da177e4SLinus Torvalds unsigned long flags;
191c59dbcadSJeff Dike int n, ret = 0;
1921da177e4SLinus Torvalds
193b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_lock_irqsave(&line->lock, flags);
194c59dbcadSJeff Dike if (line->head != line->tail)
1951da177e4SLinus Torvalds ret = buffer_data(line, buf, len);
196c59dbcadSJeff Dike else {
197bed5e39cSAl Viro n = write_chan(line->chan_out, buf, len,
198d5a9597dSJohannes Berg line->write_irq);
1991da177e4SLinus Torvalds if (n < 0) {
2001da177e4SLinus Torvalds ret = n;
2011da177e4SLinus Torvalds goto out_up;
2021da177e4SLinus Torvalds }
2031da177e4SLinus Torvalds
2041da177e4SLinus Torvalds len -= n;
2051da177e4SLinus Torvalds ret += n;
2061da177e4SLinus Torvalds if (len > 0)
2071da177e4SLinus Torvalds ret += buffer_data(line, buf + n, len);
2081da177e4SLinus Torvalds }
2091da177e4SLinus Torvalds out_up:
210b97b77ccSPaolo 'Blaisorblade' Giarrusso spin_unlock_irqrestore(&line->lock, flags);
211b97b77ccSPaolo 'Blaisorblade' Giarrusso return ret;
2121da177e4SLinus Torvalds }
2131da177e4SLinus Torvalds
line_throttle(struct tty_struct * tty)214e4dcee80SJeff Dike void line_throttle(struct tty_struct *tty)
215e4dcee80SJeff Dike {
216e4dcee80SJeff Dike struct line *line = tty->driver_data;
217e4dcee80SJeff Dike
218d5a9597dSJohannes Berg deactivate_chan(line->chan_in, line->read_irq);
219e4dcee80SJeff Dike line->throttled = 1;
220e4dcee80SJeff Dike }
221e4dcee80SJeff Dike
line_unthrottle(struct tty_struct * tty)222e4dcee80SJeff Dike void line_unthrottle(struct tty_struct *tty)
223e4dcee80SJeff Dike {
224e4dcee80SJeff Dike struct line *line = tty->driver_data;
225e4dcee80SJeff Dike
226e4dcee80SJeff Dike line->throttled = 0;
227d5a9597dSJohannes Berg chan_interrupt(line, line->read_irq);
228e4dcee80SJeff Dike }
229e4dcee80SJeff Dike
line_write_interrupt(int irq,void * data)2307bea96fdSAl Viro static irqreturn_t line_write_interrupt(int irq, void *data)
2311da177e4SLinus Torvalds {
232165dc591SJeff Dike struct chan *chan = data;
233165dc591SJeff Dike struct line *line = chan->line;
2341da177e4SLinus Torvalds int err;
2351da177e4SLinus Torvalds
2362f8a2dc2SJeff Dike /*
237c0b79a90SYong Zhang * Interrupts are disabled here because genirq keep irqs disabled when
238c0b79a90SYong Zhang * calling the action handler.
2392f8a2dc2SJeff Dike */
240b97b77ccSPaolo 'Blaisorblade' Giarrusso
241ec0ac8adSPaolo 'Blaisorblade' Giarrusso spin_lock(&line->lock);
2421da177e4SLinus Torvalds err = flush_buffer(line);
243b97b77ccSPaolo 'Blaisorblade' Giarrusso if (err == 0) {
244199eebbaSAl Viro spin_unlock(&line->lock);
245b97b77ccSPaolo 'Blaisorblade' Giarrusso return IRQ_NONE;
246917e2fd2SAnton Ivanov } else if ((err < 0) && (err != -EAGAIN)) {
2471da177e4SLinus Torvalds line->head = line->buffer;
2481da177e4SLinus Torvalds line->tail = line->buffer;
2491da177e4SLinus Torvalds }
250ec0ac8adSPaolo 'Blaisorblade' Giarrusso spin_unlock(&line->lock);
2511da177e4SLinus Torvalds
2526aad04f2SJiri Slaby tty_port_tty_wakeup(&line->port);
2536fc58845SJiri Slaby
254b97b77ccSPaolo 'Blaisorblade' Giarrusso return IRQ_HANDLED;
2551da177e4SLinus Torvalds }
2561da177e4SLinus Torvalds
line_setup_irq(int fd,int input,int output,struct line * line,void * data)257165dc591SJeff Dike int line_setup_irq(int fd, int input, int output, struct line *line, void *data)
2581da177e4SLinus Torvalds {
2595e7672ecSJeff Dike const struct line_driver *driver = line->driver;
26036d46a59SJohannes Berg int err;
2611da177e4SLinus Torvalds
26236d46a59SJohannes Berg if (input) {
263d5a9597dSJohannes Berg err = um_request_irq(UM_IRQ_ALLOC, fd, IRQ_READ,
264d5a9597dSJohannes Berg line_interrupt, 0,
265165dc591SJeff Dike driver->read_irq_name, data);
26636d46a59SJohannes Berg if (err < 0)
267b97b77ccSPaolo 'Blaisorblade' Giarrusso return err;
268d5a9597dSJohannes Berg
269d5a9597dSJohannes Berg line->read_irq = err;
27036d46a59SJohannes Berg }
27136d46a59SJohannes Berg
27236d46a59SJohannes Berg if (output) {
273d5a9597dSJohannes Berg err = um_request_irq(UM_IRQ_ALLOC, fd, IRQ_WRITE,
274d5a9597dSJohannes Berg line_write_interrupt, 0,
275165dc591SJeff Dike driver->write_irq_name, data);
27636d46a59SJohannes Berg if (err < 0)
277b97b77ccSPaolo 'Blaisorblade' Giarrusso return err;
278d5a9597dSJohannes Berg
279d5a9597dSJohannes Berg line->write_irq = err;
2801da177e4SLinus Torvalds }
2811da177e4SLinus Torvalds
28236d46a59SJohannes Berg return 0;
28336d46a59SJohannes Berg }
28436d46a59SJohannes Berg
line_activate(struct tty_port * port,struct tty_struct * tty)28579e0273dSRichard Weinberger static int line_activate(struct tty_port *port, struct tty_struct *tty)
2861da177e4SLinus Torvalds {
28779e0273dSRichard Weinberger int ret;
28879e0273dSRichard Weinberger struct line *line = tty->driver_data;
2891da177e4SLinus Torvalds
29079e0273dSRichard Weinberger ret = enable_chan(line);
29179e0273dSRichard Weinberger if (ret)
29279e0273dSRichard Weinberger return ret;
293d14ad81fSJeff Dike
2941da177e4SLinus Torvalds if (!line->sigio) {
2952116bda6SRichard Weinberger chan_enable_winch(line->chan_out, port);
2961da177e4SLinus Torvalds line->sigio = 1;
2971da177e4SLinus Torvalds }
298165dc591SJeff Dike
299bed5e39cSAl Viro chan_window_size(line, &tty->winsize.ws_row,
3001da177e4SLinus Torvalds &tty->winsize.ws_col);
30179e0273dSRichard Weinberger
30279e0273dSRichard Weinberger return 0;
30379e0273dSRichard Weinberger }
30479e0273dSRichard Weinberger
305cc4f0248SRichard Weinberger static void unregister_winch(struct tty_struct *tty);
306cc4f0248SRichard Weinberger
line_destruct(struct tty_port * port)307cc4f0248SRichard Weinberger static void line_destruct(struct tty_port *port)
308cc4f0248SRichard Weinberger {
309cc4f0248SRichard Weinberger struct tty_struct *tty = tty_port_tty_get(port);
310cc4f0248SRichard Weinberger struct line *line = tty->driver_data;
311cc4f0248SRichard Weinberger
312cc4f0248SRichard Weinberger if (line->sigio) {
313cc4f0248SRichard Weinberger unregister_winch(tty);
314cc4f0248SRichard Weinberger line->sigio = 0;
315cc4f0248SRichard Weinberger }
316cc4f0248SRichard Weinberger }
317cc4f0248SRichard Weinberger
31879e0273dSRichard Weinberger static const struct tty_port_operations line_port_ops = {
31979e0273dSRichard Weinberger .activate = line_activate,
320cc4f0248SRichard Weinberger .destruct = line_destruct,
32179e0273dSRichard Weinberger };
32279e0273dSRichard Weinberger
line_open(struct tty_struct * tty,struct file * filp)32379e0273dSRichard Weinberger int line_open(struct tty_struct *tty, struct file *filp)
32479e0273dSRichard Weinberger {
32579e0273dSRichard Weinberger struct line *line = tty->driver_data;
32679e0273dSRichard Weinberger
32779e0273dSRichard Weinberger return tty_port_open(&line->port, tty, filp);
32879e0273dSRichard Weinberger }
32979e0273dSRichard Weinberger
line_install(struct tty_driver * driver,struct tty_struct * tty,struct line * line)33079e0273dSRichard Weinberger int line_install(struct tty_driver *driver, struct tty_struct *tty,
33179e0273dSRichard Weinberger struct line *line)
33279e0273dSRichard Weinberger {
33379e0273dSRichard Weinberger int ret;
33479e0273dSRichard Weinberger
33579e0273dSRichard Weinberger ret = tty_standard_install(driver, tty);
33679e0273dSRichard Weinberger if (ret)
33779e0273dSRichard Weinberger return ret;
33879e0273dSRichard Weinberger
33979e0273dSRichard Weinberger tty->driver_data = line;
34079e0273dSRichard Weinberger
34179e0273dSRichard Weinberger return 0;
3421da177e4SLinus Torvalds }
3431da177e4SLinus Torvalds
line_close(struct tty_struct * tty,struct file * filp)34479e0273dSRichard Weinberger void line_close(struct tty_struct *tty, struct file * filp)
34579e0273dSRichard Weinberger {
34679e0273dSRichard Weinberger struct line *line = tty->driver_data;
34779e0273dSRichard Weinberger
34879e0273dSRichard Weinberger tty_port_close(&line->port, tty, filp);
34979e0273dSRichard Weinberger }
35079e0273dSRichard Weinberger
line_hangup(struct tty_struct * tty)35179e0273dSRichard Weinberger void line_hangup(struct tty_struct *tty)
35279e0273dSRichard Weinberger {
35379e0273dSRichard Weinberger struct line *line = tty->driver_data;
35479e0273dSRichard Weinberger
35579e0273dSRichard Weinberger tty_port_hangup(&line->port);
3561da177e4SLinus Torvalds }
3571da177e4SLinus Torvalds
close_lines(struct line * lines,int nlines)3581da177e4SLinus Torvalds void close_lines(struct line *lines, int nlines)
3591da177e4SLinus Torvalds {
3601da177e4SLinus Torvalds int i;
3611da177e4SLinus Torvalds
3621da177e4SLinus Torvalds for(i = 0; i < nlines; i++)
36310c890c0SAl Viro close_chan(&lines[i]);
3641da177e4SLinus Torvalds }
3651da177e4SLinus Torvalds
setup_one_line(struct line * lines,int n,char * init,const struct chan_opts * opts,char ** error_out)36604292b2cSAl Viro int setup_one_line(struct line *lines, int n, char *init,
36731efcebbSAl Viro const struct chan_opts *opts, char **error_out)
368d79a5809SJeff Dike {
369d79a5809SJeff Dike struct line *line = &lines[n];
370cfe6b7c7SAl Viro struct tty_driver *driver = line->driver->driver;
371f28169d2SJeff Dike int err = -EINVAL;
372d79a5809SJeff Dike
373060ed31dSJiri Slaby if (line->port.count) {
374f28169d2SJeff Dike *error_out = "Device is already open";
375d79a5809SJeff Dike goto out;
376d79a5809SJeff Dike }
377d79a5809SJeff Dike
37831efcebbSAl Viro if (!strcmp(init, "none")) {
37931efcebbSAl Viro if (line->valid) {
380d79a5809SJeff Dike line->valid = 0;
38131efcebbSAl Viro kfree(line->init_str);
382cfe6b7c7SAl Viro tty_unregister_device(driver, n);
38331efcebbSAl Viro parse_chan_pair(NULL, line, n, opts, error_out);
384f28169d2SJeff Dike err = 0;
38531efcebbSAl Viro }
38631efcebbSAl Viro } else {
38731efcebbSAl Viro char *new = kstrdup(init, GFP_KERNEL);
38831efcebbSAl Viro if (!new) {
38931efcebbSAl Viro *error_out = "Failed to allocate memory";
39031efcebbSAl Viro return -ENOMEM;
39131efcebbSAl Viro }
392c8e2876fSAl Viro if (line->valid) {
393cfe6b7c7SAl Viro tty_unregister_device(driver, n);
394c8e2876fSAl Viro kfree(line->init_str);
395c8e2876fSAl Viro }
39631efcebbSAl Viro line->init_str = new;
39731efcebbSAl Viro line->valid = 1;
39831efcebbSAl Viro err = parse_chan_pair(new, line, n, opts, error_out);
399cfe6b7c7SAl Viro if (!err) {
400734cc178SJiri Slaby struct device *d = tty_port_register_device(&line->port,
401734cc178SJiri Slaby driver, n, NULL);
402cfe6b7c7SAl Viro if (IS_ERR(d)) {
403cfe6b7c7SAl Viro *error_out = "Failed to register device";
404cfe6b7c7SAl Viro err = PTR_ERR(d);
405cfe6b7c7SAl Viro parse_chan_pair(NULL, line, n, opts, error_out);
406cfe6b7c7SAl Viro }
407cfe6b7c7SAl Viro }
40831efcebbSAl Viro if (err) {
40931efcebbSAl Viro line->init_str = NULL;
41031efcebbSAl Viro line->valid = 0;
41131efcebbSAl Viro kfree(new);
41231efcebbSAl Viro }
41331efcebbSAl Viro }
414d79a5809SJeff Dike out:
415f28169d2SJeff Dike return err;
416d79a5809SJeff Dike }
417d79a5809SJeff Dike
4182f8a2dc2SJeff Dike /*
4192f8a2dc2SJeff Dike * Common setup code for both startup command line and mconsole initialization.
4204b3f686dSMatt LaPlante * @lines contains the array (of size @num) to modify;
421b97b77ccSPaolo 'Blaisorblade' Giarrusso * @init is the setup string;
422f28169d2SJeff Dike * @error_out is an error string in the case of failure;
423d571cd18SJeff Dike */
424b97b77ccSPaolo 'Blaisorblade' Giarrusso
line_setup(char ** conf,unsigned int num,char ** def,char * init,char * name)42543574c1aSAl Viro int line_setup(char **conf, unsigned int num, char **def,
42643574c1aSAl Viro char *init, char *name)
4271da177e4SLinus Torvalds {
42843574c1aSAl Viro char *error;
4291da177e4SLinus Torvalds
430b97b77ccSPaolo 'Blaisorblade' Giarrusso if (*init == '=') {
4312f8a2dc2SJeff Dike /*
4322f8a2dc2SJeff Dike * We said con=/ssl= instead of con#=, so we are configuring all
4332f8a2dc2SJeff Dike * consoles at once.
4342f8a2dc2SJeff Dike */
43543574c1aSAl Viro *def = init + 1;
43643574c1aSAl Viro } else {
43743574c1aSAl Viro char *end;
43843574c1aSAl Viro unsigned n = simple_strtoul(init, &end, 0);
439b97b77ccSPaolo 'Blaisorblade' Giarrusso
44043574c1aSAl Viro if (*end != '=') {
44143574c1aSAl Viro error = "Couldn't parse device number";
44243574c1aSAl Viro goto out;
44343574c1aSAl Viro }
44443574c1aSAl Viro if (n >= num) {
44543574c1aSAl Viro error = "Device number out of range";
44643574c1aSAl Viro goto out;
44743574c1aSAl Viro }
44843574c1aSAl Viro conf[n] = end + 1;
44943574c1aSAl Viro }
45043574c1aSAl Viro return 0;
45143574c1aSAl Viro
45243574c1aSAl Viro out:
45343574c1aSAl Viro printk(KERN_ERR "Failed to set up %s with "
45443574c1aSAl Viro "configuration string \"%s\" : %s\n", name, init, error);
455f28169d2SJeff Dike return -EINVAL;
456d50084a2SJeff Dike }
4571da177e4SLinus Torvalds
line_config(struct line * lines,unsigned int num,char * str,const struct chan_opts * opts,char ** error_out)4581f80171eSJeff Dike int line_config(struct line *lines, unsigned int num, char *str,
459f28169d2SJeff Dike const struct chan_opts *opts, char **error_out)
4601da177e4SLinus Torvalds {
461fe9a6b00SAl Viro char *end;
46231efcebbSAl Viro int n;
4631da177e4SLinus Torvalds
464d571cd18SJeff Dike if (*str == '=') {
465f28169d2SJeff Dike *error_out = "Can't configure all devices from mconsole";
466f28169d2SJeff Dike return -EINVAL;
467d571cd18SJeff Dike }
468d571cd18SJeff Dike
469fe9a6b00SAl Viro n = simple_strtoul(str, &end, 0);
470fe9a6b00SAl Viro if (*end++ != '=') {
471fe9a6b00SAl Viro *error_out = "Couldn't parse device number";
472fe9a6b00SAl Viro return -EINVAL;
473fe9a6b00SAl Viro }
474fe9a6b00SAl Viro if (n >= num) {
475fe9a6b00SAl Viro *error_out = "Device number out of range";
476fe9a6b00SAl Viro return -EINVAL;
477fe9a6b00SAl Viro }
478fe9a6b00SAl Viro
47931efcebbSAl Viro return setup_one_line(lines, n, end, opts, error_out);
4801da177e4SLinus Torvalds }
4811da177e4SLinus Torvalds
line_get_config(char * name,struct line * lines,unsigned int num,char * str,int size,char ** error_out)482b97b77ccSPaolo 'Blaisorblade' Giarrusso int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
4831da177e4SLinus Torvalds int size, char **error_out)
4841da177e4SLinus Torvalds {
4851da177e4SLinus Torvalds struct line *line;
4861da177e4SLinus Torvalds char *end;
4871da177e4SLinus Torvalds int dev, n = 0;
4881da177e4SLinus Torvalds
4891da177e4SLinus Torvalds dev = simple_strtoul(name, &end, 0);
4901da177e4SLinus Torvalds if ((*end != '\0') || (end == name)) {
4911da177e4SLinus Torvalds *error_out = "line_get_config failed to parse device number";
492b97b77ccSPaolo 'Blaisorblade' Giarrusso return 0;
4931da177e4SLinus Torvalds }
4941da177e4SLinus Torvalds
4951da177e4SLinus Torvalds if ((dev < 0) || (dev >= num)) {
496b97b77ccSPaolo 'Blaisorblade' Giarrusso *error_out = "device number out of range";
497b97b77ccSPaolo 'Blaisorblade' Giarrusso return 0;
4981da177e4SLinus Torvalds }
4991da177e4SLinus Torvalds
5001da177e4SLinus Torvalds line = &lines[dev];
5011da177e4SLinus Torvalds
5021da177e4SLinus Torvalds if (!line->valid)
5031da177e4SLinus Torvalds CONFIG_CHUNK(str, size, n, "none", 1);
5046fc58845SJiri Slaby else {
5056fc58845SJiri Slaby struct tty_struct *tty = tty_port_tty_get(&line->port);
5066fc58845SJiri Slaby if (tty == NULL) {
5071da177e4SLinus Torvalds CONFIG_CHUNK(str, size, n, line->init_str, 1);
5086fc58845SJiri Slaby } else {
5096fc58845SJiri Slaby n = chan_config_string(line, str, size, error_out);
5106fc58845SJiri Slaby tty_kref_put(tty);
5116fc58845SJiri Slaby }
5126fc58845SJiri Slaby }
5131da177e4SLinus Torvalds
514b97b77ccSPaolo 'Blaisorblade' Giarrusso return n;
5151da177e4SLinus Torvalds }
5161da177e4SLinus Torvalds
line_id(char ** str,int * start_out,int * end_out)51729d56cfeSJeff Dike int line_id(char **str, int *start_out, int *end_out)
51829d56cfeSJeff Dike {
51929d56cfeSJeff Dike char *end;
52029d56cfeSJeff Dike int n;
52129d56cfeSJeff Dike
52229d56cfeSJeff Dike n = simple_strtoul(*str, &end, 0);
52329d56cfeSJeff Dike if ((*end != '\0') || (end == *str))
52429d56cfeSJeff Dike return -1;
52529d56cfeSJeff Dike
52629d56cfeSJeff Dike *str = end;
52729d56cfeSJeff Dike *start_out = n;
52829d56cfeSJeff Dike *end_out = n;
52929d56cfeSJeff Dike return n;
53029d56cfeSJeff Dike }
53129d56cfeSJeff Dike
line_remove(struct line * lines,unsigned int num,int n,char ** error_out)532f28169d2SJeff Dike int line_remove(struct line *lines, unsigned int num, int n, char **error_out)
5331da177e4SLinus Torvalds {
534da645f3bSAl Viro if (n >= num) {
535da645f3bSAl Viro *error_out = "Device number out of range";
536da645f3bSAl Viro return -EINVAL;
537da645f3bSAl Viro }
53831efcebbSAl Viro return setup_one_line(lines, n, "none", NULL, error_out);
5391da177e4SLinus Torvalds }
5401da177e4SLinus Torvalds
register_lines(struct line_driver * line_driver,const struct tty_operations * ops,struct line * lines,int nlines)541cfe6b7c7SAl Viro int register_lines(struct line_driver *line_driver,
542b68e31d0SJeff Dike const struct tty_operations *ops,
543b68e31d0SJeff Dike struct line *lines, int nlines)
5441da177e4SLinus Torvalds {
54539b7b42bSJiri Slaby struct tty_driver *driver;
546cfe6b7c7SAl Viro int err;
54704292b2cSAl Viro int i;
5481da177e4SLinus Torvalds
54939b7b42bSJiri Slaby driver = tty_alloc_driver(nlines, TTY_DRIVER_REAL_RAW |
55039b7b42bSJiri Slaby TTY_DRIVER_DYNAMIC_DEV);
55139b7b42bSJiri Slaby if (IS_ERR(driver))
55239b7b42bSJiri Slaby return PTR_ERR(driver);
5531da177e4SLinus Torvalds
5541da177e4SLinus Torvalds driver->driver_name = line_driver->name;
5551da177e4SLinus Torvalds driver->name = line_driver->device_name;
5561da177e4SLinus Torvalds driver->major = line_driver->major;
5571da177e4SLinus Torvalds driver->minor_start = line_driver->minor_start;
5581da177e4SLinus Torvalds driver->type = line_driver->type;
5591da177e4SLinus Torvalds driver->subtype = line_driver->subtype;
5601da177e4SLinus Torvalds driver->init_termios = tty_std_termios;
56104292b2cSAl Viro
56204292b2cSAl Viro for (i = 0; i < nlines; i++) {
563060ed31dSJiri Slaby tty_port_init(&lines[i].port);
56479e0273dSRichard Weinberger lines[i].port.ops = &line_port_ops;
56504292b2cSAl Viro spin_lock_init(&lines[i].lock);
56604292b2cSAl Viro lines[i].driver = line_driver;
56704292b2cSAl Viro INIT_LIST_HEAD(&lines[i].chan_list);
56804292b2cSAl Viro }
5691da177e4SLinus Torvalds tty_set_operations(driver, ops);
5701da177e4SLinus Torvalds
571cfe6b7c7SAl Viro err = tty_register_driver(driver);
572cfe6b7c7SAl Viro if (err) {
5732f8a2dc2SJeff Dike printk(KERN_ERR "register_lines : can't register %s driver\n",
5742f8a2dc2SJeff Dike line_driver->name);
5759f90a4ddSJiri Slaby tty_driver_kref_put(driver);
576191c5f10SJiri Slaby for (i = 0; i < nlines; i++)
577191c5f10SJiri Slaby tty_port_destroy(&lines[i].port);
578cfe6b7c7SAl Viro return err;
5791da177e4SLinus Torvalds }
5801da177e4SLinus Torvalds
581cfe6b7c7SAl Viro line_driver->driver = driver;
5821da177e4SLinus Torvalds mconsole_register_dev(&line_driver->mc);
583cfe6b7c7SAl Viro return 0;
5841da177e4SLinus Torvalds }
5851da177e4SLinus Torvalds
5869010772cSJeff Dike static DEFINE_SPINLOCK(winch_handler_lock);
5879010772cSJeff Dike static LIST_HEAD(winch_handlers);
588605a69acSPaolo 'Blaisorblade' Giarrusso
5891da177e4SLinus Torvalds struct winch {
5901da177e4SLinus Torvalds struct list_head list;
5911da177e4SLinus Torvalds int fd;
5921da177e4SLinus Torvalds int tty_fd;
5931da177e4SLinus Torvalds int pid;
5942116bda6SRichard Weinberger struct tty_port *port;
59542a359e3SJeff Dike unsigned long stack;
5967cf3cf21SAl Viro struct work_struct work;
5971da177e4SLinus Torvalds };
5981da177e4SLinus Torvalds
__free_winch(struct work_struct * work)5997cf3cf21SAl Viro static void __free_winch(struct work_struct *work)
60042a359e3SJeff Dike {
6017cf3cf21SAl Viro struct winch *winch = container_of(work, struct winch, work);
602fa7a0449SRichard Weinberger um_free_irq(WINCH_IRQ, winch);
60369e83dadSWill Newton
60442a359e3SJeff Dike if (winch->pid != -1)
60542a359e3SJeff Dike os_kill_process(winch->pid, 1);
60642a359e3SJeff Dike if (winch->stack != 0)
60742a359e3SJeff Dike free_stack(winch->stack, 0);
60842a359e3SJeff Dike kfree(winch);
60942a359e3SJeff Dike }
61042a359e3SJeff Dike
free_winch(struct winch * winch)6117cf3cf21SAl Viro static void free_winch(struct winch *winch)
6127cf3cf21SAl Viro {
6137cf3cf21SAl Viro int fd = winch->fd;
6147cf3cf21SAl Viro winch->fd = -1;
6157cf3cf21SAl Viro if (fd != -1)
6167cf3cf21SAl Viro os_close_file(fd);
6177cf3cf21SAl Viro __free_winch(&winch->work);
6187cf3cf21SAl Viro }
6197cf3cf21SAl Viro
winch_interrupt(int irq,void * data)6207bea96fdSAl Viro static irqreturn_t winch_interrupt(int irq, void *data)
6211da177e4SLinus Torvalds {
6221da177e4SLinus Torvalds struct winch *winch = data;
6231da177e4SLinus Torvalds struct tty_struct *tty;
6241da177e4SLinus Torvalds struct line *line;
6257cf3cf21SAl Viro int fd = winch->fd;
6261da177e4SLinus Torvalds int err;
6271da177e4SLinus Torvalds char c;
6288a8a5510SPeter Hurley struct pid *pgrp;
6291da177e4SLinus Torvalds
6307cf3cf21SAl Viro if (fd != -1) {
6317cf3cf21SAl Viro err = generic_read(fd, &c, NULL);
6321da177e4SLinus Torvalds if (err < 0) {
6331da177e4SLinus Torvalds if (err != -EAGAIN) {
6347cf3cf21SAl Viro winch->fd = -1;
6357cf3cf21SAl Viro list_del(&winch->list);
6367cf3cf21SAl Viro os_close_file(fd);
6372f8a2dc2SJeff Dike printk(KERN_ERR "winch_interrupt : "
6382f8a2dc2SJeff Dike "read failed, errno = %d\n", -err);
6392f8a2dc2SJeff Dike printk(KERN_ERR "fd %d is losing SIGWINCH "
6402f8a2dc2SJeff Dike "support\n", winch->tty_fd);
6417cf3cf21SAl Viro INIT_WORK(&winch->work, __free_winch);
6427cf3cf21SAl Viro schedule_work(&winch->work);
643b97b77ccSPaolo 'Blaisorblade' Giarrusso return IRQ_HANDLED;
6441da177e4SLinus Torvalds }
6451da177e4SLinus Torvalds goto out;
6461da177e4SLinus Torvalds }
6471da177e4SLinus Torvalds }
6482116bda6SRichard Weinberger tty = tty_port_tty_get(winch->port);
6491da177e4SLinus Torvalds if (tty != NULL) {
6501da177e4SLinus Torvalds line = tty->driver_data;
651438ee679SJeff Dike if (line != NULL) {
652bed5e39cSAl Viro chan_window_size(line, &tty->winsize.ws_row,
6531da177e4SLinus Torvalds &tty->winsize.ws_col);
6548a8a5510SPeter Hurley pgrp = tty_get_pgrp(tty);
6558a8a5510SPeter Hurley if (pgrp)
6568a8a5510SPeter Hurley kill_pgrp(pgrp, SIGWINCH, 1);
6578a8a5510SPeter Hurley put_pid(pgrp);
6581da177e4SLinus Torvalds }
6592116bda6SRichard Weinberger tty_kref_put(tty);
660438ee679SJeff Dike }
6611da177e4SLinus Torvalds out:
662b97b77ccSPaolo 'Blaisorblade' Giarrusso return IRQ_HANDLED;
6631da177e4SLinus Torvalds }
6641da177e4SLinus Torvalds
register_winch_irq(int fd,int tty_fd,int pid,struct tty_port * port,unsigned long stack)6652116bda6SRichard Weinberger void register_winch_irq(int fd, int tty_fd, int pid, struct tty_port *port,
66642a359e3SJeff Dike unsigned long stack)
6671da177e4SLinus Torvalds {
6681da177e4SLinus Torvalds struct winch *winch;
6691da177e4SLinus Torvalds
6701da177e4SLinus Torvalds winch = kmalloc(sizeof(*winch), GFP_KERNEL);
6711da177e4SLinus Torvalds if (winch == NULL) {
6722f8a2dc2SJeff Dike printk(KERN_ERR "register_winch_irq - kmalloc failed\n");
67342a359e3SJeff Dike goto cleanup;
6741da177e4SLinus Torvalds }
675605a69acSPaolo 'Blaisorblade' Giarrusso
6761da177e4SLinus Torvalds *winch = ((struct winch) { .list = LIST_HEAD_INIT(winch->list),
6771da177e4SLinus Torvalds .fd = fd,
6781da177e4SLinus Torvalds .tty_fd = tty_fd,
6791da177e4SLinus Torvalds .pid = pid,
6802116bda6SRichard Weinberger .port = port,
68142a359e3SJeff Dike .stack = stack });
68242a359e3SJeff Dike
68342a359e3SJeff Dike if (um_request_irq(WINCH_IRQ, fd, IRQ_READ, winch_interrupt,
684aab94460STheodore Ts'o IRQF_SHARED, "winch", winch) < 0) {
6852f8a2dc2SJeff Dike printk(KERN_ERR "register_winch_irq - failed to register "
6862f8a2dc2SJeff Dike "IRQ\n");
68742a359e3SJeff Dike goto out_free;
68842a359e3SJeff Dike }
689605a69acSPaolo 'Blaisorblade' Giarrusso
690605a69acSPaolo 'Blaisorblade' Giarrusso spin_lock(&winch_handler_lock);
6911da177e4SLinus Torvalds list_add(&winch->list, &winch_handlers);
692605a69acSPaolo 'Blaisorblade' Giarrusso spin_unlock(&winch_handler_lock);
693605a69acSPaolo 'Blaisorblade' Giarrusso
69442a359e3SJeff Dike return;
6951da177e4SLinus Torvalds
69642a359e3SJeff Dike out_free:
697cd2ee4a3SJeff Dike kfree(winch);
69842a359e3SJeff Dike cleanup:
69942a359e3SJeff Dike os_kill_process(pid, 1);
70042a359e3SJeff Dike os_close_file(fd);
70142a359e3SJeff Dike if (stack != 0)
70242a359e3SJeff Dike free_stack(stack, 0);
703cd2ee4a3SJeff Dike }
704cd2ee4a3SJeff Dike
unregister_winch(struct tty_struct * tty)705e464bf2bSJeff Dike static void unregister_winch(struct tty_struct *tty)
7061da177e4SLinus Torvalds {
70748a0b740SWill Newton struct list_head *ele, *next;
7081da177e4SLinus Torvalds struct winch *winch;
7092116bda6SRichard Weinberger struct tty_struct *wtty;
7101da177e4SLinus Torvalds
711e464bf2bSJeff Dike spin_lock(&winch_handler_lock);
712e464bf2bSJeff Dike
71348a0b740SWill Newton list_for_each_safe(ele, next, &winch_handlers) {
7141da177e4SLinus Torvalds winch = list_entry(ele, struct winch, list);
7152116bda6SRichard Weinberger wtty = tty_port_tty_get(winch->port);
7162116bda6SRichard Weinberger if (wtty == tty) {
717f4ab7818SJohannes Berg list_del(&winch->list);
718f4ab7818SJohannes Berg spin_unlock(&winch_handler_lock);
7197cf3cf21SAl Viro free_winch(winch);
720e464bf2bSJeff Dike break;
7211da177e4SLinus Torvalds }
7222116bda6SRichard Weinberger tty_kref_put(wtty);
7231da177e4SLinus Torvalds }
724e464bf2bSJeff Dike spin_unlock(&winch_handler_lock);
725e464bf2bSJeff Dike }
726e464bf2bSJeff Dike
winch_cleanup(void)727e464bf2bSJeff Dike static void winch_cleanup(void)
728e464bf2bSJeff Dike {
729e464bf2bSJeff Dike struct winch *winch;
730e464bf2bSJeff Dike
731e464bf2bSJeff Dike spin_lock(&winch_handler_lock);
732f4ab7818SJohannes Berg while ((winch = list_first_entry_or_null(&winch_handlers,
733f4ab7818SJohannes Berg struct winch, list))) {
734f4ab7818SJohannes Berg list_del(&winch->list);
735f4ab7818SJohannes Berg spin_unlock(&winch_handler_lock);
736e464bf2bSJeff Dike
7377cf3cf21SAl Viro free_winch(winch);
738f4ab7818SJohannes Berg
739f4ab7818SJohannes Berg spin_lock(&winch_handler_lock);
740e464bf2bSJeff Dike }
741e464bf2bSJeff Dike
742e464bf2bSJeff Dike spin_unlock(&winch_handler_lock);
7431da177e4SLinus Torvalds }
7441da177e4SLinus Torvalds __uml_exitcall(winch_cleanup);
7451da177e4SLinus Torvalds
add_xterm_umid(char * base)7461da177e4SLinus Torvalds char *add_xterm_umid(char *base)
7471da177e4SLinus Torvalds {
7481da177e4SLinus Torvalds char *umid, *title;
7491da177e4SLinus Torvalds int len;
7501da177e4SLinus Torvalds
7517eebe8a9SJeff Dike umid = get_umid();
7527eebe8a9SJeff Dike if (*umid == '\0')
753b97b77ccSPaolo 'Blaisorblade' Giarrusso return base;
7541da177e4SLinus Torvalds
7551da177e4SLinus Torvalds len = strlen(base) + strlen(" ()") + strlen(umid) + 1;
7561da177e4SLinus Torvalds title = kmalloc(len, GFP_KERNEL);
7571da177e4SLinus Torvalds if (title == NULL) {
7582f8a2dc2SJeff Dike printk(KERN_ERR "Failed to allocate buffer for xterm title\n");
759b97b77ccSPaolo 'Blaisorblade' Giarrusso return base;
7601da177e4SLinus Torvalds }
7611da177e4SLinus Torvalds
7621da177e4SLinus Torvalds snprintf(title, len, "%s (%s)", base, umid);
763b97b77ccSPaolo 'Blaisorblade' Giarrusso return title;
7641da177e4SLinus Torvalds }
765