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