1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include "qemu/osdep.h"
17#include "hw/qdev.h"
18#include "qemu/thread.h"
19#include "qemu/error-report.h"
20#include "chardev/char-fe.h"
21
22#include "hw/s390x/sclp.h"
23#include "hw/s390x/event-facility.h"
24#include "hw/s390x/ebcdic.h"
25
26#define SIZE_BUFFER 4096
27#define NEWLINE "\n"
28
29typedef struct OprtnsCommand {
30 EventBufferHeader header;
31 MDMSU message_unit;
32 char data[0];
33} QEMU_PACKED OprtnsCommand;
34
35
36#define SIZE_CONSOLE_BUFFER (SCCB_DATA_LEN - sizeof(OprtnsCommand))
37
38typedef struct SCLPConsoleLM {
39 SCLPEvent event;
40 CharBackend chr;
41 bool echo;
42 uint32_t write_errors;
43 uint32_t length;
44 uint8_t buf[SIZE_CONSOLE_BUFFER];
45} SCLPConsoleLM;
46
47#define TYPE_SCLPLM_CONSOLE "sclplmconsole"
48#define SCLPLM_CONSOLE(obj) \
49 OBJECT_CHECK(SCLPConsoleLM, (obj), TYPE_SCLPLM_CONSOLE)
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64static int chr_can_read(void *opaque)
65{
66 SCLPConsoleLM *scon = opaque;
67
68 if (scon->event.event_pending) {
69 return 0;
70 }
71 return 1;
72}
73
74static void chr_read(void *opaque, const uint8_t *buf, int size)
75{
76 SCLPConsoleLM *scon = opaque;
77
78 assert(size == 1);
79
80 if (*buf == '\r' || *buf == '\n') {
81 scon->event.event_pending = true;
82 sclp_service_interrupt(0);
83 return;
84 }
85 if (scon->length == SIZE_CONSOLE_BUFFER) {
86
87 return;
88 }
89 scon->buf[scon->length] = *buf;
90 scon->length += 1;
91 if (scon->echo) {
92
93
94 qemu_chr_fe_write_all(&scon->chr, buf, size);
95 }
96}
97
98
99
100static bool can_handle_event(uint8_t type)
101{
102 return type == SCLP_EVENT_MESSAGE || type == SCLP_EVENT_PMSGCMD;
103}
104
105static sccb_mask_t send_mask(void)
106{
107 return SCLP_EVENT_MASK_OP_CMD | SCLP_EVENT_MASK_PMSGCMD;
108}
109
110static sccb_mask_t receive_mask(void)
111{
112 return SCLP_EVENT_MASK_MSG | SCLP_EVENT_MASK_PMSGCMD;
113}
114
115
116
117
118
119
120static int get_console_data(SCLPEvent *event, uint8_t *buf, size_t *size,
121 int avail)
122{
123 int len;
124
125 SCLPConsoleLM *cons = SCLPLM_CONSOLE(event);
126
127 len = cons->length;
128
129 if (len > avail) {
130 return 1;
131 }
132
133 ebcdic_put(buf, (char *)&cons->buf, len);
134 *size = len;
135 cons->length = 0;
136
137 event->event_pending = false;
138 qemu_notify_event();
139 return 0;
140}
141
142static int read_event_data(SCLPEvent *event, EventBufferHeader *evt_buf_hdr,
143 int *slen)
144{
145 int avail, rc;
146 size_t src_len;
147 uint8_t *to;
148 OprtnsCommand *oc = (OprtnsCommand *) evt_buf_hdr;
149
150 if (!event->event_pending) {
151
152 return 0;
153 }
154
155 to = (uint8_t *)&oc->data;
156 avail = *slen - sizeof(OprtnsCommand);
157 rc = get_console_data(event, to, &src_len, avail);
158 if (rc) {
159
160 return 1;
161 }
162
163 oc->message_unit.mdmsu.gds_id = GDS_ID_MDSMU;
164 oc->message_unit.mdmsu.length = cpu_to_be16(sizeof(struct MDMSU));
165
166 oc->message_unit.cpmsu.gds_id = GDS_ID_CPMSU;
167 oc->message_unit.cpmsu.length =
168 cpu_to_be16(sizeof(struct MDMSU) - sizeof(GdsVector));
169
170 oc->message_unit.text_command.gds_id = GDS_ID_TEXTCMD;
171 oc->message_unit.text_command.length =
172 cpu_to_be16(sizeof(struct MDMSU) - (2 * sizeof(GdsVector)));
173
174 oc->message_unit.self_def_text_message.key = GDS_KEY_SELFDEFTEXTMSG;
175 oc->message_unit.self_def_text_message.length =
176 cpu_to_be16(sizeof(struct MDMSU) - (3 * sizeof(GdsVector)));
177
178 oc->message_unit.text_message.key = GDS_KEY_TEXTMSG;
179 oc->message_unit.text_message.length =
180 cpu_to_be16(sizeof(GdsSubvector) + src_len);
181
182 oc->header.length = cpu_to_be16(sizeof(OprtnsCommand) + src_len);
183 oc->header.type = SCLP_EVENT_OPRTNS_COMMAND;
184 *slen = avail - src_len;
185
186 return 1;
187}
188
189
190
191
192
193
194static int write_console_data(SCLPEvent *event, const uint8_t *buf, int len)
195{
196 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
197
198 if (!qemu_chr_fe_backend_connected(&scon->chr)) {
199
200 return len;
201 }
202
203
204
205 return qemu_chr_fe_write_all(&scon->chr, buf, len);
206}
207
208static int process_mdb(SCLPEvent *event, MDBO *mdbo)
209{
210 int rc;
211 int len;
212 uint8_t buffer[SIZE_BUFFER];
213
214 len = be16_to_cpu(mdbo->length);
215 len -= sizeof(mdbo->length) + sizeof(mdbo->type)
216 + sizeof(mdbo->mto.line_type_flags)
217 + sizeof(mdbo->mto.alarm_control)
218 + sizeof(mdbo->mto._reserved);
219
220 assert(len <= SIZE_BUFFER);
221
222
223 ascii_put(buffer, mdbo->mto.message, len);
224 rc = write_console_data(event, (uint8_t *)NEWLINE, 1);
225 if (rc < 0) {
226 return rc;
227 }
228 return write_console_data(event, buffer, len);
229}
230
231static int write_event_data(SCLPEvent *event, EventBufferHeader *ebh)
232{
233 int len;
234 int written;
235 int errors = 0;
236 MDBO *mdbo;
237 SclpMsg *data = (SclpMsg *) ebh;
238 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
239
240 len = be16_to_cpu(data->mdb.header.length);
241 if (len < sizeof(data->mdb.header)) {
242 return SCLP_RC_INCONSISTENT_LENGTHS;
243 }
244 len -= sizeof(data->mdb.header);
245
246
247 mdbo = data->mdb.mdbo;
248 while (len > 0) {
249 if (be16_to_cpu(mdbo->length) > len
250 || be16_to_cpu(mdbo->length) == 0) {
251 return SCLP_RC_INCONSISTENT_LENGTHS;
252 }
253 len -= be16_to_cpu(mdbo->length);
254 mdbo = (void *) mdbo + be16_to_cpu(mdbo->length);
255 }
256
257
258 len = be16_to_cpu(data->mdb.header.length) - sizeof(data->mdb.header);
259 mdbo = data->mdb.mdbo;
260 while (len > 0) {
261 switch (be16_to_cpu(mdbo->type)) {
262 case MESSAGE_TEXT:
263
264 written = process_mdb(event, mdbo);
265 if (written < 0) {
266
267 errors++;
268 }
269 break;
270 default:
271 break;
272 }
273 len -= be16_to_cpu(mdbo->length);
274 mdbo = (void *) mdbo + be16_to_cpu(mdbo->length);
275 }
276 if (errors) {
277 scon->write_errors += errors;
278 }
279 data->header.flags = SCLP_EVENT_BUFFER_ACCEPTED;
280
281 return SCLP_RC_NORMAL_COMPLETION;
282}
283
284
285
286static const VMStateDescription vmstate_sclplmconsole = {
287 .name = "sclplmconsole",
288 .version_id = 0,
289 .minimum_version_id = 0,
290 .fields = (VMStateField[]) {
291 VMSTATE_BOOL(event.event_pending, SCLPConsoleLM),
292 VMSTATE_UINT32(write_errors, SCLPConsoleLM),
293 VMSTATE_UINT32(length, SCLPConsoleLM),
294 VMSTATE_UINT8_ARRAY(buf, SCLPConsoleLM, SIZE_CONSOLE_BUFFER),
295 VMSTATE_END_OF_LIST()
296 }
297};
298
299
300
301
302
303static int console_init(SCLPEvent *event)
304{
305 static bool console_available;
306
307 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
308
309 if (console_available) {
310 error_report("Multiple line-mode operator consoles are not supported");
311 return -1;
312 }
313 console_available = true;
314
315 qemu_chr_fe_set_handlers(&scon->chr, chr_can_read,
316 chr_read, NULL, NULL, scon, NULL, true);
317
318 return 0;
319}
320
321static void console_reset(DeviceState *dev)
322{
323 SCLPEvent *event = SCLP_EVENT(dev);
324 SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
325
326 event->event_pending = false;
327 scon->length = 0;
328 scon->write_errors = 0;
329}
330
331static Property console_properties[] = {
332 DEFINE_PROP_CHR("chardev", SCLPConsoleLM, chr),
333 DEFINE_PROP_UINT32("write_errors", SCLPConsoleLM, write_errors, 0),
334 DEFINE_PROP_BOOL("echo", SCLPConsoleLM, echo, true),
335 DEFINE_PROP_END_OF_LIST(),
336};
337
338static void console_class_init(ObjectClass *klass, void *data)
339{
340 DeviceClass *dc = DEVICE_CLASS(klass);
341 SCLPEventClass *ec = SCLP_EVENT_CLASS(klass);
342
343 dc->props = console_properties;
344 dc->reset = console_reset;
345 dc->vmsd = &vmstate_sclplmconsole;
346 ec->init = console_init;
347 ec->get_send_mask = send_mask;
348 ec->get_receive_mask = receive_mask;
349 ec->can_handle_event = can_handle_event;
350 ec->read_event_data = read_event_data;
351 ec->write_event_data = write_event_data;
352 set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
353}
354
355static const TypeInfo sclp_console_info = {
356 .name = "sclplmconsole",
357 .parent = TYPE_SCLP_EVENT,
358 .instance_size = sizeof(SCLPConsoleLM),
359 .class_init = console_class_init,
360 .class_size = sizeof(SCLPEventClass),
361};
362
363static void register_types(void)
364{
365 type_register_static(&sclp_console_info);
366}
367
368type_init(register_types)
369