diff mbox series

[kvm-unit-tests,v3,08/13] s390x: Add linemode console

Message ID 20181218092657.46466-9-frankja@linux.ibm.com (mailing list archive)
State New, archived
Headers show
Series 390x: Add cross hypervisor and disk boot | expand

Commit Message

Janosch Frank Dec. 18, 2018, 9:26 a.m. UTC 
z/VM isn't fond of vt220, so we need line mode when running under z/VM.

Signed-off-by: Janosch Frank <frankja@linux.ibm.com>
---
 lib/s390x/sclp-console.c | 195 ++++++++++++++++++++++++++++++++++++++++++-----
 lib/s390x/sclp.h         |  67 ++++++++++++++++
 2 files changed, 243 insertions(+), 19 deletions(-)

Comments

Thomas Huth Dec. 18, 2018, 11:50 a.m. UTC | #1 
On 2018-12-18 10:26, Janosch Frank wrote:
> z/VM isn't fond of vt220, so we need line mode when running under z/VM.
> 
> Signed-off-by: Janosch Frank <frankja@linux.ibm.com>
> ---
>  lib/s390x/sclp-console.c | 195 ++++++++++++++++++++++++++++++++++++++++++-----
>  lib/s390x/sclp.h         |  67 ++++++++++++++++
>  2 files changed, 243 insertions(+), 19 deletions(-)
[...]
> +
> +static bool initialized;
> +
> +static void sclp_print_ascii(const char *str)
> +{
> +	int len = strlen(str);
> +	WriteEventData *sccb = (void *)_sccb;
> +
> +	sclp_wait_busy();
> +	sclp_busy = true;

What happened to sclp_mark_busy() ?

> +	memset(sccb, 0, sizeof(*sccb));
> +	sccb->h.length = sizeof(WriteEventData) + len;
> +	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
> +	sccb->ebh.length = sizeof(EventBufferHeader) + len;
> +	sccb->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA;
> +	memcpy(sccb->data, str, len);
> +
> +	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
> +	sclp_wait_busy();

Hmm, if the functions do a sclp_wait_busy() at the beginning already, do
we still need it at the end of the functions, too?

... I've got the feeling that we need some clearer conventions here.
Could you maybe add some comments to the source code?

> +}
> +
> +static void sclp_print_lm(const char *str)
> +{
> +	unsigned char *ptr, *end, ch;
> +	unsigned int count, offset, len;
> +	struct write_sccb *sccb;
> +	struct msg_buf *msg;
> +	struct mdb *mdb;
> +	struct mto *mto;
> +	struct go *go;
> +
> +	sclp_wait_busy();
> +	sclp_busy = true;

sclp_mark_busy() ?

> +	sccb = (struct write_sccb *) _sccb;
> +	end = (unsigned char *) sccb + 4096 - 1;
> +	memset(sccb, 0, sizeof(*sccb));
> +	ptr = (unsigned char *) &sccb->msg.mdb.mto;
> +	len = strlen(str);
> +	offset = 0;
> +	do {
> +		for (count = sizeof(*mto); offset < len; count++) {
> +			ch = str[offset++];
> +			if ((ch == 0x0a) || (ptr + count > end))
> +				break;
> +			ptr[count] = _ascebc[ch];
> +		}
> +		mto = (struct mto *) ptr;
> +		memset(mto, 0, sizeof(*mto));
> +		mto->length = count;
> +		mto->type = 4;
> +		mto->line_type_flags = LNTPFLGS_ENDTEXT;
> +		ptr += count;
> +	} while ((offset < len) && (ptr + sizeof(*mto) <= end));

	} while (offset < len && ptr + sizeof(*mto) <= end);

