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