444 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * driver: reading from and writing to system console on S/390 via SCLP4 *5 * Copyright IBM Corp. 1999, 20096 *7 * Author(s): Martin Peschke <mpeschke@de.ibm.com>8 * Martin Schwidefsky <schwidefsky@de.ibm.com>9 */10 11#include <linux/kmod.h>12#include <linux/types.h>13#include <linux/err.h>14#include <linux/string.h>15#include <linux/spinlock.h>16#include <linux/ctype.h>17#include <linux/uaccess.h>18 19#include "sclp.h"20#include "sclp_rw.h"21 22/*23 * The room for the SCCB (only for writing) is not equal to a pages size24 * (as it is specified as the maximum size in the SCLP documentation)25 * because of the additional data structure described above.26 */27#define MAX_SCCB_ROOM (PAGE_SIZE - sizeof(struct sclp_buffer))28 29/* Event type structure for write message and write priority message */30static struct sclp_register sclp_rw_event = {31 .send_mask = EVTYP_MSG_MASK,32};33 34/*35 * Setup a sclp write buffer. Gets a page as input (4K) and returns36 * a pointer to a struct sclp_buffer structure that is located at the37 * end of the input page. This reduces the buffer space by a few38 * bytes but simplifies things.39 */40struct sclp_buffer *41sclp_make_buffer(void *page, unsigned short columns, unsigned short htab)42{43 struct sclp_buffer *buffer;44 struct sccb_header *sccb;45 46 sccb = (struct sccb_header *) page;47 /*48 * We keep the struct sclp_buffer structure at the end49 * of the sccb page.50 */51 buffer = ((struct sclp_buffer *) ((addr_t) sccb + PAGE_SIZE)) - 1;52 buffer->sccb = sccb;53 buffer->retry_count = 0;54 buffer->messages = 0;55 buffer->char_sum = 0;56 buffer->current_line = NULL;57 buffer->current_length = 0;58 buffer->columns = columns;59 buffer->htab = htab;60 61 /* initialize sccb */62 memset(sccb, 0, sizeof(struct sccb_header));63 sccb->length = sizeof(struct sccb_header);64 65 return buffer;66}67 68/*69 * Return a pointer to the original page that has been used to create70 * the buffer.71 */72void *73sclp_unmake_buffer(struct sclp_buffer *buffer)74{75 return buffer->sccb;76}77 78/*79 * Initialize a new message the end of the provided buffer with80 * enough room for max_len characters. Return 0 on success.81 */82static int83sclp_initialize_mto(struct sclp_buffer *buffer, int max_len)84{85 struct sccb_header *sccb;86 struct msg_buf *msg;87 struct mdb *mdb;88 struct go *go;89 struct mto *mto;90 int msg_size;91 92 /* max size of new message including message text */93 msg_size = sizeof(struct msg_buf) + max_len;94 95 /* check if current buffer sccb can contain the mto */96 sccb = buffer->sccb;97 if ((MAX_SCCB_ROOM - sccb->length) < msg_size)98 return -ENOMEM;99 100 msg = (struct msg_buf *)((addr_t) sccb + sccb->length);101 memset(msg, 0, sizeof(struct msg_buf));102 msg->header.length = sizeof(struct msg_buf);103 msg->header.type = EVTYP_MSG;104 105 mdb = &msg->mdb;106 mdb->header.length = sizeof(struct mdb);107 mdb->header.type = 1;108 mdb->header.tag = 0xD4C4C240; /* ebcdic "MDB " */109 mdb->header.revision_code = 1;110 111 go = &mdb->go;112 go->length = sizeof(struct go);113 go->type = 1;114 115 mto = &mdb->mto;116 mto->length = sizeof(struct mto);117 mto->type = 4; /* message text object */118 mto->line_type_flags = LNTPFLGS_ENDTEXT; /* end text */119 120 /* set pointer to first byte after struct mto. */121 buffer->current_msg = msg;122 buffer->current_line = (char *) (mto + 1);123 buffer->current_length = 0;124 125 return 0;126}127 128/*129 * Finalize message initialized by sclp_initialize_mto(),130 * updating the sizes of MTO, enclosing MDB, event buffer and SCCB.131 */132static void133sclp_finalize_mto(struct sclp_buffer *buffer)134{135 struct sccb_header *sccb;136 struct msg_buf *msg;137 138 /*139 * update values of sizes140 * (SCCB, Event(Message) Buffer, Message Data Block)141 */142 sccb = buffer->sccb;143 msg = buffer->current_msg;144 msg->header.length += buffer->current_length;145 msg->mdb.header.length += buffer->current_length;146 msg->mdb.mto.length += buffer->current_length;147 sccb->length += msg->header.length;148 149 /*150 * count number of buffered messages (= number of Message Text151 * Objects) and number of buffered characters152 * for the SCCB currently used for buffering and at all153 */154 buffer->messages++;155 buffer->char_sum += buffer->current_length;156 157 buffer->current_line = NULL;158 buffer->current_length = 0;159 buffer->current_msg = NULL;160}161 162/*163 * processing of a message including escape characters,164 * returns number of characters written to the output sccb165 * ("processed" means that is not guaranteed that the character have already166 * been sent to the SCLP but that it will be done at least next time the SCLP167 * is not busy)168 */169int170sclp_write(struct sclp_buffer *buffer, const unsigned char *msg, int count)171{172 int spaces, i_msg;173 int rc;174 175 /*176 * parse msg for escape sequences (\t,\v ...) and put formated177 * msg into an mto (created by sclp_initialize_mto).178 *179 * We have to do this work ourselfs because there is no support for180 * these characters on the native machine and only partial support181 * under VM (Why does VM interpret \n but the native machine doesn't ?)182 *183 * Depending on i/o-control setting the message is always written184 * immediately or we wait for a final new line maybe coming with the185 * next message. Besides we avoid a buffer overrun by writing its186 * content.187 *188 * RESTRICTIONS:189 *190 * \r and \b work within one line because we are not able to modify191 * previous output that have already been accepted by the SCLP.192 *193 * \t combined with following \r is not correctly represented because194 * \t is expanded to some spaces but \r does not know about a195 * previous \t and decreases the current position by one column.196 * This is in order to a slim and quick implementation.197 */198 for (i_msg = 0; i_msg < count; i_msg++) {199 switch (msg[i_msg]) {200 case '\n': /* new line, line feed (ASCII) */201 /* check if new mto needs to be created */202 if (buffer->current_line == NULL) {203 rc = sclp_initialize_mto(buffer, 0);204 if (rc)205 return i_msg;206 }207 sclp_finalize_mto(buffer);208 break;209 case '\a': /* bell, one for several times */210 /* set SCLP sound alarm bit in General Object */211 if (buffer->current_line == NULL) {212 rc = sclp_initialize_mto(buffer,213 buffer->columns);214 if (rc)215 return i_msg;216 }217 buffer->current_msg->mdb.go.general_msg_flags |=218 GNRLMSGFLGS_SNDALRM;219 break;220 case '\t': /* horizontal tabulator */221 /* check if new mto needs to be created */222 if (buffer->current_line == NULL) {223 rc = sclp_initialize_mto(buffer,224 buffer->columns);225 if (rc)226 return i_msg;227 }228 /* "go to (next htab-boundary + 1, same line)" */229 do {230 if (buffer->current_length >= buffer->columns)231 break;232 /* ok, add a blank */233 *buffer->current_line++ = 0x40;234 buffer->current_length++;235 } while (buffer->current_length % buffer->htab);236 break;237 case '\f': /* form feed */238 case '\v': /* vertical tabulator */239 /* "go to (actual column, actual line + 1)" */240 /* = new line, leading spaces */241 if (buffer->current_line != NULL) {242 spaces = buffer->current_length;243 sclp_finalize_mto(buffer);244 rc = sclp_initialize_mto(buffer,245 buffer->columns);246 if (rc)247 return i_msg;248 memset(buffer->current_line, 0x40, spaces);249 buffer->current_line += spaces;250 buffer->current_length = spaces;251 } else {252 /* one an empty line this is the same as \n */253 rc = sclp_initialize_mto(buffer,254 buffer->columns);255 if (rc)256 return i_msg;257 sclp_finalize_mto(buffer);258 }259 break;260 case '\b': /* backspace */261 /* "go to (actual column - 1, actual line)" */262 /* decrement counter indicating position, */263 /* do not remove last character */264 if (buffer->current_line != NULL &&265 buffer->current_length > 0) {266 buffer->current_length--;267 buffer->current_line--;268 }269 break;270 case 0x00: /* end of string */271 /* transfer current line to SCCB */272 if (buffer->current_line != NULL)273 sclp_finalize_mto(buffer);274 /* skip the rest of the message including the 0 byte */275 i_msg = count - 1;276 break;277 default: /* no escape character */278 /* do not output unprintable characters */279 if (!isprint(msg[i_msg]))280 break;281 /* check if new mto needs to be created */282 if (buffer->current_line == NULL) {283 rc = sclp_initialize_mto(buffer,284 buffer->columns);285 if (rc)286 return i_msg;287 }288 *buffer->current_line++ = sclp_ascebc(msg[i_msg]);289 buffer->current_length++;290 break;291 }292 /* check if current mto is full */293 if (buffer->current_line != NULL &&294 buffer->current_length >= buffer->columns)295 sclp_finalize_mto(buffer);296 }297 298 /* return number of processed characters */299 return i_msg;300}301 302/*303 * Return the number of free bytes in the sccb304 */305int306sclp_buffer_space(struct sclp_buffer *buffer)307{308 struct sccb_header *sccb;309 int count;310 311 sccb = buffer->sccb;312 count = MAX_SCCB_ROOM - sccb->length;313 if (buffer->current_line != NULL)314 count -= sizeof(struct msg_buf) + buffer->current_length;315 return count;316}317 318/*319 * Return number of characters in buffer320 */321unsigned int322sclp_chars_in_buffer(struct sclp_buffer *buffer)323{324 unsigned int count;325 326 count = buffer->char_sum;327 if (buffer->current_line != NULL)328 count += buffer->current_length;329 return count;330}331 332/*333 * called by sclp_console_init and/or sclp_tty_init334 */335int336sclp_rw_init(void)337{338 static int init_done = 0;339 int rc;340 341 if (init_done)342 return 0;343 344 rc = sclp_register(&sclp_rw_event);345 if (rc == 0)346 init_done = 1;347 return rc;348}349 350#define SCLP_BUFFER_MAX_RETRY 1351 352/*353 * second half of Write Event Data-function that has to be done after354 * interruption indicating completion of Service Call.355 */356static void357sclp_writedata_callback(struct sclp_req *request, void *data)358{359 int rc;360 struct sclp_buffer *buffer;361 struct sccb_header *sccb;362 363 buffer = (struct sclp_buffer *) data;364 sccb = buffer->sccb;365 366 if (request->status == SCLP_REQ_FAILED) {367 if (buffer->callback != NULL)368 buffer->callback(buffer, -EIO);369 return;370 }371 /* check SCLP response code and choose suitable action */372 switch (sccb->response_code) {373 case 0x0020 :374 /* Normal completion, buffer processed, message(s) sent */375 rc = 0;376 break;377 378 case 0x0340: /* Contained SCLP equipment check */379 if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {380 rc = -EIO;381 break;382 }383 /* remove processed buffers and requeue rest */384 if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {385 /* not all buffers were processed */386 sccb->response_code = 0x0000;387 buffer->request.status = SCLP_REQ_FILLED;388 rc = sclp_add_request(request);389 if (rc == 0)390 return;391 } else392 rc = 0;393 break;394 395 case 0x0040: /* SCLP equipment check */396 case 0x05f0: /* Target resource in improper state */397 if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {398 rc = -EIO;399 break;400 }401 /* retry request */402 sccb->response_code = 0x0000;403 buffer->request.status = SCLP_REQ_FILLED;404 rc = sclp_add_request(request);405 if (rc == 0)406 return;407 break;408 default:409 if (sccb->response_code == 0x71f0)410 rc = -ENOMEM;411 else412 rc = -EINVAL;413 break;414 }415 if (buffer->callback != NULL)416 buffer->callback(buffer, rc);417}418 419/*420 * Setup the request structure in the struct sclp_buffer to do SCLP Write421 * Event Data and pass the request to the core SCLP loop. Return zero on422 * success, non-zero otherwise.423 */424int425sclp_emit_buffer(struct sclp_buffer *buffer,426 void (*callback)(struct sclp_buffer *, int))427{428 /* add current line if there is one */429 if (buffer->current_line != NULL)430 sclp_finalize_mto(buffer);431 432 /* Are there messages in the output buffer ? */433 if (buffer->messages == 0)434 return -EIO;435 436 buffer->request.command = SCLP_CMDW_WRITE_EVENT_DATA;437 buffer->request.status = SCLP_REQ_FILLED;438 buffer->request.callback = sclp_writedata_callback;439 buffer->request.callback_data = buffer;440 buffer->request.sccb = buffer->sccb;441 buffer->callback = callback;442 return sclp_add_request(&buffer->request);443}444