> +	len = ptr - (unsigned char *) sccb;
> +	sccb->header.length = len - offsetof(struct write_sccb, header);
> +	msg = &sccb->msg;
> +	msg->header.type = EVTYP_MSG;
> +	msg->header.length = len - offsetof(struct write_sccb, msg.header);
> +	mdb = &msg->mdb;
> +	mdb->header.type = 1;
> +	mdb->header.tag = 0xD4C4C240;
> +	mdb->header.revision_code = 1;
> +	mdb->header.length = len - offsetof(struct write_sccb, msg.mdb.header);
> +	go = &mdb->go;
> +	go->length = sizeof(*go);
> +	go->type = 1;
> +	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
> +	sclp_wait_busy();
> +}
> +
> +/*
> + * SCLP needs to be initialized by setting a send and receive mask,
> + * indicating which messages the control program (we) want(s) to
> + * send/receive.
> + */
> +static bool sclp_set_write_mask(void)
>  {
>  	WriteEventMask *sccb = (void *)_sccb;
>  
>  	sclp_mark_busy();
> +	memset(_sccb, 0, sizeof(*sccb));
>  	sccb->h.length = sizeof(WriteEventMask);
> -	sccb->mask_length = sizeof(unsigned int);
> -	sccb->receive_mask = SCLP_EVENT_MASK_MSG_ASCII;
> -	sccb->cp_receive_mask = SCLP_EVENT_MASK_MSG_ASCII;
> -	sccb->send_mask = SCLP_EVENT_MASK_MSG_ASCII;
> -	sccb->cp_send_mask = SCLP_EVENT_MASK_MSG_ASCII;
> +	sccb->h.function_code = 0;
> +	sccb->mask_length = sizeof(sccb_mask_t);
> +
> +	/* For now we don't process sclp input. */
> +	sccb->cp_receive_mask = 0;
> +	/* We send ASCII and line mode. */
> +	sccb->cp_send_mask = SCLP_EVENT_MASK_MSG_ASCII | SCLP_EVENT_MASK_MSG;
>  
>  	sclp_service_call(SCLP_CMD_WRITE_EVENT_MASK, sccb);
> +	sclp_wait_busy();
> +	if (sccb->h.response_code != SCLP_RC_NORMAL_COMPLETION)
> +		return false;
> +	else {
> +		initialized = true;
> +		return true;
> +	}

Maybe rather assert(sccb->h.response_code == SCLP_RC_NORMAL_COMPLETION) ?
It does not make much sense to continue otherwise, does it?

 Thomas
Janosch Frank Dec. 18, 2018, 12:01 p.m. UTC | #2 
On 18.12.18 12:50, Thomas Huth wrote:
> On 2018-12-18 10:26, Janosch Frank wrote:
>> z/VM isn't fond of vt220, so we need line mode when running under z/VM.
>>
>> Signed-off-by: Janosch Frank <frankja@linux.ibm.com>
>> ---
>>  lib/s390x/sclp-console.c | 195 ++++++++++++++++++++++++++++++++++++++++++-----
>>  lib/s390x/sclp.h         |  67 ++++++++++++++++
>>  2 files changed, 243 insertions(+), 19 deletions(-)
> [...]
>> +
>> +static bool initialized;
>> +
>> +static void sclp_print_ascii(const char *str)
>> +{
>> +	int len = strlen(str);
>> +	WriteEventData *sccb = (void *)_sccb;
>> +
>> +	sclp_wait_busy();
>> +	sclp_busy = true;
> 
> What happened to sclp_mark_busy() ?

It seems this got lost in a rebase where a search/replace took place -_-

> 
>> +	memset(sccb, 0, sizeof(*sccb));
>> +	sccb->h.length = sizeof(WriteEventData) + len;
>> +	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
>> +	sccb->ebh.length = sizeof(EventBufferHeader) + len;
>> +	sccb->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA;
>> +	memcpy(sccb->data, str, len);
>> +
>> +	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
>> +	sclp_wait_busy();
> 
> Hmm, if the functions do a sclp_wait_busy() at the beginning already, do
> we still need it at the end of the functions, too?
> 
> ... I've got the feeling that we need some clearer conventions here.
> Could you maybe add some comments to the source code?

I'll integrate it into sclp_service_call

> 
>> +}
>> +
>> +static void sclp_print_lm(const char *str)
>> +{
>> +	unsigned char *ptr, *end, ch;
>> +	unsigned int count, offset, len;
>> +	struct write_sccb *sccb;
>> +	struct msg_buf *msg;
>> +	struct mdb *mdb;
>> +	struct mto *mto;
>> +	struct go *go;
>> +
>> +	sclp_wait_busy();
>> +	sclp_busy = true;
> 
> sclp_mark_busy() ?
> 
>> +	sccb = (struct write_sccb *) _sccb;
>> +	end = (unsigned char *) sccb + 4096 - 1;
>> +	memset(sccb, 0, sizeof(*sccb));
>> +	ptr = (unsigned char *) &sccb->msg.mdb.mto;
>> +	len = strlen(str);
>> +	offset = 0;
[...]
>> +	}
> 
> Maybe rather assert(sccb->h.response_code == SCLP_RC_NORMAL_COMPLETION) ?
> It does not make much sense to continue otherwise, does it?

Will the assert abort without any further prints?

> 
>  Thomas
>
Thomas Huth Dec. 18, 2018, 12:28 p.m. UTC | #3 
On 2018-12-18 13:01, Janosch Frank wrote:
> On 18.12.18 12:50, Thomas Huth wrote:
[...]
>> Maybe rather assert(sccb->h.response_code == SCLP_RC_NORMAL_COMPLETION) ?
>> It does not make much sense to continue otherwise, does it?
> 
> Will the assert abort without any further prints?

No ... so that does not work. So maybe do a disabled wait with irqs
disabled instead to signal a crash to the host?

 Thomas
Janosch Frank Dec. 19, 2018, 10:07 a.m. UTC | #4 
On 18.12.18 13:28, Thomas Huth wrote:
> On 2018-12-18 13:01, Janosch Frank wrote:
>> On 18.12.18 12:50, Thomas Huth wrote:
> [...]
>>> Maybe rather assert(sccb->h.response_code == SCLP_RC_NORMAL_COMPLETION) ?
>>> It does not make much sense to continue otherwise, does it?
>>
>> Will the assert abort without any further prints?
> 
> No ... so that does not work. So maybe do a disabled wait with irqs
> disabled instead to signal a crash to the host?
> 
>  Thomas
> 

Honestly, I'm thinking about dropping the check.
It often works without any init because the stage 3 bootloader does an
init and we do not check the print functions for errors.

It's best effort at this point :)
I'm more concerned with interrupts that print things while a printf
holds the sclp_busy lock. But that mostly happens if you mess up a sclp
call.
diff mbox series

Patch

diff --git a/lib/s390x/sclp-console.c b/lib/s390x/sclp-console.c
index 2016ea0..f0ce6a0 100644
--- a/lib/s390x/sclp-console.c
+++ b/lib/s390x/sclp-console.c
@@ -11,21 +11,179 @@ 
 #include <libcflat.h>
 #include <string.h>
 #include <asm/page.h>
+#include <asm/arch_def.h>
+#include <asm/io.h>
 #include "sclp.h"
 
-static void sclp_set_write_mask(void)
+/*
+ * ASCII (IBM PC 437) -> EBCDIC 037
+ */
+static uint8_t _ascebc[256] = {
+ /*00 NUL   SOH   STX   ETX   EOT   ENQ   ACK   BEL */
+     0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
+ /*08  BS    HT    LF    VT    FF    CR    SO    SI */
+ /*              ->NL                               */
+     0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
+ /*10 DLE   DC1   DC2   DC3   DC4   NAK   SYN   ETB */
+     0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
+ /*18 CAN    EM   SUB   ESC    FS    GS    RS    US */
+ /*                               ->IGS ->IRS ->IUS */
+     0x18, 0x19, 0x3F, 0x27, 0x22, 0x1D, 0x1E, 0x1F,
+ /*20  SP     !     "     #     $     %     &     ' */
+     0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
+ /*28   (     )     *     +     ,     -    .      / */
+     0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
+ /*30   0     1     2     3     4     5     6     7 */
+     0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
+ /*38   8     9     :     ;     <     =     >     ? */
+     0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
+ /*40   @     A     B     C     D     E     F     G */
+     0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
+ /*48   H     I     J     K     L     M     N     O */
+     0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
+ /*50   P     Q     R     S     T     U     V     W */
+     0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
+ /*58   X     Y     Z     [     \     ]     ^     _ */
+     0xE7, 0xE8, 0xE9, 0xBA, 0xE0, 0xBB, 0xB0, 0x6D,
+ /*60   `     a     b     c     d     e     f     g */
+     0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+ /*68   h     i     j     k     l     m     n     o */
+     0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
+ /*70   p     q     r     s     t     u     v     w */
+     0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
+ /*78   x     y     z     {     |     }     ~    DL */
+     0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07,
+ /*80*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*88*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*90*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*98*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*A0*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*A8*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*B0*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*B8*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*C0*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*C8*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*D0*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*D8*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*E0        sz						*/
+     0x3F, 0x59, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*E8*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*F0*/
+     0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ /*F8*/
+     0x90, 0x3F, 0x3F, 0x3F, 0x3F, 0xEA, 0x3F, 0xFF
+};
+
+static bool initialized;
+
+static void sclp_print_ascii(const char *str)
+{
+	int len = strlen(str);
+	WriteEventData *sccb = (void *)_sccb;
+
+	sclp_wait_busy();
+	sclp_busy = true;
+	memset(sccb, 0, sizeof(*sccb));
+	sccb->h.length = sizeof(WriteEventData) + len;
+	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
+	sccb->ebh.length = sizeof(EventBufferHeader) + len;
+	sccb->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA;
+	memcpy(sccb->data, str, len);
+
+	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
+	sclp_wait_busy();
+}
+
+static void sclp_print_lm(const char *str)
+{
+	unsigned char *ptr, *end, ch;
+	unsigned int count, offset, len;
+	struct write_sccb *sccb;
+	struct msg_buf *msg;
+	struct mdb *mdb;
+	struct mto *mto;
+	struct go *go;
+
+	sclp_wait_busy();
+	sclp_busy = true;
+	sccb = (struct write_sccb *) _sccb;
+	end = (unsigned char *) sccb + 4096 - 1;
+	memset(sccb, 0, sizeof(*sccb));
+	ptr = (unsigned char *) &sccb->msg.mdb.mto;
+	len = strlen(str);
+	offset = 0;
+	do {
+		for (count = sizeof(*mto); offset < len; count++) {
+			ch = str[offset++];
+			if ((ch == 0x0a) || (ptr + count > end))
+				break;
+			ptr[count] = _ascebc[ch];
+		}
+		mto = (struct mto *) ptr;
+		memset(mto, 0, sizeof(*mto));
+		mto->length = count;
+		mto->type = 4;
+		mto->line_type_flags = LNTPFLGS_ENDTEXT;
+		ptr += count;
+	} while ((offset < len) && (ptr + sizeof(*mto) <= end));
+	len = ptr - (unsigned char *) sccb;
+	sccb->header.length = len - offsetof(struct write_sccb, header);
+	msg = &sccb->msg;
+	msg->header.type = EVTYP_MSG;
+	msg->header.length = len - offsetof(struct write_sccb, msg.header);
+	mdb = &msg->mdb;
+	mdb->header.type = 1;
+	mdb->header.tag = 0xD4C4C240;
+	mdb->header.revision_code = 1;
+	mdb->header.length = len - offsetof(struct write_sccb, msg.mdb.header);
+	go = &mdb->go;
+	go->length = sizeof(*go);
+	go->type = 1;
+	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
+	sclp_wait_busy();
+}
+
+/*
+ * SCLP needs to be initialized by setting a send and receive mask,
+ * indicating which messages the control program (we) want(s) to
+ * send/receive.
+ */
+static bool sclp_set_write_mask(void)
 {
 	WriteEventMask *sccb = (void *)_sccb;
 
 	sclp_mark_busy();
+	memset(_sccb, 0, sizeof(*sccb));
 	sccb->h.length = sizeof(WriteEventMask);
-	sccb->mask_length = sizeof(unsigned int);
-	sccb->receive_mask = SCLP_EVENT_MASK_MSG_ASCII;
-	sccb->cp_receive_mask = SCLP_EVENT_MASK_MSG_ASCII;
-	sccb->send_mask = SCLP_EVENT_MASK_MSG_ASCII;
-	sccb->cp_send_mask = SCLP_EVENT_MASK_MSG_ASCII;
+	sccb->h.function_code = 0;
+	sccb->mask_length = sizeof(sccb_mask_t);
+
+	/* For now we don't process sclp input. */
+	sccb->cp_receive_mask = 0;
+	/* We send ASCII and line mode. */
+	sccb->cp_send_mask = SCLP_EVENT_MASK_MSG_ASCII | SCLP_EVENT_MASK_MSG;
 
 	sclp_service_call(SCLP_CMD_WRITE_EVENT_MASK, sccb);
+	sclp_wait_busy();
+	if (sccb->h.response_code != SCLP_RC_NORMAL_COMPLETION)
+		return false;
+	else {
+		initialized = true;
+		return true;
+	}
 }
 
 void sclp_console_setup(void)
@@ -35,17 +193,16 @@  void sclp_console_setup(void)
 
 void sclp_print(const char *str)
 {
-	int len = strlen(str);
-	WriteEventData *sccb = (void *)_sccb;
-
-	sclp_mark_busy();
-	sccb->h.length = sizeof(WriteEventData) + len;
-	sccb->h.function_code = SCLP_FC_NORMAL_WRITE;
-	sccb->ebh.length = sizeof(EventBufferHeader) + len;
-	sccb->ebh.type = SCLP_EVENT_ASCII_CONSOLE_DATA;
-	sccb->ebh.flags = 0;
-	memcpy(sccb->data, str, len);
-
-	sclp_service_call(SCLP_CMD_WRITE_EVENT_DATA, sccb);
-	sclp_wait_busy();
+	if (!initialized)
+		return;
+	/*
+	 * z/VM advertises a vt220 console which is not functional:
+	 * (response code 05F0, "not active because of the state of
+	 * the machine"). Hence testing the masks would only work if
+	 * we also use stsi data to distinguish z/VM.
+	 *
+	 * Let's rather print on all available consoles.
+	 */
+	sclp_print_ascii(str);
+	sclp_print_lm(str);
 }
diff --git a/lib/s390x/sclp.h b/lib/s390x/sclp.h
index 427b0d7..bb6f167 100644
--- a/lib/s390x/sclp.h
+++ b/lib/s390x/sclp.h
@@ -179,6 +179,7 @@  typedef struct SCCB {
 /* SCLP event masks */
 #define SCLP_EVENT_MASK_SIGNAL_QUIESCE          0x00000008
 #define SCLP_EVENT_MASK_MSG_ASCII               0x00000040
+#define SCLP_EVENT_MASK_MSG          		0x40000000
 
 #define SCLP_UNCONDITIONAL_READ                 0x00
 #define SCLP_SELECTIVE_READ                     0x01
@@ -212,6 +213,72 @@  typedef struct ReadEventData {
     uint32_t mask;
 } __attribute__((packed)) ReadEventData;
 
+#define MDBTYP_GO               0x0001
+#define MDBTYP_MTO              0x0004
+#define EVTYP_MSG               0x02
+#define LNTPFLGS_CNTLTEXT       0x8000
+#define LNTPFLGS_LABELTEXT      0x4000
+#define LNTPFLGS_DATATEXT       0x2000
+#define LNTPFLGS_ENDTEXT        0x1000
+#define LNTPFLGS_PROMPTTEXT     0x0800
+
+typedef uint32_t sccb_mask_t;
+
+/* SCLP line mode console related structures. */
+
+struct mto {
+	u16 length;
+	u16 type;
+	u16 line_type_flags;
+	u8  alarm_control;
+	u8  _reserved[3];
+} __attribute__((packed));
+
+struct go {
+	u16 length;
+	u16 type;
+	u32 domid;
+	u8  hhmmss_time[8];
+	u8  th_time[3];
+	u8  reserved_0;
+	u8  dddyyyy_date[7];
+	u8  _reserved_1;
+	u16 general_msg_flags;
+	u8  _reserved_2[10];
+	u8  originating_system_name[8];
+	u8  job_guest_name[8];
+} __attribute__((packed));
+
+struct mdb_header {
+	u16 length;
+	u16 type;
+	u32 tag;
+	u32 revision_code;
+} __attribute__((packed));
+
+struct mdb {
+	struct mdb_header header;
+	struct go go;
+	struct mto mto;
+} __attribute__((packed));
+
+struct evbuf_header {
+	u16	length;
+	u8	type;
+	u8	flags;
+	u16	_reserved;
+} __attribute__((packed));
+
+struct msg_buf {
+	struct evbuf_header header;
+	struct mdb mdb;
+} __attribute__((packed));
+
+struct write_sccb {
+	struct SCCBHeader header;
+	struct msg_buf msg;
+} __packed;
+
 extern char _sccb[];
 volatile bool sclp_busy;
 void sclp_handle_ext(void);