Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ee337f54 authored by Philipp Rudo's avatar Philipp Rudo Committed by Martin Schwidefsky
Browse files

s390/kexec_file: Add crash support to image loader 



Add support to load a crash kernel to the image loader. This requires
extending the purgatory.

Signed-off-by: default avatarPhilipp Rudo <prudo@linux.vnet.ibm.com>
Reviewed-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent e49bb0a2

arch/s390/kernel/kexec_image.c

+2 −4
Original line number Diff line number Diff line
@@ -25,6 +25,8 @@ static int kexec_file_add_image_kernel(struct kimage *image, 
	buf.bufsz = kernel_len - STARTUP_NORMAL_OFFSET;



	buf.mem = STARTUP_NORMAL_OFFSET;

	if (image->type == KEXEC_TYPE_CRASH)

		buf.mem += crashk_res.start;

	buf.memsz = buf.bufsz;



	ret = kexec_add_buffer(&buf);
@@ -43,10 +45,6 @@ static void *s390_image_load(struct kimage *image, 
	struct s390_load_data data = {0};

	int ret;



	/* We don't support crash kernels yet. */

	if (image->type == KEXEC_TYPE_CRASH)

		return ERR_PTR(-ENOTSUPP);



	ret = kexec_file_add_image_kernel(image, &data, kernel, kernel_len);

	if (ret)

		return ERR_PTR(ret);

arch/s390/kernel/machine_kexec_file.c

+44 −1
Original line number Diff line number Diff line
@@ -28,6 +28,14 @@ int *kexec_file_update_kernel(struct kimage *image, 
		memcpy(data->kernel_buf + COMMAND_LINE_OFFSET,

		       image->cmdline_buf, image->cmdline_buf_len);



	if (image->type == KEXEC_TYPE_CRASH) {

		loc = (unsigned long *)(data->kernel_buf + OLDMEM_BASE_OFFSET);

		*loc = crashk_res.start;



		loc = (unsigned long *)(data->kernel_buf + OLDMEM_SIZE_OFFSET);

		*loc = crashk_res.end - crashk_res.start + 1;

	}



	if (image->initrd_buf) {

		loc = (unsigned long *)(data->kernel_buf + INITRD_START_OFFSET);

		*loc = data->initrd_load_addr;
@@ -44,9 +52,40 @@ static int kexec_file_update_purgatory(struct kimage *image) 
	u64 entry, type;

	int ret;



	if (image->type == KEXEC_TYPE_CRASH) {

		entry = STARTUP_KDUMP_OFFSET;

		type = KEXEC_TYPE_CRASH;

	} else {

		entry = STARTUP_NORMAL_OFFSET;

		type = KEXEC_TYPE_DEFAULT;

	}



	ret = kexec_purgatory_get_set_symbol(image, "kernel_entry", &entry,

					     sizeof(entry), false);

	if (ret)

		return ret;



	ret = kexec_purgatory_get_set_symbol(image, "kernel_type", &type,

					     sizeof(type), false);

	if (ret)

		return ret;



	if (image->type == KEXEC_TYPE_CRASH) {

		u64 crash_size;



		ret = kexec_purgatory_get_set_symbol(image, "crash_start",

						     &crashk_res.start,

						     sizeof(crashk_res.start),

						     false);

		if (ret)

			return ret;



		crash_size = crashk_res.end - crashk_res.start + 1;

		ret = kexec_purgatory_get_set_symbol(image, "crash_size",

						     &crash_size,

						     sizeof(crash_size),

						     false);

	}

	return ret;

}
@@ -59,6 +98,8 @@ int kexec_file_add_purgatory(struct kimage *image, struct s390_load_data *data) 


	data->memsz = ALIGN(data->memsz, PAGE_SIZE);

	buf.mem = data->memsz;

	if (image->type == KEXEC_TYPE_CRASH)

		buf.mem += crashk_res.start;



	ret = kexec_load_purgatory(image, &buf);

	if (ret)
@@ -81,6 +122,8 @@ int kexec_file_add_initrd(struct kimage *image, struct s390_load_data *data, 


	data->memsz = ALIGN(data->memsz, PAGE_SIZE);

	buf.mem = data->memsz;

	if (image->type == KEXEC_TYPE_CRASH)

		buf.mem += crashk_res.start;

	buf.memsz = buf.bufsz;



	data->initrd_load_addr = buf.mem;

arch/s390/purgatory/head.S

+184 −1
Original line number Diff line number Diff line
@@ -15,8 +15,52 @@ 
/* The purgatory is the code running between two kernels. It's main purpose

 * is to verify that the next kernel was not corrupted after load and to

 * start it.

 *

 * If the next kernel is a crash kernel there are some peculiarities to

 * consider:

 *

 * First the purgatory is called twice. Once only to verify the

 * sha digest. So if the crash kernel got corrupted the old kernel can try

 * to trigger a stand-alone dumper. And once to actually load the crash kernel.

 *

 * Second the purgatory also has to swap the crash memory region with its

 * destination at address 0. As the purgatory is part of crash memory this

 * requires some finesse. The tactic here is that the purgatory first copies

 * itself to the end of the destination and then swaps the rest of the

 * memory running from there.

 */



#define bufsz purgatory_end-stack



.macro MEMCPY dst,src,len

	lgr	%r0,\dst

	lgr	%r1,\len

	lgr	%r2,\src

	lgr	%r3,\len



20:	mvcle	%r0,%r2,0

	jo	20b

.endm



.macro MEMSWAP dst,src,buf,len

10:	cghi	\len,bufsz

	jh	11f

	lgr	%r4,\len

	j	12f

11:	lghi	%r4,bufsz



12:	MEMCPY	\buf,\dst,%r4

	MEMCPY	\dst,\src,%r4

	MEMCPY	\src,\buf,%r4



	agr	\dst,%r4

	agr	\src,%r4

	sgr	\len,%r4



	cghi	\len,0

	jh	10b

.endm



.macro START_NEXT_KERNEL base

	lg	%r4,kernel_entry-\base(%r13)

	lg	%r5,load_psw_mask-\base(%r13)
@@ -47,18 +91,144 @@ ENTRY(purgatory_start) 
	larl	%r15,purgatory_end

	aghi	%r15,-160



	/* If the next kernel is KEXEC_TYPE_CRASH the purgatory is called

	 * directly with a flag passed in %r2 whether the purgatory shall do

	 * checksum verification only (%r2 = 0 -> verification only).

	 *

	 * Check now and preserve over C function call by storing in

	 * %r10 whith

	 *	1 -> checksum verification only

	 *	0 -> load new kernel

	 */

	lghi	%r10,0

	lg	%r11,kernel_type-.base_crash(%r13)

	cghi	%r11,1		/* KEXEC_TYPE_CRASH */

	jne	.do_checksum_verification

	cghi	%r2,0		/* checksum verification only */

	jne	.do_checksum_verification

	lghi	%r10,1



.do_checksum_verification:

	brasl	%r14,verify_sha256_digest



	cghi	%r10,1		/* checksum verification only */

	je	.return_old_kernel

	cghi	%r2,0		/* checksum match */

	jne	.disabled_wait



	/* If the next kernel is a crash kernel the purgatory has to swap

	 * the mem regions first.

	 */

	cghi	%r11,1 /* KEXEC_TYPE_CRASH */

	je	.start_crash_kernel



	/* start normal kernel */

	START_NEXT_KERNEL .base_crash



.return_old_kernel:

	lmg	%r6,%r15,gprregs-.base_crash(%r13)

	br	%r14



.disabled_wait:

	lpswe	disabled_wait_psw-.base_crash(%r13)



.start_crash_kernel:

	/* Location of purgatory_start in crash memory */

	lgr	%r8,%r13

	aghi	%r8,-(.base_crash-purgatory_start)



	/* Destination for this code i.e. end of memory to be swapped. */

	lg	%r9,crash_size-.base_crash(%r13)

	aghi	%r9,-(purgatory_end-purgatory_start)



	/* Destination in crash memory, i.e. same as r9 but in crash memory. */

	lg	%r10,crash_start-.base_crash(%r13)

	agr	%r10,%r9



	/* Buffer location (in crash memory) and size. As the purgatory is

	 * behind the point of no return it can re-use the stack as buffer.

	 */

	lghi	%r11,bufsz

	larl	%r12,stack



	MEMCPY	%r12,%r9,%r11	/* dst	-> (crash) buf */

	MEMCPY	%r9,%r8,%r11	/* self -> dst */



	/* Jump to new location. */

	lgr	%r7,%r9

	aghi	%r7,.jump_to_dst-purgatory_start

	br	%r7



.jump_to_dst:

	basr	%r13,0

.base_dst:



	/* clear buffer */

	MEMCPY	%r12,%r10,%r11	/* (crash) buf -> (crash) dst */



	/* Load new buffer location after jump */

	larl	%r7,stack

	aghi	%r10,stack-purgatory_start

	MEMCPY	%r10,%r7,%r11	/* (new) buf -> (crash) buf */



	/* Now the code is set up to run from its designated location. Start

	 * swapping the rest of crash memory now.

	 *

	 * The registers will be used as follow:

	 *

	 *	%r0-%r4	reserved for macros defined above

	 *	%r5-%r6 tmp registers

	 *	%r7	pointer to current struct sha region

	 *	%r8	index to iterate over all sha regions

	 *	%r9	pointer in crash memory

	 *	%r10	pointer in old kernel

	 *	%r11	total size (still) to be moved

	 *	%r12	pointer to buffer

	 */

	lgr	%r12,%r7

	lgr	%r11,%r9

	lghi	%r10,0

	lg	%r9,crash_start-.base_dst(%r13)

	lghi	%r8,16	/* KEXEC_SEGMENTS_MAX */

	larl	%r7,purgatory_sha_regions



	j .loop_first



	/* Loop over all purgatory_sha_regions. */

.loop_next:

	aghi	%r8,-1

	cghi	%r8,0

	je	.loop_out



	aghi	%r7,__KEXEC_SHA_REGION_SIZE



.loop_first:

	lg	%r5,__KEXEC_SHA_REGION_START(%r7)

	cghi	%r5,0

	je	.loop_next



	/* Copy [end last sha region, start current sha region) */

	/* Note: kexec_sha_region->start points in crash memory */

	sgr	%r5,%r9

	MEMCPY	%r9,%r10,%r5



	agr	%r9,%r5

	agr	%r10,%r5

	sgr	%r11,%r5



	/* Swap sha region */

	lg	%r6,__KEXEC_SHA_REGION_LEN(%r7)

	MEMSWAP	%r9,%r10,%r12,%r6

	sg	%r11,__KEXEC_SHA_REGION_LEN(%r7)

	j	.loop_next



.loop_out:

	/* Copy rest of crash memory */

	MEMCPY	%r9,%r10,%r11



	/* start crash kernel */

	START_NEXT_KERNEL .base_dst





load_psw_mask:

	.long	0x00080000,0x80000000
@@ -89,8 +259,21 @@ kernel_entry: 
	.global kernel_entry

	.quad	0



kernel_type:

	.global kernel_type

	.quad	0



crash_start:

	.global crash_start

	.quad	0



crash_size:

	.global crash_size

	.quad	0



	.align	PAGE_SIZE

stack:

	.skip	PAGE_SIZE

	/* The buffer to move this code must be as big as the code. */

	.skip	stack-purgatory_start

	.align	PAGE_SIZE

purgatory_end:

arch/s390/purgatory/purgatory.c

+4 −0
Original line number Diff line number Diff line
@@ -16,6 +16,10 @@ struct kexec_sha_region purgatory_sha_regions[KEXEC_SEGMENT_MAX]; 
u8 purgatory_sha256_digest[SHA256_DIGEST_SIZE];



u64 kernel_entry;

u64 kernel_type;



u64 crash_start;

u64 crash_size;



int verify_sha256_digest(void)

{