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 static void sclp_rw_pm_event(struct sclp_register *reg,
30 enum sclp_pm_event sclp_pm_event)
31 {
32 sclp_console_pm_event(sclp_pm_event);
33 }
34
35 /* Event type structure for write message and write priority message */
36 static struct sclp_register sclp_rw_event = {
37 .send_mask = EVTYP_MSG_MASK,
38 .pm_event_fn = sclp_rw_pm_event,
39 };
40
41 /*
42 * Setup a sclp write buffer. Gets a page as input (4K) and returns
43 * a pointer to a struct sclp_buffer structure that is located at the
44 * end of the input page. This reduces the buffer space by a few
45 * bytes but simplifies things.
46 */
47 struct sclp_buffer *
48 sclp_make_buffer(void *page, unsigned short columns, unsigned short htab)
49 {
50 struct sclp_buffer *buffer;
51 struct sccb_header *sccb;
52
53 sccb = (struct sccb_header *) page;
54 /*
55 * We keep the struct sclp_buffer structure at the end
56 * of the sccb page.
57 */
58 buffer = ((struct sclp_buffer *) ((addr_t) sccb + PAGE_SIZE)) - 1;
59 buffer->sccb = sccb;
60 buffer->retry_count = 0;
61 buffer->messages = 0;
62 buffer->char_sum = 0;
63 buffer->current_line = NULL;
64 buffer->current_length = 0;
65 buffer->columns = columns;
66 buffer->htab = htab;
67
68 /* initialize sccb */
69 memset(sccb, 0, sizeof(struct sccb_header));
70 sccb->length = sizeof(struct sccb_header);
71
72 return buffer;
73 }
74
75 /*
76 * Return a pointer to the original page that has been used to create
77 * the buffer.
78 */
79 void *
80 sclp_unmake_buffer(struct sclp_buffer *buffer)
81 {
82 return buffer->sccb;
83 }
84
85 /*
86 * Initialize a new message the end of the provided buffer with
87 * enough room for max_len characters. Return 0 on success.
88 */
89 static int
90 sclp_initialize_mto(struct sclp_buffer *buffer, int max_len)
91 {
92 struct sccb_header *sccb;
93 struct msg_buf *msg;
94 struct mdb *mdb;
95 struct go *go;
96 struct mto *mto;
97 int msg_size;
98
99 /* max size of new message including message text */
100 msg_size = sizeof(struct msg_buf) + max_len;
101
102 /* check if current buffer sccb can contain the mto */
103 sccb = buffer->sccb;
104 if ((MAX_SCCB_ROOM - sccb->length) < msg_size)
105 return -ENOMEM;
106
107 msg = (struct msg_buf *)((addr_t) sccb + sccb->length);
108 memset(msg, 0, sizeof(struct msg_buf));
109 msg->header.length = sizeof(struct msg_buf);
110 msg->header.type = EVTYP_MSG;
111
112 mdb = &msg->mdb;
113 mdb->header.length = sizeof(struct mdb);
114 mdb->header.type = 1;
115 mdb->header.tag = 0xD4C4C240; /* ebcdic "MDB " */
116 mdb->header.revision_code = 1;
117
118 go = &mdb->go;
119 go->length = sizeof(struct go);
120 go->type = 1;
121
122 mto = &mdb->mto;
123 mto->length = sizeof(struct mto);
124 mto->type = 4; /* message text object */
125 mto->line_type_flags = LNTPFLGS_ENDTEXT; /* end text */
126
127 /* set pointer to first byte after struct mto. */
128 buffer->current_msg = msg;
129 buffer->current_line = (char *) (mto + 1);
130 buffer->current_length = 0;
131
132 return 0;
133 }
134
135 /*
136 * Finalize message initialized by sclp_initialize_mto(),
137 * updating the sizes of MTO, enclosing MDB, event buffer and SCCB.
138 */
139 static void
140 sclp_finalize_mto(struct sclp_buffer *buffer)
141 {
142 struct sccb_header *sccb;
143 struct msg_buf *msg;
144
145 /*
146 * update values of sizes
147 * (SCCB, Event(Message) Buffer, Message Data Block)
148 */
149 sccb = buffer->sccb;
150 msg = buffer->current_msg;
151 msg->header.length += buffer->current_length;
152 msg->mdb.header.length += buffer->current_length;
153 msg->mdb.mto.length += buffer->current_length;
154 sccb->length += msg->header.length;
155
156 /*
157 * count number of buffered messages (= number of Message Text
158 * Objects) and number of buffered characters
159 * for the SCCB currently used for buffering and at all
160 */
161 buffer->messages++;
162 buffer->char_sum += buffer->current_length;
163
164 buffer->current_line = NULL;
165 buffer->current_length = 0;
166 buffer->current_msg = NULL;
167 }
168
169 /*
170 * processing of a message including escape characters,
171 * returns number of characters written to the output sccb
172 * ("processed" means that is not guaranteed that the character have already
173 * been sent to the SCLP but that it will be done at least next time the SCLP
174 * is not busy)
175 */
176 int
177 sclp_write(struct sclp_buffer *buffer, const unsigned char *msg, int count)
178 {
179 int spaces, i_msg;
180 int rc;
181
182 /*
183 * parse msg for escape sequences (\t,\v ...) and put formated
184 * msg into an mto (created by sclp_initialize_mto).
185 *
186 * We have to do this work ourselfs because there is no support for
187 * these characters on the native machine and only partial support
188 * under VM (Why does VM interpret \n but the native machine doesn't ?)
189 *
190 * Depending on i/o-control setting the message is always written
191 * immediately or we wait for a final new line maybe coming with the
192 * next message. Besides we avoid a buffer overrun by writing its
193 * content.
194 *
195 * RESTRICTIONS:
196 *
197 * \r and \b work within one line because we are not able to modify
198 * previous output that have already been accepted by the SCLP.
199 *
200 * \t combined with following \r is not correctly represented because
201 * \t is expanded to some spaces but \r does not know about a
202 * previous \t and decreases the current position by one column.
203 * This is in order to a slim and quick implementation.
204 */
205 for (i_msg = 0; i_msg < count; i_msg++) {
206 switch (msg[i_msg]) {
207 case '\n': /* new line, line feed (ASCII) */
208 /* check if new mto needs to be created */
209 if (buffer->current_line == NULL) {
210 rc = sclp_initialize_mto(buffer, 0);
211 if (rc)
212 return i_msg;
213 }
214 sclp_finalize_mto(buffer);
215 break;
216 case '\a': /* bell, one for several times */
217 /* set SCLP sound alarm bit in General Object */
218 if (buffer->current_line == NULL) {
219 rc = sclp_initialize_mto(buffer,
220 buffer->columns);
221 if (rc)
222 return i_msg;
223 }
224 buffer->current_msg->mdb.go.general_msg_flags |=
225 GNRLMSGFLGS_SNDALRM;
226 break;
227 case '\t': /* horizontal tabulator */
228 /* check if new mto needs to be created */
229 if (buffer->current_line == NULL) {
230 rc = sclp_initialize_mto(buffer,
231 buffer->columns);
232 if (rc)
233 return i_msg;
234 }
235 /* "go to (next htab-boundary + 1, same line)" */
236 do {
237 if (buffer->current_length >= buffer->columns)
238 break;
239 /* ok, add a blank */
240 *buffer->current_line++ = 0x40;
241 buffer->current_length++;
242 } while (buffer->current_length % buffer->htab);
243 break;
244 case '\f': /* form feed */
245 case '\v': /* vertical tabulator */
246 /* "go to (actual column, actual line + 1)" */
247 /* = new line, leading spaces */
248 if (buffer->current_line != NULL) {
249 spaces = buffer->current_length;
250 sclp_finalize_mto(buffer);
251 rc = sclp_initialize_mto(buffer,
252 buffer->columns);
253 if (rc)
254 return i_msg;
255 memset(buffer->current_line, 0x40, spaces);
256 buffer->current_line += spaces;
257 buffer->current_length = spaces;
258 } else {
259 /* one an empty line this is the same as \n */
260 rc = sclp_initialize_mto(buffer,
261 buffer->columns);
262 if (rc)
263 return i_msg;
264 sclp_finalize_mto(buffer);
265 }
266 break;
267 case '\b': /* backspace */
268 /* "go to (actual column - 1, actual line)" */
269 /* decrement counter indicating position, */
270 /* do not remove last character */
271 if (buffer->current_line != NULL &&
272 buffer->current_length > 0) {
273 buffer->current_length--;
274 buffer->current_line--;
275 }
276 break;
277 case 0x00: /* end of string */
278 /* transfer current line to SCCB */
279 if (buffer->current_line != NULL)
280 sclp_finalize_mto(buffer);
281 /* skip the rest of the message including the 0 byte */
282 i_msg = count - 1;
283 break;
284 default: /* no escape character */
285 /* do not output unprintable characters */
286 if (!isprint(msg[i_msg]))
287 break;
288 /* check if new mto needs to be created */
289 if (buffer->current_line == NULL) {
290 rc = sclp_initialize_mto(buffer,
291 buffer->columns);
292 if (rc)
293 return i_msg;
294 }
295 *buffer->current_line++ = sclp_ascebc(msg[i_msg]);
296 buffer->current_length++;
297 break;
298 }
299 /* check if current mto is full */
300 if (buffer->current_line != NULL &&
301 buffer->current_length >= buffer->columns)
302 sclp_finalize_mto(buffer);
303 }
304
305 /* return number of processed characters */
306 return i_msg;
307 }
308
309 /*
310 * Return the number of free bytes in the sccb
311 */
312 int
313 sclp_buffer_space(struct sclp_buffer *buffer)
314 {
315 struct sccb_header *sccb;
316 int count;
317
318 sccb = buffer->sccb;
319 count = MAX_SCCB_ROOM - sccb->length;
320 if (buffer->current_line != NULL)
321 count -= sizeof(struct msg_buf) + buffer->current_length;
322 return count;
323 }
324
325 /*
326 * Return number of characters in buffer
327 */
328 int
329 sclp_chars_in_buffer(struct sclp_buffer *buffer)
330 {
331 int count;
332
333 count = buffer->char_sum;
334 if (buffer->current_line != NULL)
335 count += buffer->current_length;
336 return count;
337 }
338
339 /*
340 * sets or provides some values that influence the drivers behaviour
341 */
342 void
343 sclp_set_columns(struct sclp_buffer *buffer, unsigned short columns)
344 {
345 buffer->columns = columns;
346 if (buffer->current_line != NULL &&
347 buffer->current_length > buffer->columns)
348 sclp_finalize_mto(buffer);
349 }
350
351 void
352 sclp_set_htab(struct sclp_buffer *buffer, unsigned short htab)
353 {
354 buffer->htab = htab;
355 }
356
357 /*
358 * called by sclp_console_init and/or sclp_tty_init
359 */
360 int
361 sclp_rw_init(void)
362 {
363 static int init_done = 0;
364 int rc;
365
366 if (init_done)
367 return 0;
368
369 rc = sclp_register(&sclp_rw_event);
370 if (rc == 0)
371 init_done = 1;
372 return rc;
373 }
374
375 #define SCLP_BUFFER_MAX_RETRY 1
376
377 /*
378 * second half of Write Event Data-function that has to be done after
379 * interruption indicating completion of Service Call.
380 */
381 static void
382 sclp_writedata_callback(struct sclp_req *request, void *data)
383 {
384 int rc;
385 struct sclp_buffer *buffer;
386 struct sccb_header *sccb;
387
388 buffer = (struct sclp_buffer *) data;
389 sccb = buffer->sccb;
390
391 if (request->status == SCLP_REQ_FAILED) {
392 if (buffer->callback != NULL)
393 buffer->callback(buffer, -EIO);
394 return;
395 }
396 /* check SCLP response code and choose suitable action */
397 switch (sccb->response_code) {
398 case 0x0020 :
399 /* Normal completion, buffer processed, message(s) sent */
400 rc = 0;
401 break;
402
403 case 0x0340: /* Contained SCLP equipment check */
404 if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
405 rc = -EIO;
406 break;
407 }
408 /* remove processed buffers and requeue rest */
409 if (sclp_remove_processed((struct sccb_header *) sccb) > 0) {
410 /* not all buffers were processed */
411 sccb->response_code = 0x0000;
412 buffer->request.status = SCLP_REQ_FILLED;
413 rc = sclp_add_request(request);
414 if (rc == 0)
415 return;
416 } else
417 rc = 0;
418 break;
419
420 case 0x0040: /* SCLP equipment check */
421 case 0x05f0: /* Target resource in improper state */
422 if (++buffer->retry_count > SCLP_BUFFER_MAX_RETRY) {
423 rc = -EIO;
424 break;
425 }
426 /* retry request */
427 sccb->response_code = 0x0000;
428 buffer->request.status = SCLP_REQ_FILLED;
429 rc = sclp_add_request(request);
430 if (rc == 0)
431 return;
432 break;
433 default:
434 if (sccb->response_code == 0x71f0)
435 rc = -ENOMEM;
436 else
437 rc = -EINVAL;
438 break;
439 }
440 if (buffer->callback != NULL)
441 buffer->callback(buffer, rc);
442 }
443
444 /*
445 * Setup the request structure in the struct sclp_buffer to do SCLP Write
446 * Event Data and pass the request to the core SCLP loop. Return zero on
447 * success, non-zero otherwise.
448 */
449 int
450 sclp_emit_buffer(struct sclp_buffer *buffer,
451 void (*callback)(struct sclp_buffer *, int))
452 {
453 /* add current line if there is one */
454 if (buffer->current_line != NULL)
455 sclp_finalize_mto(buffer);
456
457 /* Are there messages in the output buffer ? */
458 if (buffer->messages == 0)
459 return -EIO;
460
461 buffer->request.command = SCLP_CMDW_WRITE_EVENT_DATA;
462 buffer->request.status = SCLP_REQ_FILLED;
463 buffer->request.callback = sclp_writedata_callback;
464 buffer->request.callback_data = buffer;
465 buffer->request.sccb = buffer->sccb;
466 buffer->callback = callback;
467 return sclp_add_request(&buffer->request);
468 }