Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /*
3 : : * Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
4 : : * Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
5 : : * Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
6 : : * Copyright (C) 2004 IBM Corporation
7 : : *
8 : : * Additional Author(s):
9 : : * Ryan S. Arnold <rsa@us.ibm.com>
10 : : */
11 : :
12 : : #include <linux/console.h>
13 : : #include <linux/cpumask.h>
14 : : #include <linux/init.h>
15 : : #include <linux/kbd_kern.h>
16 : : #include <linux/kernel.h>
17 : : #include <linux/kthread.h>
18 : : #include <linux/list.h>
19 : : #include <linux/major.h>
20 : : #include <linux/atomic.h>
21 : : #include <linux/sysrq.h>
22 : : #include <linux/tty.h>
23 : : #include <linux/tty_flip.h>
24 : : #include <linux/sched.h>
25 : : #include <linux/spinlock.h>
26 : : #include <linux/delay.h>
27 : : #include <linux/freezer.h>
28 : : #include <linux/slab.h>
29 : : #include <linux/serial_core.h>
30 : :
31 : : #include <linux/uaccess.h>
32 : :
33 : : #include "hvc_console.h"
34 : :
35 : : #define HVC_MAJOR 229
36 : : #define HVC_MINOR 0
37 : :
38 : : /*
39 : : * Wait this long per iteration while trying to push buffered data to the
40 : : * hypervisor before allowing the tty to complete a close operation.
41 : : */
42 : : #define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
43 : :
44 : : /*
45 : : * These sizes are most efficient for vio, because they are the
46 : : * native transfer size. We could make them selectable in the
47 : : * future to better deal with backends that want other buffer sizes.
48 : : */
49 : : #define N_OUTBUF 16
50 : : #define N_INBUF 16
51 : :
52 : : #define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
53 : :
54 : : static struct tty_driver *hvc_driver;
55 : : static struct task_struct *hvc_task;
56 : :
57 : : /* Picks up late kicks after list walk but before schedule() */
58 : : static int hvc_kicked;
59 : :
60 : : /* hvc_init is triggered from hvc_alloc, i.e. only when actually used */
61 : : static atomic_t hvc_needs_init __read_mostly = ATOMIC_INIT(-1);
62 : :
63 : : static int hvc_init(void);
64 : :
65 : : #ifdef CONFIG_MAGIC_SYSRQ
66 : : static int sysrq_pressed;
67 : : #endif
68 : :
69 : : /* dynamic list of hvc_struct instances */
70 : : static LIST_HEAD(hvc_structs);
71 : :
72 : : /*
73 : : * Protect the list of hvc_struct instances from inserts and removals during
74 : : * list traversal.
75 : : */
76 : : static DEFINE_MUTEX(hvc_structs_mutex);
77 : :
78 : : /*
79 : : * This value is used to assign a tty->index value to a hvc_struct based
80 : : * upon order of exposure via hvc_probe(), when we can not match it to
81 : : * a console candidate registered with hvc_instantiate().
82 : : */
83 : : static int last_hvc = -1;
84 : :
85 : : /*
86 : : * Do not call this function with either the hvc_structs_mutex or the hvc_struct
87 : : * lock held. If successful, this function increments the kref reference
88 : : * count against the target hvc_struct so it should be released when finished.
89 : : */
90 : 0 : static struct hvc_struct *hvc_get_by_index(int index)
91 : : {
92 : 0 : struct hvc_struct *hp;
93 : 0 : unsigned long flags;
94 : :
95 : 0 : mutex_lock(&hvc_structs_mutex);
96 : :
97 [ # # ]: 0 : list_for_each_entry(hp, &hvc_structs, next) {
98 : 0 : spin_lock_irqsave(&hp->lock, flags);
99 [ # # ]: 0 : if (hp->index == index) {
100 [ # # ]: 0 : tty_port_get(&hp->port);
101 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
102 : 0 : mutex_unlock(&hvc_structs_mutex);
103 : 0 : return hp;
104 : : }
105 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
106 : : }
107 : 0 : hp = NULL;
108 : 0 : mutex_unlock(&hvc_structs_mutex);
109 : :
110 : 0 : return hp;
111 : : }
112 : :
113 : 0 : static int __hvc_flush(const struct hv_ops *ops, uint32_t vtermno, bool wait)
114 : : {
115 : 0 : if (wait)
116 : 0 : might_sleep();
117 : :
118 [ # # ]: 0 : if (ops->flush)
119 : 0 : return ops->flush(vtermno, wait);
120 : : return 0;
121 : : }
122 : :
123 : 0 : static int hvc_console_flush(const struct hv_ops *ops, uint32_t vtermno)
124 : : {
125 : 0 : return __hvc_flush(ops, vtermno, false);
126 : : }
127 : :
128 : : /*
129 : : * Wait for the console to flush before writing more to it. This sleeps.
130 : : */
131 : 0 : static int hvc_flush(struct hvc_struct *hp)
132 : : {
133 : 0 : return __hvc_flush(hp->ops, hp->vtermno, true);
134 : : }
135 : :
136 : : /*
137 : : * Initial console vtermnos for console API usage prior to full console
138 : : * initialization. Any vty adapter outside this range will not have usable
139 : : * console interfaces but can still be used as a tty device. This has to be
140 : : * static because kmalloc will not work during early console init.
141 : : */
142 : : static const struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
143 : : static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
144 : : {[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
145 : :
146 : : /*
147 : : * Console APIs, NOT TTY. These APIs are available immediately when
148 : : * hvc_console_setup() finds adapters.
149 : : */
150 : :
151 : 0 : static void hvc_console_print(struct console *co, const char *b,
152 : : unsigned count)
153 : : {
154 : 0 : char c[N_OUTBUF] __ALIGNED__;
155 : 0 : unsigned i = 0, n = 0;
156 : 0 : int r, donecr = 0, index = co->index;
157 : :
158 : : /* Console access attempt outside of acceptable console range. */
159 [ # # ]: 0 : if (index >= MAX_NR_HVC_CONSOLES)
160 : 0 : return;
161 : :
162 : : /* This console adapter was removed so it is not usable. */
163 [ # # ]: 0 : if (vtermnos[index] == -1)
164 : : return;
165 : :
166 [ # # ]: 0 : while (count > 0 || i > 0) {
167 [ # # ]: 0 : if (count > 0 && i < sizeof(c)) {
168 [ # # # # ]: 0 : if (b[n] == '\n' && !donecr) {
169 : 0 : c[i++] = '\r';
170 : 0 : donecr = 1;
171 : : } else {
172 : 0 : c[i++] = b[n++];
173 : 0 : donecr = 0;
174 : 0 : --count;
175 : : }
176 : : } else {
177 : 0 : r = cons_ops[index]->put_chars(vtermnos[index], c, i);
178 [ # # ]: 0 : if (r <= 0) {
179 : : /* throw away characters on error
180 : : * but spin in case of -EAGAIN */
181 [ # # ]: 0 : if (r != -EAGAIN) {
182 : : i = 0;
183 : : } else {
184 [ # # ]: 0 : hvc_console_flush(cons_ops[index],
185 : : vtermnos[index]);
186 : : }
187 : 0 : } else if (r > 0) {
188 : 0 : i -= r;
189 [ # # ]: 0 : if (i > 0)
190 : 0 : memmove(c, c+r, i);
191 : : }
192 : : }
193 : : }
194 [ # # ]: 0 : hvc_console_flush(cons_ops[index], vtermnos[index]);
195 : : }
196 : :
197 : 0 : static struct tty_driver *hvc_console_device(struct console *c, int *index)
198 : : {
199 [ # # ]: 0 : if (vtermnos[c->index] == -1)
200 : : return NULL;
201 : :
202 : 0 : *index = c->index;
203 : 0 : return hvc_driver;
204 : : }
205 : :
206 : 0 : static int hvc_console_setup(struct console *co, char *options)
207 : : {
208 [ # # ]: 0 : if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
209 : : return -ENODEV;
210 : :
211 [ # # ]: 0 : if (vtermnos[co->index] == -1)
212 : 0 : return -ENODEV;
213 : :
214 : : return 0;
215 : : }
216 : :
217 : : static struct console hvc_console = {
218 : : .name = "hvc",
219 : : .write = hvc_console_print,
220 : : .device = hvc_console_device,
221 : : .setup = hvc_console_setup,
222 : : .flags = CON_PRINTBUFFER,
223 : : .index = -1,
224 : : };
225 : :
226 : : /*
227 : : * Early console initialization. Precedes driver initialization.
228 : : *
229 : : * (1) we are first, and the user specified another driver
230 : : * -- index will remain -1
231 : : * (2) we are first and the user specified no driver
232 : : * -- index will be set to 0, then we will fail setup.
233 : : * (3) we are first and the user specified our driver
234 : : * -- index will be set to user specified driver, and we will fail
235 : : * (4) we are after driver, and this initcall will register us
236 : : * -- if the user didn't specify a driver then the console will match
237 : : *
238 : : * Note that for cases 2 and 3, we will match later when the io driver
239 : : * calls hvc_instantiate() and call register again.
240 : : */
241 : 78 : static int __init hvc_console_init(void)
242 : : {
243 : 78 : register_console(&hvc_console);
244 : 78 : return 0;
245 : : }
246 : : console_initcall(hvc_console_init);
247 : :
248 : : /* callback when the kboject ref count reaches zero. */
249 : 0 : static void hvc_port_destruct(struct tty_port *port)
250 : : {
251 : 0 : struct hvc_struct *hp = container_of(port, struct hvc_struct, port);
252 : 0 : unsigned long flags;
253 : :
254 : 0 : mutex_lock(&hvc_structs_mutex);
255 : :
256 : 0 : spin_lock_irqsave(&hp->lock, flags);
257 : 0 : list_del(&(hp->next));
258 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
259 : :
260 : 0 : mutex_unlock(&hvc_structs_mutex);
261 : :
262 : 0 : kfree(hp);
263 : 0 : }
264 : :
265 : 0 : static void hvc_check_console(int index)
266 : : {
267 : : /* Already enabled, bail out */
268 : 0 : if (hvc_console.flags & CON_ENABLED)
269 : : return;
270 : :
271 : : /* If this index is what the user requested, then register
272 : : * now (setup won't fail at this point). It's ok to just
273 : : * call register again if previously .setup failed.
274 : : */
275 [ # # # # ]: 0 : if (index == hvc_console.index)
276 : 0 : register_console(&hvc_console);
277 : : }
278 : :
279 : : /*
280 : : * hvc_instantiate() is an early console discovery method which locates
281 : : * consoles * prior to the vio subsystem discovering them. Hotplugged
282 : : * vty adapters do NOT get an hvc_instantiate() callback since they
283 : : * appear after early console init.
284 : : */
285 : 0 : int hvc_instantiate(uint32_t vtermno, int index, const struct hv_ops *ops)
286 : : {
287 : 0 : struct hvc_struct *hp;
288 : :
289 [ # # ]: 0 : if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
290 : : return -1;
291 : :
292 [ # # ]: 0 : if (vtermnos[index] != -1)
293 : : return -1;
294 : :
295 : : /* make sure no no tty has been registered in this index */
296 : 0 : hp = hvc_get_by_index(index);
297 [ # # ]: 0 : if (hp) {
298 : 0 : tty_port_put(&hp->port);
299 : 0 : return -1;
300 : : }
301 : :
302 : 0 : vtermnos[index] = vtermno;
303 : 0 : cons_ops[index] = ops;
304 : :
305 : : /* reserve all indices up to and including this index */
306 [ # # ]: 0 : if (last_hvc < index)
307 : 0 : last_hvc = index;
308 : :
309 : : /* check if we need to re-register the kernel console */
310 [ # # ]: 0 : hvc_check_console(index);
311 : :
312 : : return 0;
313 : : }
314 : : EXPORT_SYMBOL_GPL(hvc_instantiate);
315 : :
316 : : /* Wake the sleeping khvcd */
317 : 0 : void hvc_kick(void)
318 : : {
319 : 0 : hvc_kicked = 1;
320 : 0 : wake_up_process(hvc_task);
321 : 0 : }
322 : : EXPORT_SYMBOL_GPL(hvc_kick);
323 : :
324 : 0 : static void hvc_unthrottle(struct tty_struct *tty)
325 : : {
326 : 0 : hvc_kick();
327 : 0 : }
328 : :
329 : 0 : static int hvc_install(struct tty_driver *driver, struct tty_struct *tty)
330 : : {
331 : 0 : struct hvc_struct *hp;
332 : 0 : int rc;
333 : :
334 : : /* Auto increments kref reference if found. */
335 : 0 : hp = hvc_get_by_index(tty->index);
336 [ # # ]: 0 : if (!hp)
337 : : return -ENODEV;
338 : :
339 : 0 : tty->driver_data = hp;
340 : :
341 : 0 : rc = tty_port_install(&hp->port, driver, tty);
342 [ # # ]: 0 : if (rc)
343 : 0 : tty_port_put(&hp->port);
344 : : return rc;
345 : : }
346 : :
347 : : /*
348 : : * The TTY interface won't be used until after the vio layer has exposed the vty
349 : : * adapter to the kernel.
350 : : */
351 : 0 : static int hvc_open(struct tty_struct *tty, struct file * filp)
352 : : {
353 : 0 : struct hvc_struct *hp = tty->driver_data;
354 : 0 : unsigned long flags;
355 : 0 : int rc = 0;
356 : :
357 : 0 : spin_lock_irqsave(&hp->port.lock, flags);
358 : : /* Check and then increment for fast path open. */
359 [ # # ]: 0 : if (hp->port.count++ > 0) {
360 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
361 : 0 : hvc_kick();
362 : 0 : return 0;
363 : : } /* else count == 0 */
364 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
365 : :
366 : 0 : tty_port_tty_set(&hp->port, tty);
367 : :
368 [ # # ]: 0 : if (hp->ops->notifier_add)
369 : 0 : rc = hp->ops->notifier_add(hp, hp->data);
370 : :
371 : : /*
372 : : * If the notifier fails we return an error. The tty layer
373 : : * will call hvc_close() after a failed open but we don't want to clean
374 : : * up there so we'll clean up here and clear out the previously set
375 : : * tty fields and return the kref reference.
376 : : */
377 [ # # ]: 0 : if (rc) {
378 : 0 : tty_port_tty_set(&hp->port, NULL);
379 : 0 : tty->driver_data = NULL;
380 : 0 : tty_port_put(&hp->port);
381 : 0 : printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
382 : : } else
383 : : /* We are ready... raise DTR/RTS */
384 [ # # ]: 0 : if (C_BAUD(tty))
385 [ # # ]: 0 : if (hp->ops->dtr_rts)
386 : 0 : hp->ops->dtr_rts(hp, 1);
387 : :
388 : : /* Force wakeup of the polling thread */
389 : 0 : hvc_kick();
390 : :
391 : 0 : return rc;
392 : : }
393 : :
394 : 0 : static void hvc_close(struct tty_struct *tty, struct file * filp)
395 : : {
396 : 0 : struct hvc_struct *hp;
397 : 0 : unsigned long flags;
398 : :
399 [ # # ]: 0 : if (tty_hung_up_p(filp))
400 : : return;
401 : :
402 : : /*
403 : : * No driver_data means that this close was issued after a failed
404 : : * hvc_open by the tty layer's release_dev() function and we can just
405 : : * exit cleanly because the kref reference wasn't made.
406 : : */
407 [ # # ]: 0 : if (!tty->driver_data)
408 : : return;
409 : :
410 : 0 : hp = tty->driver_data;
411 : :
412 : 0 : spin_lock_irqsave(&hp->port.lock, flags);
413 : :
414 [ # # ]: 0 : if (--hp->port.count == 0) {
415 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
416 : : /* We are done with the tty pointer now. */
417 : 0 : tty_port_tty_set(&hp->port, NULL);
418 : :
419 [ # # ]: 0 : if (C_HUPCL(tty))
420 [ # # ]: 0 : if (hp->ops->dtr_rts)
421 : 0 : hp->ops->dtr_rts(hp, 0);
422 : :
423 [ # # ]: 0 : if (hp->ops->notifier_del)
424 : 0 : hp->ops->notifier_del(hp, hp->data);
425 : :
426 : : /* cancel pending tty resize work */
427 : 0 : cancel_work_sync(&hp->tty_resize);
428 : :
429 : : /*
430 : : * Chain calls chars_in_buffer() and returns immediately if
431 : : * there is no buffered data otherwise sleeps on a wait queue
432 : : * waking periodically to check chars_in_buffer().
433 : : */
434 : 0 : tty_wait_until_sent(tty, HVC_CLOSE_WAIT);
435 : : } else {
436 [ # # ]: 0 : if (hp->port.count < 0)
437 : 0 : printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
438 : : hp->vtermno, hp->port.count);
439 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
440 : : }
441 : : }
442 : :
443 : 0 : static void hvc_cleanup(struct tty_struct *tty)
444 : : {
445 : 0 : struct hvc_struct *hp = tty->driver_data;
446 : :
447 : 0 : tty_port_put(&hp->port);
448 : 0 : }
449 : :
450 : 0 : static void hvc_hangup(struct tty_struct *tty)
451 : : {
452 : 0 : struct hvc_struct *hp = tty->driver_data;
453 : 0 : unsigned long flags;
454 : :
455 [ # # ]: 0 : if (!hp)
456 : : return;
457 : :
458 : : /* cancel pending tty resize work */
459 : 0 : cancel_work_sync(&hp->tty_resize);
460 : :
461 : 0 : spin_lock_irqsave(&hp->port.lock, flags);
462 : :
463 : : /*
464 : : * The N_TTY line discipline has problems such that in a close vs
465 : : * open->hangup case this can be called after the final close so prevent
466 : : * that from happening for now.
467 : : */
468 [ # # ]: 0 : if (hp->port.count <= 0) {
469 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
470 : 0 : return;
471 : : }
472 : :
473 : 0 : hp->port.count = 0;
474 : 0 : spin_unlock_irqrestore(&hp->port.lock, flags);
475 : 0 : tty_port_tty_set(&hp->port, NULL);
476 : :
477 : 0 : hp->n_outbuf = 0;
478 : :
479 [ # # ]: 0 : if (hp->ops->notifier_hangup)
480 : 0 : hp->ops->notifier_hangup(hp, hp->data);
481 : : }
482 : :
483 : : /*
484 : : * Push buffered characters whether they were just recently buffered or waiting
485 : : * on a blocked hypervisor. Call this function with hp->lock held.
486 : : */
487 : 0 : static int hvc_push(struct hvc_struct *hp)
488 : : {
489 : 0 : int n;
490 : :
491 : 0 : n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
492 [ # # ]: 0 : if (n <= 0) {
493 [ # # ]: 0 : if (n == 0 || n == -EAGAIN) {
494 : 0 : hp->do_wakeup = 1;
495 : 0 : return 0;
496 : : }
497 : : /* throw away output on error; this happens when
498 : : there is no session connected to the vterm. */
499 : 0 : hp->n_outbuf = 0;
500 : : } else
501 : 0 : hp->n_outbuf -= n;
502 [ # # ]: 0 : if (hp->n_outbuf > 0)
503 : 0 : memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
504 : : else
505 : 0 : hp->do_wakeup = 1;
506 : :
507 : : return n;
508 : : }
509 : :
510 : 0 : static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
511 : : {
512 : 0 : struct hvc_struct *hp = tty->driver_data;
513 : 0 : unsigned long flags;
514 : 0 : int rsize, written = 0;
515 : :
516 : : /* This write was probably executed during a tty close. */
517 [ # # ]: 0 : if (!hp)
518 : : return -EPIPE;
519 : :
520 : : /* FIXME what's this (unprotected) check for? */
521 [ # # ]: 0 : if (hp->port.count <= 0)
522 : : return -EIO;
523 : :
524 [ # # ]: 0 : while (count > 0) {
525 : 0 : int ret = 0;
526 : :
527 : 0 : spin_lock_irqsave(&hp->lock, flags);
528 : :
529 : 0 : rsize = hp->outbuf_size - hp->n_outbuf;
530 : :
531 [ # # ]: 0 : if (rsize) {
532 : 0 : if (rsize > count)
533 : : rsize = count;
534 : 0 : memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
535 : 0 : count -= rsize;
536 : 0 : buf += rsize;
537 : 0 : hp->n_outbuf += rsize;
538 : 0 : written += rsize;
539 : : }
540 : :
541 [ # # ]: 0 : if (hp->n_outbuf > 0)
542 : 0 : ret = hvc_push(hp);
543 : :
544 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
545 : :
546 [ # # ]: 0 : if (!ret)
547 : : break;
548 : :
549 [ # # ]: 0 : if (count) {
550 [ # # ]: 0 : if (hp->n_outbuf > 0)
551 : 0 : hvc_flush(hp);
552 : 0 : cond_resched();
553 : : }
554 : : }
555 : :
556 : : /*
557 : : * Racy, but harmless, kick thread if there is still pending data.
558 : : */
559 [ # # ]: 0 : if (hp->n_outbuf)
560 : 0 : hvc_kick();
561 : :
562 : : return written;
563 : : }
564 : :
565 : : /**
566 : : * hvc_set_winsz() - Resize the hvc tty terminal window.
567 : : * @work: work structure.
568 : : *
569 : : * The routine shall not be called within an atomic context because it
570 : : * might sleep.
571 : : *
572 : : * Locking: hp->lock
573 : : */
574 : 0 : static void hvc_set_winsz(struct work_struct *work)
575 : : {
576 : 0 : struct hvc_struct *hp;
577 : 0 : unsigned long hvc_flags;
578 : 0 : struct tty_struct *tty;
579 : 0 : struct winsize ws;
580 : :
581 : 0 : hp = container_of(work, struct hvc_struct, tty_resize);
582 : :
583 : 0 : tty = tty_port_tty_get(&hp->port);
584 [ # # ]: 0 : if (!tty)
585 : 0 : return;
586 : :
587 : 0 : spin_lock_irqsave(&hp->lock, hvc_flags);
588 : 0 : ws = hp->ws;
589 : 0 : spin_unlock_irqrestore(&hp->lock, hvc_flags);
590 : :
591 : 0 : tty_do_resize(tty, &ws);
592 : 0 : tty_kref_put(tty);
593 : : }
594 : :
595 : : /*
596 : : * This is actually a contract between the driver and the tty layer outlining
597 : : * how much write room the driver can guarantee will be sent OR BUFFERED. This
598 : : * driver MUST honor the return value.
599 : : */
600 : 0 : static int hvc_write_room(struct tty_struct *tty)
601 : : {
602 : 0 : struct hvc_struct *hp = tty->driver_data;
603 : :
604 [ # # ]: 0 : if (!hp)
605 : : return 0;
606 : :
607 : 0 : return hp->outbuf_size - hp->n_outbuf;
608 : : }
609 : :
610 : 0 : static int hvc_chars_in_buffer(struct tty_struct *tty)
611 : : {
612 : 0 : struct hvc_struct *hp = tty->driver_data;
613 : :
614 [ # # ]: 0 : if (!hp)
615 : : return 0;
616 : 0 : return hp->n_outbuf;
617 : : }
618 : :
619 : : /*
620 : : * timeout will vary between the MIN and MAX values defined here. By default
621 : : * and during console activity we will use a default MIN_TIMEOUT of 10. When
622 : : * the console is idle, we increase the timeout value on each pass through
623 : : * msleep until we reach the max. This may be noticeable as a brief (average
624 : : * one second) delay on the console before the console responds to input when
625 : : * there has been no input for some time.
626 : : */
627 : : #define MIN_TIMEOUT (10)
628 : : #define MAX_TIMEOUT (2000)
629 : : static u32 timeout = MIN_TIMEOUT;
630 : :
631 : : /*
632 : : * Maximum number of bytes to get from the console driver if hvc_poll is
633 : : * called from driver (and can't sleep). Any more than this and we break
634 : : * and start polling with khvcd. This value was derived from from an OpenBMC
635 : : * console with the OPAL driver that results in about 0.25ms interrupts off
636 : : * latency.
637 : : */
638 : : #define HVC_ATOMIC_READ_MAX 128
639 : :
640 : : #define HVC_POLL_READ 0x00000001
641 : : #define HVC_POLL_WRITE 0x00000002
642 : :
643 : 0 : static int __hvc_poll(struct hvc_struct *hp, bool may_sleep)
644 : : {
645 : 0 : struct tty_struct *tty;
646 : 0 : int i, n, count, poll_mask = 0;
647 : 0 : char buf[N_INBUF] __ALIGNED__;
648 : 0 : unsigned long flags;
649 : 0 : int read_total = 0;
650 : 0 : int written_total = 0;
651 : :
652 : 0 : spin_lock_irqsave(&hp->lock, flags);
653 : :
654 : : /* Push pending writes */
655 [ # # ]: 0 : if (hp->n_outbuf > 0)
656 : 0 : written_total = hvc_push(hp);
657 : :
658 : : /* Reschedule us if still some write pending */
659 [ # # ]: 0 : if (hp->n_outbuf > 0) {
660 : 0 : poll_mask |= HVC_POLL_WRITE;
661 : : /* If hvc_push() was not able to write, sleep a few msecs */
662 [ # # ]: 0 : timeout = (written_total) ? 0 : MIN_TIMEOUT;
663 : : }
664 : :
665 [ # # ]: 0 : if (may_sleep) {
666 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
667 : 0 : cond_resched();
668 : 0 : spin_lock_irqsave(&hp->lock, flags);
669 : : }
670 : :
671 : : /* No tty attached, just skip */
672 : 0 : tty = tty_port_tty_get(&hp->port);
673 [ # # ]: 0 : if (tty == NULL)
674 : 0 : goto bail;
675 : :
676 : : /* Now check if we can get data (are we throttled ?) */
677 [ # # ]: 0 : if (tty_throttled(tty))
678 : 0 : goto out;
679 : :
680 : : /* If we aren't notifier driven and aren't throttled, we always
681 : : * request a reschedule
682 : : */
683 [ # # ]: 0 : if (!hp->irq_requested)
684 : 0 : poll_mask |= HVC_POLL_READ;
685 : :
686 : 0 : read_again:
687 : : /* Read data if any */
688 : 0 : count = tty_buffer_request_room(&hp->port, N_INBUF);
689 : :
690 : : /* If flip is full, just reschedule a later read */
691 [ # # ]: 0 : if (count == 0) {
692 : 0 : poll_mask |= HVC_POLL_READ;
693 : 0 : goto out;
694 : : }
695 : :
696 : 0 : n = hp->ops->get_chars(hp->vtermno, buf, count);
697 [ # # ]: 0 : if (n <= 0) {
698 : : /* Hangup the tty when disconnected from host */
699 [ # # ]: 0 : if (n == -EPIPE) {
700 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
701 : 0 : tty_hangup(tty);
702 : 0 : spin_lock_irqsave(&hp->lock, flags);
703 [ # # ]: 0 : } else if ( n == -EAGAIN ) {
704 : : /*
705 : : * Some back-ends can only ensure a certain min
706 : : * num of bytes read, which may be > 'count'.
707 : : * Let the tty clear the flip buff to make room.
708 : : */
709 : 0 : poll_mask |= HVC_POLL_READ;
710 : : }
711 : 0 : goto out;
712 : : }
713 : :
714 [ # # ]: 0 : for (i = 0; i < n; ++i) {
715 : : #ifdef CONFIG_MAGIC_SYSRQ
716 [ # # ]: 0 : if (hp->index == hvc_console.index) {
717 : : /* Handle the SysRq Hack */
718 : : /* XXX should support a sequence */
719 [ # # ]: 0 : if (buf[i] == '\x0f') { /* ^O */
720 : : /* if ^O is pressed again, reset
721 : : * sysrq_pressed and flip ^O char */
722 : 0 : sysrq_pressed = !sysrq_pressed;
723 [ # # ]: 0 : if (sysrq_pressed)
724 : 0 : continue;
725 [ # # ]: 0 : } else if (sysrq_pressed) {
726 : 0 : handle_sysrq(buf[i]);
727 : 0 : sysrq_pressed = 0;
728 : 0 : continue;
729 : : }
730 : : }
731 : : #endif /* CONFIG_MAGIC_SYSRQ */
732 : 0 : tty_insert_flip_char(&hp->port, buf[i], 0);
733 : : }
734 : 0 : read_total += n;
735 : :
736 [ # # ]: 0 : if (may_sleep) {
737 : : /* Keep going until the flip is full */
738 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
739 : 0 : cond_resched();
740 : 0 : spin_lock_irqsave(&hp->lock, flags);
741 : 0 : goto read_again;
742 [ # # ]: 0 : } else if (read_total < HVC_ATOMIC_READ_MAX) {
743 : : /* Break and defer if it's a large read in atomic */
744 : 0 : goto read_again;
745 : : }
746 : :
747 : : /*
748 : : * Latency break, schedule another poll immediately.
749 : : */
750 : 0 : poll_mask |= HVC_POLL_READ;
751 : :
752 : 0 : out:
753 : : /* Wakeup write queue if necessary */
754 [ # # ]: 0 : if (hp->do_wakeup) {
755 : 0 : hp->do_wakeup = 0;
756 : 0 : tty_wakeup(tty);
757 : : }
758 : 0 : bail:
759 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
760 : :
761 [ # # ]: 0 : if (read_total) {
762 : : /* Activity is occurring, so reset the polling backoff value to
763 : : a minimum for performance. */
764 : 0 : timeout = MIN_TIMEOUT;
765 : :
766 : 0 : tty_flip_buffer_push(&hp->port);
767 : : }
768 : 0 : tty_kref_put(tty);
769 : :
770 : 0 : return poll_mask;
771 : : }
772 : :
773 : 0 : int hvc_poll(struct hvc_struct *hp)
774 : : {
775 : 0 : return __hvc_poll(hp, false);
776 : : }
777 : : EXPORT_SYMBOL_GPL(hvc_poll);
778 : :
779 : : /**
780 : : * __hvc_resize() - Update terminal window size information.
781 : : * @hp: HVC console pointer
782 : : * @ws: Terminal window size structure
783 : : *
784 : : * Stores the specified window size information in the hvc structure of @hp.
785 : : * The function schedule the tty resize update.
786 : : *
787 : : * Locking: Locking free; the function MUST be called holding hp->lock
788 : : */
789 : 0 : void __hvc_resize(struct hvc_struct *hp, struct winsize ws)
790 : : {
791 : 0 : hp->ws = ws;
792 : 0 : schedule_work(&hp->tty_resize);
793 : 0 : }
794 : : EXPORT_SYMBOL_GPL(__hvc_resize);
795 : :
796 : : /*
797 : : * This kthread is either polling or interrupt driven. This is determined by
798 : : * calling hvc_poll() who determines whether a console adapter support
799 : : * interrupts.
800 : : */
801 : 0 : static int khvcd(void *unused)
802 : : {
803 : 0 : int poll_mask;
804 : 0 : struct hvc_struct *hp;
805 : :
806 : 0 : set_freezable();
807 : 0 : do {
808 : 0 : poll_mask = 0;
809 : 0 : hvc_kicked = 0;
810 : 0 : try_to_freeze();
811 : 0 : wmb();
812 : 0 : if (!cpus_are_in_xmon()) {
813 : 0 : mutex_lock(&hvc_structs_mutex);
814 [ # # ]: 0 : list_for_each_entry(hp, &hvc_structs, next) {
815 : 0 : poll_mask |= __hvc_poll(hp, true);
816 : 0 : cond_resched();
817 : : }
818 : 0 : mutex_unlock(&hvc_structs_mutex);
819 : : } else
820 : : poll_mask |= HVC_POLL_READ;
821 [ # # ]: 0 : if (hvc_kicked)
822 : 0 : continue;
823 : 0 : set_current_state(TASK_INTERRUPTIBLE);
824 [ # # ]: 0 : if (!hvc_kicked) {
825 [ # # ]: 0 : if (poll_mask == 0)
826 : 0 : schedule();
827 : : else {
828 : 0 : unsigned long j_timeout;
829 : :
830 [ # # ]: 0 : if (timeout < MAX_TIMEOUT)
831 : 0 : timeout += (timeout >> 6) + 1;
832 : :
833 : : /*
834 : : * We don't use msleep_interruptible otherwise
835 : : * "kick" will fail to wake us up
836 : : */
837 [ # # ]: 0 : j_timeout = msecs_to_jiffies(timeout) + 1;
838 : 0 : schedule_timeout_interruptible(j_timeout);
839 : : }
840 : : }
841 : 0 : __set_current_state(TASK_RUNNING);
842 [ # # ]: 0 : } while (!kthread_should_stop());
843 : :
844 : 0 : return 0;
845 : : }
846 : :
847 : 0 : static int hvc_tiocmget(struct tty_struct *tty)
848 : : {
849 : 0 : struct hvc_struct *hp = tty->driver_data;
850 : :
851 [ # # # # ]: 0 : if (!hp || !hp->ops->tiocmget)
852 : : return -EINVAL;
853 : 0 : return hp->ops->tiocmget(hp);
854 : : }
855 : :
856 : 0 : static int hvc_tiocmset(struct tty_struct *tty,
857 : : unsigned int set, unsigned int clear)
858 : : {
859 : 0 : struct hvc_struct *hp = tty->driver_data;
860 : :
861 [ # # # # ]: 0 : if (!hp || !hp->ops->tiocmset)
862 : : return -EINVAL;
863 : 0 : return hp->ops->tiocmset(hp, set, clear);
864 : : }
865 : :
866 : : #ifdef CONFIG_CONSOLE_POLL
867 : : static int hvc_poll_init(struct tty_driver *driver, int line, char *options)
868 : : {
869 : : return 0;
870 : : }
871 : :
872 : : static int hvc_poll_get_char(struct tty_driver *driver, int line)
873 : : {
874 : : struct tty_struct *tty = driver->ttys[0];
875 : : struct hvc_struct *hp = tty->driver_data;
876 : : int n;
877 : : char ch;
878 : :
879 : : n = hp->ops->get_chars(hp->vtermno, &ch, 1);
880 : :
881 : : if (n <= 0)
882 : : return NO_POLL_CHAR;
883 : :
884 : : return ch;
885 : : }
886 : :
887 : : static void hvc_poll_put_char(struct tty_driver *driver, int line, char ch)
888 : : {
889 : : struct tty_struct *tty = driver->ttys[0];
890 : : struct hvc_struct *hp = tty->driver_data;
891 : : int n;
892 : :
893 : : do {
894 : : n = hp->ops->put_chars(hp->vtermno, &ch, 1);
895 : : } while (n <= 0);
896 : : }
897 : : #endif
898 : :
899 : : static const struct tty_operations hvc_ops = {
900 : : .install = hvc_install,
901 : : .open = hvc_open,
902 : : .close = hvc_close,
903 : : .cleanup = hvc_cleanup,
904 : : .write = hvc_write,
905 : : .hangup = hvc_hangup,
906 : : .unthrottle = hvc_unthrottle,
907 : : .write_room = hvc_write_room,
908 : : .chars_in_buffer = hvc_chars_in_buffer,
909 : : .tiocmget = hvc_tiocmget,
910 : : .tiocmset = hvc_tiocmset,
911 : : #ifdef CONFIG_CONSOLE_POLL
912 : : .poll_init = hvc_poll_init,
913 : : .poll_get_char = hvc_poll_get_char,
914 : : .poll_put_char = hvc_poll_put_char,
915 : : #endif
916 : : };
917 : :
918 : : static const struct tty_port_operations hvc_port_ops = {
919 : : .destruct = hvc_port_destruct,
920 : : };
921 : :
922 : 0 : struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
923 : : const struct hv_ops *ops,
924 : : int outbuf_size)
925 : : {
926 : 0 : struct hvc_struct *hp;
927 : 0 : int i;
928 : :
929 : : /* We wait until a driver actually comes along */
930 [ # # ]: 0 : if (atomic_inc_not_zero(&hvc_needs_init)) {
931 : 0 : int err = hvc_init();
932 [ # # ]: 0 : if (err)
933 : 0 : return ERR_PTR(err);
934 : : }
935 : :
936 : 0 : hp = kzalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
937 : : GFP_KERNEL);
938 [ # # ]: 0 : if (!hp)
939 : : return ERR_PTR(-ENOMEM);
940 : :
941 : 0 : hp->vtermno = vtermno;
942 : 0 : hp->data = data;
943 : 0 : hp->ops = ops;
944 : 0 : hp->outbuf_size = outbuf_size;
945 : 0 : hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
946 : :
947 : 0 : tty_port_init(&hp->port);
948 : 0 : hp->port.ops = &hvc_port_ops;
949 : :
950 : 0 : INIT_WORK(&hp->tty_resize, hvc_set_winsz);
951 : 0 : spin_lock_init(&hp->lock);
952 : 0 : mutex_lock(&hvc_structs_mutex);
953 : :
954 : : /*
955 : : * find index to use:
956 : : * see if this vterm id matches one registered for console.
957 : : */
958 [ # # ]: 0 : for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
959 [ # # ]: 0 : if (vtermnos[i] == hp->vtermno &&
960 [ # # ]: 0 : cons_ops[i] == hp->ops)
961 : : break;
962 : :
963 : : /* no matching slot, just use a counter */
964 [ # # ]: 0 : if (i >= MAX_NR_HVC_CONSOLES)
965 : 0 : i = ++last_hvc;
966 : :
967 : 0 : hp->index = i;
968 : 0 : cons_ops[i] = ops;
969 : 0 : vtermnos[i] = vtermno;
970 : :
971 : 0 : list_add_tail(&(hp->next), &hvc_structs);
972 : 0 : mutex_unlock(&hvc_structs_mutex);
973 : :
974 : : /* check if we need to re-register the kernel console */
975 [ # # ]: 0 : hvc_check_console(i);
976 : :
977 : : return hp;
978 : : }
979 : : EXPORT_SYMBOL_GPL(hvc_alloc);
980 : :
981 : 0 : int hvc_remove(struct hvc_struct *hp)
982 : : {
983 : 0 : unsigned long flags;
984 : 0 : struct tty_struct *tty;
985 : :
986 : 0 : tty = tty_port_tty_get(&hp->port);
987 : :
988 : 0 : console_lock();
989 : 0 : spin_lock_irqsave(&hp->lock, flags);
990 [ # # ]: 0 : if (hp->index < MAX_NR_HVC_CONSOLES) {
991 : 0 : vtermnos[hp->index] = -1;
992 : 0 : cons_ops[hp->index] = NULL;
993 : : }
994 : :
995 : : /* Don't whack hp->irq because tty_hangup() will need to free the irq. */
996 : :
997 : 0 : spin_unlock_irqrestore(&hp->lock, flags);
998 : 0 : console_unlock();
999 : :
1000 : : /*
1001 : : * We 'put' the instance that was grabbed when the kref instance
1002 : : * was initialized using kref_init(). Let the last holder of this
1003 : : * kref cause it to be removed, which will probably be the tty_vhangup
1004 : : * below.
1005 : : */
1006 : 0 : tty_port_put(&hp->port);
1007 : :
1008 : : /*
1009 : : * This function call will auto chain call hvc_hangup.
1010 : : */
1011 [ # # ]: 0 : if (tty) {
1012 : 0 : tty_vhangup(tty);
1013 : 0 : tty_kref_put(tty);
1014 : : }
1015 : 0 : return 0;
1016 : : }
1017 : : EXPORT_SYMBOL_GPL(hvc_remove);
1018 : :
1019 : : /* Driver initialization: called as soon as someone uses hvc_alloc(). */
1020 : 0 : static int hvc_init(void)
1021 : : {
1022 : 0 : struct tty_driver *drv;
1023 : 0 : int err;
1024 : :
1025 : : /* We need more than hvc_count adapters due to hotplug additions. */
1026 : 0 : drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
1027 [ # # ]: 0 : if (!drv) {
1028 : 0 : err = -ENOMEM;
1029 : 0 : goto out;
1030 : : }
1031 : :
1032 : 0 : drv->driver_name = "hvc";
1033 : 0 : drv->name = "hvc";
1034 : 0 : drv->major = HVC_MAJOR;
1035 : 0 : drv->minor_start = HVC_MINOR;
1036 : 0 : drv->type = TTY_DRIVER_TYPE_SYSTEM;
1037 : 0 : drv->init_termios = tty_std_termios;
1038 : 0 : drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
1039 : 0 : tty_set_operations(drv, &hvc_ops);
1040 : :
1041 : : /* Always start the kthread because there can be hotplug vty adapters
1042 : : * added later. */
1043 [ # # ]: 0 : hvc_task = kthread_run(khvcd, NULL, "khvcd");
1044 [ # # ]: 0 : if (IS_ERR(hvc_task)) {
1045 : 0 : printk(KERN_ERR "Couldn't create kthread for console.\n");
1046 : 0 : err = PTR_ERR(hvc_task);
1047 : 0 : goto put_tty;
1048 : : }
1049 : :
1050 : 0 : err = tty_register_driver(drv);
1051 [ # # ]: 0 : if (err) {
1052 : 0 : printk(KERN_ERR "Couldn't register hvc console driver\n");
1053 : 0 : goto stop_thread;
1054 : : }
1055 : :
1056 : : /*
1057 : : * Make sure tty is fully registered before allowing it to be
1058 : : * found by hvc_console_device.
1059 : : */
1060 : 0 : smp_mb();
1061 : 0 : hvc_driver = drv;
1062 : 0 : return 0;
1063 : :
1064 : : stop_thread:
1065 : 0 : kthread_stop(hvc_task);
1066 : 0 : hvc_task = NULL;
1067 : 0 : put_tty:
1068 : 0 : put_tty_driver(drv);
1069 : : out:
1070 : : return err;
1071 : : }
|
