1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * driver: reading from and writing to system console on S/390 via SCLP
4 *
5 * Copyright IBM Corp. 1999, 2009
6 *
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 size
24 * (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 */
30 static 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 returns
36 * a pointer to a struct sclp_buffer structure that is located at the
37 * end of the input page. This reduces the buffer space by a few
38 * bytes but simplifies things.
39 */
40 struct sclp_buffer *
sclp_make_buffer(void * page,unsigned short columns,unsigned short htab)41 sclp_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 end
49 * 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 create
70 * the buffer.
71 */
72 void *
sclp_unmake_buffer(struct sclp_buffer * buffer)73 sclp_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 with
80 * enough room for max_len characters. Return 0 on success.
81 */
82 static int
sclp_initialize_mto(struct sclp_buffer * buffer,int max_len)83 sclp_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 */
132 static void
sclp_finalize_mto(struct sclp_buffer * buffer)133 sclp_finalize_mto(struct sclp_buffer *buffer)
134 {
135 struct sccb_header *sccb;
136 struct msg_buf *msg;
137
138 /*
139 * update values of sizes
140 * (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 Text
151 * Objects) and number of buffered characters
152 * for the SCCB currently used for buffering and at all
153 */
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 sccb
165 * ("processed" means that is not guaranteed that the character have already
166 * been sent to the SCLP but that it will be done at least next time the SCLP
167 * is not busy)
168 */
169 int
sclp_write(struct sclp_buffer * buffer,const unsigned char * msg,int count)170 sclp_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 formated
177 * msg into an mto (created by sclp_initialize_mto).
178 *
179 * We have to do this work ourselfs because there is no support for
180 * these characters on the native machine and only partial support
181 * 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 written
184 * immediately or we wait for a final new line maybe coming with the
185 * next message. Besides we avoid a buffer overrun by writing its
186 * content.
187 *
188 * RESTRICTIONS:
189 *
190 * \r and \b work within one line because we are not able to modify
191 * previous output that have already been accepted by the SCLP.
192 *
193 * \t combined with following \r is not correctly represented because
194 * \t is expanded to some spaces but \r does not know about a
195 * 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 sccb
304 */
305 int
sclp_buffer_space(struct sclp_buffer * buffer)306 sclp_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 buffer
320 */
321 unsigned int
sclp_chars_in_buffer(struct sclp_buffer * buffer)322 sclp_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_init
334 */
335 int
sclp_rw_init(void)336 sclp_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 1
351
352 /*
353 * second half of Write Event Data-function that has to be done after
354 * interruption indicating completion of Service Call.
355 */
356 static void
sclp_writedata_callback(struct sclp_req * request,void * data)357 sclp_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 } else
392 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 else
412 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 Write
421 * Event Data and pass the request to the core SCLP loop. Return zero on
422 * success, non-zero otherwise.
423 */
424 int
sclp_emit_buffer(struct sclp_buffer * buffer,void (* callback)(struct sclp_buffer *,int))425 sclp_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