2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
|
|
|
|
* Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
|
|
|
|
* Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
|
|
|
|
* Copyright (C) 2004 IBM Corporation
|
|
|
|
*
|
|
|
|
* Additional Author(s):
|
|
|
|
* Ryan S. Arnold <rsa@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/console.h>
|
|
|
|
#include <linux/cpumask.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kbd_kern.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/major.h>
|
|
|
|
#include <linux/sysrq.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/delay.h>
|
2006-12-07 05:34:23 +01:00
|
|
|
#include <linux/freezer.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2011-07-12 21:44:05 +02:00
|
|
|
#include <linux/serial_core.h>
|
2006-03-27 21:25:16 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <asm/uaccess.h>
|
2006-03-27 21:25:16 +02:00
|
|
|
|
|
|
|
#include "hvc_console.h"
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
#define HVC_MAJOR 229
|
|
|
|
#define HVC_MINOR 0
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait this long per iteration while trying to push buffered data to the
|
|
|
|
* hypervisor before allowing the tty to complete a close operation.
|
|
|
|
*/
|
|
|
|
#define HVC_CLOSE_WAIT (HZ/100) /* 1/10 of a second */
|
|
|
|
|
|
|
|
/*
|
2006-03-27 21:25:16 +02:00
|
|
|
* These sizes are most efficient for vio, because they are the
|
|
|
|
* native transfer size. We could make them selectable in the
|
|
|
|
* future to better deal with backends that want other buffer sizes.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
#define N_OUTBUF 16
|
|
|
|
#define N_INBUF 16
|
|
|
|
|
2006-03-27 21:25:16 +02:00
|
|
|
#define __ALIGNED__ __attribute__((__aligned__(sizeof(long))))
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
static struct tty_driver *hvc_driver;
|
|
|
|
static struct task_struct *hvc_task;
|
|
|
|
|
|
|
|
/* Picks up late kicks after list walk but before schedule() */
|
|
|
|
static int hvc_kicked;
|
|
|
|
|
2007-10-17 08:30:13 +02:00
|
|
|
static int hvc_init(void);
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
#ifdef CONFIG_MAGIC_SYSRQ
|
|
|
|
static int sysrq_pressed;
|
|
|
|
#endif
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* dynamic list of hvc_struct instances */
|
2008-02-06 10:37:35 +01:00
|
|
|
static LIST_HEAD(hvc_structs);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Protect the list of hvc_struct instances from inserts and removals during
|
|
|
|
* list traversal.
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(hvc_structs_lock);
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
/*
|
2005-07-08 02:56:17 +02:00
|
|
|
* This value is used to assign a tty->index value to a hvc_struct based
|
|
|
|
* upon order of exposure via hvc_probe(), when we can not match it to
|
2007-04-17 16:54:51 +02:00
|
|
|
* a console candidate registered with hvc_instantiate().
|
2005-07-08 02:56:16 +02:00
|
|
|
*/
|
2005-07-08 02:56:17 +02:00
|
|
|
static int last_hvc = -1;
|
2005-07-08 02:56:16 +02:00
|
|
|
|
|
|
|
/*
|
2007-04-17 16:54:51 +02:00
|
|
|
* Do not call this function with either the hvc_structs_lock or the hvc_struct
|
2007-11-28 19:46:22 +01:00
|
|
|
* lock held. If successful, this function increments the kref reference
|
2005-07-08 02:56:16 +02:00
|
|
|
* count against the target hvc_struct so it should be released when finished.
|
|
|
|
*/
|
2007-05-08 09:24:24 +02:00
|
|
|
static struct hvc_struct *hvc_get_by_index(int index)
|
2005-07-08 02:56:16 +02:00
|
|
|
{
|
|
|
|
struct hvc_struct *hp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock(&hvc_structs_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(hp, &hvc_structs, next) {
|
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
|
|
|
if (hp->index == index) {
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_get(&hp->port);
|
2005-07-08 02:56:16 +02:00
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
spin_unlock(&hvc_structs_lock);
|
|
|
|
return hp;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
}
|
|
|
|
hp = NULL;
|
|
|
|
|
|
|
|
spin_unlock(&hvc_structs_lock);
|
|
|
|
return hp;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Initial console vtermnos for console API usage prior to full console
|
|
|
|
* initialization. Any vty adapter outside this range will not have usable
|
|
|
|
* console interfaces but can still be used as a tty device. This has to be
|
|
|
|
* static because kmalloc will not work during early console init.
|
|
|
|
*/
|
2010-01-18 04:44:57 +01:00
|
|
|
static const struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
|
2005-07-08 02:56:22 +02:00
|
|
|
static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
|
|
|
|
{[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
/*
|
|
|
|
* Console APIs, NOT TTY. These APIs are available immediately when
|
|
|
|
* hvc_console_setup() finds adapters.
|
|
|
|
*/
|
|
|
|
|
2007-05-08 09:24:24 +02:00
|
|
|
static void hvc_console_print(struct console *co, const char *b,
|
|
|
|
unsigned count)
|
2005-07-08 02:56:16 +02:00
|
|
|
{
|
2006-03-27 21:25:16 +02:00
|
|
|
char c[N_OUTBUF] __ALIGNED__;
|
2005-07-08 02:56:16 +02:00
|
|
|
unsigned i = 0, n = 0;
|
2005-07-08 02:56:25 +02:00
|
|
|
int r, donecr = 0, index = co->index;
|
2005-07-08 02:56:16 +02:00
|
|
|
|
|
|
|
/* Console access attempt outside of acceptable console range. */
|
2005-07-08 02:56:25 +02:00
|
|
|
if (index >= MAX_NR_HVC_CONSOLES)
|
2005-07-08 02:56:16 +02:00
|
|
|
return;
|
|
|
|
|
2007-04-17 16:54:51 +02:00
|
|
|
/* This console adapter was removed so it is not usable. */
|
2009-12-09 21:34:16 +01:00
|
|
|
if (vtermnos[index] == -1)
|
2005-07-08 02:56:16 +02:00
|
|
|
return;
|
|
|
|
|
|
|
|
while (count > 0 || i > 0) {
|
|
|
|
if (count > 0 && i < sizeof(c)) {
|
|
|
|
if (b[n] == '\n' && !donecr) {
|
|
|
|
c[i++] = '\r';
|
|
|
|
donecr = 1;
|
|
|
|
} else {
|
|
|
|
c[i++] = b[n++];
|
|
|
|
donecr = 0;
|
|
|
|
--count;
|
|
|
|
}
|
|
|
|
} else {
|
2005-07-08 02:56:25 +02:00
|
|
|
r = cons_ops[index]->put_chars(vtermnos[index], c, i);
|
2008-10-14 01:12:50 +02:00
|
|
|
if (r <= 0) {
|
2011-07-05 23:50:18 +02:00
|
|
|
/* throw away characters on error
|
|
|
|
* but spin in case of -EAGAIN */
|
|
|
|
if (r != -EAGAIN)
|
|
|
|
i = 0;
|
2005-07-08 02:56:16 +02:00
|
|
|
} else if (r > 0) {
|
|
|
|
i -= r;
|
|
|
|
if (i > 0)
|
|
|
|
memmove(c, c+r, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct tty_driver *hvc_console_device(struct console *c, int *index)
|
|
|
|
{
|
2005-07-08 02:56:23 +02:00
|
|
|
if (vtermnos[c->index] == -1)
|
|
|
|
return NULL;
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
*index = c->index;
|
|
|
|
return hvc_driver;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init hvc_console_setup(struct console *co, char *options)
|
powerpc/pseries: Re-implement HVSI as part of hvc_vio
On pseries machines, consoles are provided by the hypervisor using
a low level get_chars/put_chars type interface. However, this is
really just a transport to the service processor which implements
them either as "raw" console (networked consoles, HMC, ...) or as
"hvsi" serial ports.
The later is a simple packet protocol on top of the raw character
interface that is supposed to convey additional "serial port" style
semantics. In practice however, all it does is provide a way to
read the CD line and set/clear our DTR line, that's it.
We currently implement the "raw" protocol as an hvc console backend
(/dev/hvcN) and the "hvsi" protocol using a separate tty driver
(/dev/hvsi0).
However this is quite impractical. The arbitrary difference between
the two type of devices has been a major source of user (and distro)
confusion. Additionally, there's an additional mini -hvsi implementation
in the pseries platform code for our low level debug console and early
boot kernel messages, which means code duplication, though that low
level variant is impractical as it's incapable of doing the initial
protocol negociation to establish the link to the FSP.
This essentially replaces the dedicated hvsi driver and the platform
udbg code completely by extending the existing hvc_vio backend used
in "raw" mode so that:
- It now supports HVSI as well
- We add support for hvc backend providing tiocm{get,set}
- It also provides a udbg interface for early debug and boot console
This is overall less code, though this will only be obvious once we
remove the old "hvsi" driver, which is still available for now. When
the old driver is enabled, the new code still kicks in for the low
level udbg console, replacing the old mini implementation in the platform
code, it just doesn't provide the higher level "hvc" interface.
In addition to producing generally simler code, this has several benefits
over our current situation:
- The user/distro only has to deal with /dev/hvcN for the hypervisor
console, avoiding all sort of confusion that has plagued us in the past
- The tty, kernel and low level debug console all use the same code
base which supports the full protocol establishment process, thus the
console is now available much earlier than it used to be with the
old HVSI driver. The kernel console works much earlier and udbg is
available much earlier too. Hackers can enable a hard coded very-early
debug console as well that works with HVSI (previously that was only
supported for the "raw" mode).
I've tried to keep the same semantics as hvsi relative to how I react
to things like CD changes, with some subtle differences though:
- I clear DTR on close if HUPCL is set
- Current hvsi triggers a hangup if it detects a up->down transition
on CD (you can still open a console with CD down). My new implementation
triggers a hangup if the link to the FSP is severed, and severs it upon
detecting a up->down transition on CD.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2011-05-12 05:46:38 +02:00
|
|
|
{
|
2005-07-08 02:56:23 +02:00
|
|
|
if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (vtermnos[co->index] == -1)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-06 10:03:16 +02:00
|
|
|
static struct console hvc_console = {
|
2005-07-08 02:56:16 +02:00
|
|
|
.name = "hvc",
|
|
|
|
.write = hvc_console_print,
|
|
|
|
.device = hvc_console_device,
|
|
|
|
.setup = hvc_console_setup,
|
|
|
|
.flags = CON_PRINTBUFFER,
|
|
|
|
.index = -1,
|
|
|
|
};
|
|
|
|
|
2005-07-08 02:56:24 +02:00
|
|
|
/*
|
2007-04-17 16:54:51 +02:00
|
|
|
* Early console initialization. Precedes driver initialization.
|
2005-07-08 02:56:24 +02:00
|
|
|
*
|
|
|
|
* (1) we are first, and the user specified another driver
|
|
|
|
* -- index will remain -1
|
|
|
|
* (2) we are first and the user specified no driver
|
|
|
|
* -- index will be set to 0, then we will fail setup.
|
|
|
|
* (3) we are first and the user specified our driver
|
|
|
|
* -- index will be set to user specified driver, and we will fail
|
|
|
|
* (4) we are after driver, and this initcall will register us
|
|
|
|
* -- if the user didn't specify a driver then the console will match
|
|
|
|
*
|
|
|
|
* Note that for cases 2 and 3, we will match later when the io driver
|
|
|
|
* calls hvc_instantiate() and call register again.
|
|
|
|
*/
|
2005-07-08 02:56:16 +02:00
|
|
|
static int __init hvc_console_init(void)
|
|
|
|
{
|
2010-07-06 10:03:16 +02:00
|
|
|
register_console(&hvc_console);
|
2005-07-08 02:56:16 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
console_initcall(hvc_console_init);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-11-28 19:46:22 +01:00
|
|
|
/* callback when the kboject ref count reaches zero. */
|
2012-04-02 13:54:21 +02:00
|
|
|
static void hvc_port_destruct(struct tty_port *port)
|
2007-11-28 19:46:22 +01:00
|
|
|
{
|
2012-04-02 13:54:21 +02:00
|
|
|
struct hvc_struct *hp = container_of(port, struct hvc_struct, port);
|
2007-11-28 19:46:22 +01:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock(&hvc_structs_lock);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
|
|
|
list_del(&(hp->next));
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
|
|
|
|
spin_unlock(&hvc_structs_lock);
|
|
|
|
|
|
|
|
kfree(hp);
|
|
|
|
}
|
|
|
|
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
static void hvc_check_console(int index)
|
|
|
|
{
|
|
|
|
/* Already enabled, bail out */
|
|
|
|
if (hvc_console.flags & CON_ENABLED)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* If this index is what the user requested, then register
|
|
|
|
* now (setup won't fail at this point). It's ok to just
|
|
|
|
* call register again if previously .setup failed.
|
|
|
|
*/
|
|
|
|
if (index == hvc_console.index)
|
|
|
|
register_console(&hvc_console);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
2005-07-08 02:56:17 +02:00
|
|
|
* hvc_instantiate() is an early console discovery method which locates
|
|
|
|
* consoles * prior to the vio subsystem discovering them. Hotplugged
|
|
|
|
* vty adapters do NOT get an hvc_instantiate() callback since they
|
|
|
|
* appear after early console init.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2010-01-18 04:44:57 +01:00
|
|
|
int hvc_instantiate(uint32_t vtermno, int index, const struct hv_ops *ops)
|
2005-07-08 02:56:16 +02:00
|
|
|
{
|
2005-07-08 02:56:23 +02:00
|
|
|
struct hvc_struct *hp;
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
if (index < 0 || index >= MAX_NR_HVC_CONSOLES)
|
|
|
|
return -1;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
if (vtermnos[index] != -1)
|
|
|
|
return -1;
|
|
|
|
|
2007-04-17 16:54:51 +02:00
|
|
|
/* make sure no no tty has been registered in this index */
|
2005-07-08 02:56:23 +02:00
|
|
|
hp = hvc_get_by_index(index);
|
|
|
|
if (hp) {
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_put(&hp->port);
|
2005-07-08 02:56:23 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
vtermnos[index] = vtermno;
|
2005-07-08 02:56:25 +02:00
|
|
|
cons_ops[index] = ops;
|
2005-07-08 02:56:17 +02:00
|
|
|
|
2007-04-17 16:54:51 +02:00
|
|
|
/* reserve all indices up to and including this index */
|
2005-07-08 02:56:17 +02:00
|
|
|
if (last_hvc < index)
|
|
|
|
last_hvc = index;
|
|
|
|
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
/* check if we need to re-register the kernel console */
|
|
|
|
hvc_check_console(index);
|
2005-07-08 02:56:24 +02:00
|
|
|
|
2005-07-08 02:56:16 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2008-07-25 19:06:06 +02:00
|
|
|
EXPORT_SYMBOL_GPL(hvc_instantiate);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Wake the sleeping khvcd */
|
2008-06-20 15:24:08 +02:00
|
|
|
void hvc_kick(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
hvc_kicked = 1;
|
|
|
|
wake_up_process(hvc_task);
|
|
|
|
}
|
2008-07-25 19:06:06 +02:00
|
|
|
EXPORT_SYMBOL_GPL(hvc_kick);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static void hvc_unthrottle(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
hvc_kick();
|
|
|
|
}
|
|
|
|
|
2012-08-07 21:48:04 +02:00
|
|
|
static int hvc_install(struct tty_driver *driver, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* Auto increments kref reference if found. */
|
|
|
|
if (!(hp = hvc_get_by_index(tty->index)))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
tty->driver_data = hp;
|
|
|
|
|
|
|
|
rc = tty_port_install(&hp->port, driver, tty);
|
|
|
|
if (rc)
|
|
|
|
tty_port_put(&hp->port);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* The TTY interface won't be used until after the vio layer has exposed the vty
|
|
|
|
* adapter to the kernel.
|
|
|
|
*/
|
|
|
|
static int hvc_open(struct tty_struct *tty, struct file * filp)
|
|
|
|
{
|
2012-08-07 21:48:04 +02:00
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long flags;
|
|
|
|
int rc = 0;
|
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
spin_lock_irqsave(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Check and then increment for fast path open. */
|
2012-04-02 13:54:23 +02:00
|
|
|
if (hp->port.count++ > 0) {
|
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
hvc_kick();
|
|
|
|
return 0;
|
|
|
|
} /* else count == 0 */
|
2012-04-02 13:54:23 +02:00
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-04-02 13:54:22 +02:00
|
|
|
tty_port_tty_set(&hp->port, tty);
|
|
|
|
|
2008-08-07 09:18:34 +02:00
|
|
|
if (hp->ops->notifier_add)
|
|
|
|
rc = hp->ops->notifier_add(hp, hp->data);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2008-06-20 15:24:08 +02:00
|
|
|
* If the notifier fails we return an error. The tty layer
|
2005-04-17 00:20:36 +02:00
|
|
|
* will call hvc_close() after a failed open but we don't want to clean
|
|
|
|
* up there so we'll clean up here and clear out the previously set
|
2007-11-28 19:46:22 +01:00
|
|
|
* tty fields and return the kref reference.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
if (rc) {
|
2012-04-02 13:54:22 +02:00
|
|
|
tty_port_tty_set(&hp->port, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
tty->driver_data = NULL;
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_put(&hp->port);
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_ERR "hvc_open: request_irq failed with rc %d.\n", rc);
|
|
|
|
}
|
|
|
|
/* Force wakeup of the polling thread */
|
|
|
|
hvc_kick();
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hvc_close(struct tty_struct *tty, struct file * filp)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (tty_hung_up_p(filp))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* No driver_data means that this close was issued after a failed
|
|
|
|
* hvc_open by the tty layer's release_dev() function and we can just
|
2007-11-28 19:46:22 +01:00
|
|
|
* exit cleanly because the kref reference wasn't made.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
|
|
|
if (!tty->driver_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
hp = tty->driver_data;
|
2010-03-12 07:23:15 +01:00
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
spin_lock_irqsave(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
if (--hp->port.count == 0) {
|
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2012-04-02 13:54:22 +02:00
|
|
|
/* We are done with the tty pointer now. */
|
|
|
|
tty_port_tty_set(&hp->port, NULL);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-12 23:51:31 +02:00
|
|
|
if (hp->ops->notifier_del)
|
|
|
|
hp->ops->notifier_del(hp, hp->data);
|
|
|
|
|
2008-10-14 07:02:09 +02:00
|
|
|
/* cancel pending tty resize work */
|
|
|
|
cancel_work_sync(&hp->tty_resize);
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Chain calls chars_in_buffer() and returns immediately if
|
|
|
|
* there is no buffered data otherwise sleeps on a wait queue
|
|
|
|
* waking periodically to check chars_in_buffer().
|
|
|
|
*/
|
2011-08-25 15:12:08 +02:00
|
|
|
tty_wait_until_sent_from_close(tty, HVC_CLOSE_WAIT);
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2012-04-02 13:54:23 +02:00
|
|
|
if (hp->port.count < 0)
|
2005-04-17 00:20:36 +02:00
|
|
|
printk(KERN_ERR "hvc_close %X: oops, count is %d\n",
|
2012-04-02 13:54:23 +02:00
|
|
|
hp->vtermno, hp->port.count);
|
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2012-08-07 21:48:04 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hvc_cleanup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_put(&hp->port);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void hvc_hangup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!hp)
|
|
|
|
return;
|
|
|
|
|
2008-10-14 07:02:09 +02:00
|
|
|
/* cancel pending tty resize work */
|
|
|
|
cancel_work_sync(&hp->tty_resize);
|
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
spin_lock_irqsave(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The N_TTY line discipline has problems such that in a close vs
|
|
|
|
* open->hangup case this can be called after the final close so prevent
|
|
|
|
* that from happening for now.
|
|
|
|
*/
|
2012-04-02 13:54:23 +02:00
|
|
|
if (hp->port.count <= 0) {
|
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
hp->port.count = 0;
|
|
|
|
spin_unlock_irqrestore(&hp->port.lock, flags);
|
2012-04-02 13:54:22 +02:00
|
|
|
tty_port_tty_set(&hp->port, NULL);
|
2008-10-12 23:51:31 +02:00
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
hp->n_outbuf = 0;
|
|
|
|
|
2008-10-14 01:12:48 +02:00
|
|
|
if (hp->ops->notifier_hangup)
|
2010-03-12 07:23:15 +01:00
|
|
|
hp->ops->notifier_hangup(hp, hp->data);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Push buffered characters whether they were just recently buffered or waiting
|
|
|
|
* on a blocked hypervisor. Call this function with hp->lock held.
|
|
|
|
*/
|
2008-10-14 01:12:50 +02:00
|
|
|
static int hvc_push(struct hvc_struct *hp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
2005-07-08 02:56:25 +02:00
|
|
|
n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (n <= 0) {
|
2011-07-05 23:50:18 +02:00
|
|
|
if (n == 0 || n == -EAGAIN) {
|
2006-03-27 21:25:16 +02:00
|
|
|
hp->do_wakeup = 1;
|
2008-10-14 01:12:50 +02:00
|
|
|
return 0;
|
2006-03-27 21:25:16 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
/* throw away output on error; this happens when
|
|
|
|
there is no session connected to the vterm. */
|
|
|
|
hp->n_outbuf = 0;
|
|
|
|
} else
|
|
|
|
hp->n_outbuf -= n;
|
|
|
|
if (hp->n_outbuf > 0)
|
|
|
|
memmove(hp->outbuf, hp->outbuf + n, hp->n_outbuf);
|
|
|
|
else
|
|
|
|
hp->do_wakeup = 1;
|
2008-10-14 01:12:50 +02:00
|
|
|
|
|
|
|
return n;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-03-27 21:25:16 +02:00
|
|
|
static int hvc_write(struct tty_struct *tty, const unsigned char *buf, int count)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-27 21:25:16 +02:00
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned long flags;
|
|
|
|
int rsize, written = 0;
|
|
|
|
|
2006-03-27 21:25:16 +02:00
|
|
|
/* This write was probably executed during a tty close. */
|
|
|
|
if (!hp)
|
|
|
|
return -EPIPE;
|
|
|
|
|
2012-04-02 13:54:23 +02:00
|
|
|
/* FIXME what's this (unprotected) check for? */
|
|
|
|
if (hp->port.count <= 0)
|
2006-03-27 21:25:16 +02:00
|
|
|
return -EIO;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
|
|
|
|
|
|
|
/* Push pending writes */
|
|
|
|
if (hp->n_outbuf > 0)
|
|
|
|
hvc_push(hp);
|
|
|
|
|
2006-07-13 10:53:32 +02:00
|
|
|
while (count > 0 && (rsize = hp->outbuf_size - hp->n_outbuf) > 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
if (rsize > count)
|
|
|
|
rsize = count;
|
|
|
|
memcpy(hp->outbuf + hp->n_outbuf, buf, rsize);
|
|
|
|
count -= rsize;
|
|
|
|
buf += rsize;
|
|
|
|
hp->n_outbuf += rsize;
|
|
|
|
written += rsize;
|
|
|
|
hvc_push(hp);
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Racy, but harmless, kick thread if there is still pending data.
|
|
|
|
*/
|
|
|
|
if (hp->n_outbuf)
|
|
|
|
hvc_kick();
|
|
|
|
|
|
|
|
return written;
|
|
|
|
}
|
|
|
|
|
2008-10-14 07:02:09 +02:00
|
|
|
/**
|
|
|
|
* hvc_set_winsz() - Resize the hvc tty terminal window.
|
|
|
|
* @work: work structure.
|
|
|
|
*
|
|
|
|
* The routine shall not be called within an atomic context because it
|
|
|
|
* might sleep.
|
|
|
|
*
|
|
|
|
* Locking: hp->lock
|
|
|
|
*/
|
|
|
|
static void hvc_set_winsz(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp;
|
|
|
|
unsigned long hvc_flags;
|
|
|
|
struct tty_struct *tty;
|
|
|
|
struct winsize ws;
|
|
|
|
|
|
|
|
hp = container_of(work, struct hvc_struct, tty_resize);
|
|
|
|
|
2012-04-02 13:54:22 +02:00
|
|
|
tty = tty_port_tty_get(&hp->port);
|
|
|
|
if (!tty)
|
2008-10-14 07:02:09 +02:00
|
|
|
return;
|
2012-04-02 13:54:22 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(&hp->lock, hvc_flags);
|
|
|
|
ws = hp->ws;
|
2008-10-14 07:02:09 +02:00
|
|
|
spin_unlock_irqrestore(&hp->lock, hvc_flags);
|
|
|
|
|
2009-01-02 14:43:17 +01:00
|
|
|
tty_do_resize(tty, &ws);
|
2008-10-14 07:02:09 +02:00
|
|
|
tty_kref_put(tty);
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* This is actually a contract between the driver and the tty layer outlining
|
2007-04-17 16:54:51 +02:00
|
|
|
* how much write room the driver can guarantee will be sent OR BUFFERED. This
|
2005-04-17 00:20:36 +02:00
|
|
|
* driver MUST honor the return value.
|
|
|
|
*/
|
|
|
|
static int hvc_write_room(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
|
|
|
|
if (!hp)
|
2012-09-17 13:03:39 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-13 10:53:32 +02:00
|
|
|
return hp->outbuf_size - hp->n_outbuf;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static int hvc_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
|
|
|
|
if (!hp)
|
2009-07-20 17:05:27 +02:00
|
|
|
return 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
return hp->n_outbuf;
|
|
|
|
}
|
|
|
|
|
2007-04-17 16:44:46 +02:00
|
|
|
/*
|
|
|
|
* timeout will vary between the MIN and MAX values defined here. By default
|
|
|
|
* and during console activity we will use a default MIN_TIMEOUT of 10. When
|
|
|
|
* the console is idle, we increase the timeout value on each pass through
|
|
|
|
* msleep until we reach the max. This may be noticeable as a brief (average
|
|
|
|
* one second) delay on the console before the console responds to input when
|
|
|
|
* there has been no input for some time.
|
|
|
|
*/
|
|
|
|
#define MIN_TIMEOUT (10)
|
|
|
|
#define MAX_TIMEOUT (2000)
|
|
|
|
static u32 timeout = MIN_TIMEOUT;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
#define HVC_POLL_READ 0x00000001
|
|
|
|
#define HVC_POLL_WRITE 0x00000002
|
|
|
|
|
2008-06-20 15:24:08 +02:00
|
|
|
int hvc_poll(struct hvc_struct *hp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct tty_struct *tty;
|
|
|
|
int i, n, poll_mask = 0;
|
|
|
|
char buf[N_INBUF] __ALIGNED__;
|
|
|
|
unsigned long flags;
|
|
|
|
int read_total = 0;
|
2008-10-14 01:12:50 +02:00
|
|
|
int written_total = 0;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
|
|
|
|
|
|
|
/* Push pending writes */
|
|
|
|
if (hp->n_outbuf > 0)
|
2008-10-14 01:12:50 +02:00
|
|
|
written_total = hvc_push(hp);
|
2006-06-07 09:10:03 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/* Reschedule us if still some write pending */
|
2008-10-14 01:12:50 +02:00
|
|
|
if (hp->n_outbuf > 0) {
|
2005-04-17 00:20:36 +02:00
|
|
|
poll_mask |= HVC_POLL_WRITE;
|
2008-10-14 01:12:50 +02:00
|
|
|
/* If hvc_push() was not able to write, sleep a few msecs */
|
|
|
|
timeout = (written_total) ? 0 : MIN_TIMEOUT;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* No tty attached, just skip */
|
2012-04-02 13:54:22 +02:00
|
|
|
tty = tty_port_tty_get(&hp->port);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (tty == NULL)
|
|
|
|
goto bail;
|
|
|
|
|
|
|
|
/* Now check if we can get data (are we throttled ?) */
|
|
|
|
if (test_bit(TTY_THROTTLED, &tty->flags))
|
|
|
|
goto throttled;
|
|
|
|
|
2008-06-20 15:24:08 +02:00
|
|
|
/* If we aren't notifier driven and aren't throttled, we always
|
2005-04-17 00:20:36 +02:00
|
|
|
* request a reschedule
|
|
|
|
*/
|
2008-06-20 15:24:08 +02:00
|
|
|
if (!hp->irq_requested)
|
2005-04-17 00:20:36 +02:00
|
|
|
poll_mask |= HVC_POLL_READ;
|
|
|
|
|
|
|
|
/* Read data if any */
|
|
|
|
for (;;) {
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 05:54:13 +01:00
|
|
|
int count = tty_buffer_request_room(tty, N_INBUF);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* If flip is full, just reschedule a later read */
|
|
|
|
if (count == 0) {
|
|
|
|
poll_mask |= HVC_POLL_READ;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2005-07-08 02:56:25 +02:00
|
|
|
n = hp->ops->get_chars(hp->vtermno, buf, count);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (n <= 0) {
|
|
|
|
/* Hangup the tty when disconnected from host */
|
|
|
|
if (n == -EPIPE) {
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
tty_hangup(tty);
|
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
2006-03-27 21:25:16 +02:00
|
|
|
} else if ( n == -EAGAIN ) {
|
|
|
|
/*
|
|
|
|
* Some back-ends can only ensure a certain min
|
|
|
|
* num of bytes read, which may be > 'count'.
|
|
|
|
* Let the tty clear the flip buff to make room.
|
|
|
|
*/
|
|
|
|
poll_mask |= HVC_POLL_READ;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
|
|
#ifdef CONFIG_MAGIC_SYSRQ
|
2010-07-06 10:03:16 +02:00
|
|
|
if (hp->index == hvc_console.index) {
|
2005-07-08 02:56:19 +02:00
|
|
|
/* Handle the SysRq Hack */
|
|
|
|
/* XXX should support a sequence */
|
|
|
|
if (buf[i] == '\x0f') { /* ^O */
|
2008-12-16 01:09:38 +01:00
|
|
|
/* if ^O is pressed again, reset
|
|
|
|
* sysrq_pressed and flip ^O char */
|
|
|
|
sysrq_pressed = !sysrq_pressed;
|
|
|
|
if (sysrq_pressed)
|
|
|
|
continue;
|
2005-07-08 02:56:19 +02:00
|
|
|
} else if (sysrq_pressed) {
|
2010-08-18 06:15:47 +02:00
|
|
|
handle_sysrq(buf[i]);
|
2005-07-08 02:56:19 +02:00
|
|
|
sysrq_pressed = 0;
|
|
|
|
continue;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_MAGIC_SYSRQ */
|
|
|
|
tty_insert_flip_char(tty, buf[i], 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
read_total += n;
|
|
|
|
}
|
|
|
|
throttled:
|
|
|
|
/* Wakeup write queue if necessary */
|
|
|
|
if (hp->do_wakeup) {
|
|
|
|
hp->do_wakeup = 0;
|
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
bail:
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
|
2007-04-17 16:44:46 +02:00
|
|
|
if (read_total) {
|
|
|
|
/* Activity is occurring, so reset the polling backoff value to
|
|
|
|
a minimum for performance. */
|
|
|
|
timeout = MIN_TIMEOUT;
|
|
|
|
|
2006-02-18 15:29:59 +01:00
|
|
|
tty_flip_buffer_push(tty);
|
2007-04-17 16:44:46 +02:00
|
|
|
}
|
2012-04-02 13:54:22 +02:00
|
|
|
tty_kref_put(tty);
|
2007-04-17 16:44:46 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
return poll_mask;
|
|
|
|
}
|
2008-07-25 19:06:06 +02:00
|
|
|
EXPORT_SYMBOL_GPL(hvc_poll);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-14 07:02:09 +02:00
|
|
|
/**
|
2009-08-27 03:45:39 +02:00
|
|
|
* __hvc_resize() - Update terminal window size information.
|
2008-10-14 07:02:09 +02:00
|
|
|
* @hp: HVC console pointer
|
|
|
|
* @ws: Terminal window size structure
|
|
|
|
*
|
|
|
|
* Stores the specified window size information in the hvc structure of @hp.
|
|
|
|
* The function schedule the tty resize update.
|
|
|
|
*
|
|
|
|
* Locking: Locking free; the function MUST be called holding hp->lock
|
|
|
|
*/
|
2009-08-27 03:45:39 +02:00
|
|
|
void __hvc_resize(struct hvc_struct *hp, struct winsize ws)
|
2008-10-14 07:02:09 +02:00
|
|
|
{
|
2008-11-18 02:28:28 +01:00
|
|
|
hp->ws = ws;
|
|
|
|
schedule_work(&hp->tty_resize);
|
2008-10-14 07:02:09 +02:00
|
|
|
}
|
2009-08-27 03:45:39 +02:00
|
|
|
EXPORT_SYMBOL_GPL(__hvc_resize);
|
2008-10-14 07:02:09 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* This kthread is either polling or interrupt driven. This is determined by
|
|
|
|
* calling hvc_poll() who determines whether a console adapter support
|
|
|
|
* interrupts.
|
|
|
|
*/
|
2007-07-09 20:37:38 +02:00
|
|
|
static int khvcd(void *unused)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int poll_mask;
|
|
|
|
struct hvc_struct *hp;
|
|
|
|
|
2007-07-17 13:03:35 +02:00
|
|
|
set_freezable();
|
2005-04-17 00:20:36 +02:00
|
|
|
do {
|
|
|
|
poll_mask = 0;
|
|
|
|
hvc_kicked = 0;
|
2006-09-16 21:15:38 +02:00
|
|
|
try_to_freeze();
|
2005-04-17 00:20:36 +02:00
|
|
|
wmb();
|
2008-05-08 06:27:17 +02:00
|
|
|
if (!cpus_are_in_xmon()) {
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock(&hvc_structs_lock);
|
|
|
|
list_for_each_entry(hp, &hvc_structs, next) {
|
|
|
|
poll_mask |= hvc_poll(hp);
|
|
|
|
}
|
|
|
|
spin_unlock(&hvc_structs_lock);
|
|
|
|
} else
|
|
|
|
poll_mask |= HVC_POLL_READ;
|
|
|
|
if (hvc_kicked)
|
|
|
|
continue;
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
if (!hvc_kicked) {
|
|
|
|
if (poll_mask == 0)
|
|
|
|
schedule();
|
2007-04-17 16:44:46 +02:00
|
|
|
else {
|
|
|
|
if (timeout < MAX_TIMEOUT)
|
|
|
|
timeout += (timeout >> 6) + 1;
|
|
|
|
|
|
|
|
msleep_interruptible(timeout);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
} while (!kthread_should_stop());
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
powerpc/pseries: Re-implement HVSI as part of hvc_vio
On pseries machines, consoles are provided by the hypervisor using
a low level get_chars/put_chars type interface. However, this is
really just a transport to the service processor which implements
them either as "raw" console (networked consoles, HMC, ...) or as
"hvsi" serial ports.
The later is a simple packet protocol on top of the raw character
interface that is supposed to convey additional "serial port" style
semantics. In practice however, all it does is provide a way to
read the CD line and set/clear our DTR line, that's it.
We currently implement the "raw" protocol as an hvc console backend
(/dev/hvcN) and the "hvsi" protocol using a separate tty driver
(/dev/hvsi0).
However this is quite impractical. The arbitrary difference between
the two type of devices has been a major source of user (and distro)
confusion. Additionally, there's an additional mini -hvsi implementation
in the pseries platform code for our low level debug console and early
boot kernel messages, which means code duplication, though that low
level variant is impractical as it's incapable of doing the initial
protocol negociation to establish the link to the FSP.
This essentially replaces the dedicated hvsi driver and the platform
udbg code completely by extending the existing hvc_vio backend used
in "raw" mode so that:
- It now supports HVSI as well
- We add support for hvc backend providing tiocm{get,set}
- It also provides a udbg interface for early debug and boot console
This is overall less code, though this will only be obvious once we
remove the old "hvsi" driver, which is still available for now. When
the old driver is enabled, the new code still kicks in for the low
level udbg console, replacing the old mini implementation in the platform
code, it just doesn't provide the higher level "hvc" interface.
In addition to producing generally simler code, this has several benefits
over our current situation:
- The user/distro only has to deal with /dev/hvcN for the hypervisor
console, avoiding all sort of confusion that has plagued us in the past
- The tty, kernel and low level debug console all use the same code
base which supports the full protocol establishment process, thus the
console is now available much earlier than it used to be with the
old HVSI driver. The kernel console works much earlier and udbg is
available much earlier too. Hackers can enable a hard coded very-early
debug console as well that works with HVSI (previously that was only
supported for the "raw" mode).
I've tried to keep the same semantics as hvsi relative to how I react
to things like CD changes, with some subtle differences though:
- I clear DTR on close if HUPCL is set
- Current hvsi triggers a hangup if it detects a up->down transition
on CD (you can still open a console with CD down). My new implementation
triggers a hangup if the link to the FSP is severed, and severs it upon
detecting a up->down transition on CD.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2011-05-12 05:46:38 +02:00
|
|
|
static int hvc_tiocmget(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
|
|
|
|
if (!hp || !hp->ops->tiocmget)
|
|
|
|
return -EINVAL;
|
|
|
|
return hp->ops->tiocmget(hp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hvc_tiocmset(struct tty_struct *tty,
|
|
|
|
unsigned int set, unsigned int clear)
|
|
|
|
{
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
|
|
|
|
if (!hp || !hp->ops->tiocmset)
|
|
|
|
return -EINVAL;
|
|
|
|
return hp->ops->tiocmset(hp, set, clear);
|
|
|
|
}
|
|
|
|
|
2011-07-12 21:44:05 +02:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
int hvc_poll_init(struct tty_driver *driver, int line, char *options)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hvc_poll_get_char(struct tty_driver *driver, int line)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty = driver->ttys[0];
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
int n;
|
|
|
|
char ch;
|
|
|
|
|
|
|
|
n = hp->ops->get_chars(hp->vtermno, &ch, 1);
|
|
|
|
|
|
|
|
if (n == 0)
|
|
|
|
return NO_POLL_CHAR;
|
|
|
|
|
|
|
|
return ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void hvc_poll_put_char(struct tty_driver *driver, int line, char ch)
|
|
|
|
{
|
|
|
|
struct tty_struct *tty = driver->ttys[0];
|
|
|
|
struct hvc_struct *hp = tty->driver_data;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
do {
|
|
|
|
n = hp->ops->put_chars(hp->vtermno, &ch, 1);
|
|
|
|
} while (n <= 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-02 11:17:18 +02:00
|
|
|
static const struct tty_operations hvc_ops = {
|
2012-08-07 21:48:04 +02:00
|
|
|
.install = hvc_install,
|
2005-04-17 00:20:36 +02:00
|
|
|
.open = hvc_open,
|
|
|
|
.close = hvc_close,
|
2012-08-07 21:48:04 +02:00
|
|
|
.cleanup = hvc_cleanup,
|
2005-04-17 00:20:36 +02:00
|
|
|
.write = hvc_write,
|
|
|
|
.hangup = hvc_hangup,
|
|
|
|
.unthrottle = hvc_unthrottle,
|
|
|
|
.write_room = hvc_write_room,
|
|
|
|
.chars_in_buffer = hvc_chars_in_buffer,
|
powerpc/pseries: Re-implement HVSI as part of hvc_vio
On pseries machines, consoles are provided by the hypervisor using
a low level get_chars/put_chars type interface. However, this is
really just a transport to the service processor which implements
them either as "raw" console (networked consoles, HMC, ...) or as
"hvsi" serial ports.
The later is a simple packet protocol on top of the raw character
interface that is supposed to convey additional "serial port" style
semantics. In practice however, all it does is provide a way to
read the CD line and set/clear our DTR line, that's it.
We currently implement the "raw" protocol as an hvc console backend
(/dev/hvcN) and the "hvsi" protocol using a separate tty driver
(/dev/hvsi0).
However this is quite impractical. The arbitrary difference between
the two type of devices has been a major source of user (and distro)
confusion. Additionally, there's an additional mini -hvsi implementation
in the pseries platform code for our low level debug console and early
boot kernel messages, which means code duplication, though that low
level variant is impractical as it's incapable of doing the initial
protocol negociation to establish the link to the FSP.
This essentially replaces the dedicated hvsi driver and the platform
udbg code completely by extending the existing hvc_vio backend used
in "raw" mode so that:
- It now supports HVSI as well
- We add support for hvc backend providing tiocm{get,set}
- It also provides a udbg interface for early debug and boot console
This is overall less code, though this will only be obvious once we
remove the old "hvsi" driver, which is still available for now. When
the old driver is enabled, the new code still kicks in for the low
level udbg console, replacing the old mini implementation in the platform
code, it just doesn't provide the higher level "hvc" interface.
In addition to producing generally simler code, this has several benefits
over our current situation:
- The user/distro only has to deal with /dev/hvcN for the hypervisor
console, avoiding all sort of confusion that has plagued us in the past
- The tty, kernel and low level debug console all use the same code
base which supports the full protocol establishment process, thus the
console is now available much earlier than it used to be with the
old HVSI driver. The kernel console works much earlier and udbg is
available much earlier too. Hackers can enable a hard coded very-early
debug console as well that works with HVSI (previously that was only
supported for the "raw" mode).
I've tried to keep the same semantics as hvsi relative to how I react
to things like CD changes, with some subtle differences though:
- I clear DTR on close if HUPCL is set
- Current hvsi triggers a hangup if it detects a up->down transition
on CD (you can still open a console with CD down). My new implementation
triggers a hangup if the link to the FSP is severed, and severs it upon
detecting a up->down transition on CD.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2011-05-12 05:46:38 +02:00
|
|
|
.tiocmget = hvc_tiocmget,
|
|
|
|
.tiocmset = hvc_tiocmset,
|
2011-07-12 21:44:05 +02:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
.poll_init = hvc_poll_init,
|
|
|
|
.poll_get_char = hvc_poll_get_char,
|
|
|
|
.poll_put_char = hvc_poll_put_char,
|
|
|
|
#endif
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
2012-04-02 13:54:21 +02:00
|
|
|
static const struct tty_port_operations hvc_port_ops = {
|
|
|
|
.destruct = hvc_port_destruct,
|
|
|
|
};
|
|
|
|
|
2010-01-18 04:44:58 +01:00
|
|
|
struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
|
|
|
|
const struct hv_ops *ops,
|
|
|
|
int outbuf_size)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct hvc_struct *hp;
|
2005-07-08 02:56:17 +02:00
|
|
|
int i;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-17 08:30:13 +02:00
|
|
|
/* We wait until a driver actually comes along */
|
|
|
|
if (!hvc_driver) {
|
|
|
|
int err = hvc_init();
|
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
2009-01-08 03:14:28 +01:00
|
|
|
hp = kzalloc(ALIGN(sizeof(*hp), sizeof(long)) + outbuf_size,
|
2006-07-13 10:53:32 +02:00
|
|
|
GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!hp)
|
2005-07-08 02:56:24 +02:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-08 02:56:24 +02:00
|
|
|
hp->vtermno = vtermno;
|
2008-06-20 15:24:08 +02:00
|
|
|
hp->data = data;
|
2005-07-08 02:56:25 +02:00
|
|
|
hp->ops = ops;
|
2006-07-13 10:53:32 +02:00
|
|
|
hp->outbuf_size = outbuf_size;
|
|
|
|
hp->outbuf = &((char *)hp)[ALIGN(sizeof(*hp), sizeof(long))];
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_init(&hp->port);
|
|
|
|
hp->port.ops = &hvc_port_ops;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-14 07:02:09 +02:00
|
|
|
INIT_WORK(&hp->tty_resize, hvc_set_winsz);
|
2005-04-17 00:20:36 +02:00
|
|
|
spin_lock_init(&hp->lock);
|
|
|
|
spin_lock(&hvc_structs_lock);
|
2005-07-08 02:56:17 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* find index to use:
|
|
|
|
* see if this vterm id matches one registered for console.
|
|
|
|
*/
|
2011-11-07 07:22:16 +01:00
|
|
|
for (i=0; i < MAX_NR_HVC_CONSOLES; i++)
|
2006-03-27 21:25:16 +02:00
|
|
|
if (vtermnos[i] == hp->vtermno &&
|
|
|
|
cons_ops[i] == hp->ops)
|
2005-07-08 02:56:17 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* no matching slot, just use a counter */
|
|
|
|
if (i >= MAX_NR_HVC_CONSOLES)
|
|
|
|
i = ++last_hvc;
|
|
|
|
|
|
|
|
hp->index = i;
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
cons_ops[i] = ops;
|
|
|
|
vtermnos[i] = vtermno;
|
2005-07-08 02:56:17 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
list_add_tail(&(hp->next), &hvc_structs);
|
|
|
|
spin_unlock(&hvc_structs_lock);
|
|
|
|
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
/* check if we need to re-register the kernel console */
|
|
|
|
hvc_check_console(i);
|
|
|
|
|
2005-07-08 02:56:24 +02:00
|
|
|
return hp;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-07-25 19:06:06 +02:00
|
|
|
EXPORT_SYMBOL_GPL(hvc_alloc);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-10-14 01:12:52 +02:00
|
|
|
int hvc_remove(struct hvc_struct *hp)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
struct tty_struct *tty;
|
|
|
|
|
2012-04-02 13:54:22 +02:00
|
|
|
tty = tty_port_tty_get(&hp->port);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2012-04-02 13:54:22 +02:00
|
|
|
spin_lock_irqsave(&hp->lock, flags);
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
if (hp->index < MAX_NR_HVC_CONSOLES) {
|
|
|
|
console_lock();
|
2005-04-17 00:20:36 +02:00
|
|
|
vtermnos[hp->index] = -1;
|
hvc_console: Better kernel console support
hvc_console has two methods to instanciate the consoles.
hvc_instanciate is meant to be called at early boot, while hvc_alloc is
called for more dynamically probed objects.
Currently, it only deals with adding kernel consoles in the former case,
which means for example that if a console only uses dynamic probing, it
will never be usable as a kernel console even when specifying
console=hvc0 explicitly, which could be considered annoying...
More specifically, on pseries, we only do the early instanciate for the
console currently used by the firmware, so if you have your firmware
configured to go to a video card, for example, you cannot get your
kernel console, oops messages, etc... on your serial port or hypervisor
console, which would be handy to deal with oopses.
This fixes it by checking if hvc_console.flags & CON_ENABLED is set when
registering a new dynamic console, and if not, redo the index check and
re-register the console if the index matches, allowing console=hvcN to
work.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
2012-07-23 23:33:13 +02:00
|
|
|
cons_ops[hp->index] = NULL;
|
|
|
|
console_unlock();
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Don't whack hp->irq because tty_hangup() will need to free the irq. */
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&hp->lock, flags);
|
|
|
|
|
|
|
|
/*
|
2007-11-28 19:46:22 +01:00
|
|
|
* We 'put' the instance that was grabbed when the kref instance
|
|
|
|
* was initialized using kref_init(). Let the last holder of this
|
2010-03-12 07:23:15 +01:00
|
|
|
* kref cause it to be removed, which will probably be the tty_vhangup
|
2005-04-17 00:20:36 +02:00
|
|
|
* below.
|
|
|
|
*/
|
2012-04-02 13:54:21 +02:00
|
|
|
tty_port_put(&hp->port);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/*
|
2010-03-12 07:23:15 +01:00
|
|
|
* This function call will auto chain call hvc_hangup.
|
2005-04-17 00:20:36 +02:00
|
|
|
*/
|
2010-03-12 07:23:15 +01:00
|
|
|
if (tty) {
|
|
|
|
tty_vhangup(tty);
|
|
|
|
tty_kref_put(tty);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
2009-11-27 21:50:49 +01:00
|
|
|
EXPORT_SYMBOL_GPL(hvc_remove);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-17 08:30:13 +02:00
|
|
|
/* Driver initialization: called as soon as someone uses hvc_alloc(). */
|
|
|
|
static int hvc_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-03-25 07:30:00 +01:00
|
|
|
struct tty_driver *drv;
|
2007-10-17 08:30:13 +02:00
|
|
|
int err;
|
2006-03-25 07:30:00 +01:00
|
|
|
|
2005-07-08 02:56:21 +02:00
|
|
|
/* We need more than hvc_count adapters due to hotplug additions. */
|
2006-03-25 07:30:00 +01:00
|
|
|
drv = alloc_tty_driver(HVC_ALLOC_TTY_ADAPTERS);
|
2007-10-17 08:30:13 +02:00
|
|
|
if (!drv) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-03-25 07:30:00 +01:00
|
|
|
drv->driver_name = "hvc";
|
|
|
|
drv->name = "hvc";
|
|
|
|
drv->major = HVC_MAJOR;
|
|
|
|
drv->minor_start = HVC_MINOR;
|
|
|
|
drv->type = TTY_DRIVER_TYPE_SYSTEM;
|
|
|
|
drv->init_termios = tty_std_termios;
|
2008-10-14 01:12:49 +02:00
|
|
|
drv->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_RESET_TERMIOS;
|
2006-03-25 07:30:00 +01:00
|
|
|
tty_set_operations(drv, &hvc_ops);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* Always start the kthread because there can be hotplug vty adapters
|
|
|
|
* added later. */
|
|
|
|
hvc_task = kthread_run(khvcd, NULL, "khvcd");
|
|
|
|
if (IS_ERR(hvc_task)) {
|
2007-10-17 08:30:13 +02:00
|
|
|
printk(KERN_ERR "Couldn't create kthread for console.\n");
|
|
|
|
err = PTR_ERR(hvc_task);
|
|
|
|
goto put_tty;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-10-17 08:30:13 +02:00
|
|
|
err = tty_register_driver(drv);
|
|
|
|
if (err) {
|
|
|
|
printk(KERN_ERR "Couldn't register hvc console driver\n");
|
|
|
|
goto stop_thread;
|
|
|
|
}
|
2005-09-14 23:19:18 +02:00
|
|
|
|
2009-01-08 03:14:18 +01:00
|
|
|
/*
|
|
|
|
* Make sure tty is fully registered before allowing it to be
|
|
|
|
* found by hvc_console_device.
|
|
|
|
*/
|
|
|
|
smp_mb();
|
2006-03-25 07:30:00 +01:00
|
|
|
hvc_driver = drv;
|
2005-07-08 02:56:24 +02:00
|
|
|
return 0;
|
2007-10-17 08:30:13 +02:00
|
|
|
|
|
|
|
stop_thread:
|
|
|
|
kthread_stop(hvc_task);
|
|
|
|
hvc_task = NULL;
|
drivers/char/hvc_console.c: adjust call to put_tty_driver
The call to put_tty_driver is out of place and is applied to the wrong
argument.
The function enclosing the patched code calls alloc_tty_driver and stores
the result in drv. Subsequently, there are two occurrences of error
handling code, one making a goto to put_tty and one making a goto to
stop_thread. At the point of the first one the assignment hvc_driver = drv
has not yet been executed, and from inspecting the rest of the file it
seems that hvc_driver would be NULL. Thus the current call to
put_tty_driver is useless, and one applied to drv is needed. The goto
stop_thread is in the error handling code for a call to
tty_register_driver, but the error cases in tty_register_driver do not free
its argument, so it should be done here. Thus, I have moved the put_tty
label after the stop_thread label, so that put_tty_driver is called in both
cases.
The semantic match that finds this problem is as follows:
(http://www.emn.fr/x-info/coccinelle/)
// <smpl>
@r exists@
local idexpression x;
expression E,f;
position p1,p2,p3;
identifier l;
statement S;
@@
x = alloc_tty_driver@p1(...)
...
if (x == NULL) S
... when != E = x
when != put_tty_driver(x)
goto@p2 l;
... when != E = x
when != f(...,x,...)
when any
(
return \(0\|x\);
|
return@p3 ...;
)
@script:python@
p1 << r.p1;
p2 << r.p2;
p3 << r.p3;
@@
print "%s: call on line %s not freed or saved before return on line %s via line %s" % (p1[0].file,p1[0].line,p3[0].line,p2[0].line)
// </smpl>
Signed-off-by: Julia Lawall <julia@diku.dk>
Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-10-13 11:31:49 +02:00
|
|
|
put_tty:
|
|
|
|
put_tty_driver(drv);
|
2007-10-17 08:30:13 +02:00
|
|
|
out:
|
|
|
|
return err;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2007-04-17 16:54:51 +02:00
|
|
|
/* This isn't particularly necessary due to this being a console driver
|
2005-07-08 02:56:20 +02:00
|
|
|
* but it is nice to be thorough.
|
|
|
|
*/
|
2005-04-17 00:20:36 +02:00
|
|
|
static void __exit hvc_exit(void)
|
|
|
|
{
|
2007-10-17 08:30:13 +02:00
|
|
|
if (hvc_driver) {
|
|
|
|
kthread_stop(hvc_task);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-10-17 08:30:13 +02:00
|
|
|
tty_unregister_driver(hvc_driver);
|
|
|
|
/* return tty_struct instances allocated in hvc_init(). */
|
|
|
|
put_tty_driver(hvc_driver);
|
2010-07-06 10:03:16 +02:00
|
|
|
unregister_console(&hvc_console);
|
2007-10-17 08:30:13 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
module_exit(hvc_exit);
|