![Peter Oberparleiter](/assets/img/avatar_default.png)
Use the same code structure when determining preferred consoles for Linux running as KVM guest as with Linux running in LPAR and z/VM guest: - Extend the console_mode variable to cover vt220 and hvc consoles - Determine sensible console defaults in conmode_default() - Remove KVM-special handling in set_preferred_console() Ensure that the sclp line mode console is also registered when the vt220 console was selected to not change existing behavior that someone might be relying on. As an externally visible change, KVM guest users can now select the 3270 or 3215 console devices using the conmode= kernel parameter, provided that support for the corresponding driver was compiled into the kernel. Signed-off-by: Peter Oberparleiter <oberpar@linux.vnet.ibm.com> Signed-off-by: Jing Liu <liujbjl@linux.vnet.ibm.com> Reviewed-by: Cornelia Huck <cornelia.huck@de.ibm.com> Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
358 lines
8.6 KiB
C
358 lines
8.6 KiB
C
/*
|
|
* SCLP line mode console driver
|
|
*
|
|
* Copyright IBM Corp. 1999, 2009
|
|
* Author(s): Martin Peschke <mpeschke@de.ibm.com>
|
|
* Martin Schwidefsky <schwidefsky@de.ibm.com>
|
|
*/
|
|
|
|
#include <linux/kmod.h>
|
|
#include <linux/console.h>
|
|
#include <linux/init.h>
|
|
#include <linux/timer.h>
|
|
#include <linux/jiffies.h>
|
|
#include <linux/termios.h>
|
|
#include <linux/err.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/gfp.h>
|
|
|
|
#include "sclp.h"
|
|
#include "sclp_rw.h"
|
|
#include "sclp_tty.h"
|
|
|
|
#define sclp_console_major 4 /* TTYAUX_MAJOR */
|
|
#define sclp_console_minor 64
|
|
#define sclp_console_name "ttyS"
|
|
|
|
/* Lock to guard over changes to global variables */
|
|
static spinlock_t sclp_con_lock;
|
|
/* List of free pages that can be used for console output buffering */
|
|
static struct list_head sclp_con_pages;
|
|
/* List of full struct sclp_buffer structures ready for output */
|
|
static struct list_head sclp_con_outqueue;
|
|
/* Pointer to current console buffer */
|
|
static struct sclp_buffer *sclp_conbuf;
|
|
/* Timer for delayed output of console messages */
|
|
static struct timer_list sclp_con_timer;
|
|
/* Suspend mode flag */
|
|
static int sclp_con_suspended;
|
|
/* Flag that output queue is currently running */
|
|
static int sclp_con_queue_running;
|
|
|
|
/* Output format for console messages */
|
|
static unsigned short sclp_con_columns;
|
|
static unsigned short sclp_con_width_htab;
|
|
|
|
static void
|
|
sclp_conbuf_callback(struct sclp_buffer *buffer, int rc)
|
|
{
|
|
unsigned long flags;
|
|
void *page;
|
|
|
|
do {
|
|
page = sclp_unmake_buffer(buffer);
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
|
|
/* Remove buffer from outqueue */
|
|
list_del(&buffer->list);
|
|
list_add_tail((struct list_head *) page, &sclp_con_pages);
|
|
|
|
/* Check if there is a pending buffer on the out queue. */
|
|
buffer = NULL;
|
|
if (!list_empty(&sclp_con_outqueue))
|
|
buffer = list_first_entry(&sclp_con_outqueue,
|
|
struct sclp_buffer, list);
|
|
if (!buffer || sclp_con_suspended) {
|
|
sclp_con_queue_running = 0;
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
break;
|
|
}
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
} while (sclp_emit_buffer(buffer, sclp_conbuf_callback));
|
|
}
|
|
|
|
/*
|
|
* Finalize and emit first pending buffer.
|
|
*/
|
|
static void sclp_conbuf_emit(void)
|
|
{
|
|
struct sclp_buffer* buffer;
|
|
unsigned long flags;
|
|
int rc;
|
|
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
if (sclp_conbuf)
|
|
list_add_tail(&sclp_conbuf->list, &sclp_con_outqueue);
|
|
sclp_conbuf = NULL;
|
|
if (sclp_con_queue_running || sclp_con_suspended)
|
|
goto out_unlock;
|
|
if (list_empty(&sclp_con_outqueue))
|
|
goto out_unlock;
|
|
buffer = list_first_entry(&sclp_con_outqueue, struct sclp_buffer,
|
|
list);
|
|
sclp_con_queue_running = 1;
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
|
|
rc = sclp_emit_buffer(buffer, sclp_conbuf_callback);
|
|
if (rc)
|
|
sclp_conbuf_callback(buffer, rc);
|
|
return;
|
|
out_unlock:
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
}
|
|
|
|
/*
|
|
* Wait until out queue is empty
|
|
*/
|
|
static void sclp_console_sync_queue(void)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
if (timer_pending(&sclp_con_timer))
|
|
del_timer(&sclp_con_timer);
|
|
while (sclp_con_queue_running) {
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
sclp_sync_wait();
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
}
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
}
|
|
|
|
/*
|
|
* When this routine is called from the timer then we flush the
|
|
* temporary write buffer without further waiting on a final new line.
|
|
*/
|
|
static void
|
|
sclp_console_timeout(unsigned long data)
|
|
{
|
|
sclp_conbuf_emit();
|
|
}
|
|
|
|
/*
|
|
* Drop oldest console buffer if sclp_con_drop is set
|
|
*/
|
|
static int
|
|
sclp_console_drop_buffer(void)
|
|
{
|
|
struct list_head *list;
|
|
struct sclp_buffer *buffer;
|
|
void *page;
|
|
|
|
if (!sclp_console_drop)
|
|
return 0;
|
|
list = sclp_con_outqueue.next;
|
|
if (sclp_con_queue_running)
|
|
/* The first element is in I/O */
|
|
list = list->next;
|
|
if (list == &sclp_con_outqueue)
|
|
return 0;
|
|
list_del(list);
|
|
buffer = list_entry(list, struct sclp_buffer, list);
|
|
page = sclp_unmake_buffer(buffer);
|
|
list_add_tail((struct list_head *) page, &sclp_con_pages);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* Writes the given message to S390 system console
|
|
*/
|
|
static void
|
|
sclp_console_write(struct console *console, const char *message,
|
|
unsigned int count)
|
|
{
|
|
unsigned long flags;
|
|
void *page;
|
|
int written;
|
|
|
|
if (count == 0)
|
|
return;
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
/*
|
|
* process escape characters, write message into buffer,
|
|
* send buffer to SCLP
|
|
*/
|
|
do {
|
|
/* make sure we have a console output buffer */
|
|
if (sclp_conbuf == NULL) {
|
|
if (list_empty(&sclp_con_pages))
|
|
sclp_console_full++;
|
|
while (list_empty(&sclp_con_pages)) {
|
|
if (sclp_con_suspended)
|
|
goto out;
|
|
if (sclp_console_drop_buffer())
|
|
break;
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
sclp_sync_wait();
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
}
|
|
page = sclp_con_pages.next;
|
|
list_del((struct list_head *) page);
|
|
sclp_conbuf = sclp_make_buffer(page, sclp_con_columns,
|
|
sclp_con_width_htab);
|
|
}
|
|
/* try to write the string to the current output buffer */
|
|
written = sclp_write(sclp_conbuf, (const unsigned char *)
|
|
message, count);
|
|
if (written == count)
|
|
break;
|
|
/*
|
|
* Not all characters could be written to the current
|
|
* output buffer. Emit the buffer, create a new buffer
|
|
* and then output the rest of the string.
|
|
*/
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
sclp_conbuf_emit();
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
message += written;
|
|
count -= written;
|
|
} while (count > 0);
|
|
/* Setup timer to output current console buffer after 1/10 second */
|
|
if (sclp_conbuf != NULL && sclp_chars_in_buffer(sclp_conbuf) != 0 &&
|
|
!timer_pending(&sclp_con_timer)) {
|
|
init_timer(&sclp_con_timer);
|
|
sclp_con_timer.function = sclp_console_timeout;
|
|
sclp_con_timer.data = 0UL;
|
|
sclp_con_timer.expires = jiffies + HZ/10;
|
|
add_timer(&sclp_con_timer);
|
|
}
|
|
out:
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
}
|
|
|
|
static struct tty_driver *
|
|
sclp_console_device(struct console *c, int *index)
|
|
{
|
|
*index = c->index;
|
|
return sclp_tty_driver;
|
|
}
|
|
|
|
/*
|
|
* Make sure that all buffers will be flushed to the SCLP.
|
|
*/
|
|
static void
|
|
sclp_console_flush(void)
|
|
{
|
|
sclp_conbuf_emit();
|
|
sclp_console_sync_queue();
|
|
}
|
|
|
|
/*
|
|
* Resume console: If there are cached messages, emit them.
|
|
*/
|
|
static void sclp_console_resume(void)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
sclp_con_suspended = 0;
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
sclp_conbuf_emit();
|
|
}
|
|
|
|
/*
|
|
* Suspend console: Set suspend flag and flush console
|
|
*/
|
|
static void sclp_console_suspend(void)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&sclp_con_lock, flags);
|
|
sclp_con_suspended = 1;
|
|
spin_unlock_irqrestore(&sclp_con_lock, flags);
|
|
sclp_console_flush();
|
|
}
|
|
|
|
static int sclp_console_notify(struct notifier_block *self,
|
|
unsigned long event, void *data)
|
|
{
|
|
sclp_console_flush();
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block on_panic_nb = {
|
|
.notifier_call = sclp_console_notify,
|
|
.priority = SCLP_PANIC_PRIO_CLIENT,
|
|
};
|
|
|
|
static struct notifier_block on_reboot_nb = {
|
|
.notifier_call = sclp_console_notify,
|
|
.priority = 1,
|
|
};
|
|
|
|
/*
|
|
* used to register the SCLP console to the kernel and to
|
|
* give printk necessary information
|
|
*/
|
|
static struct console sclp_console =
|
|
{
|
|
.name = sclp_console_name,
|
|
.write = sclp_console_write,
|
|
.device = sclp_console_device,
|
|
.flags = CON_PRINTBUFFER,
|
|
.index = 0 /* ttyS0 */
|
|
};
|
|
|
|
/*
|
|
* This function is called for SCLP suspend and resume events.
|
|
*/
|
|
void sclp_console_pm_event(enum sclp_pm_event sclp_pm_event)
|
|
{
|
|
switch (sclp_pm_event) {
|
|
case SCLP_PM_EVENT_FREEZE:
|
|
sclp_console_suspend();
|
|
break;
|
|
case SCLP_PM_EVENT_RESTORE:
|
|
case SCLP_PM_EVENT_THAW:
|
|
sclp_console_resume();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* called by console_init() in drivers/char/tty_io.c at boot-time.
|
|
*/
|
|
static int __init
|
|
sclp_console_init(void)
|
|
{
|
|
void *page;
|
|
int i;
|
|
int rc;
|
|
|
|
/* SCLP consoles are handled together */
|
|
if (!(CONSOLE_IS_SCLP || CONSOLE_IS_VT220))
|
|
return 0;
|
|
rc = sclp_rw_init();
|
|
if (rc)
|
|
return rc;
|
|
/* Allocate pages for output buffering */
|
|
INIT_LIST_HEAD(&sclp_con_pages);
|
|
for (i = 0; i < sclp_console_pages; i++) {
|
|
page = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
|
|
list_add_tail(page, &sclp_con_pages);
|
|
}
|
|
INIT_LIST_HEAD(&sclp_con_outqueue);
|
|
spin_lock_init(&sclp_con_lock);
|
|
sclp_conbuf = NULL;
|
|
init_timer(&sclp_con_timer);
|
|
|
|
/* Set output format */
|
|
if (MACHINE_IS_VM)
|
|
/*
|
|
* save 4 characters for the CPU number
|
|
* written at start of each line by VM/CP
|
|
*/
|
|
sclp_con_columns = 76;
|
|
else
|
|
sclp_con_columns = 80;
|
|
sclp_con_width_htab = 8;
|
|
|
|
/* enable printk-access to this driver */
|
|
atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
|
|
register_reboot_notifier(&on_reboot_nb);
|
|
register_console(&sclp_console);
|
|
return 0;
|
|
}
|
|
|
|
console_initcall(sclp_console_init);
|