blob: 4fe1c4d2890a7c9479c5283bfdf81a5874f574e4 [file] [log] [blame]
Heinz Graalfs6a444f82013-05-22 14:11:36 +02001/*
2 * SCLP event types
3 * Operations Command - Line Mode input
4 * Message - Line Mode output
5 *
6 * Copyright IBM, Corp. 2013
7 *
8 * Authors:
9 * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
10 *
11 * This work is licensed under the terms of the GNU GPL, version 2 or (at your
12 * option) any later version. See the COPYING file in the top-level directory.
13 *
14 */
15
Peter Maydell96154952016-01-26 18:17:00 +000016#include "qemu/osdep.h"
Heinz Graalfs6a444f82013-05-22 14:11:36 +020017#include "qemu/thread.h"
18#include "qemu/error-report.h"
Markus Armbruster0b8fa322019-05-23 16:35:07 +020019#include "qemu/module.h"
Marc-André Lureau4d43a602017-01-26 18:26:44 +040020#include "chardev/char-fe.h"
Heinz Graalfs6a444f82013-05-22 14:11:36 +020021
22#include "hw/s390x/sclp.h"
Markus Armbrusterd6454272019-08-12 07:23:45 +020023#include "migration/vmstate.h"
Heinz Graalfs6a444f82013-05-22 14:11:36 +020024#include "hw/s390x/event-facility.h"
Markus Armbrustera27bd6c2019-08-12 07:23:51 +020025#include "hw/qdev-properties.h"
Eduardo Habkostce35e222020-12-11 17:05:12 -050026#include "hw/qdev-properties-system.h"
Heinz Graalfs6a444f82013-05-22 14:11:36 +020027#include "hw/s390x/ebcdic.h"
Eduardo Habkostdb1015e2020-09-03 16:43:22 -040028#include "qom/object.h"
Heinz Graalfs6a444f82013-05-22 14:11:36 +020029
30#define SIZE_BUFFER 4096
31#define NEWLINE "\n"
32
33typedef struct OprtnsCommand {
34 EventBufferHeader header;
35 MDMSU message_unit;
Philippe Mathieu-Daudé880a7812020-03-04 16:38:16 +010036 char data[];
Heinz Graalfs6a444f82013-05-22 14:11:36 +020037} QEMU_PACKED OprtnsCommand;
38
39/* max size for line-mode data in 4K SCCB page */
40#define SIZE_CONSOLE_BUFFER (SCCB_DATA_LEN - sizeof(OprtnsCommand))
41
Eduardo Habkostdb1015e2020-09-03 16:43:22 -040042struct SCLPConsoleLM {
Heinz Graalfs6a444f82013-05-22 14:11:36 +020043 SCLPEvent event;
Marc-André Lureaubecdfa02016-10-22 12:52:51 +030044 CharBackend chr;
Heinz Graalfs6a444f82013-05-22 14:11:36 +020045 bool echo; /* immediate echo of input if true */
46 uint32_t write_errors; /* errors writing to char layer */
47 uint32_t length; /* length of byte stream in buffer */
48 uint8_t buf[SIZE_CONSOLE_BUFFER];
Eduardo Habkostdb1015e2020-09-03 16:43:22 -040049};
50typedef struct SCLPConsoleLM SCLPConsoleLM;
Heinz Graalfs6a444f82013-05-22 14:11:36 +020051
xiaoqiang zhaoe563c592016-03-29 15:47:24 +080052#define TYPE_SCLPLM_CONSOLE "sclplmconsole"
Eduardo Habkost8110fa12020-08-31 17:07:33 -040053DECLARE_INSTANCE_CHECKER(SCLPConsoleLM, SCLPLM_CONSOLE,
54 TYPE_SCLPLM_CONSOLE)
xiaoqiang zhaoe563c592016-03-29 15:47:24 +080055
Heinz Graalfs6a444f82013-05-22 14:11:36 +020056/*
57* Character layer call-back functions
58 *
59 * Allow 1 character at a time
60 *
61 * Accumulate bytes from character layer in console buffer,
62 * event_pending is set when a newline character is encountered
63 *
64 * The maximum command line length is limited by the maximum
Heinz Graalfsb3191432014-10-29 08:58:05 +000065 * space available in an SCCB. Line mode console input is sent
66 * truncated to the guest in case it doesn't fit into the SCCB.
Heinz Graalfs6a444f82013-05-22 14:11:36 +020067 */
68
69static int chr_can_read(void *opaque)
70{
71 SCLPConsoleLM *scon = opaque;
72
73 if (scon->event.event_pending) {
74 return 0;
Heinz Graalfs6a444f82013-05-22 14:11:36 +020075 }
Heinz Graalfsb3191432014-10-29 08:58:05 +000076 return 1;
Heinz Graalfs6a444f82013-05-22 14:11:36 +020077}
78
Christian Borntraeger4f3ed192014-03-10 14:19:52 +010079static void chr_read(void *opaque, const uint8_t *buf, int size)
Heinz Graalfs6a444f82013-05-22 14:11:36 +020080{
Christian Borntraeger4f3ed192014-03-10 14:19:52 +010081 SCLPConsoleLM *scon = opaque;
82
Heinz Graalfs6a444f82013-05-22 14:11:36 +020083 assert(size == 1);
84
85 if (*buf == '\r' || *buf == '\n') {
86 scon->event.event_pending = true;
Christian Borntraeger4f3ed192014-03-10 14:19:52 +010087 sclp_service_interrupt(0);
Heinz Graalfs6a444f82013-05-22 14:11:36 +020088 return;
89 }
Heinz Graalfsb3191432014-10-29 08:58:05 +000090 if (scon->length == SIZE_CONSOLE_BUFFER) {
91 /* Eat the character, but still process CR and LF. */
92 return;
93 }
Heinz Graalfs6a444f82013-05-22 14:11:36 +020094 scon->buf[scon->length] = *buf;
95 scon->length += 1;
96 if (scon->echo) {
Daniel P. Berrange6ab3fc32016-09-06 14:56:04 +010097 /* XXX this blocks entire thread. Rewrite to use
98 * qemu_chr_fe_write and background I/O callbacks */
Marc-André Lureau5345fdb2016-10-22 12:52:55 +030099 qemu_chr_fe_write_all(&scon->chr, buf, size);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200100 }
101}
102
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200103/* functions to be called by event facility */
104
105static bool can_handle_event(uint8_t type)
106{
107 return type == SCLP_EVENT_MESSAGE || type == SCLP_EVENT_PMSGCMD;
108}
109
Claudio Imbrenda1ffed982018-02-23 18:42:57 +0100110static sccb_mask_t send_mask(void)
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200111{
112 return SCLP_EVENT_MASK_OP_CMD | SCLP_EVENT_MASK_PMSGCMD;
113}
114
Claudio Imbrenda1ffed982018-02-23 18:42:57 +0100115static sccb_mask_t receive_mask(void)
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200116{
117 return SCLP_EVENT_MASK_MSG | SCLP_EVENT_MASK_PMSGCMD;
118}
119
120/*
121 * Triggered by SCLP's read_event_data
122 * - convert ASCII byte stream to EBCDIC and
123 * - copy converted data into provided (SCLP) buffer
124 */
125static int get_console_data(SCLPEvent *event, uint8_t *buf, size_t *size,
126 int avail)
127{
128 int len;
129
xiaoqiang zhaoe563c592016-03-29 15:47:24 +0800130 SCLPConsoleLM *cons = SCLPLM_CONSOLE(event);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200131
132 len = cons->length;
133 /* data need to fit into provided SCLP buffer */
134 if (len > avail) {
135 return 1;
136 }
137
138 ebcdic_put(buf, (char *)&cons->buf, len);
139 *size = len;
140 cons->length = 0;
141 /* data provided and no more data pending */
142 event->event_pending = false;
Heinz Graalfs87f2eff2014-10-29 12:52:02 +0000143 qemu_notify_event();
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200144 return 0;
145}
146
147static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
148 int *slen)
149{
150 int avail, rc;
151 size_t src_len;
152 uint8_t *to;
153 OprtnsCommand *oc = (OprtnsCommand *) evt_buf_hdr;
154
155 if (!event->event_pending) {
156 /* no data pending */
157 return 0;
158 }
159
160 to = (uint8_t *)&oc->data;
161 avail = *slen - sizeof(OprtnsCommand);
162 rc = get_console_data(event, to, &src_len, avail);
163 if (rc) {
164 /* data didn't fit, try next SCCB */
165 return 1;
166 }
167
168 oc->message_unit.mdmsu.gds_id = GDS_ID_MDSMU;
169 oc->message_unit.mdmsu.length = cpu_to_be16(sizeof(struct MDMSU));
170
171 oc->message_unit.cpmsu.gds_id = GDS_ID_CPMSU;
172 oc->message_unit.cpmsu.length =
173 cpu_to_be16(sizeof(struct MDMSU) - sizeof(GdsVector));
174
175 oc->message_unit.text_command.gds_id = GDS_ID_TEXTCMD;
176 oc->message_unit.text_command.length =
177 cpu_to_be16(sizeof(struct MDMSU) - (2 * sizeof(GdsVector)));
178
179 oc->message_unit.self_def_text_message.key = GDS_KEY_SELFDEFTEXTMSG;
180 oc->message_unit.self_def_text_message.length =
181 cpu_to_be16(sizeof(struct MDMSU) - (3 * sizeof(GdsVector)));
182
183 oc->message_unit.text_message.key = GDS_KEY_TEXTMSG;
184 oc->message_unit.text_message.length =
185 cpu_to_be16(sizeof(GdsSubvector) + src_len);
186
187 oc->header.length = cpu_to_be16(sizeof(OprtnsCommand) + src_len);
188 oc->header.type = SCLP_EVENT_OPRTNS_COMMAND;
189 *slen = avail - src_len;
190
191 return 1;
192}
193
194/*
195 * Triggered by SCLP's write_event_data
196 * - write console data to character layer
197 * returns < 0 if an error occurred
198 */
199static int write_console_data(SCLPEvent *event, const uint8_t *buf, int len)
200{
xiaoqiang zhaoe563c592016-03-29 15:47:24 +0800201 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200202
Anton Nefedov30650702017-07-06 15:08:52 +0300203 if (!qemu_chr_fe_backend_connected(&scon->chr)) {
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200204 /* If there's no backend, we can just say we consumed all data. */
205 return len;
206 }
207
Daniel P. Berrange7983e822016-09-06 14:56:03 +0100208 /* XXX this blocks entire thread. Rewrite to use
209 * qemu_chr_fe_write and background I/O callbacks */
Marc-André Lureau5345fdb2016-10-22 12:52:55 +0300210 return qemu_chr_fe_write_all(&scon->chr, buf, len);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200211}
212
213static int process_mdb(SCLPEvent *event, MDBO *mdbo)
214{
215 int rc;
216 int len;
217 uint8_t buffer[SIZE_BUFFER];
218
219 len = be16_to_cpu(mdbo->length);
220 len -= sizeof(mdbo->length) + sizeof(mdbo->type)
221 + sizeof(mdbo->mto.line_type_flags)
222 + sizeof(mdbo->mto.alarm_control)
223 + sizeof(mdbo->mto._reserved);
224
225 assert(len <= SIZE_BUFFER);
226
227 /* convert EBCDIC SCLP contents to ASCII console message */
228 ascii_put(buffer, mdbo->mto.message, len);
229 rc = write_console_data(event, (uint8_t *)NEWLINE, 1);
230 if (rc < 0) {
231 return rc;
232 }
233 return write_console_data(event, buffer, len);
234}
235
236static int write_event_data(SCLPEvent *event, EventBufferHeader *ebh)
237{
238 int len;
239 int written;
240 int errors = 0;
241 MDBO *mdbo;
242 SclpMsg *data = (SclpMsg *) ebh;
xiaoqiang zhaoe563c592016-03-29 15:47:24 +0800243 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200244
245 len = be16_to_cpu(data->mdb.header.length);
246 if (len < sizeof(data->mdb.header)) {
247 return SCLP_RC_INCONSISTENT_LENGTHS;
248 }
249 len -= sizeof(data->mdb.header);
250
251 /* first check message buffers */
252 mdbo = data->mdb.mdbo;
253 while (len > 0) {
254 if (be16_to_cpu(mdbo->length) > len
255 || be16_to_cpu(mdbo->length) == 0) {
256 return SCLP_RC_INCONSISTENT_LENGTHS;
257 }
258 len -= be16_to_cpu(mdbo->length);
259 mdbo = (void *) mdbo + be16_to_cpu(mdbo->length);
260 }
261
262 /* then execute */
263 len = be16_to_cpu(data->mdb.header.length) - sizeof(data->mdb.header);
264 mdbo = data->mdb.mdbo;
265 while (len > 0) {
266 switch (be16_to_cpu(mdbo->type)) {
267 case MESSAGE_TEXT:
268 /* message text object */
269 written = process_mdb(event, mdbo);
270 if (written < 0) {
271 /* character layer error */
272 errors++;
273 }
274 break;
275 default: /* ignore */
276 break;
277 }
278 len -= be16_to_cpu(mdbo->length);
279 mdbo = (void *) mdbo + be16_to_cpu(mdbo->length);
280 }
281 if (errors) {
282 scon->write_errors += errors;
283 }
284 data->header.flags = SCLP_EVENT_BUFFER_ACCEPTED;
285
286 return SCLP_RC_NORMAL_COMPLETION;
287}
288
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200289/* functions for live migration */
290
291static const VMStateDescription vmstate_sclplmconsole = {
292 .name = "sclplmconsole",
293 .version_id = 0,
294 .minimum_version_id = 0,
Richard Henderson2f6cab02023-12-21 14:16:06 +1100295 .fields = (const VMStateField[]) {
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200296 VMSTATE_BOOL(event.event_pending, SCLPConsoleLM),
297 VMSTATE_UINT32(write_errors, SCLPConsoleLM),
298 VMSTATE_UINT32(length, SCLPConsoleLM),
299 VMSTATE_UINT8_ARRAY(buf, SCLPConsoleLM, SIZE_CONSOLE_BUFFER),
300 VMSTATE_END_OF_LIST()
301 }
302};
303
304/* qemu object creation and initialization functions */
305
306/* tell character layer our call-back functions */
307
308static int console_init(SCLPEvent *event)
309{
310 static bool console_available;
311
xiaoqiang zhaoe563c592016-03-29 15:47:24 +0800312 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200313
314 if (console_available) {
315 error_report("Multiple line-mode operator consoles are not supported");
316 return -1;
317 }
318 console_available = true;
319
Marc-André Lureaufa394ed2016-10-22 12:52:59 +0300320 qemu_chr_fe_set_handlers(&scon->chr, chr_can_read,
Anton Nefedov81517ba2017-07-06 15:08:49 +0300321 chr_read, NULL, NULL, scon, NULL, true);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200322
323 return 0;
324}
325
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200326static void console_reset(DeviceState *dev)
327{
328 SCLPEvent *event = SCLP_EVENT(dev);
xiaoqiang zhaoe563c592016-03-29 15:47:24 +0800329 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200330
331 event->event_pending = false;
332 scon->length = 0;
333 scon->write_errors = 0;
334}
335
336static Property console_properties[] = {
337 DEFINE_PROP_CHR("chardev", SCLPConsoleLM, chr),
338 DEFINE_PROP_UINT32("write_errors", SCLPConsoleLM, write_errors, 0),
339 DEFINE_PROP_BOOL("echo", SCLPConsoleLM, echo, true),
340 DEFINE_PROP_END_OF_LIST(),
341};
342
343static void console_class_init(ObjectClass *klass, void *data)
344{
345 DeviceClass *dc = DEVICE_CLASS(klass);
346 SCLPEventClass *ec = SCLP_EVENT_CLASS(klass);
347
Marc-André Lureau4f67d302020-01-10 19:30:32 +0400348 device_class_set_props(dc, console_properties);
Peter Maydelle3d08142024-09-13 15:31:44 +0100349 device_class_set_legacy_reset(dc, console_reset);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200350 dc->vmsd = &vmstate_sclplmconsole;
351 ec->init = console_init;
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200352 ec->get_send_mask = send_mask;
353 ec->get_receive_mask = receive_mask;
354 ec->can_handle_event = can_handle_event;
355 ec->read_event_data = read_event_data;
356 ec->write_event_data = write_event_data;
Cornelia Huck183f6b82015-03-17 13:44:39 +0100357 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200358}
359
360static const TypeInfo sclp_console_info = {
Eduardo Habkost1a3bae72020-08-26 14:43:30 -0400361 .name = TYPE_SCLPLM_CONSOLE,
Heinz Graalfs6a444f82013-05-22 14:11:36 +0200362 .parent = TYPE_SCLP_EVENT,
363 .instance_size = sizeof(SCLPConsoleLM),
364 .class_init = console_class_init,
365 .class_size = sizeof(SCLPEventClass),
366};
367
368static void register_types(void)
369{
370 type_register_static(&sclp_console_info);
371}
372
373type_init(register_types)