3 * Operations Command - Line Mode input
4 * Message - Line Mode output
6 * Copyright IBM, Corp. 2013
9 * Heinz Graalfs <graalfs@linux.vnet.ibm.com>
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.
17 #include "qemu/thread.h"
18 #include "qemu/error-report.h"
19 #include "sysemu/char.h"
21 #include "hw/s390x/sclp.h"
22 #include "hw/s390x/event-facility.h"
23 #include "hw/s390x/ebcdic.h"
25 #define SIZE_BUFFER 4096
28 typedef struct OprtnsCommand
{
29 EventBufferHeader header
;
32 } QEMU_PACKED OprtnsCommand
;
34 /* max size for line-mode data in 4K SCCB page */
35 #define SIZE_CONSOLE_BUFFER (SCCB_DATA_LEN - sizeof(OprtnsCommand))
37 typedef struct SCLPConsoleLM
{
40 bool echo
; /* immediate echo of input if true */
41 uint32_t write_errors
; /* errors writing to char layer */
42 uint32_t length
; /* length of byte stream in buffer */
43 uint8_t buf
[SIZE_CONSOLE_BUFFER
];
47 * Character layer call-back functions
49 * Allow 1 character at a time
51 * Accumulate bytes from character layer in console buffer,
52 * event_pending is set when a newline character is encountered
54 * The maximum command line length is limited by the maximum
55 * space available in an SCCB. Line mode console input is sent
56 * truncated to the guest in case it doesn't fit into the SCCB.
59 static int chr_can_read(void *opaque
)
61 SCLPConsoleLM
*scon
= opaque
;
63 if (scon
->event
.event_pending
) {
69 static void chr_read(void *opaque
, const uint8_t *buf
, int size
)
71 SCLPConsoleLM
*scon
= opaque
;
75 if (*buf
== '\r' || *buf
== '\n') {
76 scon
->event
.event_pending
= true;
77 sclp_service_interrupt(0);
80 if (scon
->length
== SIZE_CONSOLE_BUFFER
) {
81 /* Eat the character, but still process CR and LF. */
84 scon
->buf
[scon
->length
] = *buf
;
87 qemu_chr_fe_write(scon
->chr
, buf
, size
);
91 /* functions to be called by event facility */
93 static bool can_handle_event(uint8_t type
)
95 return type
== SCLP_EVENT_MESSAGE
|| type
== SCLP_EVENT_PMSGCMD
;
98 static unsigned int send_mask(void)
100 return SCLP_EVENT_MASK_OP_CMD
| SCLP_EVENT_MASK_PMSGCMD
;
103 static unsigned int receive_mask(void)
105 return SCLP_EVENT_MASK_MSG
| SCLP_EVENT_MASK_PMSGCMD
;
109 * Triggered by SCLP's read_event_data
110 * - convert ASCII byte stream to EBCDIC and
111 * - copy converted data into provided (SCLP) buffer
113 static int get_console_data(SCLPEvent
*event
, uint8_t *buf
, size_t *size
,
118 SCLPConsoleLM
*cons
= DO_UPCAST(SCLPConsoleLM
, event
, event
);
121 /* data need to fit into provided SCLP buffer */
126 ebcdic_put(buf
, (char *)&cons
->buf
, len
);
129 /* data provided and no more data pending */
130 event
->event_pending
= false;
134 static int read_event_data(SCLPEvent
*event
, EventBufferHeader
*evt_buf_hdr
,
140 OprtnsCommand
*oc
= (OprtnsCommand
*) evt_buf_hdr
;
142 if (!event
->event_pending
) {
143 /* no data pending */
147 to
= (uint8_t *)&oc
->data
;
148 avail
= *slen
- sizeof(OprtnsCommand
);
149 rc
= get_console_data(event
, to
, &src_len
, avail
);
151 /* data didn't fit, try next SCCB */
155 oc
->message_unit
.mdmsu
.gds_id
= GDS_ID_MDSMU
;
156 oc
->message_unit
.mdmsu
.length
= cpu_to_be16(sizeof(struct MDMSU
));
158 oc
->message_unit
.cpmsu
.gds_id
= GDS_ID_CPMSU
;
159 oc
->message_unit
.cpmsu
.length
=
160 cpu_to_be16(sizeof(struct MDMSU
) - sizeof(GdsVector
));
162 oc
->message_unit
.text_command
.gds_id
= GDS_ID_TEXTCMD
;
163 oc
->message_unit
.text_command
.length
=
164 cpu_to_be16(sizeof(struct MDMSU
) - (2 * sizeof(GdsVector
)));
166 oc
->message_unit
.self_def_text_message
.key
= GDS_KEY_SELFDEFTEXTMSG
;
167 oc
->message_unit
.self_def_text_message
.length
=
168 cpu_to_be16(sizeof(struct MDMSU
) - (3 * sizeof(GdsVector
)));
170 oc
->message_unit
.text_message
.key
= GDS_KEY_TEXTMSG
;
171 oc
->message_unit
.text_message
.length
=
172 cpu_to_be16(sizeof(GdsSubvector
) + src_len
);
174 oc
->header
.length
= cpu_to_be16(sizeof(OprtnsCommand
) + src_len
);
175 oc
->header
.type
= SCLP_EVENT_OPRTNS_COMMAND
;
176 *slen
= avail
- src_len
;
182 * Triggered by SCLP's write_event_data
183 * - write console data to character layer
184 * returns < 0 if an error occurred
186 static int write_console_data(SCLPEvent
*event
, const uint8_t *buf
, int len
)
189 const uint8_t *buf_offset
;
191 SCLPConsoleLM
*scon
= DO_UPCAST(SCLPConsoleLM
, event
, event
);
194 /* If there's no backend, we can just say we consumed all data. */
200 ret
= qemu_chr_fe_write(scon
->chr
, buf
, len
);
202 /* a pty doesn't seem to be connected - no error */
204 } else if (ret
== -EAGAIN
|| (ret
> 0 && ret
< len
)) {
215 static int process_mdb(SCLPEvent
*event
, MDBO
*mdbo
)
219 uint8_t buffer
[SIZE_BUFFER
];
221 len
= be16_to_cpu(mdbo
->length
);
222 len
-= sizeof(mdbo
->length
) + sizeof(mdbo
->type
)
223 + sizeof(mdbo
->mto
.line_type_flags
)
224 + sizeof(mdbo
->mto
.alarm_control
)
225 + sizeof(mdbo
->mto
._reserved
);
227 assert(len
<= SIZE_BUFFER
);
229 /* convert EBCDIC SCLP contents to ASCII console message */
230 ascii_put(buffer
, mdbo
->mto
.message
, len
);
231 rc
= write_console_data(event
, (uint8_t *)NEWLINE
, 1);
235 return write_console_data(event
, buffer
, len
);
238 static int write_event_data(SCLPEvent
*event
, EventBufferHeader
*ebh
)
244 SclpMsg
*data
= (SclpMsg
*) ebh
;
245 SCLPConsoleLM
*scon
= DO_UPCAST(SCLPConsoleLM
, event
, event
);
247 len
= be16_to_cpu(data
->mdb
.header
.length
);
248 if (len
< sizeof(data
->mdb
.header
)) {
249 return SCLP_RC_INCONSISTENT_LENGTHS
;
251 len
-= sizeof(data
->mdb
.header
);
253 /* first check message buffers */
254 mdbo
= data
->mdb
.mdbo
;
256 if (be16_to_cpu(mdbo
->length
) > len
257 || be16_to_cpu(mdbo
->length
) == 0) {
258 return SCLP_RC_INCONSISTENT_LENGTHS
;
260 len
-= be16_to_cpu(mdbo
->length
);
261 mdbo
= (void *) mdbo
+ be16_to_cpu(mdbo
->length
);
265 len
= be16_to_cpu(data
->mdb
.header
.length
) - sizeof(data
->mdb
.header
);
266 mdbo
= data
->mdb
.mdbo
;
268 switch (be16_to_cpu(mdbo
->type
)) {
270 /* message text object */
271 written
= process_mdb(event
, mdbo
);
273 /* character layer error */
277 default: /* ignore */
280 len
-= be16_to_cpu(mdbo
->length
);
281 mdbo
= (void *) mdbo
+ be16_to_cpu(mdbo
->length
);
284 scon
->write_errors
+= errors
;
286 data
->header
.flags
= SCLP_EVENT_BUFFER_ACCEPTED
;
288 return SCLP_RC_NORMAL_COMPLETION
;
291 /* functions for live migration */
293 static const VMStateDescription vmstate_sclplmconsole
= {
294 .name
= "sclplmconsole",
296 .minimum_version_id
= 0,
297 .fields
= (VMStateField
[]) {
298 VMSTATE_BOOL(event
.event_pending
, SCLPConsoleLM
),
299 VMSTATE_UINT32(write_errors
, SCLPConsoleLM
),
300 VMSTATE_UINT32(length
, SCLPConsoleLM
),
301 VMSTATE_UINT8_ARRAY(buf
, SCLPConsoleLM
, SIZE_CONSOLE_BUFFER
),
302 VMSTATE_END_OF_LIST()
306 /* qemu object creation and initialization functions */
308 /* tell character layer our call-back functions */
310 static int console_init(SCLPEvent
*event
)
312 static bool console_available
;
314 SCLPConsoleLM
*scon
= DO_UPCAST(SCLPConsoleLM
, event
, event
);
316 if (console_available
) {
317 error_report("Multiple line-mode operator consoles are not supported");
320 console_available
= true;
323 qemu_chr_add_handlers(scon
->chr
, chr_can_read
, chr_read
, NULL
, scon
);
329 static int console_exit(SCLPEvent
*event
)
334 static void console_reset(DeviceState
*dev
)
336 SCLPEvent
*event
= SCLP_EVENT(dev
);
337 SCLPConsoleLM
*scon
= DO_UPCAST(SCLPConsoleLM
, event
, event
);
339 event
->event_pending
= false;
341 scon
->write_errors
= 0;
344 static Property console_properties
[] = {
345 DEFINE_PROP_CHR("chardev", SCLPConsoleLM
, chr
),
346 DEFINE_PROP_UINT32("write_errors", SCLPConsoleLM
, write_errors
, 0),
347 DEFINE_PROP_BOOL("echo", SCLPConsoleLM
, echo
, true),
348 DEFINE_PROP_END_OF_LIST(),
351 static void console_class_init(ObjectClass
*klass
, void *data
)
353 DeviceClass
*dc
= DEVICE_CLASS(klass
);
354 SCLPEventClass
*ec
= SCLP_EVENT_CLASS(klass
);
356 dc
->props
= console_properties
;
357 dc
->reset
= console_reset
;
358 dc
->vmsd
= &vmstate_sclplmconsole
;
359 ec
->init
= console_init
;
360 ec
->exit
= console_exit
;
361 ec
->get_send_mask
= send_mask
;
362 ec
->get_receive_mask
= receive_mask
;
363 ec
->can_handle_event
= can_handle_event
;
364 ec
->read_event_data
= read_event_data
;
365 ec
->write_event_data
= write_event_data
;
368 static const TypeInfo sclp_console_info
= {
369 .name
= "sclplmconsole",
370 .parent
= TYPE_SCLP_EVENT
,
371 .instance_size
= sizeof(SCLPConsoleLM
),
372 .class_init
= console_class_init
,
373 .class_size
= sizeof(SCLPEventClass
),
376 static void register_types(void)
378 type_register_static(&sclp_console_info
);
381 type_init(register_types
)