sclp_rw.c

Go to the documentation of this file.

/*
 * driver: reading from and writing to system console on S/390 via SCLP
 *
 * Copyright IBM Corp. 1999, 2009
 *
 * Author(s): Martin Peschke <[email protected]>
 *        Martin Schwidefsky <[email protected]>
 */

#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 | EVTYP_PMSGCMD_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;
    if (sclp_rw_event.sclp_receive_mask & EVTYP_MSG_MASK)
        /* Use normal write message */
        sccb->msg_buf.header.type = EVTYP_MSG;
    else if (sclp_rw_event.sclp_receive_mask & EVTYP_PMSGCMD_MASK)
        /* Use write priority message */
        sccb->msg_buf.header.type = EVTYP_PMSGCMD;
    else
        return -EOPNOTSUPP;
    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);
}