![Martin Schwidefsky](/assets/img/avatar_default.png)
The event type masks can change asynchronously. These changes are reported by SCLP to the OS by state-change events which are retrieved with the read event data command. The SCLP driver has a request queue, there is a window where the read event data request has not completed yet but the SCLP console drivers are trying to queue output requests. As the masks are not updated yet the requests are discarded. The simplest fix is to queue the console requests independent of the event type masks and rely on SCLP to return with an error code if a specific event type is not available. Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
470 lines
12 KiB
C
470 lines
12 KiB
C
/*
|
|
* driver: reading from and writing to system console on S/390 via SCLP
|
|
*
|
|
* 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/types.h>
|
|
#include <linux/err.h>
|
|
#include <linux/string.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/ctype.h>
|
|
#include <asm/uaccess.h>
|
|
|
|
#include "sclp.h"
|
|
#include "sclp_rw.h"
|
|
|
|
/*
|
|
* The room for the SCCB (only for writing) is not equal to a pages size
|
|
* (as it is specified as the maximum size in the SCLP documentation)
|
|
* because of the additional data structure described above.
|
|
*/
|
|
#define MAX_SCCB_ROOM (PAGE_SIZE - sizeof(struct sclp_buffer))
|
|
|
|
static void sclp_rw_pm_event(struct sclp_register *reg,
|
|
enum sclp_pm_event sclp_pm_event)
|
|
{
|
|
sclp_console_pm_event(sclp_pm_event);
|
|
}
|
|
|
|
/* Event type structure for write message and write priority message */
|
|
static struct sclp_register sclp_rw_event = {
|
|
.send_mask = EVTYP_MSG_MASK,
|
|
.pm_event_fn = sclp_rw_pm_event,
|
|
};
|
|
|
|
/*
|
|
* Setup a sclp write buffer. Gets a page as input (4K) and returns
|
|
* a pointer to a struct sclp_buffer structure that is located at the
|
|
* end of the input page. This reduces the buffer space by a few
|
|
* bytes but simplifies things.
|
|
*/
|
|
struct sclp_buffer *
|
|
sclp_make_buffer(void *page, unsigned short columns, unsigned short htab)
|
|
{
|
|
struct sclp_buffer *buffer;
|
|
struct write_sccb *sccb;
|
|
|
|
sccb = (struct write_sccb *) page;
|
|
/*
|
|
* We keep the struct sclp_buffer structure at the end
|
|
* of the sccb page.
|
|
*/
|
|
buffer = ((struct sclp_buffer *) ((addr_t) sccb + PAGE_SIZE)) - 1;
|
|
buffer->sccb = sccb;
|
|
buffer->retry_count = 0;
|
|
buffer->mto_number = 0;
|
|
buffer->mto_char_sum = 0;
|
|
buffer->current_line = NULL;
|
|
buffer->current_length = 0;
|
|
buffer->columns = columns;
|
|
buffer->htab = htab;
|
|
|
|
/* initialize sccb */
|
|
memset(sccb, 0, sizeof(struct write_sccb));
|
|
sccb->header.length = sizeof(struct write_sccb);
|
|
sccb->msg_buf.header.length = sizeof(struct msg_buf);
|
|
sccb->msg_buf.header.type = EVTYP_MSG;
|
|
sccb->msg_buf.mdb.header.length = sizeof(struct mdb);
|
|
sccb->msg_buf.mdb.header.type = 1;
|
|
sccb->msg_buf.mdb.header.tag = 0xD4C4C240; /* ebcdic "MDB " */
|
|
sccb->msg_buf.mdb.header.revision_code = 1;
|
|
sccb->msg_buf.mdb.go.length = sizeof(struct go);
|
|
sccb->msg_buf.mdb.go.type = 1;
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/*
|
|
* Return a pointer to the original page that has been used to create
|
|
* the buffer.
|
|
*/
|
|
void *
|
|
sclp_unmake_buffer(struct sclp_buffer *buffer)
|
|
{
|
|
return buffer->sccb;
|
|
}
|
|
|
|
/*
|
|
* Initialize a new Message Text Object (MTO) at the end of the provided buffer
|
|
* with enough room for max_len characters. Return 0 on success.
|
|
*/
|
|
static int
|
|
sclp_initialize_mto(struct sclp_buffer *buffer, int max_len)
|
|
{
|
|
struct write_sccb *sccb;
|
|
struct mto *mto;
|
|
int mto_size;
|
|
|
|
/* max size of new Message Text Object including message text */
|
|
mto_size = sizeof(struct mto) + max_len;
|
|
|
|
/* check if current buffer sccb can contain the mto */
|
|
sccb = buffer->sccb;
|
|
if ((MAX_SCCB_ROOM - sccb->header.length) < mto_size)
|
|
return -ENOMEM;
|
|
|
|
/* find address of new message text object */
|
|
mto = (struct mto *)(((addr_t) sccb) + sccb->header.length);
|
|
|
|
/*
|
|
* fill the new Message-Text Object,
|
|
* starting behind the former last byte of the SCCB
|
|
*/
|
|
memset(mto, 0, sizeof(struct mto));
|
|
mto->length = sizeof(struct mto);
|
|
mto->type = 4; /* message text object */
|
|
mto->line_type_flags = LNTPFLGS_ENDTEXT; /* end text */
|
|
|
|
/* set pointer to first byte after struct mto. */
|
|
buffer->current_line = (char *) (mto + 1);
|
|
buffer->current_length = 0;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Finalize MTO initialized by sclp_initialize_mto(), updating the sizes of
|
|
* MTO, enclosing MDB, event buffer and SCCB.
|
|
*/
|
|
static void
|
|
sclp_finalize_mto(struct sclp_buffer *buffer)
|
|
{
|
|
struct write_sccb *sccb;
|
|
struct mto *mto;
|
|
int str_len, mto_size;
|
|
|
|
str_len = buffer->current_length;
|
|
buffer->current_line = NULL;
|
|
buffer->current_length = 0;
|
|
|
|
/* real size of new Message Text Object including message text */
|
|
mto_size = sizeof(struct mto) + str_len;
|
|
|
|
/* find address of new message text object */
|
|
sccb = buffer->sccb;
|
|
mto = (struct mto *)(((addr_t) sccb) + sccb->header.length);
|
|
|
|
/* set size of message text object */
|
|
mto->length = mto_size;
|
|
|
|
/*
|
|
* update values of sizes
|
|
* (SCCB, Event(Message) Buffer, Message Data Block)
|
|
*/
|
|
sccb->header.length += mto_size;
|
|
sccb->msg_buf.header.length += mto_size;
|
|
sccb->msg_buf.mdb.header.length += mto_size;
|
|
|
|
/*
|
|
* count number of buffered messages (= number of Message Text
|
|
* Objects) and number of buffered characters
|
|
* for the SCCB currently used for buffering and at all
|
|
*/
|
|
buffer->mto_number++;
|
|
buffer->mto_char_sum += str_len;
|
|
}
|
|
|
|
/*
|
|
* processing of a message including escape characters,
|
|
* returns number of characters written to the output sccb
|
|
* ("processed" means that is not guaranteed that the character have already
|
|
* been sent to the SCLP but that it will be done at least next time the SCLP
|
|
* is not busy)
|
|
*/
|
|
int
|
|
sclp_write(struct sclp_buffer *buffer, const unsigned char *msg, int count)
|
|
{
|
|
int spaces, i_msg;
|
|
int rc;
|
|
|
|
/*
|
|
* parse msg for escape sequences (\t,\v ...) and put formated
|
|
* msg into an mto (created by sclp_initialize_mto).
|
|
*
|
|
* We have to do this work ourselfs because there is no support for
|
|
* these characters on the native machine and only partial support
|
|
* under VM (Why does VM interpret \n but the native machine doesn't ?)
|
|
*
|
|
* Depending on i/o-control setting the message is always written
|
|
* immediately or we wait for a final new line maybe coming with the
|
|
* next message. Besides we avoid a buffer overrun by writing its
|
|
* content.
|
|
*
|
|
* RESTRICTIONS:
|
|
*
|
|
* \r and \b work within one line because we are not able to modify
|
|
* previous output that have already been accepted by the SCLP.
|
|
*
|
|
* \t combined with following \r is not correctly represented because
|
|
* \t is expanded to some spaces but \r does not know about a
|
|
* previous \t and decreases the current position by one column.
|
|
* This is in order to a slim and quick implementation.
|
|
*/
|
|
for (i_msg = 0; i_msg < count; i_msg++) {
|
|
switch (msg[i_msg]) {
|
|
case '\n': /* new line, line feed (ASCII) */
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer, 0);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
sclp_finalize_mto(buffer);
|
|
break;
|
|
case '\a': /* bell, one for several times */
|
|
/* set SCLP sound alarm bit in General Object */
|
|
buffer->sccb->msg_buf.mdb.go.general_msg_flags |=
|
|
GNRLMSGFLGS_SNDALRM;
|
|
break;
|
|
case '\t': /* horizontal tabulator */
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
/* "go to (next htab-boundary + 1, same line)" */
|
|
do {
|
|
if (buffer->current_length >= buffer->columns)
|
|
break;
|
|
/* ok, add a blank */
|
|
*buffer->current_line++ = 0x40;
|
|
buffer->current_length++;
|
|
} while (buffer->current_length % buffer->htab);
|
|
break;
|
|
case '\f': /* form feed */
|
|
case '\v': /* vertical tabulator */
|
|
/* "go to (actual column, actual line + 1)" */
|
|
/* = new line, leading spaces */
|
|
if (buffer->current_line != NULL) {
|
|
spaces = buffer->current_length;
|
|
sclp_finalize_mto(buffer);
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
memset(buffer->current_line, 0x40, spaces);
|
|
buffer->current_line += spaces;
|
|
buffer->current_length = spaces;
|
|
} else {
|
|
/* one an empty line this is the same as \n */
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
break;
|
|
case '\b': /* backspace */
|
|
/* "go to (actual column - 1, actual line)" */
|
|
/* decrement counter indicating position, */
|
|
/* do not remove last character */
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length > 0) {
|
|
buffer->current_length--;
|
|
buffer->current_line--;
|
|
}
|
|
break;
|
|
case 0x00: /* end of string */
|
|
/* transfer current line to SCCB */
|
|
if (buffer->current_line != NULL)
|
|
sclp_finalize_mto(buffer);
|
|
/* skip the rest of the message including the 0 byte */
|
|
i_msg = count - 1;
|
|
break;
|
|
default: /* no escape character */
|
|
/* do not output unprintable characters */
|
|
if (!isprint(msg[i_msg]))
|
|
break;
|
|
/* check if new mto needs to be created */
|
|
if (buffer->current_line == NULL) {
|
|
rc = sclp_initialize_mto(buffer,
|
|
buffer->columns);
|
|
if (rc)
|
|
return i_msg;
|
|
}
|
|
*buffer->current_line++ = sclp_ascebc(msg[i_msg]);
|
|
buffer->current_length++;
|
|
break;
|
|
}
|
|
/* check if current mto is full */
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length >= buffer->columns)
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
|
|
/* return number of processed characters */
|
|
return i_msg;
|
|
}
|
|
|
|
/*
|
|
* Return the number of free bytes in the sccb
|
|
*/
|
|
int
|
|
sclp_buffer_space(struct sclp_buffer *buffer)
|
|
{
|
|
int count;
|
|
|
|
count = MAX_SCCB_ROOM - buffer->sccb->header.length;
|
|
if (buffer->current_line != NULL)
|
|
count -= sizeof(struct mto) + buffer->current_length;
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* Return number of characters in buffer
|
|
*/
|
|
int
|
|
sclp_chars_in_buffer(struct sclp_buffer *buffer)
|
|
{
|
|
int count;
|
|
|
|
count = buffer->mto_char_sum;
|
|
if (buffer->current_line != NULL)
|
|
count += buffer->current_length;
|
|
return count;
|
|
}
|
|
|
|
/*
|
|
* sets or provides some values that influence the drivers behaviour
|
|
*/
|
|
void
|
|
sclp_set_columns(struct sclp_buffer *buffer, unsigned short columns)
|
|
{
|
|
buffer->columns = columns;
|
|
if (buffer->current_line != NULL &&
|
|
buffer->current_length > buffer->columns)
|
|
sclp_finalize_mto(buffer);
|
|
}
|
|
|
|
void
|
|
sclp_set_htab(struct sclp_buffer *buffer, unsigned short htab)
|
|
{
|
|
buffer->htab = htab;
|
|
}
|
|
|
|
/*
|
|
* called by sclp_console_init and/or sclp_tty_init
|
|
*/
|
|
int
|
|
sclp_rw_init(void)
|
|
{
|
|
static int init_done = 0;
|
|
int rc;
|
|
|
|
if (init_done)
|
|
return 0;
|
|
|
|
rc = sclp_register(&sclp_rw_event);
|
|
if (rc == 0)
|
|
init_done = 1;
|
|
return rc;
|
|
}
|
|
|
|
#define SCLP_BUFFER_MAX_RETRY 1
|
|
|
|
/*
|
|
* second half of Write Event Data-function that has to be done after
|
|
* interruption indicating completion of Service Call.
|
|
*/
|
|
static void
|
|
sclp_writedata_callback(struct sclp_req *request, void *data)
|
|
{
|
|
int rc;
|
|
struct sclp_buffer *buffer;
|
|
struct write_sccb *sccb;
|
|
|
|
buffer = (struct sclp_buffer *) data;
|
|
sccb = buffer->sccb;
|
|
|
|
if (request->status == SCLP_REQ_FAILED) {
|
|
if (buffer->callback != NULL)
|
|
buffer->callback(buffer, -EIO);
|
|
return;
|
|
}
|
|
/* check SCLP response code and choose suitable action */
|
|
switch (sccb->header.response_code) {
|
|
case 0x0020 :
|
|
/* Normal completion, buffer processed, message(s) sent */
|
|
rc = 0;
|
|
break;
|
|
|
|
case 0x0340: /* Contained SCLP equipment check */
|
|
if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
/* remove processed buffers and requeue rest */
|
|
if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {
|
|
/* not all buffers were processed */
|
|
sccb->header.response_code = 0x0000;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
rc = sclp_add_request(request);
|
|
if (rc == 0)
|
|
return;
|
|
} else
|
|
rc = 0;
|
|
break;
|
|
|
|
case 0x0040: /* SCLP equipment check */
|
|
case 0x05f0: /* Target resource in improper state */
|
|
if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
|
|
rc = -EIO;
|
|
break;
|
|
}
|
|
/* retry request */
|
|
sccb->header.response_code = 0x0000;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
rc = sclp_add_request(request);
|
|
if (rc == 0)
|
|
return;
|
|
break;
|
|
default:
|
|
if (sccb->header.response_code == 0x71f0)
|
|
rc = -ENOMEM;
|
|
else
|
|
rc = -EINVAL;
|
|
break;
|
|
}
|
|
if (buffer->callback != NULL)
|
|
buffer->callback(buffer, rc);
|
|
}
|
|
|
|
/*
|
|
* Setup the request structure in the struct sclp_buffer to do SCLP Write
|
|
* Event Data and pass the request to the core SCLP loop. Return zero on
|
|
* success, non-zero otherwise.
|
|
*/
|
|
int
|
|
sclp_emit_buffer(struct sclp_buffer *buffer,
|
|
void (*callback)(struct sclp_buffer *, int))
|
|
{
|
|
struct write_sccb *sccb;
|
|
|
|
/* add current line if there is one */
|
|
if (buffer->current_line != NULL)
|
|
sclp_finalize_mto(buffer);
|
|
|
|
/* Are there messages in the output buffer ? */
|
|
if (buffer->mto_number == 0)
|
|
return -EIO;
|
|
|
|
sccb = buffer->sccb;
|
|
/* Use normal write message */
|
|
sccb->msg_buf.header.type = EVTYP_MSG;
|
|
|
|
buffer->request.command = SCLP_CMDW_WRITE_EVENT_DATA;
|
|
buffer->request.status = SCLP_REQ_FILLED;
|
|
buffer->request.callback = sclp_writedata_callback;
|
|
buffer->request.callback_data = buffer;
|
|
buffer->request.sccb = sccb;
|
|
buffer->callback = callback;
|
|
return sclp_add_request(&buffer->request);
|
|
}
|