lael-labs/linux

arch/s390/Makefile+2−0

 endif
 aflags_dwarf	:= -Wa,-gdwarf-2
 KBUILD_AFLAGS_DECOMPRESSOR := $(CLANG_FLAGS) -m64 -D__ASSEMBLY__
+ifndef CONFIG_AS_IS_LLVM
 KBUILD_AFLAGS_DECOMPRESSOR += $(if $(CONFIG_DEBUG_INFO),$(aflags_dwarf))
+endif
 KBUILD_CFLAGS_DECOMPRESSOR := $(CLANG_FLAGS) -m64 -O2 -mpacked-stack
 KBUILD_CFLAGS_DECOMPRESSOR += -DDISABLE_BRANCH_PROFILING -D__NO_FORTIFY
 KBUILD_CFLAGS_DECOMPRESSOR += -fno-delete-null-pointer-checks -msoft-float -mbackchain

arch/s390/boot/.gitignore+3−0

@@ -2,3 +2,6 @@ · 1 unmodified line
2	image	2	image
3	bzImage	3	bzImage
4	section_cmp.*	4	section_cmp.*
		5	vmlinux
		6	vmlinux.lds
		7	vmlinux.syms

arch/s390/boot/Makefile+69−9

@@ -37,14 +37,21 @@ CFLAGS_sclp_early_core.o += -I$(srctree)/drivers/s390/char · 36 unmodified lines
37		37
38	obj-y := head.o als.o startup.o mem_detect.o ipl_parm.o ipl_report.o	38	obj-y := head.o als.o startup.o mem_detect.o ipl_parm.o ipl_report.o
39	obj-y += string.o ebcdic.o sclp_early_core.o mem.o ipl_vmparm.o cmdline.o	39	obj-y += string.o ebcdic.o sclp_early_core.o mem.o ipl_vmparm.o cmdline.o
40	obj-y += version.o pgm_check_info.o ctype.o	40	obj-y += version.o pgm_check_info.o ctype.o ipl_data.o
41	obj-$(findstring y, $(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) $(CONFIG_PGSTE)) += uv.o	41	obj-$(findstring y, $(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) $(CONFIG_PGSTE)) += uv.o
42	obj-$(CONFIG_RELOCATABLE) += machine_kexec_reloc.o	42	obj-$(CONFIG_RELOCATABLE) += machine_kexec_reloc.o
43	obj-$(CONFIG_RANDOMIZE_BASE) += kaslr.o	43	obj-$(CONFIG_RANDOMIZE_BASE) += kaslr.o
44	targets := bzImage startup.a section_cmp.boot.data section_cmp.boot.preserved.data $(obj-y)	44	obj-y += $(if $(CONFIG_KERNEL_UNCOMPRESSED),,decompressor.o) info.o
45	subdir- := compressed	45	obj-$(CONFIG_KERNEL_ZSTD) += clz_ctz.o
		46	obj-all := $(obj-y) piggy.o syms.o
		47
		48	targets := bzImage section_cmp.boot.data section_cmp.boot.preserved.data $(obj-y)
		49	targets += vmlinux.lds vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2
		50	targets += vmlinux.bin.xz vmlinux.bin.lzma vmlinux.bin.lzo vmlinux.bin.lz4
		51	targets += vmlinux.bin.zst info.bin syms.bin vmlinux.syms $(obj-all)
46		52
47	OBJECTS := $(addprefix $(obj)/,$(obj-y))	53	OBJECTS := $(addprefix $(obj)/,$(obj-y))
		54	OBJECTS_ALL := $(addprefix $(obj)/,$(obj-all))
48		55
49	quiet_cmd_section_cmp = SECTCMP $*	56	quiet_cmd_section_cmp = SECTCMP $*
50	define cmd_section_cmp	57	define cmd_section_cmp
@@ -59,14 +66,67 @@ define cmd_section_cmp · 8 unmodified lines
59	touch $@	66	touch $@
60	endef	67	endef
61		68
62	$(obj)/bzImage: $(obj)/compressed/vmlinux $(obj)/section_cmp.boot.data $(obj)/section_cmp.boot.preserved.data FORCE	69	$(obj)/bzImage: $(obj)/vmlinux $(obj)/section_cmp.boot.data $(obj)/section_cmp.boot.preserved.data FORCE
63	$(call if_changed,objcopy)	70	$(call if_changed,objcopy)
64		71
65	$(obj)/section_cmp%: vmlinux $(obj)/compressed/vmlinux FORCE	72	$(obj)/section_cmp%: vmlinux $(obj)/vmlinux FORCE
66	$(call if_changed,section_cmp)	73	$(call if_changed,section_cmp)
67		74
68	$(obj)/compressed/vmlinux: $(obj)/startup.a FORCE	75	LDFLAGS_vmlinux := --oformat $(LD_BFD) -e startup --build-id=sha1 -T
69	$(Q)$(MAKE) $(build)=$(obj)/compressed $@	76	$(obj)/vmlinux: $(obj)/vmlinux.lds $(OBJECTS_ALL) FORCE
		77	$(call if_changed,ld)
		78
		79	LDFLAGS_vmlinux.syms := --oformat $(LD_BFD) -e startup -T
		80	$(obj)/vmlinux.syms: $(obj)/vmlinux.lds $(OBJECTS) FORCE
		81	$(call if_changed,ld)
		82
		83	quiet_cmd_dumpsyms = DUMPSYMS $<
		84	define cmd_dumpsyms
		85	$(NM) -n -S --format=bsd "$<" \| sed -nE 's/^0([0-9a-fA-F]+) 0([0-9a-fA-F]+) [tT] ([^ ]*)$$/\1 \2 \3/p' \| tr '\n' '\0' > "$@"
		86	endef
		87
		88	$(obj)/syms.bin: $(obj)/vmlinux.syms FORCE
		89	$(call if_changed,dumpsyms)
		90
		91	OBJCOPYFLAGS_syms.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.decompressor.syms
		92	$(obj)/syms.o: $(obj)/syms.bin FORCE
		93	$(call if_changed,objcopy)
		94
		95	OBJCOPYFLAGS_info.bin := -O binary --only-section=.vmlinux.info --set-section-flags .vmlinux.info=load
		96	$(obj)/info.bin: vmlinux FORCE
		97	$(call if_changed,objcopy)
		98
		99	OBJCOPYFLAGS_info.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.vmlinux.info
		100	$(obj)/info.o: $(obj)/info.bin FORCE
		101	$(call if_changed,objcopy)
		102
		103	OBJCOPYFLAGS_vmlinux.bin := -O binary --remove-section=.comment --remove-section=.vmlinux.info -S
		104	$(obj)/vmlinux.bin: vmlinux FORCE
		105	$(call if_changed,objcopy)
		106
		107	suffix-$(CONFIG_KERNEL_GZIP) := .gz
		108	suffix-$(CONFIG_KERNEL_BZIP2) := .bz2
		109	suffix-$(CONFIG_KERNEL_LZ4) := .lz4
		110	suffix-$(CONFIG_KERNEL_LZMA) := .lzma
		111	suffix-$(CONFIG_KERNEL_LZO) := .lzo
		112	suffix-$(CONFIG_KERNEL_XZ) := .xz
		113	suffix-$(CONFIG_KERNEL_ZSTD) := .zst
70		114
71	$(obj)/startup.a: $(OBJECTS) FORCE	115	$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
72	$(call if_changed,ar)	116	$(call if_changed,gzip)
		117	$(obj)/vmlinux.bin.bz2: $(obj)/vmlinux.bin FORCE
		118	$(call if_changed,bzip2_with_size)
		119	$(obj)/vmlinux.bin.lz4: $(obj)/vmlinux.bin FORCE
		120	$(call if_changed,lz4_with_size)
		121	$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE
		122	$(call if_changed,lzma_with_size)
		123	$(obj)/vmlinux.bin.lzo: $(obj)/vmlinux.bin FORCE
		124	$(call if_changed,lzo_with_size)
		125	$(obj)/vmlinux.bin.xz: $(obj)/vmlinux.bin FORCE
		126	$(call if_changed,xzkern_with_size)
		127	$(obj)/vmlinux.bin.zst: $(obj)/vmlinux.bin FORCE
		128	$(call if_changed,zstd22_with_size)
		129
		130	OBJCOPYFLAGS_piggy.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.vmlinux.bin.compressed
		131	$(obj)/piggy.o: $(obj)/vmlinux.bin$(suffix-y) FORCE
		132	$(call if_changed,objcopy)

arch/s390/boot/boot.h+5−1

 #ifndef BOOT_BOOT_H
 #define BOOT_BOOT_H
-#include <asm/extable.h>
 #include <linux/types.h>
+#define IPL_START	0x200
+#ifndef __ASSEMBLY__
 void startup_kernel(void);
 unsigned long detect_memory(void);
 bool is_ipl_block_dump(void);
 unsigned long read_ipl_report(unsigned long safe_offset);
+#endif /* __ASSEMBLY__ */
 #endif /* BOOT_BOOT_H */

arch/s390/boot/clz_ctz.crenamed from arch/s390/boot/compressed/clz_ctz.c+0−0

File renamed without changes.

arch/s390/boot/compressed/.gitignore+0−4

@@ -1,4 +0,0 @@
1	# SPDX-License-Identifier: GPL-2.0-only
2	vmlinux
3	vmlinux.lds
4	vmlinux.syms

arch/s390/boot/compressed/Makefile+0−86

@@ -1,86 +0,0 @@
1	# SPDX-License-Identifier: GPL-2.0
2	#
3	# linux/arch/s390/boot/compressed/Makefile
4	#
5	# create a compressed vmlinux image from the original vmlinux
6	#
7
8	KCOV_INSTRUMENT := n
9	GCOV_PROFILE := n
10	UBSAN_SANITIZE := n
11	KASAN_SANITIZE := n
12	KCSAN_SANITIZE := n
13
14	obj-y := $(if $(CONFIG_KERNEL_UNCOMPRESSED),,decompressor.o) info.o
15	obj-$(CONFIG_KERNEL_ZSTD) += clz_ctz.o
16	obj-all := $(obj-y) piggy.o syms.o
17	targets := vmlinux.lds vmlinux vmlinux.bin vmlinux.bin.gz vmlinux.bin.bz2
18	targets += vmlinux.bin.xz vmlinux.bin.lzma vmlinux.bin.lzo vmlinux.bin.lz4
19	targets += vmlinux.bin.zst
20	targets += info.bin syms.bin vmlinux.syms $(obj-all)
21
22	KBUILD_AFLAGS := $(KBUILD_AFLAGS_DECOMPRESSOR)
23	KBUILD_CFLAGS := $(KBUILD_CFLAGS_DECOMPRESSOR)
24	OBJCOPYFLAGS :=
25
26	OBJECTS := $(addprefix $(obj)/,$(obj-y))
27	OBJECTS_ALL := $(addprefix $(obj)/,$(obj-all))
28
29	LDFLAGS_vmlinux := --oformat $(LD_BFD) -e startup --build-id=sha1 -T
30	$(obj)/vmlinux: $(obj)/vmlinux.lds $(objtree)/arch/s390/boot/startup.a $(OBJECTS_ALL) FORCE
31	$(call if_changed,ld)
32
33	LDFLAGS_vmlinux.syms := --oformat $(LD_BFD) -e startup -T
34	$(obj)/vmlinux.syms: $(obj)/vmlinux.lds $(objtree)/arch/s390/boot/startup.a $(OBJECTS) FORCE
35	$(call if_changed,ld)
36
37	quiet_cmd_dumpsyms = DUMPSYMS $<
38	define cmd_dumpsyms
39	$(NM) -n -S --format=bsd "$<" \| sed -nE 's/^0([0-9a-fA-F]+) 0([0-9a-fA-F]+) [tT] ([^ ]*)$$/\1 \2 \3/p' \| tr '\n' '\0' > "$@"
40	endef
41
42	$(obj)/syms.bin: $(obj)/vmlinux.syms FORCE
43	$(call if_changed,dumpsyms)
44
45	OBJCOPYFLAGS_syms.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.decompressor.syms
46	$(obj)/syms.o: $(obj)/syms.bin FORCE
47	$(call if_changed,objcopy)
48
49	OBJCOPYFLAGS_info.bin := -O binary --only-section=.vmlinux.info --set-section-flags .vmlinux.info=load
50	$(obj)/info.bin: vmlinux FORCE
51	$(call if_changed,objcopy)
52
53	OBJCOPYFLAGS_info.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.vmlinux.info
54	$(obj)/info.o: $(obj)/info.bin FORCE
55	$(call if_changed,objcopy)
56
57	OBJCOPYFLAGS_vmlinux.bin := -O binary --remove-section=.comment --remove-section=.vmlinux.info -S
58	$(obj)/vmlinux.bin: vmlinux FORCE
59	$(call if_changed,objcopy)
60
61	suffix-$(CONFIG_KERNEL_GZIP) := .gz
62	suffix-$(CONFIG_KERNEL_BZIP2) := .bz2
63	suffix-$(CONFIG_KERNEL_LZ4) := .lz4
64	suffix-$(CONFIG_KERNEL_LZMA) := .lzma
65	suffix-$(CONFIG_KERNEL_LZO) := .lzo
66	suffix-$(CONFIG_KERNEL_XZ) := .xz
67	suffix-$(CONFIG_KERNEL_ZSTD) := .zst
68
69	$(obj)/vmlinux.bin.gz: $(obj)/vmlinux.bin FORCE
70	$(call if_changed,gzip)
71	$(obj)/vmlinux.bin.bz2: $(obj)/vmlinux.bin FORCE
72	$(call if_changed,bzip2_with_size)
73	$(obj)/vmlinux.bin.lz4: $(obj)/vmlinux.bin FORCE
74	$(call if_changed,lz4_with_size)
75	$(obj)/vmlinux.bin.lzma: $(obj)/vmlinux.bin FORCE
76	$(call if_changed,lzma_with_size)
77	$(obj)/vmlinux.bin.lzo: $(obj)/vmlinux.bin FORCE
78	$(call if_changed,lzo_with_size)
79	$(obj)/vmlinux.bin.xz: $(obj)/vmlinux.bin FORCE
80	$(call if_changed,xzkern_with_size)
81	$(obj)/vmlinux.bin.zst: $(obj)/vmlinux.bin FORCE
82	$(call if_changed,zstd22_with_size)
83
84	OBJCOPYFLAGS_piggy.o := -I binary -O elf64-s390 -B s390:64-bit --rename-section .data=.vmlinux.bin.compressed
85	$(obj)/piggy.o: $(obj)/vmlinux.bin$(suffix-y) FORCE
86	$(call if_changed,objcopy)

arch/s390/boot/decompressor.crenamed from arch/s390/boot/compressed/decompressor.c+0−0

File renamed without changes.

arch/s390/boot/decompressor.hrenamed from arch/s390/boot/compressed/decompressor.h+0−0

File renamed without changes.

arch/s390/boot/head.S+148−218

@@ -27,234 +27,181 @@ · 26 unmodified lines
27	#include <asm/page.h>	27	#include <asm/page.h>
28	#include <asm/ptrace.h>	28	#include <asm/ptrace.h>
29	#include <asm/sclp.h>	29	#include <asm/sclp.h>
30		30	#include "boot.h"
31	#define ARCH_OFFSET 4
32		31
33	#define EP_OFFSET 0x10008	32	#define EP_OFFSET 0x10008
34	#define EP_STRING "S390EP"	33	#define EP_STRING "S390EP"
		34	#define IPL_BS 0x730
35		35
36	__HEAD	36	__HEAD
37		37	ipl_start:
38	#define IPL_BS 0x730	38	mvi __LC_AR_MODE_ID,1 # set esame flag
39	.org 0	39	slr %r0,%r0 # set cpuid to zero
40	.long 0x00080000,0x80000000+iplstart # The first 24 bytes are loaded	40	lhi %r1,2 # mode 2 = esame (dump)
41	.long 0x02000018,0x60000050 # by ipl to addresses 0-23.	41	sigp %r1,%r0,0x12 # switch to esame mode
42	.long 0x02000068,0x60000050 # (a PSW and two CCWs).	42	sam64 # switch to 64 bit addressing mode
43	.fill 80-24,1,0x40 # bytes 24-79 are discarded !!	43	lgh %r1,__LC_SUBCHANNEL_ID # test if subchannel number
44	.long 0x020000f0,0x60000050 # The next 160 byte are loaded	44	brctg %r1,.Lnoload # is valid
45	.long 0x02000140,0x60000050 # to addresses 0x18-0xb7	45	llgf %r1,__LC_SUBCHANNEL_ID # load ipl subchannel number
46	.long 0x02000190,0x60000050 # They form the continuation	46	lghi %r2,IPL_BS # load start address
47	.long 0x020001e0,0x60000050 # of the CCW program started	47	bras %r14,.Lloader # load rest of ipl image
48	.long 0x02000230,0x60000050 # by ipl and load the range	48	larl %r12,parmarea # pointer to parameter area
49	.long 0x02000280,0x60000050 # 0x0f0-0x730 from the image	49	stg %r1,IPL_DEVICE-PARMAREA(%r12) # save ipl device number
50	.long 0x020002d0,0x60000050 # to the range 0x0f0-0x730	50	#
51	.long 0x02000320,0x60000050 # in memory. At the end of	51	# load parameter file from ipl device
52	.long 0x02000370,0x60000050 # the channel program the PSW	52	#
53	.long 0x020003c0,0x60000050 # at location 0 is loaded.	53	.Lagain1:
54	.long 0x02000410,0x60000050 # Initial processing starts	54	larl %r2,_end # ramdisk loc. is temp
55	.long 0x02000460,0x60000050 # at 0x200 = iplstart.	55	bras %r14,.Lloader # load parameter file
56	.long 0x020004b0,0x60000050	56	ltgr %r2,%r2 # got anything ?
57	.long 0x02000500,0x60000050	57	jz .Lnopf
58	.long 0x02000550,0x60000050	58	lg %r3,MAX_COMMAND_LINE_SIZE-PARMAREA(%r12)
59	.long 0x020005a0,0x60000050	59	aghi %r3,-1
60	.long 0x020005f0,0x60000050	60	clgr %r2,%r3
61	.long 0x02000640,0x60000050	61	jl .Lnotrunc
62	.long 0x02000690,0x60000050	62	lgr %r2,%r3
63	.long 0x020006e0,0x20000050	63	.Lnotrunc:
64		64	larl %r4,_end
65	.org __LC_RST_NEW_PSW # 0x1a0	65	larl %r13,.L_hdr
66	.quad 0,iplstart	66	clc 0(3,%r4),0(%r13) # if it is HDRx
67	.org __LC_EXT_NEW_PSW # 0x1b0	67	jz .Lagain1 # skip dataset header
68	.quad 0x0002000180000000,0x1b0 # disabled wait	68	larl %r13,.L_eof
69	.org __LC_PGM_NEW_PSW # 0x1d0	69	clc 0(3,%r4),0(%r13) # if it is EOFx
70	.quad 0x0000000180000000,startup_pgm_check_handler	70	jz .Lagain1 # skip dateset trailer
71	.org __LC_IO_NEW_PSW # 0x1f0	71	lgr %r5,%r2
72	.quad 0x0002000180000000,0x1f0 # disabled wait	72	la %r6,COMMAND_LINE-PARMAREA(%r12)
73		73	lgr %r7,%r2
74	.org 0x200	74	aghi %r7,1
75		75	mvcl %r6,%r4
		76	.Lnopf:
		77	#
		78	# load ramdisk from ipl device
		79	#
		80	.Lagain2:
		81	larl %r2,_end # addr of ramdisk
		82	stg %r2,INITRD_START-PARMAREA(%r12)
		83	bras %r14,.Lloader # load ramdisk
		84	stg %r2,INITRD_SIZE-PARMAREA(%r12) # store size of rd
		85	ltgr %r2,%r2
		86	jnz .Lrdcont
		87	stg %r2,INITRD_START-PARMAREA(%r12) # no ramdisk found
		88	.Lrdcont:
		89	larl %r2,_end
		90	larl %r13,.L_hdr # skip HDRx and EOFx
		91	clc 0(3,%r2),0(%r13)
		92	jz .Lagain2
		93	larl %r13,.L_eof
		94	clc 0(3,%r2),0(%r13)
		95	jz .Lagain2
		96	#
		97	# reset files in VM reader
		98	#
		99	larl %r13,.Lcpuid
		100	stidp 0(%r13) # store cpuid
		101	tm 0(%r13),0xff # running VM ?
		102	jno .Lnoreset
		103	larl %r2,.Lreset
		104	lghi %r3,26
		105	diag %r2,%r3,8
		106	larl %r5,.Lirb
		107	stsch 0(%r5) # check if irq is pending
		108	tm 30(%r5),0x0f # by verifying if any of the
		109	jnz .Lwaitforirq # activity or status control
		110	tm 31(%r5),0xff # bits is set in the schib
		111	jz .Lnoreset
		112	.Lwaitforirq:
		113	bras %r14,.Lirqwait # wait for IO interrupt
		114	c %r1,__LC_SUBCHANNEL_ID # compare subchannel number
		115	jne .Lwaitforirq
		116	larl %r5,.Lirb
		117	tsch 0(%r5)
		118	.Lnoreset:
		119	j .Lnoload
		120	#
		121	# everything loaded, go for it
		122	#
		123	.Lnoload:
		124	jg startup
76	#	125	#
77	# subroutine to wait for end I/O	126	# subroutine to wait for end I/O
78	#	127	#
79	.Lirqwait:	128	.Lirqwait:
80	mvc __LC_IO_NEW_PSW(16),.Lnewpsw # set up IO interrupt psw	129	larl %r13,.Lnewpswmask # set up IO interrupt psw
81	lpsw .Lwaitpsw	130	mvc __LC_IO_NEW_PSW(8),0(%r13)
		131	stg %r14,__LC_IO_NEW_PSW+8
		132	larl %r13,.Lwaitpsw
		133	lpswe 0(%r13)
82	.Lioint:	134	.Lioint:
83	br %r14
84	.align 8
85	.Lnewpsw:
86	.quad 0x0000000080000000,.Lioint
87	.Lwaitpsw:
88	.long 0x020a0000,0x80000000+.Lioint
89
90	#	135	#
91	# subroutine for loading cards from the reader	136	# subroutine for loading cards from the reader
92	#	137	#
93	.Lloader:	138	.Lloader:
94	la %r4,0(%r14)	139	lgr %r4,%r14
95	la %r3,.Lorb # r2 = address of orb into r2	140	larl %r3,.Lorb # r2 = address of orb into r2
96	la %r5,.Lirb # r4 = address of irb	141	larl %r5,.Lirb # r4 = address of irb
97	la %r6,.Lccws	142	larl %r6,.Lccws
98	la %r7,20	143	lghi %r7,20
99	.Linit:	144	.Linit:
100	st %r2,4(%r6) # initialize CCW data addresses	145	st %r2,4(%r6) # initialize CCW data addresses
101	la %r2,0x50(%r2)	146	la %r2,0x50(%r2)
102	la %r6,8(%r6)	147	la %r6,8(%r6)
103	bct 7,.Linit	148	brctg %r7,.Linit
104		149	larl %r13,.Lcr6
105	lctl %c6,%c6,.Lcr6 # set IO subclass mask	150	lctlg %c6,%c6,0(%r13)
106	slr %r2,%r2	151	xgr %r2,%r2
107	.Lldlp:	152	.Lldlp:
108	ssch 0(%r3) # load chunk of 1600 bytes	153	ssch 0(%r3) # load chunk of 1600 bytes
109	bnz .Llderr	154	jnz .Llderr
110	.Lwait4irq:	155	.Lwait4irq:
111	bas %r14,.Lirqwait	156	bras %r14,.Lirqwait
112	c %r1,__LC_SUBCHANNEL_ID # compare subchannel number	157	c %r1,__LC_SUBCHANNEL_ID # compare subchannel number
113	bne .Lwait4irq	158	jne .Lwait4irq
114	tsch 0(%r5)	159	tsch 0(%r5)
115		160	xgr %r0,%r0
116	slr %r0,%r0
117	ic %r0,8(%r5) # get device status	161	ic %r0,8(%r5) # get device status
118	chi %r0,8 # channel end ?	162	cghi %r0,8 # channel end ?
119	be .Lcont	163	je .Lcont
120	chi %r0,12 # channel end + device end ?	164	cghi %r0,12 # channel end + device end ?
121	be .Lcont	165	je .Lcont
122		166	llgf %r0,4(%r5)
123	l %r0,4(%r5)	167	sgf %r0,8(%r3) # r0/8 = number of ccws executed
124	s %r0,8(%r3) # r0/8 = number of ccws executed	168	mghi %r0,10 # *10 = number of bytes in ccws
125	mhi %r0,10 # *10 = number of bytes in ccws	169	llgh %r3,10(%r5) # get residual count
126	lh %r3,10(%r5) # get residual count	170	sgr %r0,%r3 # #ccws*80-residual=#bytes read
127	sr %r0,%r3 # #ccws*80-residual=#bytes read	171	agr %r2,%r0
128	ar %r2,%r0
129
130	br %r4 # r2 contains the total size	172	br %r4 # r2 contains the total size
131
132	.Lcont:	173	.Lcont:
133	ahi %r2,0x640 # add 0x640 to total size	174	aghi %r2,0x640 # add 0x640 to total size
134	la %r6,.Lccws	175	larl %r6,.Lccws
135	la %r7,20	176	lghi %r7,20
136	.Lincr:	177	.Lincr:
137	l %r0,4(%r6) # update CCW data addresses	178	l %r0,4(%r6) # update CCW data addresses
138	ahi %r0,0x640	179	aghi %r0,0x640
139	st %r0,4(%r6)	180	st %r0,4(%r6)
140	ahi %r6,8	181	aghi %r6,8
141	bct 7,.Lincr	182	brctg %r7,.Lincr
142		183	j .Lldlp
143	b .Lldlp
144	.Llderr:	184	.Llderr:
145	lpsw .Lcrash	185	larl %r13,.Lcrash
		186	lpsw 0(%r13)
146		187
		188	.align 8
		189	.Lwaitpsw:
		190	.quad 0x0202000180000000,.Lioint
		191	.Lnewpswmask:
		192	.quad 0x0000000180000000
147	.align 8	193	.align 8
148	.Lorb: .long 0x00000000,0x0080ff00,.Lccws	194	.Lorb: .long 0x00000000,0x0080ff00,.Lccws
149	.Lirb: .long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0	195	.Lirb: .long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
150	.Lcr6: .long 0xff000000	196	.align 8
151	.Lloadp:.long 0,0	197	.Lcr6: .quad 0x00000000ff000000
152	.align 8	198	.align 8
153	.Lcrash:.long 0x000a0000,0x00000000	199	.Lcrash:.long 0x000a0000,0x00000000
154
155	.align 8	200	.align 8
156	.Lccws: .rept 19	201	.Lccws: .rept 19
157	.long 0x02600050,0x00000000	202	.long 0x02600050,0x00000000
158	.endr	203	.endr
159	.long 0x02200050,0x00000000	204	.long 0x02200050,0x00000000
160
161	iplstart:
162	mvi __LC_AR_MODE_ID,1 # set esame flag
163	slr %r0,%r0 # set cpuid to zero
164	lhi %r1,2 # mode 2 = esame (dump)
165	sigp %r1,%r0,0x12 # switch to esame mode
166	bras %r13,0f
167	.fill 16,4,0x0
168	0: lmh %r0,%r15,0(%r13) # clear high-order half of gprs
169	sam31 # switch to 31 bit addressing mode
170	lh %r1,__LC_SUBCHANNEL_ID # test if subchannel number
171	bct %r1,.Lnoload # is valid
172	l %r1,__LC_SUBCHANNEL_ID # load ipl subchannel number
173	la %r2,IPL_BS # load start address
174	bas %r14,.Lloader # load rest of ipl image
175	l %r12,.Lparm # pointer to parameter area
176	st %r1,IPL_DEVICE+ARCH_OFFSET-PARMAREA(%r12) # save ipl device number
177
178	#
179	# load parameter file from ipl device
180	#
181	.Lagain1:
182	l %r2,.Linitrd # ramdisk loc. is temp
183	bas %r14,.Lloader # load parameter file
184	ltr %r2,%r2 # got anything ?
185	bz .Lnopf
186	l %r3,MAX_COMMAND_LINE_SIZE+ARCH_OFFSET-PARMAREA(%r12)
187	ahi %r3,-1
188	clr %r2,%r3
189	bl .Lnotrunc
190	lr %r2,%r3
191	.Lnotrunc:
192	l %r4,.Linitrd
193	clc 0(3,%r4),.L_hdr # if it is HDRx
194	bz .Lagain1 # skip dataset header
195	clc 0(3,%r4),.L_eof # if it is EOFx
196	bz .Lagain1 # skip dateset trailer
197
198	lr %r5,%r2
199	la %r6,COMMAND_LINE-PARMAREA(%r12)
200	lr %r7,%r2
201	ahi %r7,1
202	mvcl %r6,%r4
203	.Lnopf:
204
205	#
206	# load ramdisk from ipl device
207	#
208	.Lagain2:
209	l %r2,.Linitrd # addr of ramdisk
210	st %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
211	bas %r14,.Lloader # load ramdisk
212	st %r2,INITRD_SIZE+ARCH_OFFSET-PARMAREA(%r12) # store size of rd
213	ltr %r2,%r2
214	bnz .Lrdcont
215	st %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # no ramdisk found
216	.Lrdcont:
217	l %r2,.Linitrd
218
219	clc 0(3,%r2),.L_hdr # skip HDRx and EOFx
220	bz .Lagain2
221	clc 0(3,%r2),.L_eof
222	bz .Lagain2
223
224	#
225	# reset files in VM reader
226	#
227	stidp .Lcpuid # store cpuid
228	tm .Lcpuid,0xff # running VM ?
229	bno .Lnoreset
230	la %r2,.Lreset
231	lhi %r3,26
232	diag %r2,%r3,8
233	la %r5,.Lirb
234	stsch 0(%r5) # check if irq is pending
235	tm 30(%r5),0x0f # by verifying if any of the
236	bnz .Lwaitforirq # activity or status control
237	tm 31(%r5),0xff # bits is set in the schib
238	bz .Lnoreset
239	.Lwaitforirq:
240	bas %r14,.Lirqwait # wait for IO interrupt
241	c %r1,__LC_SUBCHANNEL_ID # compare subchannel number
242	bne .Lwaitforirq
243	la %r5,.Lirb
244	tsch 0(%r5)
245	.Lnoreset:
246	b .Lnoload
247
248	#
249	# everything loaded, go for it
250	#
251	.Lnoload:
252	l %r1,.Lstartup
253	br %r1
254
255	.Linitrd:.long _end # default address of initrd
256	.Lparm: .long PARMAREA
257	.Lstartup: .long startup
258	.Lreset:.byte 0xc3,0xc8,0xc1,0xd5,0xc7,0xc5,0x40,0xd9,0xc4,0xd9,0x40	205	.Lreset:.byte 0xc3,0xc8,0xc1,0xd5,0xc7,0xc5,0x40,0xd9,0xc4,0xd9,0x40
259	.byte 0xc1,0xd3,0xd3,0x40,0xd2,0xc5,0xc5,0xd7,0x40,0xd5,0xd6	206	.byte 0xc1,0xd3,0xd3,0x40,0xd2,0xc5,0xc5,0xd7,0x40,0xd5,0xd6
260	.byte 0xc8,0xd6,0xd3,0xc4 # "change rdr all keep nohold"	207	.byte 0xc8,0xd6,0xd3,0xc4 # "change rdr all keep nohold"
@@ -268,10 +215,10 @@ iplstart: · 7 unmodified lines
268	# this is called either by the ipl loader or directly by PSW restart	215	# this is called either by the ipl loader or directly by PSW restart
269	# or linload or SALIPL	216	# or linload or SALIPL
270	#	217	#
271	.org STARTUP_NORMAL_OFFSET	218	.org STARTUP_NORMAL_OFFSET - IPL_START
272	SYM_CODE_START(startup)	219	SYM_CODE_START(startup)
273	j startup_normal	220	j startup_normal
274	.org EP_OFFSET	221	.org EP_OFFSET - IPL_START
275	#	222	#
276	# This is a list of s390 kernel entry points. At address 0x1000f the number of	223	# This is a list of s390 kernel entry points. At address 0x1000f the number of
277	# valid entry points is stored.	224	# valid entry points is stored.
@@ -283,7 +230,7 @@ SYM_CODE_START(startup) · 5 unmodified lines
283	#	230	#
284	# kdump startup-code, running in 64 bit absolute addressing mode	231	# kdump startup-code, running in 64 bit absolute addressing mode
285	#	232	#
286	.org STARTUP_KDUMP_OFFSET	233	.org STARTUP_KDUMP_OFFSET - IPL_START
287	j startup_kdump	234	j startup_kdump
288	SYM_CODE_END(startup)	235	SYM_CODE_END(startup)
289	SYM_CODE_START_LOCAL(startup_normal)	236	SYM_CODE_START_LOCAL(startup_normal)
@@ -295,20 +242,23 @@ SYM_CODE_START_LOCAL(startup_normal) · 5 unmodified lines
295	.fill 16,4,0x0	242	.fill 16,4,0x0
296	0: lmh %r0,%r15,0(%r13) # clear high-order half of gprs	243	0: lmh %r0,%r15,0(%r13) # clear high-order half of gprs
297	sam64 # switch to 64 bit addressing mode	244	sam64 # switch to 64 bit addressing mode
298	basr %r13,0 # get base	245	larl %r13,.Lext_new_psw
299	.LPG0:	246	mvc __LC_EXT_NEW_PSW(16),0(%r13)
300	mvc __LC_EXT_NEW_PSW(16),.Lext_new_psw-.LPG0(%r13)	247	larl %r13,.Lpgm_new_psw
301	mvc __LC_PGM_NEW_PSW(16),.Lpgm_new_psw-.LPG0(%r13)	248	mvc __LC_PGM_NEW_PSW(16),0(%r13)
302	mvc __LC_IO_NEW_PSW(16),.Lio_new_psw-.LPG0(%r13)	249	larl %r13,.Lio_new_psw
		250	mvc __LC_IO_NEW_PSW(16),0(%r13)
303	xc 0x200(256),0x200 # partially clear lowcore	251	xc 0x200(256),0x200 # partially clear lowcore
304	xc 0x300(256),0x300	252	xc 0x300(256),0x300
305	xc 0xe00(256),0xe00	253	xc 0xe00(256),0xe00
306	xc 0xf00(256),0xf00	254	xc 0xf00(256),0xf00
307	lctlg %c0,%c15,.Lctl-.LPG0(%r13) # load control registers	255	larl %r13,.Lctl
		256	lctlg %c0,%c15,0(%r13) # load control registers
308	stcke __LC_BOOT_CLOCK	257	stcke __LC_BOOT_CLOCK
309	mvc __LC_LAST_UPDATE_CLOCK(8),__LC_BOOT_CLOCK+1	258	mvc __LC_LAST_UPDATE_CLOCK(8),__LC_BOOT_CLOCK+1
310	spt 6f-.LPG0(%r13)	259	larl %r13,6f
311	mvc __LC_LAST_UPDATE_TIMER(8),6f-.LPG0(%r13)	260	spt 0(%r13)
		261	mvc __LC_LAST_UPDATE_TIMER(8),0(%r13)
312	larl %r15,_stack_end-STACK_FRAME_OVERHEAD	262	larl %r15,_stack_end-STACK_FRAME_OVERHEAD
313	brasl %r14,sclp_early_setup_buffer	263	brasl %r14,sclp_early_setup_buffer
314	brasl %r14,verify_facilities	264	brasl %r14,verify_facilities
@@ -368,23 +318,3 @@ SYM_CODE_START_LOCAL(startup_pgm_check_handler) · 53 unmodified lines
368	lmg %r0,%r15,__LC_GPREGS_SAVE_AREA-4095(%r8)	318	lmg %r0,%r15,__LC_GPREGS_SAVE_AREA-4095(%r8)
369	lpswe __LC_RETURN_PSW # disabled wait	319	lpswe __LC_RETURN_PSW # disabled wait
370	SYM_CODE_END(startup_pgm_check_handler)	320	SYM_CODE_END(startup_pgm_check_handler)
371
372	#
373	# params at 10400 (setup.h)
374	# Must be keept in sync with struct parmarea in setup.h
375	#
376	.org PARMAREA
377	SYM_DATA_START(parmarea)
378	.quad 0 # IPL_DEVICE
379	.quad 0 # INITRD_START
380	.quad 0 # INITRD_SIZE
381	.quad 0 # OLDMEM_BASE
382	.quad 0 # OLDMEM_SIZE
383	.quad kernel_version # points to kernel version string
384	.quad COMMAND_LINE_SIZE
385
386	.org COMMAND_LINE
387	.byte "root=/dev/ram0 ro"
388	.byte 0
389	.org PARMAREA+__PARMAREA_SIZE
390	SYM_DATA_END(parmarea)

arch/s390/boot/ipl_data.c+84−0

@@ -0,0 +1,84 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2
	3	#include <linux/compat.h>
	4	#include <linux/ptrace.h>
	5	#include <asm/cio.h>
	6	#include <asm/asm-offsets.h>
	7	#include "boot.h"
	8
	9	#define CCW0(cmd, addr, cnt, flg) \
	10	{ .cmd_code = cmd, .cda = addr, .count = cnt, .flags = flg, }
	11
	12	#define PSW_MASK_DISABLED (PSW_MASK_WAIT \| PSW_MASK_EA \| PSW_MASK_BA)
	13
	14	struct ipl_lowcore {
	15	psw_t32 ipl_psw; /* 0x0000 */
	16	struct ccw0 ccwpgm[2]; /* 0x0008 */
	17	u8 fill[56]; /* 0x0018 */
	18	struct ccw0 ccwpgmcc[20]; /* 0x0050 */
	19	u8 pad_0xf0[0x01a0-0x00f0]; /* 0x00f0 */
	20	psw_t restart_psw; /* 0x01a0 */
	21	psw_t external_new_psw; /* 0x01b0 */
	22	psw_t svc_new_psw; /* 0x01c0 */
	23	psw_t program_new_psw; /* 0x01d0 */
	24	psw_t mcck_new_psw; /* 0x01e0 */
	25	psw_t io_new_psw; /* 0x01f0 */
	26	};
	27
	28	/*
	29	* Initial lowcore for IPL: the first 24 bytes are loaded by IPL to
	30	* addresses 0-23 (a PSW and two CCWs). Bytes 24-79 are discarded.
	31	* The next 160 bytes are loaded to addresses 0x18-0xb7. They form
	32	* the continuation of the CCW program started by IPL and load the
	33	* range 0x0f0-0x730 from the image to the range 0x0f0-0x730 in
	34	* memory. At the end of the channel program the PSW at location 0 is
	35	* loaded.
	36	* Initial processing starts at 0x200 = iplstart.
	37	*
	38	* The restart psw points to iplstart which allows to load a kernel
	39	* image into memory and starting it by a psw restart on any cpu. All
	40	* other default psw new locations contain a disabled wait psw where
	41	* the address indicates which psw was loaded.
	42	*
	43	* Note that the 'file' utility can detect s390 kernel images. For
	44	* that to succeed the two initial CCWs, and the 0x40 fill bytes must
	45	* be present.
	46	*/
	47	static struct ipl_lowcore ipl_lowcore __used __section(".ipldata") = {
	48	.ipl_psw = { .mask = PSW32_MASK_BASE, .addr = PSW32_ADDR_AMODE \| IPL_START },
	49	.ccwpgm = {
	50	[ 0] = CCW0(CCW_CMD_READ_IPL, 0x018, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	51	[ 1] = CCW0(CCW_CMD_READ_IPL, 0x068, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	52	},
	53	.fill = {
	54	[ 0 ... 55] = 0x40,
	55	},
	56	.ccwpgmcc = {
	57	[ 0] = CCW0(CCW_CMD_READ_IPL, 0x0f0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	58	[ 1] = CCW0(CCW_CMD_READ_IPL, 0x140, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	59	[ 2] = CCW0(CCW_CMD_READ_IPL, 0x190, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	60	[ 3] = CCW0(CCW_CMD_READ_IPL, 0x1e0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	61	[ 4] = CCW0(CCW_CMD_READ_IPL, 0x230, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	62	[ 5] = CCW0(CCW_CMD_READ_IPL, 0x280, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	63	[ 6] = CCW0(CCW_CMD_READ_IPL, 0x2d0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	64	[ 7] = CCW0(CCW_CMD_READ_IPL, 0x320, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	65	[ 8] = CCW0(CCW_CMD_READ_IPL, 0x370, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	66	[ 9] = CCW0(CCW_CMD_READ_IPL, 0x3c0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	67	[10] = CCW0(CCW_CMD_READ_IPL, 0x410, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	68	[11] = CCW0(CCW_CMD_READ_IPL, 0x460, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	69	[12] = CCW0(CCW_CMD_READ_IPL, 0x4b0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	70	[13] = CCW0(CCW_CMD_READ_IPL, 0x500, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	71	[14] = CCW0(CCW_CMD_READ_IPL, 0x550, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	72	[15] = CCW0(CCW_CMD_READ_IPL, 0x5a0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	73	[16] = CCW0(CCW_CMD_READ_IPL, 0x5f0, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	74	[17] = CCW0(CCW_CMD_READ_IPL, 0x640, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	75	[18] = CCW0(CCW_CMD_READ_IPL, 0x690, 0x50, CCW_FLAG_SLI \| CCW_FLAG_CC),
	76	[19] = CCW0(CCW_CMD_READ_IPL, 0x6e0, 0x50, CCW_FLAG_SLI),
	77	},
	78	.restart_psw = { .mask = 0, .addr = IPL_START, },
	79	.external_new_psw = { .mask = PSW_MASK_DISABLED, .addr = __LC_EXT_NEW_PSW, },
	80	.svc_new_psw = { .mask = PSW_MASK_DISABLED, .addr = __LC_SVC_NEW_PSW, },
	81	.program_new_psw = { .mask = PSW_MASK_DISABLED, .addr = __LC_PGM_NEW_PSW, },
	82	.mcck_new_psw = { .mask = PSW_MASK_DISABLED, .addr = __LC_MCK_NEW_PSW, },
	83	.io_new_psw = { .mask = PSW_MASK_DISABLED, .addr = __LC_IO_NEW_PSW, },
	84	};

arch/s390/boot/ipl_parm.c+7−0

 #include <asm/sections.h>
 #include <asm/boot_data.h>
 #include <asm/facility.h>
+#include <asm/setup.h>
 #include <asm/uv.h>
 #include "boot.h"
+struct parmarea parmarea __section(".parmarea") = {
+	.kernel_version		= (unsigned long)kernel_version,
+	.max_command_line_size	= COMMAND_LINE_SIZE,
+	.command_line		= "root=/dev/ram0 ro",
+};
 char __bootdata(early_command_line)[COMMAND_LINE_SIZE];
 int __bootdata(noexec_disabled);

arch/s390/boot/kaslr.c+1−1

@@ -8,7 +8,7 @@ · 7 unmodified lines
8	#include <asm/timex.h>	8	#include <asm/timex.h>
9	#include <asm/sclp.h>	9	#include <asm/sclp.h>
10	#include <asm/kasan.h>	10	#include <asm/kasan.h>
11	#include "compressed/decompressor.h"	11	#include "decompressor.h"
12	#include "boot.h"	12	#include "boot.h"
13		13
14	#define PRNG_MODE_TDES 1	14	#define PRNG_MODE_TDES 1

arch/s390/boot/mem_detect.c+1−1

@@ -7,7 +7,7 @@ · 6 unmodified lines
7	#include <asm/sections.h>	7	#include <asm/sections.h>
8	#include <asm/mem_detect.h>	8	#include <asm/mem_detect.h>
9	#include <asm/sparsemem.h>	9	#include <asm/sparsemem.h>
10	#include "compressed/decompressor.h"	10	#include "decompressor.h"
11	#include "boot.h"	11	#include "boot.h"
12		12
13	struct mem_detect_info __bootdata(mem_detect);	13	struct mem_detect_info __bootdata(mem_detect);

arch/s390/boot/startup.c+1−1

@@ -10,7 +10,7 @@ · 9 unmodified lines
10	#include <asm/sclp.h>	10	#include <asm/sclp.h>
11	#include <asm/diag.h>	11	#include <asm/diag.h>
12	#include <asm/uv.h>	12	#include <asm/uv.h>
13	#include "compressed/decompressor.h"	13	#include "decompressor.h"
14	#include "boot.h"	14	#include "boot.h"
15	#include "uv.h"	15	#include "uv.h"
16		16

arch/s390/boot/vmlinux.lds.Srenamed from arch/s390/boot/compressed/vmlinux.lds.S+9−0

 #include <asm/thread_info.h>
 #include <asm/page.h>
 #include <asm/sclp.h>
+#include "boot.h"
 OUTPUT_FORMAT("elf64-s390", "elf64-s390", "elf64-s390")
 OUTPUT_ARCH(s390:64-bit)
 SECTIONS
 {
 	. = 0;
+	.ipldata : {
+		*(.ipldata)
+	}
+	. = IPL_START;
 	.head.text : {
 		_head = . ;
 		HEAD_TEXT
 		_ehead = . ;
 	}
+	. = PARMAREA;
+	.parmarea : {
+		*(.parmarea)
+	}
 	.text :	{
 		_text = .;	/* Text */
 		*(.text)

arch/s390/crypto/des_s390.c+1−1

@@ -194,7 +194,7 @@ static struct skcipher_alg cbc_des_alg = { · 193 unmodified lines
194	* same as DES. Implementers MUST reject keys that exhibit this	194	* same as DES. Implementers MUST reject keys that exhibit this
195	* property.	195	* property.
196	*	196	*
197	* In fips mode additinally check for all 3 keys are unique.	197	* In fips mode additionally check for all 3 keys are unique.
198	*	198	*
199	*/	199	*/
200	static int des3_setkey(struct crypto_tfm tfm, const u8 key,	200	static int des3_setkey(struct crypto_tfm tfm, const u8 key,

arch/s390/crypto/prng.c+1−1

@@ -528,7 +528,7 @@ static ssize_t prng_tdes_read(struct file file, char __user ubuf, · 527 unmodified lines
528	/* give mutex free before calling schedule() */	528	/* give mutex free before calling schedule() */
529	mutex_unlock(&prng_data->mutex);	529	mutex_unlock(&prng_data->mutex);
530	schedule();	530	schedule();
531	/* occopy mutex again */	531	/* occupy mutex again */
532	if (mutex_lock_interruptible(&prng_data->mutex)) {	532	if (mutex_lock_interruptible(&prng_data->mutex)) {
533	if (ret == 0)	533	if (ret == 0)
534	ret = -ERESTARTSYS;	534	ret = -ERESTARTSYS;

arch/s390/hypfs/hypfs_vm.c+1−1

@@ -190,7 +190,7 @@ int hypfs_vm_create_files(struct dentry *root) · 189 unmodified lines
190	if (IS_ERR(data))	190	if (IS_ERR(data))
191	return PTR_ERR(data);	191	return PTR_ERR(data);
192		192
193	/* Hpervisor Info */	193	/* Hypervisor Info */
194	dir = hypfs_mkdir(root, "hyp");	194	dir = hypfs_mkdir(root, "hyp");
195	if (IS_ERR(dir)) {	195	if (IS_ERR(dir)) {
196	rc = PTR_ERR(dir);	196	rc = PTR_ERR(dir);

arch/s390/include/asm/alternative-asm.h+9−67

@@ -4,19 +4,6 @@ · 3 unmodified lines
4		4
5	#ifdef __ASSEMBLY__	5	#ifdef __ASSEMBLY__
6		6
7	/*
8	* Check the length of an instruction sequence. The length may not be larger
9	* than 254 bytes and it has to be divisible by 2.
10	*/
11	.macro alt_len_check start,end
12	.if ( \end - \start ) > 254
13	.error "cpu alternatives does not support instructions blocks > 254 bytes\n"
14	.endif
15	.if ( \end - \start ) % 2
16	.error "cpu alternatives instructions length is odd\n"
17	.endif
18	.endm
19
20	/*	7	/*
21	* Issue one struct alt_instr descriptor entry (need to put it into	8	* Issue one struct alt_instr descriptor entry (need to put it into
22	* the section .altinstructions, see below). This entry contains	9	* the section .altinstructions, see below). This entry contains
@@ -28,66 +15,29 @@ · 5 unmodified lines
28	.long \alt_start - .	15	.long \alt_start - .
29	.word \feature	16	.word \feature
30	.byte \orig_end - \orig_start	17	.byte \orig_end - \orig_start
31	.byte \alt_end - \alt_start	18	.org . - ( \orig_end - \orig_start ) + ( \alt_end - \alt_start )
32	.endm	19	.org . - ( \alt_end - \alt_start ) + ( \orig_end - \orig_start )
33
34	/*
35	* Fill up @bytes with nops. The macro emits 6-byte nop instructions
36	* for the bulk of the area, possibly followed by a 4-byte and/or
37	* a 2-byte nop if the size of the area is not divisible by 6.
38	*/
39	.macro alt_pad_fill bytes
40	.rept ( \bytes ) / 6
41	brcl 0,0
42	.endr
43	.rept ( \bytes ) % 6 / 4
44	nop
45	.endr
46	.rept ( \bytes ) % 6 % 4 / 2
47	nopr
48	.endr
49	.endm
50
51	/*
52	* Fill up @bytes with nops. If the number of bytes is larger
53	* than 6, emit a jg instruction to branch over all nops, then
54	* fill an area of size (@bytes - 6) with nop instructions.
55	*/
56	.macro alt_pad bytes
57	.if ( \bytes > 0 )
58	.if ( \bytes > 6 )
59	jg . + \bytes
60	alt_pad_fill \bytes - 6
61	.else
62	alt_pad_fill \bytes
63	.endif
64	.endif
65	.endm	20	.endm
66		21
67	/*	22	/*
68	* Define an alternative between two instructions. If @feature is	23	* Define an alternative between two instructions. If @feature is
69	* present, early code in apply_alternatives() replaces @oldinstr with	24	* present, early code in apply_alternatives() replaces @oldinstr with
70	* @newinstr. ".skip" directive takes care of proper instruction padding	25	* @newinstr.
71	* in case @newinstr is longer than @oldinstr.
72	*/	26	*/
73	.macro ALTERNATIVE oldinstr, newinstr, feature	27	.macro ALTERNATIVE oldinstr, newinstr, feature
74	.pushsection .altinstr_replacement,"ax"	28	.pushsection .altinstr_replacement,"ax"
75	770: \newinstr	29	770: \newinstr
76	771: .popsection	30	771: .popsection
77	772: \oldinstr	31	772: \oldinstr
78	773: alt_len_check 770b, 771b	32	773: .pushsection .altinstructions,"a"
79	alt_len_check 772b, 773b	33	alt_entry 772b, 773b, 770b, 771b, \feature
80	alt_pad ( ( 771b - 770b ) - ( 773b - 772b ) )
81	774: .pushsection .altinstructions,"a"
82	alt_entry 772b, 774b, 770b, 771b, \feature
83	.popsection	34	.popsection
84	.endm	35	.endm
85		36
86	/*	37	/*
87	* Define an alternative between two instructions. If @feature is	38	* Define an alternative between two instructions. If @feature is
88	* present, early code in apply_alternatives() replaces @oldinstr with	39	* present, early code in apply_alternatives() replaces @oldinstr with
89	* @newinstr. ".skip" directive takes care of proper instruction padding	40	* @newinstr.
90	* in case @newinstr is longer than @oldinstr.
91	*/	41	*/
92	.macro ALTERNATIVE_2 oldinstr, newinstr1, feature1, newinstr2, feature2	42	.macro ALTERNATIVE_2 oldinstr, newinstr1, feature1, newinstr2, feature2
93	.pushsection .altinstr_replacement,"ax"	43	.pushsection .altinstr_replacement,"ax"
@@ -95,17 +45,9 @@ · 1 unmodified line
95	771: \newinstr2	45	771: \newinstr2
96	772: .popsection	46	772: .popsection
97	773: \oldinstr	47	773: \oldinstr
98	774: alt_len_check 770b, 771b	48	774: .pushsection .altinstructions,"a"
99	alt_len_check 771b, 772b	49	alt_entry 773b, 774b, 770b, 771b,\feature1
100	alt_len_check 773b, 774b	50	alt_entry 773b, 774b, 771b, 772b,\feature2
101	.if ( 771b - 770b > 772b - 771b )
102	alt_pad ( ( 771b - 770b ) - ( 774b - 773b ) )
103	.else
104	alt_pad ( ( 772b - 771b ) - ( 774b - 773b ) )
105	.endif
106	775: .pushsection .altinstructions,"a"
107	alt_entry 773b, 775b, 770b, 771b,\feature1
108	alt_entry 773b, 775b, 771b, 772b,\feature2
109	.popsection	51	.popsection
110	.endm	52	.endm
111		53

arch/s390/include/asm/alternative.h+20−73

@@ -13,32 +13,25 @@ struct alt_instr { · 12 unmodified lines
13	s32 repl_offset; /* offset to replacement instruction */	13	s32 repl_offset; /* offset to replacement instruction */
14	u16 facility; /* facility bit set for replacement */	14	u16 facility; /* facility bit set for replacement */
15	u8 instrlen; /* length of original instruction */	15	u8 instrlen; /* length of original instruction */
16	u8 replacementlen; /* length of new instruction */
17	} __packed;	16	} __packed;
18		17
19	void apply_alternative_instructions(void);	18	void apply_alternative_instructions(void);
20	void apply_alternatives(struct alt_instr start, struct alt_instr end);	19	void apply_alternatives(struct alt_instr start, struct alt_instr end);
21		20
22	/*	21	/*
23	* \|661: \|662: \|6620 \|663:	22	* +---------------------------------+
24	* +-----------+---------------------+	23	* \|661: \|662:
25	* \| oldinstr \| oldinstr_padding \|	24	* \| oldinstr \|
26	* \| +----------+----------+	25	* +---------------------------------+
27	* \| \| \| \|
28	* \| \| >6 bytes \|6/4/2 nops\|
29	* \| \|6 bytes jg----------->
30	* +-----------+---------------------+
31	* ^^ static padding ^^
32	*	26	*
33	* .altinstr_replacement section	27	* .altinstr_replacement section
34	* +---------------------+-----------+	28	* +---------------------------------+
35	* \|6641: \|6651:	29	* \|6641: \|6651:
36	* \| alternative instr 1 \|	30	* \| alternative instr 1 \|
37	* +-----------+---------+- - - - - -+	31	* +---------------------------------+
38	* \|6642: \|6652: \|	32	* \|6642: \|6652:
39	* \| alternative instr 2 \| padding	33	* \| alternative instr 2 \|
40	* +---------------------+- - - - - -+	34	* +---------------------------------+
41	* ^ runtime ^
42	*	35	*
43	* .altinstructions section	36	* .altinstructions section
44	* +---------------------------------+	37	* +---------------------------------+
@@ -47,77 +40,31 @@ void apply_alternatives(struct alt_instr start, struct alt_instr end); · 2 unmodified lines
47	* +---------------------------------+	40	* +---------------------------------+
48	*/	41	*/
49		42
50	#define b_altinstr(num) "664"#num	43	#define b_altinstr(num) "664"#num
51	#define e_altinstr(num) "665"#num	44	#define e_altinstr(num) "665"#num
52
53	#define e_oldinstr_pad_end "663"
54	#define oldinstr_len "662b-661b"	45	#define oldinstr_len "662b-661b"
55	#define oldinstr_total_len e_oldinstr_pad_end"b-661b"
56	#define altinstr_len(num) e_altinstr(num)"b-"b_altinstr(num)"b"	46	#define altinstr_len(num) e_altinstr(num)"b-"b_altinstr(num)"b"
57	#define oldinstr_pad_len(num) \	47
58	"-(((" altinstr_len(num) ")-(" oldinstr_len ")) > 0) * " \	48	#define OLDINSTR(oldinstr) \
59	"((" altinstr_len(num) ")-(" oldinstr_len "))"	49	"661:\n\t" oldinstr "\n662:\n"
60
61	#define INSTR_LEN_SANITY_CHECK(len) \
62	".if " len " > 254\n" \
63	"\t.error \"cpu alternatives does not support instructions " \
64	"blocks > 254 bytes\"\n" \
65	".endif\n" \
66	".if (" len ") %% 2\n" \
67	"\t.error \"cpu alternatives instructions length is odd\"\n" \
68	".endif\n"
69
70	#define OLDINSTR_PADDING(oldinstr, num) \
71	".if " oldinstr_pad_len(num) " > 6\n" \
72	"\tjg " e_oldinstr_pad_end "f\n" \
73	"6620:\n" \
74	"\t.rept (" oldinstr_pad_len(num) " - (6620b-662b)) / 2\n" \
75	"\tnopr\n" \
76	".else\n" \
77	"\t.rept " oldinstr_pad_len(num) " / 6\n" \
78	"\t.brcl 0,0\n" \
79	"\t.endr\n" \
80	"\t.rept " oldinstr_pad_len(num) " %% 6 / 4\n" \
81	"\tnop\n" \
82	"\t.endr\n" \
83	"\t.rept " oldinstr_pad_len(num) " %% 6 %% 4 / 2\n" \
84	"\tnopr\n" \
85	".endr\n" \
86	".endif\n"
87
88	#define OLDINSTR(oldinstr, num) \
89	"661:\n\t" oldinstr "\n662:\n" \
90	OLDINSTR_PADDING(oldinstr, num) \
91	e_oldinstr_pad_end ":\n" \
92	INSTR_LEN_SANITY_CHECK(oldinstr_len)
93
94	#define OLDINSTR_2(oldinstr, num1, num2) \
95	"661:\n\t" oldinstr "\n662:\n" \
96	".if " altinstr_len(num1) " < " altinstr_len(num2) "\n" \
97	OLDINSTR_PADDING(oldinstr, num2) \
98	".else\n" \
99	OLDINSTR_PADDING(oldinstr, num1) \
100	".endif\n" \
101	e_oldinstr_pad_end ":\n" \
102	INSTR_LEN_SANITY_CHECK(oldinstr_len)
103		50
104	#define ALTINSTR_ENTRY(facility, num) \	51	#define ALTINSTR_ENTRY(facility, num) \
105	"\t.long 661b - .\n" /* old instruction */ \	52	"\t.long 661b - .\n" /* old instruction */ \
106	"\t.long " b_altinstr(num)"b - .\n" /* alt instruction */ \	53	"\t.long " b_altinstr(num)"b - .\n" /* alt instruction */ \
107	"\t.word " __stringify(facility) "\n" /* facility bit */ \	54	"\t.word " __stringify(facility) "\n" /* facility bit */ \
108	"\t.byte " oldinstr_total_len "\n" /* source len */ \	55	"\t.byte " oldinstr_len "\n" /* instruction len */ \
109	"\t.byte " altinstr_len(num) "\n" /* alt instruction len */	56	"\t.org . - (" oldinstr_len ") + (" altinstr_len(num) ")\n" \
		57	"\t.org . - (" altinstr_len(num) ") + (" oldinstr_len ")\n"
110		58
111	#define ALTINSTR_REPLACEMENT(altinstr, num) /* replacement */ \	59	#define ALTINSTR_REPLACEMENT(altinstr, num) /* replacement */ \
112	b_altinstr(num)":\n\t" altinstr "\n" e_altinstr(num) ":\n" \	60	b_altinstr(num)":\n\t" altinstr "\n" e_altinstr(num) ":\n"
113	INSTR_LEN_SANITY_CHECK(altinstr_len(num))
114		61
115	/* alternative assembly primitive: */	62	/* alternative assembly primitive: */
116	#define ALTERNATIVE(oldinstr, altinstr, facility) \	63	#define ALTERNATIVE(oldinstr, altinstr, facility) \
117	".pushsection .altinstr_replacement, \"ax\"\n" \	64	".pushsection .altinstr_replacement, \"ax\"\n" \
118	ALTINSTR_REPLACEMENT(altinstr, 1) \	65	ALTINSTR_REPLACEMENT(altinstr, 1) \
119	".popsection\n" \	66	".popsection\n" \
120	OLDINSTR(oldinstr, 1) \	67	OLDINSTR(oldinstr) \
121	".pushsection .altinstructions,\"a\"\n" \	68	".pushsection .altinstructions,\"a\"\n" \
122	ALTINSTR_ENTRY(facility, 1) \	69	ALTINSTR_ENTRY(facility, 1) \
123	".popsection\n"	70	".popsection\n"
@@ -127,7 +74,7 @@ void apply_alternatives(struct alt_instr start, struct alt_instr end); · 3 unmodified lines
127	ALTINSTR_REPLACEMENT(altinstr1, 1) \	74	ALTINSTR_REPLACEMENT(altinstr1, 1) \
128	ALTINSTR_REPLACEMENT(altinstr2, 2) \	75	ALTINSTR_REPLACEMENT(altinstr2, 2) \
129	".popsection\n" \	76	".popsection\n" \
130	OLDINSTR_2(oldinstr, 1, 2) \	77	OLDINSTR(oldinstr) \
131	".pushsection .altinstructions,\"a\"\n" \	78	".pushsection .altinstructions,\"a\"\n" \
132	ALTINSTR_ENTRY(facility1, 1) \	79	ALTINSTR_ENTRY(facility1, 1) \
133	ALTINSTR_ENTRY(facility2, 2) \	80	ALTINSTR_ENTRY(facility2, 2) \

arch/s390/include/asm/asm-extable.h+6−6

@@ -26,16 +26,16 @@ · 25 unmodified lines
26	stringify_in_c(.long (_target) - .;) \	26	stringify_in_c(.long (_target) - .;) \
27	stringify_in_c(.short (_type);) \	27	stringify_in_c(.short (_type);) \
28	stringify_in_c(.macro extable_reg reg;) \	28	stringify_in_c(.macro extable_reg reg;) \
29	stringify_in_c(.set found, 0;) \	29	stringify_in_c(.set .Lfound, 0;) \
30	stringify_in_c(.set regnr, 0;) \	30	stringify_in_c(.set .Lregnr, 0;) \
31	stringify_in_c(.irp rs,r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15;) \	31	stringify_in_c(.irp rs,r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15;) \
32	stringify_in_c(.ifc "\reg", "%%\rs";) \	32	stringify_in_c(.ifc "\reg", "%%\rs";) \
33	stringify_in_c(.set found, 1;) \	33	stringify_in_c(.set .Lfound, 1;) \
34	stringify_in_c(.short regnr;) \	34	stringify_in_c(.short .Lregnr;) \
35	stringify_in_c(.endif;) \	35	stringify_in_c(.endif;) \
36	stringify_in_c(.set regnr, regnr+1;) \	36	stringify_in_c(.set .Lregnr, .Lregnr+1;) \
37	stringify_in_c(.endr;) \	37	stringify_in_c(.endr;) \
38	stringify_in_c(.ifne (found != 1);) \	38	stringify_in_c(.ifne (.Lfound != 1);) \
39	stringify_in_c(.error "extable_reg: bad register argument";) \	39	stringify_in_c(.error "extable_reg: bad register argument";) \
40	stringify_in_c(.endif;) \	40	stringify_in_c(.endif;) \
41	stringify_in_c(.endm;) \	41	stringify_in_c(.endm;) \

arch/s390/include/asm/barrier.h+8−8

@@ -26,14 +26,14 @@ static __always_inline void bcr_serialize(void) · 25 unmodified lines
26	asm volatile(__ASM_BCR_SERIALIZE : : : "memory");	26	asm volatile(__ASM_BCR_SERIALIZE : : : "memory");
27	}	27	}
28		28
29	#define mb() bcr_serialize()	29	#define __mb() bcr_serialize()
30	#define rmb() barrier()	30	#define __rmb() barrier()
31	#define wmb() barrier()	31	#define __wmb() barrier()
32	#define dma_rmb() mb()	32	#define __dma_rmb() __mb()
33	#define dma_wmb() mb()	33	#define __dma_wmb() __mb()
34	#define __smp_mb() mb()	34	#define __smp_mb() __mb()
35	#define __smp_rmb() rmb()	35	#define __smp_rmb() __rmb()
36	#define __smp_wmb() wmb()	36	#define __smp_wmb() __wmb()
37		37
38	#define __smp_store_release(p, v) \	38	#define __smp_store_release(p, v) \
39	do { \	39	do { \

arch/s390/include/asm/cio.h+1−1

@@ -369,7 +369,7 @@ void cio_gp_dma_destroy(struct gen_pool gp_dma, struct device dma_dev); · 368 unmodified lines
369	struct gen_pool cio_gp_dma_create(struct device dma_dev, int nr_pages);	369	struct gen_pool cio_gp_dma_create(struct device dma_dev, int nr_pages);
370		370
371	/* Function from drivers/s390/cio/chsc.c */	371	/* Function from drivers/s390/cio/chsc.c */
372	int chsc_sstpc(void page, unsigned int op, u16 ctrl, u64 clock_delta);	372	int chsc_sstpc(void page, unsigned int op, u16 ctrl, long clock_delta);
373	int chsc_sstpi(void page, void result, size_t size);	373	int chsc_sstpi(void page, void result, size_t size);
374	int chsc_stzi(void page, void result, size_t size);	374	int chsc_stzi(void page, void result, size_t size);
375	int chsc_sgib(u32 origin);	375	int chsc_sgib(u32 origin);

arch/s390/include/asm/compat.h+1−24

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#include <linux/sched.h>	8	#include <linux/sched.h>
9	#include <linux/sched/task_stack.h>	9	#include <linux/sched/task_stack.h>
10	#include <linux/thread_info.h>	10	#include <linux/thread_info.h>
		11	#include <asm/ptrace.h>
11		12
12	#define compat_mode_t compat_mode_t	13	#define compat_mode_t compat_mode_t
13	typedef u16 compat_mode_t;	14	typedef u16 compat_mode_t;
@@ -22,32 +23,8 @@ typedef u16 compat_mode_t; · 8 unmodified lines
22	(__force t)(__TYPE_IS_PTR(t) ? ((v) & 0x7fffffff) : (v)); \	23	(__force t)(__TYPE_IS_PTR(t) ? ((v) & 0x7fffffff) : (v)); \
23	})	24	})
24		25
25	#define PSW32_MASK_PER 0x40000000UL
26	#define PSW32_MASK_DAT 0x04000000UL
27	#define PSW32_MASK_IO 0x02000000UL
28	#define PSW32_MASK_EXT 0x01000000UL
29	#define PSW32_MASK_KEY 0x00F00000UL
30	#define PSW32_MASK_BASE 0x00080000UL /* Always one */
31	#define PSW32_MASK_MCHECK 0x00040000UL
32	#define PSW32_MASK_WAIT 0x00020000UL
33	#define PSW32_MASK_PSTATE 0x00010000UL
34	#define PSW32_MASK_ASC 0x0000C000UL
35	#define PSW32_MASK_CC 0x00003000UL
36	#define PSW32_MASK_PM 0x00000f00UL
37	#define PSW32_MASK_RI 0x00000080UL
38
39	#define PSW32_MASK_USER 0x0000FF00UL	26	#define PSW32_MASK_USER 0x0000FF00UL
40		27
41	#define PSW32_ADDR_AMODE 0x80000000UL
42	#define PSW32_ADDR_INSN 0x7FFFFFFFUL
43
44	#define PSW32_DEFAULT_KEY (((u32) PAGE_DEFAULT_ACC) << 20)
45
46	#define PSW32_ASC_PRIMARY 0x00000000UL
47	#define PSW32_ASC_ACCREG 0x00004000UL
48	#define PSW32_ASC_SECONDARY 0x00008000UL
49	#define PSW32_ASC_HOME 0x0000C000UL
50
51	#define PSW32_USER_BITS (PSW32_MASK_DAT \| PSW32_MASK_IO \| PSW32_MASK_EXT \| \	28	#define PSW32_USER_BITS (PSW32_MASK_DAT \| PSW32_MASK_IO \| PSW32_MASK_EXT \| \
52	PSW32_DEFAULT_KEY \| PSW32_MASK_BASE \| \	29	PSW32_DEFAULT_KEY \| PSW32_MASK_BASE \| \
53	PSW32_MASK_MCHECK \| PSW32_MASK_PSTATE \| \	30	PSW32_MASK_MCHECK \| PSW32_MASK_PSTATE \| \

arch/s390/include/asm/ctl_reg.h+3−1

 		unsigned long tcx  : 1;	/* Transactional-Execution control */
 		unsigned long pifo : 1;	/* Transactional-Execution Program-
 					   Interruption-Filtering Override */
-		unsigned long	   : 22;
+		unsigned long	   : 3;
+		unsigned long ccc  : 1; /* Cryptography counter control */
+		unsigned long	   : 18;
 		unsigned long	   : 3;
 		unsigned long lap  : 1; /* Low-address-protection control */
 		unsigned long	   : 4;

arch/s390/include/asm/entry-common.h+9−5

 #include <linux/uaccess.h>
 #include <asm/timex.h>
 #include <asm/fpu/api.h>
+#include <asm/pai.h>
 #define ARCH_EXIT_TO_USER_MODE_WORK (_TIF_GUARDED_STORAGE | _TIF_PER_TRAP)
 void do_per_trap(struct pt_regs *regs);
-#ifdef CONFIG_DEBUG_ENTRY
+static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs)
-static __always_inline void arch_check_user_regs(struct pt_regs *regs)
 {
-	debug_user_asce(0);
+	if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
+		debug_user_asce(0);
+	pai_kernel_enter(regs);
 }
-#define arch_check_user_regs arch_check_user_regs
+#define arch_enter_from_user_mode arch_enter_from_user_mode
-#endif /* CONFIG_DEBUG_ENTRY */
 static __always_inline void arch_exit_to_user_mode_work(struct pt_regs *regs,
 							unsigned long ti_work)
 	if (IS_ENABLED(CONFIG_DEBUG_ENTRY))
 		debug_user_asce(1);
+	pai_kernel_exit(current_pt_regs());
 }
 #define arch_exit_to_user_mode arch_exit_to_user_mode

arch/s390/include/asm/ipl.h+6−0

  * DIAG 308 support
  */
 enum diag308_subcode  {
+	DIAG308_CLEAR_RESET = 0,
+	DIAG308_LOAD_NORMAL_RESET = 1,
 	DIAG308_REL_HSA = 2,
 	DIAG308_LOAD_CLEAR = 3,
 	DIAG308_LOAD_NORMAL_DUMP = 4,
 	DIAG308_LOAD_NORMAL = 7,
 };
+enum diag308_subcode_flags {
+	DIAG308_FLAG_EI = 1UL << 16,
+};
 enum diag308_rc {
 	DIAG308_RC_OK		= 0x0001,
 	DIAG308_RC_NOCONFIG	= 0x0102,

arch/s390/include/asm/lowcore.h+4−1

 	__u64	last_break_save_area;		/* 0x1338 */
 	__u32	access_regs_save_area[16];	/* 0x1340 */
 	__u64	cregs_save_area[16];		/* 0x1380 */
-	__u8	pad_0x1400[0x1800-0x1400];	/* 0x1400 */
+	__u8	pad_0x1400[0x1500-0x1400];	/* 0x1400 */
+	/* Cryptography-counter designation */
+	__u64	ccd;				/* 0x1500 */
+	__u8	pad_0x1508[0x1800-0x1508];	/* 0x1508 */
 	/* Transaction abort diagnostic block */
 	struct pgm_tdb pgm_tdb;			/* 0x1800 */

arch/s390/include/asm/nmi.h+1−1

@@ -101,7 +101,7 @@ void nmi_alloc_mcesa_early(u64 *mcesad); · 100 unmodified lines
101	int nmi_alloc_mcesa(u64 *mcesad);	101	int nmi_alloc_mcesa(u64 *mcesad);
102	void nmi_free_mcesa(u64 *mcesad);	102	void nmi_free_mcesa(u64 *mcesad);
103		103
104	void s390_handle_mcck(void);	104	void s390_handle_mcck(struct pt_regs *regs);
105	void __s390_handle_mcck(void);	105	void __s390_handle_mcck(void);
106	int s390_do_machine_check(struct pt_regs *regs);	106	int s390_do_machine_check(struct pt_regs *regs);
107		107

arch/s390/include/asm/nospec-insn.h+6−6

@@ -54,31 +54,31 @@ · 53 unmodified lines
54	.endm	54	.endm
55		55
56	.macro __DECODE_R expand,reg	56	.macro __DECODE_R expand,reg
57	.set __decode_fail,1	57	.set .L__decode_fail,1
58	.irp r1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15	58	.irp r1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
59	.ifc \reg,%r\r1	59	.ifc \reg,%r\r1
60	\expand \r1	60	\expand \r1
61	.set __decode_fail,0	61	.set .L__decode_fail,0
62	.endif	62	.endif
63	.endr	63	.endr
64	.if __decode_fail == 1	64	.if .L__decode_fail == 1
65	.error "__DECODE_R failed"	65	.error "__DECODE_R failed"
66	.endif	66	.endif
67	.endm	67	.endm
68		68
69	.macro __DECODE_RR expand,rsave,rtarget	69	.macro __DECODE_RR expand,rsave,rtarget
70	.set __decode_fail,1	70	.set .L__decode_fail,1
71	.irp r1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15	71	.irp r1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
72	.ifc \rsave,%r\r1	72	.ifc \rsave,%r\r1
73	.irp r2,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15	73	.irp r2,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
74	.ifc \rtarget,%r\r2	74	.ifc \rtarget,%r\r2
75	\expand \r1,\r2	75	\expand \r1,\r2
76	.set __decode_fail,0	76	.set .L__decode_fail,0
77	.endif	77	.endif
78	.endr	78	.endr
79	.endif	79	.endif
80	.endr	80	.endr
81	.if __decode_fail == 1	81	.if .L__decode_fail == 1
82	.error "__DECODE_RR failed"	82	.error "__DECODE_RR failed"
83	.endif	83	.endif
84	.endm	84	.endm

arch/s390/include/asm/pai.h+74−0

@@ -0,0 +1,74 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Processor Activity Instrumentation support for cryptography counters
	4	*
	5	* Copyright IBM Corp. 2022
	6	* Author(s): Thomas Richter <tmricht@linux.ibm.com>
	7	*/
	8	#ifndef _ASM_S390_PAI_H
	9	#define _ASM_S390_PAI_H
	10
	11	#include <linux/jump_label.h>
	12	#include <asm/lowcore.h>
	13	#include <asm/ptrace.h>
	14
	15	struct qpaci_info_block {
	16	u64 header;
	17	struct {
	18	u64 : 8;
	19	u64 num_cc : 8; /* # of supported crypto counters */
	20	u64 : 48;
	21	};
	22	};
	23
	24	static inline int qpaci(struct qpaci_info_block *info)
	25	{
	26	/* Size of info (in double words minus one) */
	27	size_t size = sizeof(*info) / sizeof(u64) - 1;
	28	int cc;
	29
	30	asm volatile(
	31	" lgr 0,%[size]\n"
	32	" .insn s,0xb28f0000,%[info]\n"
	33	" lgr %[size],0\n"
	34	" ipm %[cc]\n"
	35	" srl %[cc],28\n"
	36	: [cc] "=d" (cc), [info] "=Q" (*info), [size] "+&d" (size)
	37	:
	38	: "0", "cc", "memory");
	39	return cc ? (size + 1) * sizeof(u64) : 0;
	40	}
	41
	42	#define PAI_CRYPTO_BASE 0x1000 /* First event number */
	43	#define PAI_CRYPTO_MAXCTR 256 /* Max # of event counters */
	44	#define PAI_CRYPTO_KERNEL_OFFSET 2048
	45
	46	DECLARE_STATIC_KEY_FALSE(pai_key);
	47
	48	static __always_inline void pai_kernel_enter(struct pt_regs *regs)
	49	{
	50	if (!IS_ENABLED(CONFIG_PERF_EVENTS))
	51	return;
	52	if (!static_branch_unlikely(&pai_key))
	53	return;
	54	if (!S390_lowcore.ccd)
	55	return;
	56	if (!user_mode(regs))
	57	return;
	58	WRITE_ONCE(S390_lowcore.ccd, S390_lowcore.ccd \| PAI_CRYPTO_KERNEL_OFFSET);
	59	}
	60
	61	static __always_inline void pai_kernel_exit(struct pt_regs *regs)
	62	{
	63	if (!IS_ENABLED(CONFIG_PERF_EVENTS))
	64	return;
	65	if (!static_branch_unlikely(&pai_key))
	66	return;
	67	if (!S390_lowcore.ccd)
	68	return;
	69	if (!user_mode(regs))
	70	return;
	71	WRITE_ONCE(S390_lowcore.ccd, S390_lowcore.ccd & ~PAI_CRYPTO_KERNEL_OFFSET);
	72	}
	73
	74	#endif

arch/s390/include/asm/pci_debug.h+6−1

 		debug_text_event(pci_debug_err_id, 0, debug_buffer);		\
 	} while (0)
+static inline void zpci_err_hex_level(int level, void *addr, int len)
+{
+	debug_event(pci_debug_err_id, level, addr, len);
+}
 static inline void zpci_err_hex(void *addr, int len)
 {
-	debug_event(pci_debug_err_id, 0, addr, len);
+	zpci_err_hex_level(0, addr, len);
 }
 #endif

arch/s390/include/asm/preempt.h+11−4

 static inline void __preempt_count_add(int val)
 {
-	if (__builtin_constant_p(val) && (val >= -128) && (val <= 127))
+	/*
-		__atomic_add_const(val, &S390_lowcore.preempt_count);
+	 * With some obscure config options and CONFIG_PROFILE_ALL_BRANCHES
-	else
+	 * enabled, gcc 12 fails to handle __builtin_constant_p().
-		__atomic_add(val, &S390_lowcore.preempt_count);
+	 */
+	if (!IS_ENABLED(CONFIG_PROFILE_ALL_BRANCHES)) {
+		if (__builtin_constant_p(val) && (val >= -128) && (val <= 127)) {
+			__atomic_add_const(val, &S390_lowcore.preempt_count);
+			return;
+		}
+	}
+	__atomic_add(val, &S390_lowcore.preempt_count);
 }
 static inline void __preempt_count_sub(int val)

arch/s390/include/asm/processor.h+5−3

 extern const struct seq_operations cpuinfo_op;
 extern void execve_tail(void);
 extern void __bpon(void);
+unsigned long vdso_size(void);
 /*
  * User space process size: 2GB for 31 bit, 4TB or 8PT for 64 bit.
 					(_REGION3_SIZE >> 1) : (_REGION2_SIZE >> 1))
 #define TASK_SIZE_MAX		(-PAGE_SIZE)
-#define STACK_TOP		(test_thread_flag(TIF_31BIT) ? \
+#define VDSO_BASE		(STACK_TOP + PAGE_SIZE)
-					_REGION3_SIZE : _REGION2_SIZE)
+#define VDSO_LIMIT		(test_thread_flag(TIF_31BIT) ? _REGION3_SIZE : _REGION2_SIZE)
-#define STACK_TOP_MAX		_REGION2_SIZE
+#define STACK_TOP		(VDSO_LIMIT - vdso_size() - PAGE_SIZE)
+#define STACK_TOP_MAX		(_REGION2_SIZE - vdso_size() - PAGE_SIZE)
 #define HAVE_ARCH_PICK_MMAP_LAYOUT

arch/s390/include/asm/ptrace.h+29−0

@@ -71,6 +71,35 @@ enum { · 70 unmodified lines
71	&((struct psw_bits )(&(__psw))); \	71	&((struct psw_bits )(&(__psw))); \
72	}))	72	}))
73		73
		74	#define PSW32_MASK_PER 0x40000000UL
		75	#define PSW32_MASK_DAT 0x04000000UL
		76	#define PSW32_MASK_IO 0x02000000UL
		77	#define PSW32_MASK_EXT 0x01000000UL
		78	#define PSW32_MASK_KEY 0x00F00000UL
		79	#define PSW32_MASK_BASE 0x00080000UL /* Always one */
		80	#define PSW32_MASK_MCHECK 0x00040000UL
		81	#define PSW32_MASK_WAIT 0x00020000UL
		82	#define PSW32_MASK_PSTATE 0x00010000UL
		83	#define PSW32_MASK_ASC 0x0000C000UL
		84	#define PSW32_MASK_CC 0x00003000UL
		85	#define PSW32_MASK_PM 0x00000f00UL
		86	#define PSW32_MASK_RI 0x00000080UL
		87
		88	#define PSW32_ADDR_AMODE 0x80000000UL
		89	#define PSW32_ADDR_INSN 0x7FFFFFFFUL
		90
		91	#define PSW32_DEFAULT_KEY (((u32)PAGE_DEFAULT_ACC) << 20)
		92
		93	#define PSW32_ASC_PRIMARY 0x00000000UL
		94	#define PSW32_ASC_ACCREG 0x00004000UL
		95	#define PSW32_ASC_SECONDARY 0x00008000UL
		96	#define PSW32_ASC_HOME 0x0000C000UL
		97
		98	typedef struct {
		99	unsigned int mask;
		100	unsigned int addr;
		101	} psw_t32 __aligned(8);
		102
74	#define PGM_INT_CODE_MASK 0x7f	103	#define PGM_INT_CODE_MASK 0x7f
75	#define PGM_INT_CODE_PER 0x80	104	#define PGM_INT_CODE_PER 0x80
76		105

arch/s390/include/asm/sclp.h+1−0

@@ -87,6 +87,7 @@ struct sclp_info { · 86 unmodified lines
87	unsigned char has_diag318 : 1;	87	unsigned char has_diag318 : 1;
88	unsigned char has_sipl : 1;	88	unsigned char has_sipl : 1;
89	unsigned char has_dirq : 1;	89	unsigned char has_dirq : 1;
		90	unsigned char has_iplcc : 1;
90	unsigned int ibc;	91	unsigned int ibc;
91	unsigned int mtid;	92	unsigned int mtid;
92	unsigned int mtid_cp;	93	unsigned int mtid_cp;

arch/s390/include/asm/scsw.h+68−15

@@ -508,9 +508,21 @@ static inline int scsw_cmd_is_valid_zcc(union scsw *scsw) · 507 unmodified lines
508	*/	508	*/
509	static inline int scsw_cmd_is_valid_ectl(union scsw *scsw)	509	static inline int scsw_cmd_is_valid_ectl(union scsw *scsw)
510	{	510	{
511	return (scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) &&	511	/* Must be status pending. */
512	!(scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS) &&	512	if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND))
513	(scsw->cmd.stctl & SCSW_STCTL_ALERT_STATUS);	513	return 0;
		514
		515	/* Must have alert status. */
		516	if (!(scsw->cmd.stctl & SCSW_STCTL_ALERT_STATUS))
		517	return 0;
		518
		519	/* Must be alone or together with primary, secondary or both,
		520	* => no intermediate status.
		521	*/
		522	if (scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS)
		523	return 0;
		524
		525	return 1;
514	}	526	}
515		527
516	/**	528	/**
@@ -522,10 +534,25 @@ static inline int scsw_cmd_is_valid_ectl(union scsw *scsw) · 5 unmodified lines
522	*/	534	*/
523	static inline int scsw_cmd_is_valid_pno(union scsw *scsw)	535	static inline int scsw_cmd_is_valid_pno(union scsw *scsw)
524	{	536	{
525	return (scsw->cmd.fctl != 0) &&	537	/* Must indicate at least one I/O function. */
526	(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND) &&	538	if (!scsw->cmd.fctl)
527	(!(scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS) \|\|	539	return 0;
528	(scsw->cmd.actl & SCSW_ACTL_SUSPENDED));	540
		541	/* Must be status pending. */
		542	if (!(scsw->cmd.stctl & SCSW_STCTL_STATUS_PEND))
		543	return 0;
		544
		545	/* Can be status pending alone, or with any combination of primary,
		546	* secondary and alert => no intermediate status.
		547	*/
		548	if (!(scsw->cmd.stctl & SCSW_STCTL_INTER_STATUS))
		549	return 1;
		550
		551	/* If intermediate, must be suspended. */
		552	if (scsw->cmd.actl & SCSW_ACTL_SUSPENDED)
		553	return 1;
		554
		555	return 0;
529	}	556	}
530		557
531	/**	558	/**
@@ -675,9 +702,21 @@ static inline int scsw_tm_is_valid_q(union scsw *scsw) · 143 unmodified lines
675	*/	702	*/
676	static inline int scsw_tm_is_valid_ectl(union scsw *scsw)	703	static inline int scsw_tm_is_valid_ectl(union scsw *scsw)
677	{	704	{
678	return (scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&	705	/* Must be status pending. */
679	!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) &&	706	if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND))
680	(scsw->tm.stctl & SCSW_STCTL_ALERT_STATUS);	707	return 0;
		708
		709	/* Must have alert status. */
		710	if (!(scsw->tm.stctl & SCSW_STCTL_ALERT_STATUS))
		711	return 0;
		712
		713	/* Must be alone or together with primary, secondary or both,
		714	* => no intermediate status.
		715	*/
		716	if (scsw->tm.stctl & SCSW_STCTL_INTER_STATUS)
		717	return 0;
		718
		719	return 1;
681	}	720	}
682		721
683	/**	722	/**
@@ -689,11 +728,25 @@ static inline int scsw_tm_is_valid_ectl(union scsw *scsw) · 5 unmodified lines
689	*/	728	*/
690	static inline int scsw_tm_is_valid_pno(union scsw *scsw)	729	static inline int scsw_tm_is_valid_pno(union scsw *scsw)
691	{	730	{
692	return (scsw->tm.fctl != 0) &&	731	/* Must indicate at least one I/O function. */
693	(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND) &&	732	if (!scsw->tm.fctl)
694	(!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) \|\|	733	return 0;
695	((scsw->tm.stctl & SCSW_STCTL_INTER_STATUS) &&	734
696	(scsw->tm.actl & SCSW_ACTL_SUSPENDED)));	735	/* Must be status pending. */
		736	if (!(scsw->tm.stctl & SCSW_STCTL_STATUS_PEND))
		737	return 0;
		738
		739	/* Can be status pending alone, or with any combination of primary,
		740	* secondary and alert => no intermediate status.
		741	*/
		742	if (!(scsw->tm.stctl & SCSW_STCTL_INTER_STATUS))
		743	return 1;
		744
		745	/* If intermediate, must be suspended. */
		746	if (scsw->tm.actl & SCSW_ACTL_SUSPENDED)
		747	return 1;
		748
		749	return 0;
697	}	750	}
698		751
699	/**	752	/**

arch/s390/include/asm/spinlock.h+2−1

 static inline void arch_spin_unlock(arch_spinlock_t *lp)
 {
 	typecheck(int, lp->lock);
+	kcsan_release();
 	asm_inline volatile(
-		ALTERNATIVE("", ".insn rre,0xb2fa0000,7,0", 49)	/* NIAI 7 */
+		ALTERNATIVE("nop", ".insn rre,0xb2fa0000,7,0", 49) /* NIAI 7 */
 		"	sth	%1,%0\n"
 		: "=R" (((unsigned short *) &lp->lock)[1])
 		: "d" (0) : "cc", "memory");

arch/s390/include/asm/stp.h+2−2

@@ -44,8 +44,8 @@ struct stp_sstpi { · 43 unmodified lines
44	u32 : 32;	44	u32 : 32;
45	u32 ctnid[3];	45	u32 ctnid[3];
46	u32 : 32;	46	u32 : 32;
47	u32 todoff[4];	47	u64 todoff;
48	u32 rsvd[48];	48	u32 rsvd[50];
49	} __packed;	49	} __packed;
50		50
51	struct stp_tzib {	51	struct stp_tzib {

arch/s390/include/asm/vx-insn.h+3−3

@@ -366,7 +366,7 @@ · 365 unmodified lines
366	.macro VLM vfrom, vto, disp, base, hint=3	366	.macro VLM vfrom, vto, disp, base, hint=3
367	VX_NUM v1, \vfrom	367	VX_NUM v1, \vfrom
368	VX_NUM v3, \vto	368	VX_NUM v3, \vto
369	GR_NUM b2, \base /* Base register */	369	GR_NUM b2, \base
370	.word 0xE700 \| ((v1&15) << 4) \| (v3&15)	370	.word 0xE700 \| ((v1&15) << 4) \| (v3&15)
371	.word (b2 << 12) \| (\disp)	371	.word (b2 << 12) \| (\disp)
372	MRXBOPC \hint, 0x36, v1, v3	372	MRXBOPC \hint, 0x36, v1, v3
@@ -376,7 +376,7 @@ · 3 unmodified lines
376	.macro VST vr1, disp, index="%r0", base	376	.macro VST vr1, disp, index="%r0", base
377	VX_NUM v1, \vr1	377	VX_NUM v1, \vr1
378	GR_NUM x2, \index	378	GR_NUM x2, \index
379	GR_NUM b2, \base /* Base register */	379	GR_NUM b2, \base
380	.word 0xE700 \| ((v1&15) << 4) \| (x2&15)	380	.word 0xE700 \| ((v1&15) << 4) \| (x2&15)
381	.word (b2 << 12) \| (\disp)	381	.word (b2 << 12) \| (\disp)
382	MRXBOPC 0, 0x0E, v1	382	MRXBOPC 0, 0x0E, v1
@@ -386,7 +386,7 @@ · 3 unmodified lines
386	.macro VSTM vfrom, vto, disp, base, hint=3	386	.macro VSTM vfrom, vto, disp, base, hint=3
387	VX_NUM v1, \vfrom	387	VX_NUM v1, \vfrom
388	VX_NUM v3, \vto	388	VX_NUM v3, \vto
389	GR_NUM b2, \base /* Base register */	389	GR_NUM b2, \base
390	.word 0xE700 \| ((v1&15) << 4) \| (v3&15)	390	.word 0xE700 \| ((v1&15) << 4) \| (v3&15)
391	.word (b2 << 12) \| (\disp)	391	.word (b2 << 12) \| (\disp)
392	MRXBOPC \hint, 0x3E, v1, v3	392	MRXBOPC \hint, 0x3E, v1, v3

arch/s390/include/uapi/asm/pkey.h+1−1

@@ -171,7 +171,7 @@ struct pkey_skey2pkey { · 170 unmodified lines
171	#define PKEY_SKEY2PKEY _IOWR(PKEY_IOCTL_MAGIC, 0x06, struct pkey_skey2pkey)	171	#define PKEY_SKEY2PKEY _IOWR(PKEY_IOCTL_MAGIC, 0x06, struct pkey_skey2pkey)
172		172
173	/*	173	/*
174	* Verify the given CCA AES secure key for being able to be useable with	174	* Verify the given CCA AES secure key for being able to be usable with
175	* the pkey module. Check for correct key type and check for having at	175	* the pkey module. Check for correct key type and check for having at
176	* least one crypto card being able to handle this key (master key	176	* least one crypto card being able to handle this key (master key
177	* or old master key verification pattern matches).	177	* or old master key verification pattern matches).

arch/s390/include/uapi/asm/zcrypt.h+20−22

  *
  *  zcrypt 2.2.1 (user-visible header)
  *
- *  Copyright IBM Corp. 2001, 2019
+ *  Copyright IBM Corp. 2001, 2022
  *  Author(s): Robert Burroughs
  *	       Eric Rossman (edrossma@us.ibm.com)
  *
 struct CPRBX {
 	__u16	     cprb_len;		/* CPRB length	      220	 */
 	__u8	     cprb_ver_id;	/* CPRB version id.   0x02	 */
-	__u8	     pad_000[3];	/* Alignment pad bytes		 */
+	__u8	     _pad_000[3];	/* Alignment pad bytes		 */
 	__u8	     func_id[2];	/* function id	      0x5432	 */
 	__u8	     cprb_flags[4];	/* Flags			 */
 	__u32	     req_parml;		/* request parameter buffer len	 */
 	__u32	     rpl_datal;		/* reply data block len		 */
 	__u32	     rpld_datal;	/* replied data block len	 */
 	__u32	     req_extbl;		/* request extension block len	 */
-	__u8	     pad_001[4];	/* reserved			 */
+	__u8	     _pad_001[4];	/* reserved			 */
 	__u32	     rpld_extbl;	/* replied extension block len	 */
-	__u8	     padx000[16 - sizeof(__u8 *)];
+	__u8	     _pad_002[16 - sizeof(__u8 *)];
 	__u8 __user *req_parmb;		/* request parm block 'address'	 */
-	__u8	     padx001[16 - sizeof(__u8 *)];
+	__u8	     _pad_003[16 - sizeof(__u8 *)];
 	__u8 __user *req_datab;		/* request data block 'address'	 */
-	__u8	     padx002[16 - sizeof(__u8 *)];
+	__u8	     _pad_004[16 - sizeof(__u8 *)];
 	__u8 __user *rpl_parmb;		/* reply parm block 'address'	 */
-	__u8	     padx003[16 - sizeof(__u8 *)];
+	__u8	     _pad_005[16 - sizeof(__u8 *)];
 	__u8 __user *rpl_datab;		/* reply data block 'address'	 */
-	__u8	     padx004[16 - sizeof(__u8 *)];
+	__u8	     _pad_006[16 - sizeof(__u8 *)];
 	__u8 __user *req_extb;		/* request extension block 'addr'*/
-	__u8	     padx005[16 - sizeof(__u8 *)];
+	__u8	     _pad_007[16 - sizeof(__u8 *)];
 	__u8 __user *rpl_extb;		/* reply extension block 'address'*/
 	__u16	     ccp_rtcode;	/* server return code		 */
 	__u16	     ccp_rscode;	/* server reason code		 */
 	__u8	     logon_id[8];	/* Logon Identifier		 */
 	__u8	     mac_value[8];	/* Mac Value			 */
 	__u8	     mac_content_flgs;	/* Mac content flag byte	 */
-	__u8	     pad_002;		/* Alignment			 */
+	__u8	     _pad_008;		/* Alignment			 */
 	__u16	     domain;		/* Domain			 */
-	__u8	     usage_domain[4];	/* Usage domain			 */
+	__u8	     _pad_009[12];	/* reserved, checked for zeros	 */
-	__u8	     cntrl_domain[4];	/* Control domain		 */
+	__u8	     _pad_010[36];	/* reserved			 */
-	__u8	     S390enf_mask[4];	/* S/390 enforcement mask	 */
-	__u8	     pad_004[36];	/* reserved			 */
 } __attribute__((packed));
 /**
 };
 #define AUTOSELECT  0xFFFFFFFF
-#define AUTOSEL_AP  ((__u16) 0xFFFF)
+#define AUTOSEL_AP  ((__u16)0xFFFF)
-#define AUTOSEL_DOM ((__u16) 0xFFFF)
+#define AUTOSEL_DOM ((__u16)0xFFFF)
 #define ZCRYPT_IOCTL_MAGIC 'z'
 /**
  * Supported ioctl calls
  */
-#define ICARSAMODEXPO	_IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x05, 0)
+#define ICARSAMODEXPO  _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x05, 0)
-#define ICARSACRT	_IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x06, 0)
+#define ICARSACRT      _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x06, 0)
-#define ZSECSENDCPRB	_IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x81, 0)
+#define ZSECSENDCPRB   _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x81, 0)
-#define ZSENDEP11CPRB	_IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x04, 0)
+#define ZSENDEP11CPRB  _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x04, 0)
-#define ZCRYPT_DEVICE_STATUS _IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x5f, 0)
+#define ZCRYPT_DEVICE_STATUS _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x5f, 0)
 #define ZCRYPT_STATUS_MASK   _IOR(ZCRYPT_IOCTL_MAGIC, 0x58, char[MAX_ZDEV_CARDIDS_EXT])
 #define ZCRYPT_QDEPTH_MASK   _IOR(ZCRYPT_IOCTL_MAGIC, 0x59, char[MAX_ZDEV_CARDIDS_EXT])
 #define ZCRYPT_PERDEV_REQCNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x5a, int[MAX_ZDEV_CARDIDS_EXT])
 };
 /* Deprecated: use ZCRYPT_DEVICE_STATUS */
-#define ZDEVICESTATUS _IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x4f, 0)
+#define ZDEVICESTATUS _IOC(_IOC_READ | _IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x4f, 0)
 /* Deprecated: use ZCRYPT_STATUS_MASK */
 #define Z90STAT_STATUS_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x48, char[64])
 /* Deprecated: use ZCRYPT_QDEPTH_MASK */

arch/s390/kernel/Makefile+1−0

@@ -72,6 +72,7 @@ obj-$(CONFIG_IMA_SECURE_AND_OR_TRUSTED_BOOT) += ima_arch.o · 71 unmodified lines
72	obj-$(CONFIG_PERF_EVENTS) += perf_event.o perf_cpum_cf_common.o	72	obj-$(CONFIG_PERF_EVENTS) += perf_event.o perf_cpum_cf_common.o
73	obj-$(CONFIG_PERF_EVENTS) += perf_cpum_cf.o perf_cpum_sf.o	73	obj-$(CONFIG_PERF_EVENTS) += perf_cpum_cf.o perf_cpum_sf.o
74	obj-$(CONFIG_PERF_EVENTS) += perf_cpum_cf_events.o perf_regs.o	74	obj-$(CONFIG_PERF_EVENTS) += perf_cpum_cf_events.o perf_regs.o
		75	obj-$(CONFIG_PERF_EVENTS) += perf_pai_crypto.o
75		76
76	obj-$(CONFIG_TRACEPOINTS) += trace.o	77	obj-$(CONFIG_TRACEPOINTS) += trace.o
77	obj-$(findstring y, $(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) $(CONFIG_PGSTE)) += uv.o	78	obj-$(findstring y, $(CONFIG_PROTECTED_VIRTUALIZATION_GUEST) $(CONFIG_PGSTE)) += uv.o

arch/s390/kernel/alternative.c+2−59

@@ -7,8 +7,6 @@ · 6 unmodified lines
7	#include <asm/facility.h>	7	#include <asm/facility.h>
8	#include <asm/nospec-branch.h>	8	#include <asm/nospec-branch.h>
9		9
10	#define MAX_PATCH_LEN (255 - 1)
11
12	static int __initdata_or_module alt_instr_disabled;	10	static int __initdata_or_module alt_instr_disabled;
13		11
14	static int __init disable_alternative_instructions(char *str)	12	static int __init disable_alternative_instructions(char *str)
@@ -19,85 +17,30 @@ static int __init disable_alternative_instructions(char *str) · 4 unmodified lines
19		17
20	early_param("noaltinstr", disable_alternative_instructions);	18	early_param("noaltinstr", disable_alternative_instructions);
21		19
22	struct brcl_insn {
23	u16 opc;
24	s32 disp;
25	} __packed;
26
27	static u16 __initdata_or_module nop16 = 0x0700;
28	static u32 __initdata_or_module nop32 = 0x47000000;
29	static struct brcl_insn __initdata_or_module nop48 = {
30	0xc004, 0
31	};
32
33	static const void *nops[] __initdata_or_module = {
34	&nop16,
35	&nop32,
36	&nop48
37	};
38
39	static void __init_or_module add_jump_padding(void *insns, unsigned int len)
40	{
41	struct brcl_insn brcl = {
42	0xc0f4,
43	len / 2
44	};
45
46	memcpy(insns, &brcl, sizeof(brcl));
47	insns += sizeof(brcl);
48	len -= sizeof(brcl);
49
50	while (len > 0) {
51	memcpy(insns, &nop16, 2);
52	insns += 2;
53	len -= 2;
54	}
55	}
56
57	static void __init_or_module add_padding(void *insns, unsigned int len)
58	{
59	if (len > 6)
60	add_jump_padding(insns, len);
61	else if (len >= 2)
62	memcpy(insns, nops[len / 2 - 1], len);
63	}
64
65	static void __init_or_module __apply_alternatives(struct alt_instr *start,	20	static void __init_or_module __apply_alternatives(struct alt_instr *start,
66	struct alt_instr *end)	21	struct alt_instr *end)
67	{	22	{
68	struct alt_instr *a;	23	struct alt_instr *a;
69	u8 instr, replacement;	24	u8 instr, replacement;
70	u8 insnbuf[MAX_PATCH_LEN];
71		25
72	/*	26	/*
73	* The scan order should be from start to end. A later scanned	27	* The scan order should be from start to end. A later scanned
74	* alternative code can overwrite previously scanned alternative code.	28	* alternative code can overwrite previously scanned alternative code.
75	*/	29	*/
76	for (a = start; a < end; a++) {	30	for (a = start; a < end; a++) {
77	int insnbuf_sz = 0;
78
79	instr = (u8 *)&a->instr_offset + a->instr_offset;	31	instr = (u8 *)&a->instr_offset + a->instr_offset;
80	replacement = (u8 *)&a->repl_offset + a->repl_offset;	32	replacement = (u8 *)&a->repl_offset + a->repl_offset;
81		33
82	if (!__test_facility(a->facility, alt_stfle_fac_list))	34	if (!__test_facility(a->facility, alt_stfle_fac_list))
83	continue;	35	continue;
84		36
85	if (unlikely(a->instrlen % 2 \|\| a->replacementlen % 2)) {	37	if (unlikely(a->instrlen % 2)) {
86	WARN_ONCE(1, "cpu alternatives instructions length is "	38	WARN_ONCE(1, "cpu alternatives instructions length is "
87	"odd, skipping patching\n");	39	"odd, skipping patching\n");
88	continue;	40	continue;
89	}	41	}
90		42
91	memcpy(insnbuf, replacement, a->replacementlen);	43	s390_kernel_write(instr, replacement, a->instrlen);
92	insnbuf_sz = a->replacementlen;
93
94	if (a->instrlen > a->replacementlen) {
95	add_padding(insnbuf + a->replacementlen,
96	a->instrlen - a->replacementlen);
97	insnbuf_sz += a->instrlen - a->replacementlen;
98	}
99
100	s390_kernel_write(instr, insnbuf, insnbuf_sz);
101	}	44	}
102	}	45	}
103		46

arch/s390/kernel/compat_linux.h+30−59

 #include <linux/compat.h>
 #include <linux/socket.h>
 #include <linux/syscalls.h>
+#include <asm/ptrace.h>
-/* Macro that masks the high order bit of an 32 bit pointer and converts it*/
+/*
-/*       to a 64 bit pointer */
+ * Macro that masks the high order bit of a 32 bit pointer and
-#define A(__x) ((unsigned long)((__x) & 0x7FFFFFFFUL))
+ * converts it to a 64 bit pointer.
-#define AA(__x)				\
+ */
-	((unsigned long)(__x))
+#define A(__x)	((unsigned long)((__x) & 0x7FFFFFFFUL))
+#define AA(__x)	((unsigned long)(__x))
 /* Now 32bit compatibility types */
 struct ipc_kludge_32 {
-        __u32   msgp;                           /* pointer              */
+	__u32	msgp;	/* pointer */
-        __s32   msgtyp;
+	__s32	msgtyp;
 };
 /* asm/sigcontext.h */
-typedef union
+typedef union {
-{
+	__u64	d;
-	__u64   d;
+	__u32	f;
-	__u32   f;
 } freg_t32;
-typedef struct
+typedef struct {
-{
 	unsigned int	fpc;
 	unsigned int	pad;
 	freg_t32	fprs[__NUM_FPRS];
 } _s390_fp_regs32;
-typedef struct
+typedef struct {
-{
+	psw_t32		psw;
-        __u32   mask;
-        __u32	addr;
-} _psw_t32 __attribute__ ((aligned(8)));
-typedef struct
-{
-	_psw_t32	psw;
 	__u32		gprs[__NUM_GPRS];
 	__u32		acrs[__NUM_ACRS];
 } _s390_regs_common32;
-typedef struct
+typedef struct {
-{
 	_s390_regs_common32 regs;
-	_s390_fp_regs32     fpregs;
+	_s390_fp_regs32	    fpregs;
 } _sigregs32;
-typedef struct
+typedef struct {
-{
+	__u32		gprs_high[__NUM_GPRS];
-	__u32 gprs_high[__NUM_GPRS];
+	__u64		vxrs_low[__NUM_VXRS_LOW];
-	__u64 vxrs_low[__NUM_VXRS_LOW];
+	__vector128	vxrs_high[__NUM_VXRS_HIGH];
-	__vector128 vxrs_high[__NUM_VXRS_HIGH];
+	__u8		__reserved[128];
-	__u8 __reserved[128];
 } _sigregs_ext32;
 #define _SIGCONTEXT_NSIG32	64
 #define _SIGCONTEXT_NSIG_BPW32	32
 #define __SIGNAL_FRAMESIZE32	96
-#define _SIGMASK_COPY_SIZE32	(sizeof(u32)*2)
+#define _SIGMASK_COPY_SIZE32	(sizeof(u32) * 2)
-struct sigcontext32
+struct sigcontext32 {
-{
 	__u32	oldmask[_COMPAT_NSIG_WORDS];
-	__u32	sregs;				/* pointer */
+	__u32	sregs;	/* pointer */
 };
 /* asm/signal.h */
 /* asm/ucontext.h */
 struct ucontext32 {
 	__u32			uc_flags;
 	__u32			uc_link;	/* pointer */
 	compat_stack_t		uc_stack;
 	_sigregs32		uc_mcontext;
 	compat_sigset_t		uc_sigmask;
-	/* Allow for uc_sigmask growth.  Glibc uses a 1024-bit sigset_t.  */
+	/* Allow for uc_sigmask growth. Glibc uses a 1024-bit sigset_t. */
 	unsigned char		__unused[128 - sizeof(compat_sigset_t)];
 	_sigregs_ext32		uc_mcontext_ext;
 };
 struct mmap_arg_struct_emu31;
 struct fadvise64_64_args;
-long compat_sys_s390_chown16(const char __user *filename, u16 user, u16 group);
-long compat_sys_s390_lchown16(const char __user *filename, u16 user, u16 group);
-long compat_sys_s390_fchown16(unsigned int fd, u16 user, u16 group);
-long compat_sys_s390_setregid16(u16 rgid, u16 egid);
-long compat_sys_s390_setgid16(u16 gid);
-long compat_sys_s390_setreuid16(u16 ruid, u16 euid);
-long compat_sys_s390_setuid16(u16 uid);
-long compat_sys_s390_setresuid16(u16 ruid, u16 euid, u16 suid);
-long compat_sys_s390_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid);
-long compat_sys_s390_setresgid16(u16 rgid, u16 egid, u16 sgid);
-long compat_sys_s390_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid);
-long compat_sys_s390_setfsuid16(u16 uid);
-long compat_sys_s390_setfsgid16(u16 gid);
-long compat_sys_s390_getgroups16(int gidsetsize, u16 __user *grouplist);
-long compat_sys_s390_setgroups16(int gidsetsize, u16 __user *grouplist);
-long compat_sys_s390_getuid16(void);
-long compat_sys_s390_geteuid16(void);
-long compat_sys_s390_getgid16(void);
-long compat_sys_s390_getegid16(void);
 long compat_sys_s390_truncate64(const char __user *path, u32 high, u32 low);
 long compat_sys_s390_ftruncate64(unsigned int fd, u32 high, u32 low);
 long compat_sys_s390_pread64(unsigned int fd, char __user *ubuf, compat_size_t count, u32 high, u32 low);
 long compat_sys_s390_fstatat64(unsigned int dfd, const char __user *filename, struct stat64_emu31 __user *statbuf, int flag);
 long compat_sys_s390_old_mmap(struct mmap_arg_struct_emu31 __user *arg);
 long compat_sys_s390_mmap2(struct mmap_arg_struct_emu31 __user *arg);
-long compat_sys_s390_read(unsigned int fd, char __user * buf, compat_size_t count);
+long compat_sys_s390_read(unsigned int fd, char __user *buf, compat_size_t count);
-long compat_sys_s390_write(unsigned int fd, const char __user * buf, compat_size_t count);
+long compat_sys_s390_write(unsigned int fd, const char __user *buf, compat_size_t count);
 long compat_sys_s390_fadvise64(int fd, u32 high, u32 low, compat_size_t len, int advise);
 long compat_sys_s390_fadvise64_64(struct fadvise64_64_args __user *args);
 long compat_sys_s390_sync_file_range(int fd, u32 offhigh, u32 offlow, u32 nhigh, u32 nlow, unsigned int flags);

arch/s390/kernel/entry.S+24−16

 _LPP_OFFSET	= __LC_LPP
 	.macro STBEAR address
-	ALTERNATIVE "", ".insn	s,0xb2010000,\address", 193
+	ALTERNATIVE "nop", ".insn s,0xb2010000,\address", 193
 	.endm
 	.macro LBEAR address
-	ALTERNATIVE "", ".insn	s,0xb2000000,\address", 193
+	ALTERNATIVE "nop", ".insn s,0xb2000000,\address", 193
 	.endm
 	.macro LPSWEY address,lpswe
-	ALTERNATIVE "b \lpswe", ".insn siy,0xeb0000000071,\address,0", 193
+	ALTERNATIVE "b \lpswe; nopr", ".insn siy,0xeb0000000071,\address,0", 193
 	.endm
 	.macro MBEAR reg
-	ALTERNATIVE "", __stringify(mvc __PT_LAST_BREAK(8,\reg),__LC_LAST_BREAK), 193
+	ALTERNATIVE "brcl 0,0", __stringify(mvc __PT_LAST_BREAK(8,\reg),__LC_LAST_BREAK), 193
 	.endm
 	.macro	CHECK_STACK savearea
 	.endm
 	.macro BPOFF
-	ALTERNATIVE "", ".insn rrf,0xb2e80000,0,0,12,0", 82
+	ALTERNATIVE "nop", ".insn rrf,0xb2e80000,0,0,12,0", 82
 	.endm
 	.macro BPON
-	ALTERNATIVE "", ".insn rrf,0xb2e80000,0,0,13,0", 82
+	ALTERNATIVE "nop", ".insn rrf,0xb2e80000,0,0,13,0", 82
 	.endm
 	.macro BPENTER tif_ptr,tif_mask
 	ALTERNATIVE "TSTMSK \tif_ptr,\tif_mask; jz .+8; .insn rrf,0xb2e80000,0,0,13,0", \
-		    "", 82
+		    "j .+12; nop; nop", 82
 	.endm
 	.macro BPEXIT tif_ptr,tif_mask
 	lgr	%r14,\reg
 	larl	%r13,\start
 	slgr	%r14,%r13
-	lghi	%r13,\end - \start
+#ifdef CONFIG_AS_IS_LLVM
-	clgr	%r14,%r13
+	clgfrl	%r14,.Lrange_size\@
+#else
+	clgfi	%r14,\end - \start
+#endif
 	jhe	\outside_label
+#ifdef CONFIG_AS_IS_LLVM
+	.section .rodata, "a"
+	.align 4
+.Lrange_size\@:
+	.long	\end - \start
+	.previous
+#endif
 	.endm
 	.macro SIEEXIT
 	aghi	%r3,__TASK_pid
 	mvc	__LC_CURRENT_PID(4,%r0),0(%r3)	# store pid of next
 	lmg	%r6,%r15,__SF_GPRS(%r15)	# load gprs of next task
-	ALTERNATIVE "", "lpp _LPP_OFFSET", 40
+	ALTERNATIVE "nop", "lpp _LPP_OFFSET", 40
 	BR_EX	%r14
 ENDPROC(__switch_to)
 	mvc	__PT_R8(64,%r11),__LC_SAVE_AREA_ASYNC
 	MBEAR	%r11
 	stmg	%r8,%r9,__PT_PSW(%r11)
-	tm	%r8,0x0001		# coming from user space?
+	lgr	%r2,%r11		# pass pointer to pt_regs
-	jno	1f
-	lctlg	%c1,%c1,__LC_KERNEL_ASCE
-1:	lgr	%r2,%r11		# pass pointer to pt_regs
 	brasl	%r14,\handler
 	mvc	__LC_RETURN_PSW(16),__PT_PSW(%r11)
 	tmhh	%r8,0x0001		# returning to user ?
 	mvc	STACK_FRAME_OVERHEAD(__PT_SIZE,%r1),0(%r11)
 	xc	__SF_BACKCHAIN(8,%r1),__SF_BACKCHAIN(%r1)
 	la	%r11,STACK_FRAME_OVERHEAD(%r1)
+	lgr	%r2,%r11
 	lgr	%r15,%r1
 	brasl	%r14,s390_handle_mcck
 .Lmcck_return:
 	jno	0f
 	BPEXIT	__TI_flags(%r12),_TIF_ISOLATE_BP
 	stpt	__LC_EXIT_TIMER
-0:	ALTERNATIVE "", __stringify(lghi %r12,__LC_LAST_BREAK_SAVE_AREA),193
+0:	ALTERNATIVE "nop", __stringify(lghi %r12,__LC_LAST_BREAK_SAVE_AREA),193
 	LBEAR	0(%r12)
 	lmg	%r11,%r15,__PT_R11(%r11)
 	LPSWEY	__LC_RETURN_MCCK_PSW,__LC_RETURN_MCCK_LPSWE
 ENDPROC(mcck_int_handler)
 ENTRY(restart_int_handler)
-	ALTERNATIVE "", "lpp _LPP_OFFSET", 40
+	ALTERNATIVE "nop", "lpp _LPP_OFFSET", 40
 	stg	%r15,__LC_SAVE_AREA_RESTART
 	TSTMSK	__LC_RESTART_FLAGS,RESTART_FLAG_CTLREGS,4
 	jz	0f

arch/s390/kernel/irq.c+2−2

@@ -205,7 +205,7 @@ static void show_msi_interrupt(struct seq_file *p, int irq) · 204 unmodified lines
205	unsigned long flags;	205	unsigned long flags;
206	int cpu;	206	int cpu;
207		207
208	irq_lock_sparse();	208	rcu_read_lock();
209	desc = irq_to_desc(irq);	209	desc = irq_to_desc(irq);
210	if (!desc)	210	if (!desc)
211	goto out;	211	goto out;
@@ -224,7 +224,7 @@ static void show_msi_interrupt(struct seq_file *p, int irq) · 12 unmodified lines
224	seq_putc(p, '\n');	224	seq_putc(p, '\n');
225	raw_spin_unlock_irqrestore(&desc->lock, flags);	225	raw_spin_unlock_irqrestore(&desc->lock, flags);
226	out:	226	out:
227	irq_unlock_sparse();	227	rcu_read_unlock();
228	}	228	}
229		229
230	/*	230	/*

arch/s390/kernel/machine_kexec.c+8−2

 #include <asm/stacktrace.h>
 #include <asm/switch_to.h>
 #include <asm/nmi.h>
+#include <asm/sclp.h>
-typedef void (*relocate_kernel_t)(kimage_entry_t *, unsigned long);
+typedef void (*relocate_kernel_t)(kimage_entry_t *, unsigned long,
+				  unsigned long);
 extern const unsigned char relocate_kernel[];
 extern const unsigned long long relocate_kernel_len;
  */
 static void __do_machine_kexec(void *data)
 {
+	unsigned long diag308_subcode;
 	relocate_kernel_t data_mover;
 	struct kimage *image = data;
 	__arch_local_irq_stnsm(0xfb); /* disable DAT - avoid no-execute */
 	/* Call the moving routine */
-	(*data_mover)(&image->head, image->start);
+	diag308_subcode = DIAG308_CLEAR_RESET;
+	if (sclp.has_iplcc)
+		diag308_subcode |= DIAG308_FLAG_EI;
+	(*data_mover)(&image->head, image->start, diag308_subcode);
 	/* Die if kexec returns */
 	disabled_wait();

arch/s390/kernel/nmi.c+5−1

 #include <asm/switch_to.h>
 #include <asm/ctl_reg.h>
 #include <asm/asm-offsets.h>
+#include <asm/pai.h>
 #include <linux/kvm_host.h>
 struct mcck_struct {
 	}
 }
-void noinstr s390_handle_mcck(void)
+void noinstr s390_handle_mcck(struct pt_regs *regs)
 {
 	trace_hardirqs_off();
+	pai_kernel_enter(regs);
 	__s390_handle_mcck();
+	pai_kernel_exit(regs);
 	trace_hardirqs_on();
 }
 /*

arch/s390/kernel/perf_cpum_cf_events.c+148−0

@@ -295,6 +295,76 @@ CPUMF_EVENT_ATTR(cf_z15, DFLT_CC, 0x00108); · 294 unmodified lines
295	CPUMF_EVENT_ATTR(cf_z15, DFLT_CCFINISH, 0x00109);	295	CPUMF_EVENT_ATTR(cf_z15, DFLT_CCFINISH, 0x00109);
296	CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_ONE_THR_ACTIVE, 0x01c0);	296	CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_ONE_THR_ACTIVE, 0x01c0);
297	CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_TWO_THR_ACTIVE, 0x01c1);	297	CPUMF_EVENT_ATTR(cf_z15, MT_DIAG_CYCLES_TWO_THR_ACTIVE, 0x01c1);
		298	CPUMF_EVENT_ATTR(cf_z16, L1D_RO_EXCL_WRITES, 0x0080);
		299	CPUMF_EVENT_ATTR(cf_z16, DTLB2_WRITES, 0x0081);
		300	CPUMF_EVENT_ATTR(cf_z16, DTLB2_MISSES, 0x0082);
		301	CPUMF_EVENT_ATTR(cf_z16, CRSTE_1MB_WRITES, 0x0083);
		302	CPUMF_EVENT_ATTR(cf_z16, DTLB2_GPAGE_WRITES, 0x0084);
		303	CPUMF_EVENT_ATTR(cf_z16, ITLB2_WRITES, 0x0086);
		304	CPUMF_EVENT_ATTR(cf_z16, ITLB2_MISSES, 0x0087);
		305	CPUMF_EVENT_ATTR(cf_z16, TLB2_PTE_WRITES, 0x0089);
		306	CPUMF_EVENT_ATTR(cf_z16, TLB2_CRSTE_WRITES, 0x008a);
		307	CPUMF_EVENT_ATTR(cf_z16, TLB2_ENGINES_BUSY, 0x008b);
		308	CPUMF_EVENT_ATTR(cf_z16, TX_C_TEND, 0x008c);
		309	CPUMF_EVENT_ATTR(cf_z16, TX_NC_TEND, 0x008d);
		310	CPUMF_EVENT_ATTR(cf_z16, L1C_TLB2_MISSES, 0x008f);
		311	CPUMF_EVENT_ATTR(cf_z16, DCW_REQ, 0x0091);
		312	CPUMF_EVENT_ATTR(cf_z16, DCW_REQ_IV, 0x0092);
		313	CPUMF_EVENT_ATTR(cf_z16, DCW_REQ_CHIP_HIT, 0x0093);
		314	CPUMF_EVENT_ATTR(cf_z16, DCW_REQ_DRAWER_HIT, 0x0094);
		315	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_CHIP, 0x0095);
		316	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_CHIP_IV, 0x0096);
		317	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_CHIP_CHIP_HIT, 0x0097);
		318	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_CHIP_DRAWER_HIT, 0x0098);
		319	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_MODULE, 0x0099);
		320	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_DRAWER, 0x009a);
		321	CPUMF_EVENT_ATTR(cf_z16, DCW_OFF_DRAWER, 0x009b);
		322	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_CHIP_MEMORY, 0x009c);
		323	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_MODULE_MEMORY, 0x009d);
		324	CPUMF_EVENT_ATTR(cf_z16, DCW_ON_DRAWER_MEMORY, 0x009e);
		325	CPUMF_EVENT_ATTR(cf_z16, DCW_OFF_DRAWER_MEMORY, 0x009f);
		326	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_MODULE_IV, 0x00a0);
		327	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_MODULE_CHIP_HIT, 0x00a1);
		328	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_MODULE_DRAWER_HIT, 0x00a2);
		329	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_DRAWER_IV, 0x00a3);
		330	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_DRAWER_CHIP_HIT, 0x00a4);
		331	CPUMF_EVENT_ATTR(cf_z16, IDCW_ON_DRAWER_DRAWER_HIT, 0x00a5);
		332	CPUMF_EVENT_ATTR(cf_z16, IDCW_OFF_DRAWER_IV, 0x00a6);
		333	CPUMF_EVENT_ATTR(cf_z16, IDCW_OFF_DRAWER_CHIP_HIT, 0x00a7);
		334	CPUMF_EVENT_ATTR(cf_z16, IDCW_OFF_DRAWER_DRAWER_HIT, 0x00a8);
		335	CPUMF_EVENT_ATTR(cf_z16, ICW_REQ, 0x00a9);
		336	CPUMF_EVENT_ATTR(cf_z16, ICW_REQ_IV, 0x00aa);
		337	CPUMF_EVENT_ATTR(cf_z16, ICW_REQ_CHIP_HIT, 0x00ab);
		338	CPUMF_EVENT_ATTR(cf_z16, ICW_REQ_DRAWER_HIT, 0x00ac);
		339	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_CHIP, 0x00ad);
		340	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_CHIP_IV, 0x00ae);
		341	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_CHIP_CHIP_HIT, 0x00af);
		342	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_CHIP_DRAWER_HIT, 0x00b0);
		343	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_MODULE, 0x00b1);
		344	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_DRAWER, 0x00b2);
		345	CPUMF_EVENT_ATTR(cf_z16, ICW_OFF_DRAWER, 0x00b3);
		346	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_CHIP_MEMORY, 0x00b4);
		347	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_MODULE_MEMORY, 0x00b5);
		348	CPUMF_EVENT_ATTR(cf_z16, ICW_ON_DRAWER_MEMORY, 0x00b6);
		349	CPUMF_EVENT_ATTR(cf_z16, ICW_OFF_DRAWER_MEMORY, 0x00b7);
		350	CPUMF_EVENT_ATTR(cf_z16, BCD_DFP_EXECUTION_SLOTS, 0x00e0);
		351	CPUMF_EVENT_ATTR(cf_z16, VX_BCD_EXECUTION_SLOTS, 0x00e1);
		352	CPUMF_EVENT_ATTR(cf_z16, DECIMAL_INSTRUCTIONS, 0x00e2);
		353	CPUMF_EVENT_ATTR(cf_z16, LAST_HOST_TRANSLATIONS, 0x00e8);
		354	CPUMF_EVENT_ATTR(cf_z16, TX_NC_TABORT, 0x00f4);
		355	CPUMF_EVENT_ATTR(cf_z16, TX_C_TABORT_NO_SPECIAL, 0x00f5);
		356	CPUMF_EVENT_ATTR(cf_z16, TX_C_TABORT_SPECIAL, 0x00f6);
		357	CPUMF_EVENT_ATTR(cf_z16, DFLT_ACCESS, 0x00f8);
		358	CPUMF_EVENT_ATTR(cf_z16, DFLT_CYCLES, 0x00fd);
		359	CPUMF_EVENT_ATTR(cf_z16, SORTL, 0x0100);
		360	CPUMF_EVENT_ATTR(cf_z16, DFLT_CC, 0x0109);
		361	CPUMF_EVENT_ATTR(cf_z16, DFLT_CCFINISH, 0x010a);
		362	CPUMF_EVENT_ATTR(cf_z16, NNPA_INVOCATIONS, 0x010b);
		363	CPUMF_EVENT_ATTR(cf_z16, NNPA_COMPLETIONS, 0x010c);
		364	CPUMF_EVENT_ATTR(cf_z16, NNPA_WAIT_LOCK, 0x010d);
		365	CPUMF_EVENT_ATTR(cf_z16, NNPA_HOLD_LOCK, 0x010e);
		366	CPUMF_EVENT_ATTR(cf_z16, MT_DIAG_CYCLES_ONE_THR_ACTIVE, 0x01c0);
		367	CPUMF_EVENT_ATTR(cf_z16, MT_DIAG_CYCLES_TWO_THR_ACTIVE, 0x01c1);
298		368
299	static struct attribute *cpumcf_fvn1_pmu_event_attr[] __initdata = {	369	static struct attribute *cpumcf_fvn1_pmu_event_attr[] __initdata = {
300	CPUMF_EVENT_PTR(cf_fvn1, CPU_CYCLES),	370	CPUMF_EVENT_PTR(cf_fvn1, CPU_CYCLES),
@@ -635,6 +705,80 @@ static struct attribute *cpumcf_z15_pmu_event_attr[] __initdata = { · 334 unmodified lines
635	NULL,	705	NULL,
636	};	706	};
637		707
		708	static struct attribute *cpumcf_z16_pmu_event_attr[] __initdata = {
		709	CPUMF_EVENT_PTR(cf_z16, L1D_RO_EXCL_WRITES),
		710	CPUMF_EVENT_PTR(cf_z16, DTLB2_WRITES),
		711	CPUMF_EVENT_PTR(cf_z16, DTLB2_MISSES),
		712	CPUMF_EVENT_PTR(cf_z16, CRSTE_1MB_WRITES),
		713	CPUMF_EVENT_PTR(cf_z16, DTLB2_GPAGE_WRITES),
		714	CPUMF_EVENT_PTR(cf_z16, ITLB2_WRITES),
		715	CPUMF_EVENT_PTR(cf_z16, ITLB2_MISSES),
		716	CPUMF_EVENT_PTR(cf_z16, TLB2_PTE_WRITES),
		717	CPUMF_EVENT_PTR(cf_z16, TLB2_CRSTE_WRITES),
		718	CPUMF_EVENT_PTR(cf_z16, TLB2_ENGINES_BUSY),
		719	CPUMF_EVENT_PTR(cf_z16, TX_C_TEND),
		720	CPUMF_EVENT_PTR(cf_z16, TX_NC_TEND),
		721	CPUMF_EVENT_PTR(cf_z16, L1C_TLB2_MISSES),
		722	CPUMF_EVENT_PTR(cf_z16, DCW_REQ),
		723	CPUMF_EVENT_PTR(cf_z16, DCW_REQ_IV),
		724	CPUMF_EVENT_PTR(cf_z16, DCW_REQ_CHIP_HIT),
		725	CPUMF_EVENT_PTR(cf_z16, DCW_REQ_DRAWER_HIT),
		726	CPUMF_EVENT_PTR(cf_z16, DCW_ON_CHIP),
		727	CPUMF_EVENT_PTR(cf_z16, DCW_ON_CHIP_IV),
		728	CPUMF_EVENT_PTR(cf_z16, DCW_ON_CHIP_CHIP_HIT),
		729	CPUMF_EVENT_PTR(cf_z16, DCW_ON_CHIP_DRAWER_HIT),
		730	CPUMF_EVENT_PTR(cf_z16, DCW_ON_MODULE),
		731	CPUMF_EVENT_PTR(cf_z16, DCW_ON_DRAWER),
		732	CPUMF_EVENT_PTR(cf_z16, DCW_OFF_DRAWER),
		733	CPUMF_EVENT_PTR(cf_z16, DCW_ON_CHIP_MEMORY),
		734	CPUMF_EVENT_PTR(cf_z16, DCW_ON_MODULE_MEMORY),
		735	CPUMF_EVENT_PTR(cf_z16, DCW_ON_DRAWER_MEMORY),
		736	CPUMF_EVENT_PTR(cf_z16, DCW_OFF_DRAWER_MEMORY),
		737	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_MODULE_IV),
		738	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_MODULE_CHIP_HIT),
		739	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_MODULE_DRAWER_HIT),
		740	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_DRAWER_IV),
		741	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_DRAWER_CHIP_HIT),
		742	CPUMF_EVENT_PTR(cf_z16, IDCW_ON_DRAWER_DRAWER_HIT),
		743	CPUMF_EVENT_PTR(cf_z16, IDCW_OFF_DRAWER_IV),
		744	CPUMF_EVENT_PTR(cf_z16, IDCW_OFF_DRAWER_CHIP_HIT),
		745	CPUMF_EVENT_PTR(cf_z16, IDCW_OFF_DRAWER_DRAWER_HIT),
		746	CPUMF_EVENT_PTR(cf_z16, ICW_REQ),
		747	CPUMF_EVENT_PTR(cf_z16, ICW_REQ_IV),
		748	CPUMF_EVENT_PTR(cf_z16, ICW_REQ_CHIP_HIT),
		749	CPUMF_EVENT_PTR(cf_z16, ICW_REQ_DRAWER_HIT),
		750	CPUMF_EVENT_PTR(cf_z16, ICW_ON_CHIP),
		751	CPUMF_EVENT_PTR(cf_z16, ICW_ON_CHIP_IV),
		752	CPUMF_EVENT_PTR(cf_z16, ICW_ON_CHIP_CHIP_HIT),
		753	CPUMF_EVENT_PTR(cf_z16, ICW_ON_CHIP_DRAWER_HIT),
		754	CPUMF_EVENT_PTR(cf_z16, ICW_ON_MODULE),
		755	CPUMF_EVENT_PTR(cf_z16, ICW_ON_DRAWER),
		756	CPUMF_EVENT_PTR(cf_z16, ICW_OFF_DRAWER),
		757	CPUMF_EVENT_PTR(cf_z16, ICW_ON_CHIP_MEMORY),
		758	CPUMF_EVENT_PTR(cf_z16, ICW_ON_MODULE_MEMORY),
		759	CPUMF_EVENT_PTR(cf_z16, ICW_ON_DRAWER_MEMORY),
		760	CPUMF_EVENT_PTR(cf_z16, ICW_OFF_DRAWER_MEMORY),
		761	CPUMF_EVENT_PTR(cf_z16, BCD_DFP_EXECUTION_SLOTS),
		762	CPUMF_EVENT_PTR(cf_z16, VX_BCD_EXECUTION_SLOTS),
		763	CPUMF_EVENT_PTR(cf_z16, DECIMAL_INSTRUCTIONS),
		764	CPUMF_EVENT_PTR(cf_z16, LAST_HOST_TRANSLATIONS),
		765	CPUMF_EVENT_PTR(cf_z16, TX_NC_TABORT),
		766	CPUMF_EVENT_PTR(cf_z16, TX_C_TABORT_NO_SPECIAL),
		767	CPUMF_EVENT_PTR(cf_z16, TX_C_TABORT_SPECIAL),
		768	CPUMF_EVENT_PTR(cf_z16, DFLT_ACCESS),
		769	CPUMF_EVENT_PTR(cf_z16, DFLT_CYCLES),
		770	CPUMF_EVENT_PTR(cf_z16, SORTL),
		771	CPUMF_EVENT_PTR(cf_z16, DFLT_CC),
		772	CPUMF_EVENT_PTR(cf_z16, DFLT_CCFINISH),
		773	CPUMF_EVENT_PTR(cf_z16, NNPA_INVOCATIONS),
		774	CPUMF_EVENT_PTR(cf_z16, NNPA_COMPLETIONS),
		775	CPUMF_EVENT_PTR(cf_z16, NNPA_WAIT_LOCK),
		776	CPUMF_EVENT_PTR(cf_z16, NNPA_HOLD_LOCK),
		777	CPUMF_EVENT_PTR(cf_z16, MT_DIAG_CYCLES_ONE_THR_ACTIVE),
		778	CPUMF_EVENT_PTR(cf_z16, MT_DIAG_CYCLES_TWO_THR_ACTIVE),
		779	NULL,
		780	};
		781
638	/* END: CPUM_CF COUNTER DEFINITIONS ===================================== */	782	/* END: CPUM_CF COUNTER DEFINITIONS ===================================== */
639		783
640	static struct attribute_group cpumcf_pmu_events_group = {	784	static struct attribute_group cpumcf_pmu_events_group = {
@@ -749,6 +893,10 @@ __init const struct attribute_group **cpumf_cf_event_group(void) · 108 unmodified lines
749	case 0x8562:	893	case 0x8562:
750	model = cpumcf_z15_pmu_event_attr;	894	model = cpumcf_z15_pmu_event_attr;
751	break;	895	break;
		896	case 0x3931:
		897	case 0x3932:
		898	model = cpumcf_z16_pmu_event_attr;
		899	break;
752	default:	900	default:
753	model = none;	901	model = none;
754	break;	902	break;

arch/s390/kernel/perf_pai_crypto.c+688−0

@@ -0,0 +1,688 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Performance event support - Processor Activity Instrumentation Facility
	4	*
	5	* Copyright IBM Corp. 2022
	6	* Author(s): Thomas Richter <tmricht@linux.ibm.com>
	7	*/
	8	#define KMSG_COMPONENT "pai_crypto"
	9	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	10
	11	#include <linux/kernel.h>
	12	#include <linux/kernel_stat.h>
	13	#include <linux/percpu.h>
	14	#include <linux/notifier.h>
	15	#include <linux/init.h>
	16	#include <linux/export.h>
	17	#include <linux/io.h>
	18	#include <linux/perf_event.h>
	19
	20	#include <asm/ctl_reg.h>
	21	#include <asm/pai.h>
	22	#include <asm/debug.h>
	23
	24	static debug_info_t *cfm_dbg;
	25	static unsigned int paicrypt_cnt; /* Size of the mapped counter sets */
	26	/* extracted with QPACI instruction */
	27
	28	DEFINE_STATIC_KEY_FALSE(pai_key);
	29
	30	struct pai_userdata {
	31	u16 num;
	32	u64 value;
	33	} __packed;
	34
	35	struct paicrypt_map {
	36	unsigned long page; / Page for CPU to store counters */
	37	struct pai_userdata save; / Page to store no-zero counters */
	38	unsigned int users; /* # of PAI crypto users */
	39	unsigned int sampler; /* # of PAI crypto samplers */
	40	unsigned int counter; /* # of PAI crypto counters */
	41	struct perf_event event; / Perf event for sampling */
	42	};
	43
	44	static DEFINE_PER_CPU(struct paicrypt_map, paicrypt_map);
	45
	46	/* Release the PMU if event is the last perf event */
	47	static DEFINE_MUTEX(pai_reserve_mutex);
	48
	49	/* Adjust usage counters and remove allocated memory when all users are
	50	* gone.
	51	*/
	52	static void paicrypt_event_destroy(struct perf_event *event)
	53	{
	54	struct paicrypt_map *cpump = per_cpu_ptr(&paicrypt_map, event->cpu);
	55
	56	cpump->event = NULL;
	57	static_branch_dec(&pai_key);
	58	mutex_lock(&pai_reserve_mutex);
	59	if (event->attr.sample_period)
	60	cpump->sampler -= 1;
	61	else
	62	cpump->counter -= 1;
	63	debug_sprintf_event(cfm_dbg, 5, "%s event %#llx cpu %d"
	64	" sampler %d counter %d\n", __func__,
	65	event->attr.config, event->cpu, cpump->sampler,
	66	cpump->counter);
	67	if (!cpump->counter && !cpump->sampler) {
	68	debug_sprintf_event(cfm_dbg, 4, "%s page %#lx save %p\n",
	69	__func__, (unsigned long)cpump->page,
	70	cpump->save);
	71	free_page((unsigned long)cpump->page);
	72	cpump->page = NULL;
	73	kvfree(cpump->save);
	74	cpump->save = NULL;
	75	}
	76	mutex_unlock(&pai_reserve_mutex);
	77	}
	78
	79	static u64 paicrypt_getctr(struct paicrypt_map *cpump, int nr, bool kernel)
	80	{
	81	if (kernel)
	82	nr += PAI_CRYPTO_MAXCTR;
	83	return cpump->page[nr];
	84	}
	85
	86	/* Read the counter values. Return value from location in CMP. For event
	87	* CRYPTO_ALL sum up all events.
	88	*/
	89	static u64 paicrypt_getdata(struct perf_event *event, bool kernel)
	90	{
	91	struct paicrypt_map *cpump = this_cpu_ptr(&paicrypt_map);
	92	u64 sum = 0;
	93	int i;
	94
	95	if (event->attr.config != PAI_CRYPTO_BASE) {
	96	return paicrypt_getctr(cpump,
	97	event->attr.config - PAI_CRYPTO_BASE,
	98	kernel);
	99	}
	100
	101	for (i = 1; i <= paicrypt_cnt; i++) {
	102	u64 val = paicrypt_getctr(cpump, i, kernel);
	103
	104	if (!val)
	105	continue;
	106	sum += val;
	107	}
	108	return sum;
	109	}
	110
	111	static u64 paicrypt_getall(struct perf_event *event)
	112	{
	113	u64 sum = 0;
	114
	115	if (!event->attr.exclude_kernel)
	116	sum += paicrypt_getdata(event, true);
	117	if (!event->attr.exclude_user)
	118	sum += paicrypt_getdata(event, false);
	119
	120	return sum;
	121	}
	122
	123	/* Used to avoid races in checking concurrent access of counting and
	124	* sampling for crypto events
	125	*
	126	* Only one instance of event pai_crypto/CRYPTO_ALL/ for sampling is
	127	* allowed and when this event is running, no counting event is allowed.
	128	* Several counting events are allowed in parallel, but no sampling event
	129	* is allowed while one (or more) counting events are running.
	130	*
	131	* This function is called in process context and it is save to block.
	132	* When the event initialization functions fails, no other call back will
	133	* be invoked.
	134	*
	135	* Allocate the memory for the event.
	136	*/
	137	static int paicrypt_busy(struct perf_event_attr a, struct paicrypt_map cpump)
	138	{
	139	unsigned int *use_ptr;
	140	int rc = 0;
	141
	142	mutex_lock(&pai_reserve_mutex);
	143	if (a->sample_period) { /* Sampling requested */
	144	use_ptr = &cpump->sampler;
	145	if (cpump->counter \|\| cpump->sampler)
	146	rc = -EBUSY; /* ... sampling/counting active */
	147	} else { /* Counting requested */
	148	use_ptr = &cpump->counter;
	149	if (cpump->sampler)
	150	rc = -EBUSY; /* ... and sampling active */
	151	}
	152	if (rc)
	153	goto unlock;
	154
	155	/* Allocate memory for counter page and counter extraction.
	156	* Only the first counting event has to allocate a page.
	157	*/
	158	if (cpump->page)
	159	goto unlock;
	160
	161	rc = -ENOMEM;
	162	cpump->page = (unsigned long *)get_zeroed_page(GFP_KERNEL);
	163	if (!cpump->page)
	164	goto unlock;
	165	cpump->save = kvmalloc_array(paicrypt_cnt + 1,
	166	sizeof(struct pai_userdata), GFP_KERNEL);
	167	if (!cpump->save) {
	168	free_page((unsigned long)cpump->page);
	169	cpump->page = NULL;
	170	goto unlock;
	171	}
	172	rc = 0;
	173
	174	unlock:
	175	/* If rc is non-zero, do not increment counter/sampler. */
	176	if (!rc)
	177	*use_ptr += 1;
	178	debug_sprintf_event(cfm_dbg, 5, "%s sample_period %#llx sampler %d"
	179	" counter %d page %#lx save %p rc %d\n", __func__,
	180	a->sample_period, cpump->sampler, cpump->counter,
	181	(unsigned long)cpump->page, cpump->save, rc);
	182	mutex_unlock(&pai_reserve_mutex);
	183	return rc;
	184	}
	185
	186	/* Might be called on different CPU than the one the event is intended for. */
	187	static int paicrypt_event_init(struct perf_event *event)
	188	{
	189	struct perf_event_attr *a = &event->attr;
	190	struct paicrypt_map *cpump;
	191	int rc;
	192
	193	/* PAI crypto PMU registered as PERF_TYPE_RAW, check event type */
	194	if (a->type != PERF_TYPE_RAW && event->pmu->type != a->type)
	195	return -ENOENT;
	196	/* PAI crypto event must be valid */
	197	if (a->config > PAI_CRYPTO_BASE + paicrypt_cnt)
	198	return -EINVAL;
	199	/* Allow only CPU wide operation, no process context for now. */
	200	if (event->hw.target \|\| event->cpu == -1)
	201	return -ENOENT;
	202	/* Allow only CRYPTO_ALL for sampling. */
	203	if (a->sample_period && a->config != PAI_CRYPTO_BASE)
	204	return -EINVAL;
	205
	206	cpump = per_cpu_ptr(&paicrypt_map, event->cpu);
	207	rc = paicrypt_busy(a, cpump);
	208	if (rc)
	209	return rc;
	210
	211	cpump->event = event;
	212	event->destroy = paicrypt_event_destroy;
	213
	214	if (a->sample_period) {
	215	a->sample_period = 1;
	216	a->freq = 0;
	217	/* Register for paicrypt_sched_task() to be called */
	218	event->attach_state \|= PERF_ATTACH_SCHED_CB;
	219	/* Add raw data which contain the memory mapped counters */
	220	a->sample_type \|= PERF_SAMPLE_RAW;
	221	/* Turn off inheritance */
	222	a->inherit = 0;
	223	}
	224
	225	static_branch_inc(&pai_key);
	226	return 0;
	227	}
	228
	229	static void paicrypt_read(struct perf_event *event)
	230	{
	231	u64 prev, new, delta;
	232
	233	prev = local64_read(&event->hw.prev_count);
	234	new = paicrypt_getall(event);
	235	local64_set(&event->hw.prev_count, new);
	236	delta = (prev <= new) ? new - prev
	237	: (-1ULL - prev) + new + 1; /* overflow */
	238	local64_add(delta, &event->count);
	239	}
	240
	241	static void paicrypt_start(struct perf_event *event, int flags)
	242	{
	243	u64 sum;
	244
	245	sum = paicrypt_getall(event); /* Get current value */
	246	local64_set(&event->hw.prev_count, sum);
	247	local64_set(&event->count, 0);
	248	}
	249
	250	static int paicrypt_add(struct perf_event *event, int flags)
	251	{
	252	struct paicrypt_map *cpump = this_cpu_ptr(&paicrypt_map);
	253	unsigned long ccd;
	254
	255	if (cpump->users++ == 0) {
	256	ccd = virt_to_phys(cpump->page) \| PAI_CRYPTO_KERNEL_OFFSET;
	257	WRITE_ONCE(S390_lowcore.ccd, ccd);
	258	__ctl_set_bit(0, 50);
	259	}
	260	cpump->event = event;
	261	if (flags & PERF_EF_START && !event->attr.sample_period) {
	262	/* Only counting needs initial counter value */
	263	paicrypt_start(event, PERF_EF_RELOAD);
	264	}
	265	event->hw.state = 0;
	266	if (event->attr.sample_period)
	267	perf_sched_cb_inc(event->pmu);
	268	return 0;
	269	}
	270
	271	static void paicrypt_stop(struct perf_event *event, int flags)
	272	{
	273	paicrypt_read(event);
	274	event->hw.state = PERF_HES_STOPPED;
	275	}
	276
	277	static void paicrypt_del(struct perf_event *event, int flags)
	278	{
	279	struct paicrypt_map *cpump = this_cpu_ptr(&paicrypt_map);
	280
	281	if (event->attr.sample_period)
	282	perf_sched_cb_dec(event->pmu);
	283	if (!event->attr.sample_period)
	284	/* Only counting needs to read counter */
	285	paicrypt_stop(event, PERF_EF_UPDATE);
	286	if (cpump->users-- == 1) {
	287	__ctl_clear_bit(0, 50);
	288	WRITE_ONCE(S390_lowcore.ccd, 0);
	289	}
	290	}
	291
	292	/* Create raw data and save it in buffer. Returns number of bytes copied.
	293	* Saves only positive counter entries of the form
	294	* 2 bytes: Number of counter
	295	* 8 bytes: Value of counter
	296	*/
	297	static size_t paicrypt_copy(struct pai_userdata *userdata,
	298	struct paicrypt_map *cpump,
	299	bool exclude_user, bool exclude_kernel)
	300	{
	301	int i, outidx = 0;
	302
	303	for (i = 1; i <= paicrypt_cnt; i++) {
	304	u64 val = 0;
	305
	306	if (!exclude_kernel)
	307	val += paicrypt_getctr(cpump, i, true);
	308	if (!exclude_user)
	309	val += paicrypt_getctr(cpump, i, false);
	310	if (val) {
	311	userdata[outidx].num = i;
	312	userdata[outidx].value = val;
	313	outidx++;
	314	}
	315	}
	316	return outidx * sizeof(struct pai_userdata);
	317	}
	318
	319	static int paicrypt_push_sample(void)
	320	{
	321	struct paicrypt_map *cpump = this_cpu_ptr(&paicrypt_map);
	322	struct perf_event *event = cpump->event;
	323	struct perf_sample_data data;
	324	struct perf_raw_record raw;
	325	struct pt_regs regs;
	326	size_t rawsize;
	327	int overflow;
	328
	329	if (!cpump->event) /* No event active */
	330	return 0;
	331	rawsize = paicrypt_copy(cpump->save, cpump,
	332	cpump->event->attr.exclude_user,
	333	cpump->event->attr.exclude_kernel);
	334	if (!rawsize) /* No incremented counters */
	335	return 0;
	336
	337	/* Setup perf sample */
	338	memset(&regs, 0, sizeof(regs));
	339	memset(&raw, 0, sizeof(raw));
	340	memset(&data, 0, sizeof(data));
	341	perf_sample_data_init(&data, 0, event->hw.last_period);
	342	if (event->attr.sample_type & PERF_SAMPLE_TID) {
	343	data.tid_entry.pid = task_tgid_nr(current);
	344	data.tid_entry.tid = task_pid_nr(current);
	345	}
	346	if (event->attr.sample_type & PERF_SAMPLE_TIME)
	347	data.time = event->clock();
	348	if (event->attr.sample_type & (PERF_SAMPLE_ID \| PERF_SAMPLE_IDENTIFIER))
	349	data.id = event->id;
	350	if (event->attr.sample_type & PERF_SAMPLE_CPU) {
	351	data.cpu_entry.cpu = smp_processor_id();
	352	data.cpu_entry.reserved = 0;
	353	}
	354	if (event->attr.sample_type & PERF_SAMPLE_RAW) {
	355	raw.frag.size = rawsize;
	356	raw.frag.data = cpump->save;
	357	raw.size = raw.frag.size;
	358	data.raw = &raw;
	359	}
	360
	361	overflow = perf_event_overflow(event, &data, &regs);
	362	perf_event_update_userpage(event);
	363	/* Clear lowcore page after read */
	364	memset(cpump->page, 0, PAGE_SIZE);
	365	return overflow;
	366	}
	367
	368	/* Called on schedule-in and schedule-out. No access to event structure,
	369	* but for sampling only event CRYPTO_ALL is allowed.
	370	*/
	371	static void paicrypt_sched_task(struct perf_event_context *ctx, bool sched_in)
	372	{
	373	/* We started with a clean page on event installation. So read out
	374	* results on schedule_out and if page was dirty, clear values.
	375	*/
	376	if (!sched_in)
	377	paicrypt_push_sample();
	378	}
	379
	380	/* Attribute definitions for paicrypt interface. As with other CPU
	381	* Measurement Facilities, there is one attribute per mapped counter.
	382	* The number of mapped counters may vary per machine generation. Use
	383	* the QUERY PROCESSOR ACTIVITY COUNTER INFORMATION (QPACI) instruction
	384	* to determine the number of mapped counters. The instructions returns
	385	* a positive number, which is the highest number of supported counters.
	386	* All counters less than this number are also supported, there are no
	387	* holes. A returned number of zero means no support for mapped counters.
	388	*
	389	* The identification of the counter is a unique number. The chosen range
	390	* is 0x1000 + offset in mapped kernel page.
	391	* All CPU Measurement Facility counters identifiers must be unique and
	392	* the numbers from 0 to 496 are already used for the CPU Measurement
	393	* Counter facility. Numbers 0xb0000, 0xbc000 and 0xbd000 are already
	394	* used for the CPU Measurement Sampling facility.
	395	*/
	396	PMU_FORMAT_ATTR(event, "config:0-63");
	397
	398	static struct attribute *paicrypt_format_attr[] = {
	399	&format_attr_event.attr,
	400	NULL,
	401	};
	402
	403	static struct attribute_group paicrypt_events_group = {
	404	.name = "events",
	405	.attrs = NULL /* Filled in attr_event_init() */
	406	};
	407
	408	static struct attribute_group paicrypt_format_group = {
	409	.name = "format",
	410	.attrs = paicrypt_format_attr,
	411	};
	412
	413	static const struct attribute_group *paicrypt_attr_groups[] = {
	414	&paicrypt_events_group,
	415	&paicrypt_format_group,
	416	NULL,
	417	};
	418
	419	/* Performance monitoring unit for mapped counters */
	420	static struct pmu paicrypt = {
	421	.task_ctx_nr = perf_invalid_context,
	422	.event_init = paicrypt_event_init,
	423	.add = paicrypt_add,
	424	.del = paicrypt_del,
	425	.start = paicrypt_start,
	426	.stop = paicrypt_stop,
	427	.read = paicrypt_read,
	428	.sched_task = paicrypt_sched_task,
	429	.attr_groups = paicrypt_attr_groups
	430	};
	431
	432	/* List of symbolic PAI counter names. */
	433	static const char * const paicrypt_ctrnames[] = {
	434	[0] = "CRYPTO_ALL",
	435	[1] = "KM_DEA",
	436	[2] = "KM_TDEA_128",
	437	[3] = "KM_TDEA_192",
	438	[4] = "KM_ENCRYPTED_DEA",
	439	[5] = "KM_ENCRYPTED_TDEA_128",
	440	[6] = "KM_ENCRYPTED_TDEA_192",
	441	[7] = "KM_AES_128",
	442	[8] = "KM_AES_192",
	443	[9] = "KM_AES_256",
	444	[10] = "KM_ENCRYPTED_AES_128",
	445	[11] = "KM_ENCRYPTED_AES_192",
	446	[12] = "KM_ENCRYPTED_AES_256",
	447	[13] = "KM_XTS_AES_128",
	448	[14] = "KM_XTS_AES_256",
	449	[15] = "KM_XTS_ENCRYPTED_AES_128",
	450	[16] = "KM_XTS_ENCRYPTED_AES_256",
	451	[17] = "KMC_DEA",
	452	[18] = "KMC_TDEA_128",
	453	[19] = "KMC_TDEA_192",
	454	[20] = "KMC_ENCRYPTED_DEA",
	455	[21] = "KMC_ENCRYPTED_TDEA_128",
	456	[22] = "KMC_ENCRYPTED_TDEA_192",
	457	[23] = "KMC_AES_128",
	458	[24] = "KMC_AES_192",
	459	[25] = "KMC_AES_256",
	460	[26] = "KMC_ENCRYPTED_AES_128",
	461	[27] = "KMC_ENCRYPTED_AES_192",
	462	[28] = "KMC_ENCRYPTED_AES_256",
	463	[29] = "KMC_PRNG",
	464	[30] = "KMA_GCM_AES_128",
	465	[31] = "KMA_GCM_AES_192",
	466	[32] = "KMA_GCM_AES_256",
	467	[33] = "KMA_GCM_ENCRYPTED_AES_128",
	468	[34] = "KMA_GCM_ENCRYPTED_AES_192",
	469	[35] = "KMA_GCM_ENCRYPTED_AES_256",
	470	[36] = "KMF_DEA",
	471	[37] = "KMF_TDEA_128",
	472	[38] = "KMF_TDEA_192",
	473	[39] = "KMF_ENCRYPTED_DEA",
	474	[40] = "KMF_ENCRYPTED_TDEA_128",
	475	[41] = "KMF_ENCRYPTED_TDEA_192",
	476	[42] = "KMF_AES_128",
	477	[43] = "KMF_AES_192",
	478	[44] = "KMF_AES_256",
	479	[45] = "KMF_ENCRYPTED_AES_128",
	480	[46] = "KMF_ENCRYPTED_AES_192",
	481	[47] = "KMF_ENCRYPTED_AES_256",
	482	[48] = "KMCTR_DEA",
	483	[49] = "KMCTR_TDEA_128",
	484	[50] = "KMCTR_TDEA_192",
	485	[51] = "KMCTR_ENCRYPTED_DEA",
	486	[52] = "KMCTR_ENCRYPTED_TDEA_128",
	487	[53] = "KMCTR_ENCRYPTED_TDEA_192",
	488	[54] = "KMCTR_AES_128",
	489	[55] = "KMCTR_AES_192",
	490	[56] = "KMCTR_AES_256",
	491	[57] = "KMCTR_ENCRYPTED_AES_128",
	492	[58] = "KMCTR_ENCRYPTED_AES_192",
	493	[59] = "KMCTR_ENCRYPTED_AES_256",
	494	[60] = "KMO_DEA",
	495	[61] = "KMO_TDEA_128",
	496	[62] = "KMO_TDEA_192",
	497	[63] = "KMO_ENCRYPTED_DEA",
	498	[64] = "KMO_ENCRYPTED_TDEA_128",
	499	[65] = "KMO_ENCRYPTED_TDEA_192",
	500	[66] = "KMO_AES_128",
	501	[67] = "KMO_AES_192",
	502	[68] = "KMO_AES_256",
	503	[69] = "KMO_ENCRYPTED_AES_128",
	504	[70] = "KMO_ENCRYPTED_AES_192",
	505	[71] = "KMO_ENCRYPTED_AES_256",
	506	[72] = "KIMD_SHA_1",
	507	[73] = "KIMD_SHA_256",
	508	[74] = "KIMD_SHA_512",
	509	[75] = "KIMD_SHA3_224",
	510	[76] = "KIMD_SHA3_256",
	511	[77] = "KIMD_SHA3_384",
	512	[78] = "KIMD_SHA3_512",
	513	[79] = "KIMD_SHAKE_128",
	514	[80] = "KIMD_SHAKE_256",
	515	[81] = "KIMD_GHASH",
	516	[82] = "KLMD_SHA_1",
	517	[83] = "KLMD_SHA_256",
	518	[84] = "KLMD_SHA_512",
	519	[85] = "KLMD_SHA3_224",
	520	[86] = "KLMD_SHA3_256",
	521	[87] = "KLMD_SHA3_384",
	522	[88] = "KLMD_SHA3_512",
	523	[89] = "KLMD_SHAKE_128",
	524	[90] = "KLMD_SHAKE_256",
	525	[91] = "KMAC_DEA",
	526	[92] = "KMAC_TDEA_128",
	527	[93] = "KMAC_TDEA_192",
	528	[94] = "KMAC_ENCRYPTED_DEA",
	529	[95] = "KMAC_ENCRYPTED_TDEA_128",
	530	[96] = "KMAC_ENCRYPTED_TDEA_192",
	531	[97] = "KMAC_AES_128",
	532	[98] = "KMAC_AES_192",
	533	[99] = "KMAC_AES_256",
	534	[100] = "KMAC_ENCRYPTED_AES_128",
	535	[101] = "KMAC_ENCRYPTED_AES_192",
	536	[102] = "KMAC_ENCRYPTED_AES_256",
	537	[103] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_DEA",
	538	[104] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_TDEA_128",
	539	[105] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_TDEA_192",
	540	[106] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_DEA",
	541	[107] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_TDEA_128",
	542	[108] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_TDEA_192",
	543	[109] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_AES_128",
	544	[110] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_AES_192",
	545	[111] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_AES_256",
	546	[112] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_AES_128",
	547	[113] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_AES_192",
	548	[114] = "PCC_COMPUTE_LAST_BLOCK_CMAC_USING_ENCRYPTED_AES_256A",
	549	[115] = "PCC_COMPUTE_XTS_PARAMETER_USING_AES_128",
	550	[116] = "PCC_COMPUTE_XTS_PARAMETER_USING_AES_256",
	551	[117] = "PCC_COMPUTE_XTS_PARAMETER_USING_ENCRYPTED_AES_128",
	552	[118] = "PCC_COMPUTE_XTS_PARAMETER_USING_ENCRYPTED_AES_256",
	553	[119] = "PCC_SCALAR_MULTIPLY_P256",
	554	[120] = "PCC_SCALAR_MULTIPLY_P384",
	555	[121] = "PCC_SCALAR_MULTIPLY_P521",
	556	[122] = "PCC_SCALAR_MULTIPLY_ED25519",
	557	[123] = "PCC_SCALAR_MULTIPLY_ED448",
	558	[124] = "PCC_SCALAR_MULTIPLY_X25519",
	559	[125] = "PCC_SCALAR_MULTIPLY_X448",
	560	[126] = "PRNO_SHA_512_DRNG",
	561	[127] = "PRNO_TRNG_QUERY_RAW_TO_CONDITIONED_RATIO",
	562	[128] = "PRNO_TRNG",
	563	[129] = "KDSA_ECDSA_VERIFY_P256",
	564	[130] = "KDSA_ECDSA_VERIFY_P384",
	565	[131] = "KDSA_ECDSA_VERIFY_P521",
	566	[132] = "KDSA_ECDSA_SIGN_P256",
	567	[133] = "KDSA_ECDSA_SIGN_P384",
	568	[134] = "KDSA_ECDSA_SIGN_P521",
	569	[135] = "KDSA_ENCRYPTED_ECDSA_SIGN_P256",
	570	[136] = "KDSA_ENCRYPTED_ECDSA_SIGN_P384",
	571	[137] = "KDSA_ENCRYPTED_ECDSA_SIGN_P521",
	572	[138] = "KDSA_EDDSA_VERIFY_ED25519",
	573	[139] = "KDSA_EDDSA_VERIFY_ED448",
	574	[140] = "KDSA_EDDSA_SIGN_ED25519",
	575	[141] = "KDSA_EDDSA_SIGN_ED448",
	576	[142] = "KDSA_ENCRYPTED_EDDSA_SIGN_ED25519",
	577	[143] = "KDSA_ENCRYPTED_EDDSA_SIGN_ED448",
	578	[144] = "PCKMO_ENCRYPT_DEA_KEY",
	579	[145] = "PCKMO_ENCRYPT_TDEA_128_KEY",
	580	[146] = "PCKMO_ENCRYPT_TDEA_192_KEY",
	581	[147] = "PCKMO_ENCRYPT_AES_128_KEY",
	582	[148] = "PCKMO_ENCRYPT_AES_192_KEY",
	583	[149] = "PCKMO_ENCRYPT_AES_256_KEY",
	584	[150] = "PCKMO_ENCRYPT_ECC_P256_KEY",
	585	[151] = "PCKMO_ENCRYPT_ECC_P384_KEY",
	586	[152] = "PCKMO_ENCRYPT_ECC_P521_KEY",
	587	[153] = "PCKMO_ENCRYPT_ECC_ED25519_KEY",
	588	[154] = "PCKMO_ENCRYPT_ECC_ED448_KEY",
	589	[155] = "IBM_RESERVED_155",
	590	[156] = "IBM_RESERVED_156",
	591	};
	592
	593	static void __init attr_event_free(struct attribute **attrs, int num)
	594	{
	595	struct perf_pmu_events_attr *pa;
	596	int i;
	597
	598	for (i = 0; i < num; i++) {
	599	struct device_attribute *dap;
	600
	601	dap = container_of(attrs[i], struct device_attribute, attr);
	602	pa = container_of(dap, struct perf_pmu_events_attr, attr);
	603	kfree(pa);
	604	}
	605	kfree(attrs);
	606	}
	607
	608	static int __init attr_event_init_one(struct attribute **attrs, int num)
	609	{
	610	struct perf_pmu_events_attr *pa;
	611
	612	pa = kzalloc(sizeof(*pa), GFP_KERNEL);
	613	if (!pa)
	614	return -ENOMEM;
	615
	616	sysfs_attr_init(&pa->attr.attr);
	617	pa->id = PAI_CRYPTO_BASE + num;
	618	pa->attr.attr.name = paicrypt_ctrnames[num];
	619	pa->attr.attr.mode = 0444;
	620	pa->attr.show = cpumf_events_sysfs_show;
	621	pa->attr.store = NULL;
	622	attrs[num] = &pa->attr.attr;
	623	return 0;
	624	}
	625
	626	/* Create PMU sysfs event attributes on the fly. */
	627	static int __init attr_event_init(void)
	628	{
	629	struct attribute **attrs;
	630	int ret, i;
	631
	632	attrs = kmalloc_array(ARRAY_SIZE(paicrypt_ctrnames) + 1, sizeof(*attrs),
	633	GFP_KERNEL);
	634	if (!attrs)
	635	return -ENOMEM;
	636	for (i = 0; i < ARRAY_SIZE(paicrypt_ctrnames); i++) {
	637	ret = attr_event_init_one(attrs, i);
	638	if (ret) {
	639	attr_event_free(attrs, i - 1);
	640	return ret;
	641	}
	642	}
	643	attrs[i] = NULL;
	644	paicrypt_events_group.attrs = attrs;
	645	return 0;
	646	}
	647
	648	static int __init paicrypt_init(void)
	649	{
	650	struct qpaci_info_block ib;
	651	int rc;
	652
	653	if (!test_facility(196))
	654	return 0;
	655
	656	qpaci(&ib);
	657	paicrypt_cnt = ib.num_cc;
	658	if (paicrypt_cnt == 0)
	659	return 0;
	660	if (paicrypt_cnt >= PAI_CRYPTO_MAXCTR)
	661	paicrypt_cnt = PAI_CRYPTO_MAXCTR - 1;
	662
	663	rc = attr_event_init(); /* Export known PAI crypto events */
	664	if (rc) {
	665	pr_err("Creation of PMU pai_crypto /sysfs failed\n");
	666	return rc;
	667	}
	668
	669	/* Setup s390dbf facility */
	670	cfm_dbg = debug_register(KMSG_COMPONENT, 2, 256, 128);
	671	if (!cfm_dbg) {
	672	pr_err("Registration of s390dbf pai_crypto failed\n");
	673	return -ENOMEM;
	674	}
	675	debug_register_view(cfm_dbg, &debug_sprintf_view);
	676
	677	rc = perf_pmu_register(&paicrypt, "pai_crypto", -1);
	678	if (rc) {
	679	pr_err("Registering the pai_crypto PMU failed with rc=%i\n",
	680	rc);
	681	debug_unregister_view(cfm_dbg, &debug_sprintf_view);
	682	debug_unregister(cfm_dbg);
	683	return rc;
	684	}
	685	return 0;
	686	}
	687
	688	device_initcall(paicrypt_init);

arch/s390/kernel/relocate_kernel.S+2−1

  * moves the new kernel to its destination...
  * %r2 = pointer to first kimage_entry_t
  * %r3 = start address - where to jump to after the job is done...
+ * %r4 = subcode
  *
  * %r5 will be used as temp. storage
  * %r6 holds the destination address
 		jo	0b
 		j	.base
 	.done:
-		sgr	%r0,%r0		# clear register r0
+		lgr	%r0,%r4		# subcode
 		cghi	%r3,0
 		je	.diag
 		la	%r4,load_psw-.base(%r13)	# load psw-address into the register

arch/s390/kernel/setup.c+1−1

@@ -494,7 +494,7 @@ static void __init setup_lowcore_dat_off(void) · 493 unmodified lines
494	lc->return_mcck_lpswe = gen_lpswe(__LC_RETURN_MCCK_PSW);	494	lc->return_mcck_lpswe = gen_lpswe(__LC_RETURN_MCCK_PSW);
495	lc->preempt_count = PREEMPT_DISABLED;	495	lc->preempt_count = PREEMPT_DISABLED;
496		496
497	set_prefix((u32)(unsigned long) lc);	497	set_prefix(__pa(lc));
498	lowcore_ptr[0] = lc;	498	lowcore_ptr[0] = lc;
499	}	499	}
500		500

arch/s390/kernel/time.c+5−7

  * Apply clock delta to the global data structures.
  * This is called once on the CPU that performed the clock sync.
  */
-static void clock_sync_global(unsigned long delta)
+static void clock_sync_global(long delta)
 {
 	unsigned long now, adj;
 	struct ptff_qto qto;
  * Apply clock delta to the per-CPU data structures of this CPU.
  * This is called for each online CPU after the call to clock_sync_global.
  */
-static void clock_sync_local(unsigned long delta)
+static void clock_sync_local(long delta)
 {
 	/* Add the delta to the clock comparator. */
 	if (S390_lowcore.clock_comparator != clock_comparator_max) {
 struct clock_sync_data {
 	atomic_t cpus;
 	int in_sync;
-	unsigned long clock_delta;
+	long clock_delta;
 };
 /*
 static int stp_sync_clock(void *data)
 {
 	struct clock_sync_data *sync = data;
-	u64 clock_delta, flags;
+	long clock_delta, flags;
 	static int first;
 	int rc;
 		while (atomic_read(&sync->cpus) != 0)
 			cpu_relax();
 		rc = 0;
-		if (stp_info.todoff[0] || stp_info.todoff[1] ||
+		if (stp_info.todoff || stp_info.tmd != 2) {
-		    stp_info.todoff[2] || stp_info.todoff[3] ||
-		    stp_info.tmd != 2) {
 			flags = vdso_update_begin();
 			rc = chsc_sstpc(stp_page, STP_OP_SYNC, 0,
 					&clock_delta);

arch/s390/kernel/vdso.c+50−5

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <linux/slab.h>	16	#include <linux/slab.h>
17	#include <linux/smp.h>	17	#include <linux/smp.h>
18	#include <linux/time_namespace.h>	18	#include <linux/time_namespace.h>
		19	#include <linux/random.h>
19	#include <vdso/datapage.h>	20	#include <vdso/datapage.h>
20	#include <asm/vdso.h>	21	#include <asm/vdso.h>
21		22
@@ -160,10 +161,9 @@ int vdso_getcpu_init(void) · 138 unmodified lines
160	}	161	}
161	early_initcall(vdso_getcpu_init); /* Must be called before SMP init */	162	early_initcall(vdso_getcpu_init); /* Must be called before SMP init */
162		163
163	int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)	164	static int map_vdso(unsigned long addr, unsigned long vdso_mapping_len)
164	{	165	{
165	unsigned long vdso_text_len, vdso_mapping_len;	166	unsigned long vvar_start, vdso_text_start, vdso_text_len;
166	unsigned long vvar_start, vdso_text_start;
167	struct vm_special_mapping *vdso_mapping;	167	struct vm_special_mapping *vdso_mapping;
168	struct mm_struct *mm = current->mm;	168	struct mm_struct *mm = current->mm;
169	struct vm_area_struct *vma;	169	struct vm_area_struct *vma;
@@ -180,8 +180,7 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) · 10 unmodified lines
180	vdso_text_len = vdso64_end - vdso64_start;	180	vdso_text_len = vdso64_end - vdso64_start;
181	vdso_mapping = &vdso64_mapping;	181	vdso_mapping = &vdso64_mapping;
182	}	182	}
183	vdso_mapping_len = vdso_text_len + VVAR_NR_PAGES * PAGE_SIZE;	183	vvar_start = get_unmapped_area(NULL, addr, vdso_mapping_len, 0, 0);
184	vvar_start = get_unmapped_area(NULL, 0, vdso_mapping_len, 0, 0);
185	rc = vvar_start;	184	rc = vvar_start;
186	if (IS_ERR_VALUE(vvar_start))	185	if (IS_ERR_VALUE(vvar_start))
187	goto out;	186	goto out;
@@ -210,6 +209,52 @@ out: · 22 unmodified lines
210	return rc;	209	return rc;
211	}	210	}
212		211
		212	static unsigned long vdso_addr(unsigned long start, unsigned long len)
		213	{
		214	unsigned long addr, end, offset;
		215
		216	/*
		217	* Round up the start address. It can start out unaligned as a result
		218	* of stack start randomization.
		219	*/
		220	start = PAGE_ALIGN(start);
		221
		222	/* Round the lowest possible end address up to a PMD boundary. */
		223	end = (start + len + PMD_SIZE - 1) & PMD_MASK;
		224	if (end >= VDSO_BASE)
		225	end = VDSO_BASE;
		226	end -= len;
		227
		228	if (end > start) {
		229	offset = get_random_int() % (((end - start) >> PAGE_SHIFT) + 1);
		230	addr = start + (offset << PAGE_SHIFT);
		231	} else {
		232	addr = start;
		233	}
		234	return addr;
		235	}
		236
		237	unsigned long vdso_size(void)
		238	{
		239	unsigned long size = VVAR_NR_PAGES * PAGE_SIZE;
		240
		241	if (is_compat_task())
		242	size += vdso32_end - vdso32_start;
		243	else
		244	size += vdso64_end - vdso64_start;
		245	return PAGE_ALIGN(size);
		246	}
		247
		248	int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
		249	{
		250	unsigned long addr = VDSO_BASE;
		251	unsigned long size = vdso_size();
		252
		253	if (current->flags & PF_RANDOMIZE)
		254	addr = vdso_addr(current->mm->start_stack + PAGE_SIZE, size);
		255	return map_vdso(addr, size);
		256	}
		257
213	static struct page ** __init vdso_setup_pages(void start, void end)	258	static struct page ** __init vdso_setup_pages(void start, void end)
214	{	259	{
215	int pages = (end - start) >> PAGE_SHIFT;	260	int pages = (end - start) >> PAGE_SHIFT;

arch/s390/kvm/priv.c+0−1

@@ -11,7 +11,6 @@ · 10 unmodified lines
11	#include <linux/kvm.h>	11	#include <linux/kvm.h>
12	#include <linux/gfp.h>	12	#include <linux/gfp.h>
13	#include <linux/errno.h>	13	#include <linux/errno.h>
14	#include <linux/compat.h>
15	#include <linux/mm_types.h>	14	#include <linux/mm_types.h>
16	#include <linux/pgtable.h>	15	#include <linux/pgtable.h>
17		16

arch/s390/lib/spinlock.c+2−2

@@ -75,7 +75,7 @@ static inline int arch_load_niai4(int *lock) · 74 unmodified lines
75	int owner;	75	int owner;
76		76
77	asm_inline volatile(	77	asm_inline volatile(
78	ALTERNATIVE("", ".insn rre,0xb2fa0000,4,0", 49) /* NIAI 4 */	78	ALTERNATIVE("nop", ".insn rre,0xb2fa0000,4,0", 49) /* NIAI 4 */
79	" l %0,%1\n"	79	" l %0,%1\n"
80	: "=d" (owner) : "Q" (*lock) : "memory");	80	: "=d" (owner) : "Q" (*lock) : "memory");
81	return owner;	81	return owner;
@@ -86,7 +86,7 @@ static inline int arch_cmpxchg_niai8(int *lock, int old, int new) · 4 unmodified lines
86	int expected = old;	86	int expected = old;
87		87
88	asm_inline volatile(	88	asm_inline volatile(
89	ALTERNATIVE("", ".insn rre,0xb2fa0000,8,0", 49) /* NIAI 8 */	89	ALTERNATIVE("nop", ".insn rre,0xb2fa0000,8,0", 49) /* NIAI 8 */
90	" cs %0,%3,%1\n"	90	" cs %0,%3,%1\n"
91	: "=d" (old), "=Q" (*lock)	91	: "=d" (old), "=Q" (*lock)
92	: "0" (old), "d" (new), "Q" (*lock)	92	: "0" (old), "d" (new), "Q" (*lock)

arch/s390/mm/mmap.c+2−2

@@ -58,9 +58,9 @@ static inline unsigned long mmap_base(unsigned long rnd, · 57 unmodified lines
58		58
59	/*	59	/*
60	* Top of mmap area (just below the process stack).	60	* Top of mmap area (just below the process stack).
61	* Leave at least a ~32 MB hole.	61	* Leave at least a ~128 MB hole.
62	*/	62	*/
63	gap_min = 32 * 1024 * 1024UL;	63	gap_min = SZ_128M;
64	gap_max = (STACK_TOP / 6) * 5;	64	gap_max = (STACK_TOP / 6) * 5;
65		65
66	if (gap < gap_min)	66	if (gap < gap_min)

arch/s390/pci/pci.c+1−1

@@ -799,7 +799,7 @@ struct zpci_dev *zpci_create_device(u32 fid, u32 fh, enum zpci_state state) · 798 unmodified lines
799	struct zpci_dev *zdev;	799	struct zpci_dev *zdev;
800	int rc;	800	int rc;
801		801
802	zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, state);	802	zpci_dbg(1, "add fid:%x, fh:%x, c:%d\n", fid, fh, state);
803	zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);	803	zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);
804	if (!zdev)	804	if (!zdev)
805	return ERR_PTR(-ENOMEM);	805	return ERR_PTR(-ENOMEM);

arch/s390/pci/pci_clp.c+1−1

@@ -30,7 +30,7 @@ bool zpci_unique_uid; · 29 unmodified lines
30	void update_uid_checking(bool new)	30	void update_uid_checking(bool new)
31	{	31	{
32	if (zpci_unique_uid != new)	32	if (zpci_unique_uid != new)
33	zpci_dbg(1, "uid checking:%d\n", new);	33	zpci_dbg(3, "uid checking:%d\n", new);
34		34
35	zpci_unique_uid = new;	35	zpci_unique_uid = new;
36	}	36	}

arch/s390/pci/pci_debug.c+1−1

@@ -196,7 +196,7 @@ int __init zpci_debug_init(void) · 195 unmodified lines
196	if (!pci_debug_err_id)	196	if (!pci_debug_err_id)
197	return -EINVAL;	197	return -EINVAL;
198	debug_register_view(pci_debug_err_id, &debug_hex_ascii_view);	198	debug_register_view(pci_debug_err_id, &debug_hex_ascii_view);
199	debug_set_level(pci_debug_err_id, 6);	199	debug_set_level(pci_debug_err_id, 3);
200		200
201	debugfs_root = debugfs_create_dir("pci", NULL);	201	debugfs_root = debugfs_create_dir("pci", NULL);
202	return 0;	202	return 0;

arch/s390/pci/pci_event.c+0−3

@@ -321,9 +321,6 @@ static void __zpci_event_availability(struct zpci_ccdf_avail *ccdf) · 320 unmodified lines
321		321
322	zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",	322	zpci_dbg(3, "avl fid:%x, fh:%x, pec:%x\n",
323	ccdf->fid, ccdf->fh, ccdf->pec);	323	ccdf->fid, ccdf->fh, ccdf->pec);
324	zpci_err("avail CCDF:\n");
325	zpci_err_hex(ccdf, sizeof(*ccdf));
326
327	switch (ccdf->pec) {	324	switch (ccdf->pec) {
328	case 0x0301: /* Reserved\|Standby -> Configured */	325	case 0x0301: /* Reserved\|Standby -> Configured */
329	if (!zdev) {	326	if (!zdev) {

arch/s390/pci/pci_insn.c+86−22

@@ -18,16 +18,40 @@ · 17 unmodified lines
18		18
19	#define ZPCI_INSN_BUSY_DELAY 1 /* 1 microsecond */	19	#define ZPCI_INSN_BUSY_DELAY 1 /* 1 microsecond */
20		20
21	static inline void zpci_err_insn(u8 cc, u8 status, u64 req, u64 offset)	21	struct zpci_err_insn_data {
		22	u8 insn;
		23	u8 cc;
		24	u8 status;
		25	union {
		26	struct {
		27	u64 req;
		28	u64 offset;
		29	};
		30	struct {
		31	u64 addr;
		32	u64 len;
		33	};
		34	};
		35	} __packed;
		36
		37	static inline void zpci_err_insn_req(int lvl, u8 insn, u8 cc, u8 status,
		38	u64 req, u64 offset)
22	{	39	{
23	struct {	40	struct zpci_err_insn_data data = {
24	u64 req;	41	.insn = insn, .cc = cc, .status = status,
25	u64 offset;	42	.req = req, .offset = offset};
26	u8 cc;	43
27	u8 status;	44	zpci_err_hex_level(lvl, &data, sizeof(data));
28	} __packed data = {req, offset, cc, status};	45	}
29		46
30	zpci_err_hex(&data, sizeof(data));	47	static inline void zpci_err_insn_addr(int lvl, u8 insn, u8 cc, u8 status,
		48	u64 addr, u64 len)
		49	{
		50	struct zpci_err_insn_data data = {
		51	.insn = insn, .cc = cc, .status = status,
		52	.addr = addr, .len = len};
		53
		54	zpci_err_hex_level(lvl, &data, sizeof(data));
31	}	55	}
32		56
33	/* Modify PCI Function Controls */	57	/* Modify PCI Function Controls */
@@ -47,16 +71,24 @@ static inline u8 __mpcifc(u64 req, struct zpci_fib fib, u8 status) · 13 unmodified lines
47		71
48	u8 zpci_mod_fc(u64 req, struct zpci_fib fib, u8 status)	72	u8 zpci_mod_fc(u64 req, struct zpci_fib fib, u8 status)
49	{	73	{
		74	bool retried = false;
50	u8 cc;	75	u8 cc;
51		76
52	do {	77	do {
53	cc = __mpcifc(req, fib, status);	78	cc = __mpcifc(req, fib, status);
54	if (cc == 2)	79	if (cc == 2) {
55	msleep(ZPCI_INSN_BUSY_DELAY);	80	msleep(ZPCI_INSN_BUSY_DELAY);
		81	if (!retried) {
		82	zpci_err_insn_req(1, 'M', cc, *status, req, 0);
		83	retried = true;
		84	}
		85	}
56	} while (cc == 2);	86	} while (cc == 2);
57		87
58	if (cc)	88	if (cc)
59	zpci_err_insn(cc, *status, req, 0);	89	zpci_err_insn_req(0, 'M', cc, *status, req, 0);
		90	else if (retried)
		91	zpci_err_insn_req(1, 'M', cc, *status, req, 0);
60		92
61	return cc;	93	return cc;
62	}	94	}
@@ -80,16 +112,24 @@ static inline u8 __rpcit(u64 fn, u64 addr, u64 range, u8 *status) · 17 unmodified lines
80		112
81	int zpci_refresh_trans(u64 fn, u64 addr, u64 range)	113	int zpci_refresh_trans(u64 fn, u64 addr, u64 range)
82	{	114	{
		115	bool retried = false;
83	u8 cc, status;	116	u8 cc, status;
84		117
85	do {	118	do {
86	cc = __rpcit(fn, addr, range, &status);	119	cc = __rpcit(fn, addr, range, &status);
87	if (cc == 2)	120	if (cc == 2) {
88	udelay(ZPCI_INSN_BUSY_DELAY);	121	udelay(ZPCI_INSN_BUSY_DELAY);
		122	if (!retried) {
		123	zpci_err_insn_addr(1, 'R', cc, status, addr, range);
		124	retried = true;
		125	}
		126	}
89	} while (cc == 2);	127	} while (cc == 2);
90		128
91	if (cc)	129	if (cc)
92	zpci_err_insn(cc, status, addr, range);	130	zpci_err_insn_addr(0, 'R', cc, status, addr, range);
		131	else if (retried)
		132	zpci_err_insn_addr(1, 'R', cc, status, addr, range);
93		133
94	if (cc == 1 && (status == 4 \|\| status == 16))	134	if (cc == 1 && (status == 4 \|\| status == 16))
95	return -ENOMEM;	135	return -ENOMEM;
@@ -144,17 +184,25 @@ static inline int __pcilg(u64 data, u64 req, u64 offset, u8 status) · 48 unmodified lines
144		184
145	int __zpci_load(u64 *data, u64 req, u64 offset)	185	int __zpci_load(u64 *data, u64 req, u64 offset)
146	{	186	{
		187	bool retried = false;
147	u8 status;	188	u8 status;
148	int cc;	189	int cc;
149		190
150	do {	191	do {
151	cc = __pcilg(data, req, offset, &status);	192	cc = __pcilg(data, req, offset, &status);
152	if (cc == 2)	193	if (cc == 2) {
153	udelay(ZPCI_INSN_BUSY_DELAY);	194	udelay(ZPCI_INSN_BUSY_DELAY);
		195	if (!retried) {
		196	zpci_err_insn_req(1, 'l', cc, status, req, offset);
		197	retried = true;
		198	}
		199	}
154	} while (cc == 2);	200	} while (cc == 2);
155		201
156	if (cc)	202	if (cc)
157	zpci_err_insn(cc, status, req, offset);	203	zpci_err_insn_req(0, 'l', cc, status, req, offset);
		204	else if (retried)
		205	zpci_err_insn_req(1, 'l', cc, status, req, offset);
158		206
159	return (cc > 0) ? -EIO : cc;	207	return (cc > 0) ? -EIO : cc;
160	}	208	}
@@ -198,7 +246,7 @@ int zpci_load(u64 data, const volatile void __iomem addr, unsigned long len) · 37 unmodified lines
198		246
199	cc = __pcilg_mio(data, (__force u64) addr, len, &status);	247	cc = __pcilg_mio(data, (__force u64) addr, len, &status);
200	if (cc)	248	if (cc)
201	zpci_err_insn(cc, status, 0, (__force u64) addr);	249	zpci_err_insn_addr(0, 'L', cc, status, (__force u64) addr, len);
202		250
203	return (cc > 0) ? -EIO : cc;	251	return (cc > 0) ? -EIO : cc;
204	}	252	}
@@ -225,17 +273,25 @@ static inline int __pcistg(u64 data, u64 req, u64 offset, u8 *status) · 20 unmodified lines
225		273
226	int __zpci_store(u64 data, u64 req, u64 offset)	274	int __zpci_store(u64 data, u64 req, u64 offset)
227	{	275	{
		276	bool retried = false;
228	u8 status;	277	u8 status;
229	int cc;	278	int cc;
230		279
231	do {	280	do {
232	cc = __pcistg(data, req, offset, &status);	281	cc = __pcistg(data, req, offset, &status);
233	if (cc == 2)	282	if (cc == 2) {
234	udelay(ZPCI_INSN_BUSY_DELAY);	283	udelay(ZPCI_INSN_BUSY_DELAY);
		284	if (!retried) {
		285	zpci_err_insn_req(1, 's', cc, status, req, offset);
		286	retried = true;
		287	}
		288	}
235	} while (cc == 2);	289	} while (cc == 2);
236		290
237	if (cc)	291	if (cc)
238	zpci_err_insn(cc, status, req, offset);	292	zpci_err_insn_req(0, 's', cc, status, req, offset);
		293	else if (retried)
		294	zpci_err_insn_req(1, 's', cc, status, req, offset);
239		295
240	return (cc > 0) ? -EIO : cc;	296	return (cc > 0) ? -EIO : cc;
241	}	297	}
@@ -278,7 +334,7 @@ int zpci_store(const volatile void __iomem *addr, u64 data, unsigned long len) · 36 unmodified lines
278		334
279	cc = __pcistg_mio(data, (__force u64) addr, len, &status);	335	cc = __pcistg_mio(data, (__force u64) addr, len, &status);
280	if (cc)	336	if (cc)
281	zpci_err_insn(cc, status, 0, (__force u64) addr);	337	zpci_err_insn_addr(0, 'S', cc, status, (__force u64) addr, len);
282		338
283	return (cc > 0) ? -EIO : cc;	339	return (cc > 0) ? -EIO : cc;
284	}	340	}
@@ -304,17 +360,25 @@ static inline int __pcistb(const u64 data, u64 req, u64 offset, u8 status) · 19 unmodified lines
304		360
305	int __zpci_store_block(const u64 *data, u64 req, u64 offset)	361	int __zpci_store_block(const u64 *data, u64 req, u64 offset)
306	{	362	{
		363	bool retried = false;
307	u8 status;	364	u8 status;
308	int cc;	365	int cc;
309		366
310	do {	367	do {
311	cc = __pcistb(data, req, offset, &status);	368	cc = __pcistb(data, req, offset, &status);
312	if (cc == 2)	369	if (cc == 2) {
313	udelay(ZPCI_INSN_BUSY_DELAY);	370	udelay(ZPCI_INSN_BUSY_DELAY);
		371	if (!retried) {
		372	zpci_err_insn_req(0, 'b', cc, status, req, offset);
		373	retried = true;
		374	}
		375	}
314	} while (cc == 2);	376	} while (cc == 2);
315		377
316	if (cc)	378	if (cc)
317	zpci_err_insn(cc, status, req, offset);	379	zpci_err_insn_req(0, 'b', cc, status, req, offset);
		380	else if (retried)
		381	zpci_err_insn_req(1, 'b', cc, status, req, offset);
318		382
319	return (cc > 0) ? -EIO : cc;	383	return (cc > 0) ? -EIO : cc;
320	}	384	}
@@ -358,7 +422,7 @@ int zpci_write_block(volatile void __iomem *dst, · 37 unmodified lines
358		422
359	cc = __pcistb_mio(src, (__force u64) dst, len, &status);	423	cc = __pcistb_mio(src, (__force u64) dst, len, &status);
360	if (cc)	424	if (cc)
361	zpci_err_insn(cc, status, 0, (__force u64) dst);	425	zpci_err_insn_addr(0, 'B', cc, status, (__force u64) dst, len);
362		426
363	return (cc > 0) ? -EIO : cc;	427	return (cc > 0) ? -EIO : cc;
364	}	428	}

arch/s390/purgatory/head.S+23−7

 .endm
 .macro MEMSWAP dst,src,buf,len
-10:	cghi	\len,bufsz
+10:	larl	%r0,purgatory_end
+	larl	%r1,stack
+	slgr	%r0,%r1
+	cgr	\len,%r0
 	jh	11f
 	lgr	%r4,\len
 	j	12f
-11:	lghi	%r4,bufsz
+11:	lgr	%r4,%r0
 12:	MEMCPY	\buf,\dst,%r4
 	MEMCPY	\dst,\src,%r4
 .start_crash_kernel:
 	/* Location of purgatory_start in crash memory */
+	larl	%r0,.base_crash
+	larl	%r1,purgatory_start
+	slgr	%r0,%r1
 	lgr	%r8,%r13
-	aghi	%r8,-(.base_crash-purgatory_start)
+	sgr	%r8,%r0
 	/* Destination for this code i.e. end of memory to be swapped. */
+	larl	%r0,purgatory_end
+	larl	%r1,purgatory_start
+	slgr	%r0,%r1
 	lg	%r9,crash_size-.base_crash(%r13)
-	aghi	%r9,-(purgatory_end-purgatory_start)
+	sgr	%r9,%r0
 	/* Destination in crash memory, i.e. same as r9 but in crash memory. */
 	lg	%r10,crash_start-.base_crash(%r13)
 	/* 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	%r11,purgatory_end
 	larl	%r12,stack
+	slgr	%r11,%r12
 	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
+	larl	%r0,.jump_to_dst
+	larl	%r1,purgatory_start
+	slgr	%r0,%r1
+	agr	%r7,%r0
 	br	%r7
 .jump_to_dst:
 	/* Load new buffer location after jump */
 	larl	%r7,stack
-	aghi	%r10,stack-purgatory_start
+	lgr	%r0,%r7
+	larl	%r1,purgatory_start
+	slgr	%r0,%r1
+	agr	%r10,%r0
 	MEMCPY	%r10,%r7,%r11	/* (new) buf -> (crash) buf */
 	/* Now the code is set up to run from its designated location. Start

arch/x86/include/asm/entry-common.h+2−2

@@ -10,7 +10,7 @@ · 9 unmodified lines
10	#include <asm/fpu/api.h>	10	#include <asm/fpu/api.h>
11		11
12	/* Check that the stack and regs on entry from user mode are sane. */	12	/* Check that the stack and regs on entry from user mode are sane. */
13	static __always_inline void arch_check_user_regs(struct pt_regs *regs)	13	static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs)
14	{	14	{
15	if (IS_ENABLED(CONFIG_DEBUG_ENTRY)) {	15	if (IS_ENABLED(CONFIG_DEBUG_ENTRY)) {
16	/*	16	/*
@@ -42,7 +42,7 @@ static __always_inline void arch_check_user_regs(struct pt_regs *regs) · 25 unmodified lines
42	WARN_ON_ONCE(regs != task_pt_regs(current));	42	WARN_ON_ONCE(regs != task_pt_regs(current));
43	}	43	}
44	}	44	}
45	#define arch_check_user_regs arch_check_user_regs	45	#define arch_enter_from_user_mode arch_enter_from_user_mode
46		46
47	static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,	47	static inline void arch_exit_to_user_mode_prepare(struct pt_regs *regs,
48	unsigned long ti_work)	48	unsigned long ti_work)

drivers/s390/char/con3215.c+13−12

 }
 /*
- * panic() calls con3215_flush through a panic_notifier
+ * The below function is called as a panic/reboot notifier before the
- * before the system enters a disabled, endless loop.
+ * system enters a disabled, endless loop.
+ *
+ * Notice we must use the spin_trylock() alternative, to prevent lockups
+ * in atomic context (panic routine runs with secondary CPUs, local IRQs
+ * and preemption disabled).
  */
-static void con3215_flush(void)
+static int con3215_notify(struct notifier_block *self,
+			  unsigned long event, void *data)
 {
 	struct raw3215_info *raw;
 	unsigned long flags;
 	raw = raw3215[0];  /* console 3215 is the first one */
-	spin_lock_irqsave(get_ccwdev_lock(raw->cdev), flags);
+	if (!spin_trylock_irqsave(get_ccwdev_lock(raw->cdev), flags))
+		return NOTIFY_DONE;
 	raw3215_make_room(raw, RAW3215_BUFFER_SIZE);
 	spin_unlock_irqrestore(get_ccwdev_lock(raw->cdev), flags);
-}
-static int con3215_notify(struct notifier_block *self,
+	return NOTIFY_DONE;
-			  unsigned long event, void *data)
-{
-	con3215_flush();
-	return NOTIFY_OK;
 }
 static struct notifier_block on_panic_nb = {
 	.notifier_call = con3215_notify,
-	.priority = 0,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 static struct notifier_block on_reboot_nb = {
 	.notifier_call = con3215_notify,
-	.priority = 0,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 /*

drivers/s390/char/con3270.c+16−15

 }
 /*
- * panic() calls con3270_flush through a panic_notifier
+ * The below function is called as a panic/reboot notifier before the
- * before the system enters a disabled, endless loop.
+ * system enters a disabled, endless loop.
+ *
+ * Notice we must use the spin_trylock() alternative, to prevent lockups
+ * in atomic context (panic routine runs with secondary CPUs, local IRQs
+ * and preemption disabled).
  */
-static void
+static int con3270_notify(struct notifier_block *self,
-con3270_flush(void)
+			  unsigned long event, void *data)
 {
 	struct con3270 *cp;
 	unsigned long flags;
 	cp = condev;
 	if (!cp->view.dev)
-		return;
+		return NOTIFY_DONE;
-	raw3270_activate_view(&cp->view);
+	if (!raw3270_view_lock_unavailable(&cp->view))
-	spin_lock_irqsave(&cp->view.lock, flags);
+		raw3270_activate_view(&cp->view);
+	if (!spin_trylock_irqsave(&cp->view.lock, flags))
+		return NOTIFY_DONE;
 	con3270_wait_write(cp);
 	cp->nr_up = 0;
 	con3270_rebuild_update(cp);
 		con3270_wait_write(cp);
 	}
 	spin_unlock_irqrestore(&cp->view.lock, flags);
-}
-static int con3270_notify(struct notifier_block *self,
+	return NOTIFY_DONE;
-			  unsigned long event, void *data)
-{
-	con3270_flush();
-	return NOTIFY_OK;
 }
 static struct notifier_block on_panic_nb = {
 	.notifier_call = con3270_notify,
-	.priority = 0,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 static struct notifier_block on_reboot_nb = {
 	.notifier_call = con3270_notify,
-	.priority = 0,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 /*

drivers/s390/char/raw3270.c+15−0

@@ -830,6 +830,21 @@ raw3270_create_device(struct ccw_device *cdev) · 829 unmodified lines
830	return rp;	830	return rp;
831	}	831	}
832		832
		833	/*
		834	* This helper just validates that it is safe to activate a
		835	* view in the panic() context, due to locking restrictions.
		836	*/
		837	int raw3270_view_lock_unavailable(struct raw3270_view *view)
		838	{
		839	struct raw3270 *rp = view->dev;
		840
		841	if (!rp)
		842	return -ENODEV;
		843	if (spin_is_locked(get_ccwdev_lock(rp->cdev)))
		844	return -EBUSY;
		845	return 0;
		846	}
		847
833	/*	848	/*
834	* Activate a view.	849	* Activate a view.
835	*/	850	*/

drivers/s390/char/raw3270.h+1−0

@@ -160,6 +160,7 @@ struct raw3270_view { · 159 unmodified lines
160	};	160	};
161		161
162	int raw3270_add_view(struct raw3270_view , struct raw3270_fn , int, int);	162	int raw3270_add_view(struct raw3270_view , struct raw3270_fn , int, int);
		163	int raw3270_view_lock_unavailable(struct raw3270_view *view);
163	int raw3270_activate_view(struct raw3270_view *);	164	int raw3270_activate_view(struct raw3270_view *);
164	void raw3270_del_view(struct raw3270_view *);	165	void raw3270_del_view(struct raw3270_view *);
165	void raw3270_deactivate_view(struct raw3270_view *);	166	void raw3270_deactivate_view(struct raw3270_view *);

drivers/s390/char/sclp_con.c+15−11

 }
 /*
- * Make sure that all buffers will be flushed to the SCLP.
+ * This panic/reboot notifier makes sure that all buffers
+ * will be flushed to the SCLP.
  */
-static void
+static int sclp_console_notify(struct notifier_block *self,
-sclp_console_flush(void)
+			       unsigned long event, void *data)
 {
+	/*
+	 * Perform the lock check before effectively getting the
+	 * lock on sclp_conbuf_emit() / sclp_console_sync_queue()
+	 * to prevent potential lockups in atomic context.
+	 */
+	if (spin_is_locked(&sclp_con_lock))
+		return NOTIFY_DONE;
 	sclp_conbuf_emit();
 	sclp_console_sync_queue();
-}
-static int sclp_console_notify(struct notifier_block *self,
+	return NOTIFY_DONE;
-			       unsigned long event, void *data)
-{
-	sclp_console_flush();
-	return NOTIFY_OK;
 }
 static struct notifier_block on_panic_nb = {
 	.notifier_call = sclp_console_notify,
-	.priority = 1,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 static struct notifier_block on_reboot_nb = {
 	.notifier_call = sclp_console_notify,
-	.priority = 1,
+	.priority = INT_MIN + 1, /* run the callback late */
 };
 /*

drivers/s390/char/sclp_early.c+3−1

 		S390_lowcore.machine_flags |= MACHINE_FLAG_ESOP;
 	if (sccb->fac91 & 0x40)
 		S390_lowcore.machine_flags |= MACHINE_FLAG_TLB_GUEST;
-	if (sccb->cpuoff > 134)
+	if (sccb->cpuoff > 134) {
 		sclp.has_diag318 = !!(sccb->byte_134 & 0x80);
+		sclp.has_iplcc = !!(sccb->byte_134 & 0x02);
+	}
 	if (sccb->cpuoff > 137)
 		sclp.has_sipl = !!(sccb->cbl & 0x4000);
 	sclp.rnmax = sccb->rnmax ? sccb->rnmax : sccb->rnmax2;

drivers/s390/char/sclp_vt220.c+23−19

@@ -769,21 +769,6 @@ __initcall(sclp_vt220_tty_init); · 768 unmodified lines
769		769
770	#ifdef CONFIG_SCLP_VT220_CONSOLE	770	#ifdef CONFIG_SCLP_VT220_CONSOLE
771		771
772	static void __sclp_vt220_flush_buffer(void)
773	{
774	unsigned long flags;
775
776	sclp_vt220_emit_current();
777	spin_lock_irqsave(&sclp_vt220_lock, flags);
778	del_timer(&sclp_vt220_timer);
779	while (sclp_vt220_queue_running) {
780	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
781	sclp_sync_wait();
782	spin_lock_irqsave(&sclp_vt220_lock, flags);
783	}
784	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
785	}
786
787	static void	772	static void
788	sclp_vt220_con_write(struct console con, const char buf, unsigned int count)	773	sclp_vt220_con_write(struct console con, const char buf, unsigned int count)
789	{	774	{
@@ -797,22 +782,41 @@ sclp_vt220_con_device(struct console c, int index) · 7 unmodified lines
797	return sclp_vt220_driver;	782	return sclp_vt220_driver;
798	}	783	}
799		784
		785	/*
		786	* This panic/reboot notifier runs in atomic context, so
		787	* locking restrictions apply to prevent potential lockups.
		788	*/
800	static int	789	static int
801	sclp_vt220_notify(struct notifier_block *self,	790	sclp_vt220_notify(struct notifier_block *self,
802	unsigned long event, void *data)	791	unsigned long event, void *data)
803	{	792	{
804	__sclp_vt220_flush_buffer();	793	unsigned long flags;
805	return NOTIFY_OK;	794
		795	if (spin_is_locked(&sclp_vt220_lock))
		796	return NOTIFY_DONE;
		797
		798	sclp_vt220_emit_current();
		799
		800	spin_lock_irqsave(&sclp_vt220_lock, flags);
		801	del_timer(&sclp_vt220_timer);
		802	while (sclp_vt220_queue_running) {
		803	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
		804	sclp_sync_wait();
		805	spin_lock_irqsave(&sclp_vt220_lock, flags);
		806	}
		807	spin_unlock_irqrestore(&sclp_vt220_lock, flags);
		808
		809	return NOTIFY_DONE;
806	}	810	}
807		811
808	static struct notifier_block on_panic_nb = {	812	static struct notifier_block on_panic_nb = {
809	.notifier_call = sclp_vt220_notify,	813	.notifier_call = sclp_vt220_notify,
810	.priority = 1,	814	.priority = INT_MIN + 1, /* run the callback late */
811	};	815	};
812		816
813	static struct notifier_block on_reboot_nb = {	817	static struct notifier_block on_reboot_nb = {
814	.notifier_call = sclp_vt220_notify,	818	.notifier_call = sclp_vt220_notify,
815	.priority = 1,	819	.priority = INT_MIN + 1, /* run the callback late */
816	};	820	};
817		821
818	/* Structure needed to register with printk */	822	/* Structure needed to register with printk */

drivers/s390/cio/chsc.c+2−2

@@ -1255,7 +1255,7 @@ exit: · 1254 unmodified lines
1255	EXPORT_SYMBOL_GPL(css_general_characteristics);	1255	EXPORT_SYMBOL_GPL(css_general_characteristics);
1256	EXPORT_SYMBOL_GPL(css_chsc_characteristics);	1256	EXPORT_SYMBOL_GPL(css_chsc_characteristics);
1257		1257
1258	int chsc_sstpc(void page, unsigned int op, u16 ctrl, u64 clock_delta)	1258	int chsc_sstpc(void page, unsigned int op, u16 ctrl, long clock_delta)
1259	{	1259	{
1260	struct {	1260	struct {
1261	struct chsc_header request;	1261	struct chsc_header request;
@@ -1266,7 +1266,7 @@ int chsc_sstpc(void page, unsigned int op, u16 ctrl, u64 clock_delta) · 4 unmodified lines
1266	unsigned int rsvd2[5];	1266	unsigned int rsvd2[5];
1267	struct chsc_header response;	1267	struct chsc_header response;
1268	unsigned int rsvd3[3];	1268	unsigned int rsvd3[3];
1269	u64 clock_delta;	1269	s64 clock_delta;
1270	unsigned int rsvd4[2];	1270	unsigned int rsvd4[2];
1271	} *rr;	1271	} *rr;
1272	int rc;	1272	int rc;

drivers/s390/crypto/ap_bus.c+63−33

  * ap_apft_available(): Test if AP facilities test (APFT)
  * facility is available.
  *
- * Returns 1 if APFT is is available.
+ * Returns 1 if APFT is available.
  */
 static int ap_apft_available(void)
 {
 }
 EXPORT_SYMBOL(ap_send_online_uevent);
+static void ap_send_mask_changed_uevent(unsigned long *newapm,
+					unsigned long *newaqm)
+{
+	char buf[100];
+	char *envp[] = { buf, NULL };
+	if (newapm)
+		snprintf(buf, sizeof(buf),
+			 "APMASK=0x%016lx%016lx%016lx%016lx\n",
+			 newapm[0], newapm[1], newapm[2], newapm[3]);
+	else
+		snprintf(buf, sizeof(buf),
+			 "AQMASK=0x%016lx%016lx%016lx%016lx\n",
+			 newaqm[0], newaqm[1], newaqm[2], newaqm[3]);
+	kobject_uevent_env(&ap_root_device->kobj, KOBJ_CHANGE, envp);
+}
 /*
  * calc # of bound APQNs
  */
 static int __ap_calc_helper(struct device *dev, void *arg)
 {
-	struct __ap_calc_ctrs *pctrs = (struct __ap_calc_ctrs *) arg;
+	struct __ap_calc_ctrs *pctrs = (struct __ap_calc_ctrs *)arg;
 	if (is_queue_dev(dev)) {
 		pctrs->apqns++;
 	struct __ap_calc_ctrs ctrs;
 	memset(&ctrs, 0, sizeof(ctrs));
-	bus_for_each_dev(&ap_bus_type, NULL, (void *) &ctrs, __ap_calc_helper);
+	bus_for_each_dev(&ap_bus_type, NULL, (void *)&ctrs, __ap_calc_helper);
 	*apqns = ctrs.apqns;
 	*bound = ctrs.bound;
 static int __ap_queue_devices_with_id_unregister(struct device *dev, void *data)
 {
 	if (is_queue_dev(dev) &&
-	    AP_QID_CARD(to_ap_queue(dev)->qid) == (int)(long) data)
+	    AP_QID_CARD(to_ap_queue(dev)->qid) == (int)(long)data)
 		device_unregister(dev);
 	return 0;
 }
 		card = AP_QID_CARD(to_ap_queue(dev)->qid);
 		queue = AP_QID_QUEUE(to_ap_queue(dev)->qid);
 		mutex_lock(&ap_perms_mutex);
-		devres = test_bit_inv(card, ap_perms.apm)
+		devres = test_bit_inv(card, ap_perms.apm) &&
-			&& test_bit_inv(queue, ap_perms.aqm);
+			test_bit_inv(queue, ap_perms.aqm);
 		mutex_unlock(&ap_perms_mutex);
 		drvres = to_ap_drv(dev->driver)->flags
 			& AP_DRIVER_FLAG_DEFAULT;
 	mutex_lock(&ap_perms_mutex);
-	if (test_bit_inv(card, ap_perms.apm)
+	if (test_bit_inv(card, ap_perms.apm) &&
-	    && test_bit_inv(queue, ap_perms.aqm))
+	    test_bit_inv(queue, ap_perms.aqm))
 		rc = 1;
 	mutex_unlock(&ap_perms_mutex);
 		card = AP_QID_CARD(to_ap_queue(dev)->qid);
 		queue = AP_QID_QUEUE(to_ap_queue(dev)->qid);
 		mutex_lock(&ap_perms_mutex);
-		devres = test_bit_inv(card, ap_perms.apm)
+		devres = test_bit_inv(card, ap_perms.apm) &&
-			&& test_bit_inv(queue, ap_perms.aqm);
+			test_bit_inv(queue, ap_perms.aqm);
 		mutex_unlock(&ap_perms_mutex);
 		drvres = ap_drv->flags & AP_DRIVER_FLAG_DEFAULT;
 		if (!!devres != !!drvres)
 		if (is_queue_dev(dev))
 			hash_del(&to_ap_queue(dev)->hnode);
 		spin_unlock_bh(&ap_queues_lock);
-	} else
+	} else {
 		ap_check_bindings_complete();
+	}
 out:
 	if (rc)
 EXPORT_SYMBOL(ap_bus_force_rescan);
 /*
-* A config change has happened, force an ap bus rescan.
+ * A config change has happened, force an ap bus rescan.
-*/
+ */
 void ap_bus_cfg_chg(void)
 {
 	AP_DBF_DBG("%s config change, forcing bus rescan\n", __func__);
 	if (bits & 0x07)
 		return -EINVAL;
-	size = BITS_TO_LONGS(bits)*sizeof(unsigned long);
+	size = BITS_TO_LONGS(bits) * sizeof(unsigned long);
 	newmap = kmalloc(size, GFP_KERNEL);
 	if (!newmap)
 		return -ENOMEM;
 		rc = ap_poll_thread_start();
 		if (rc)
 			count = rc;
-	} else
+	} else {
 		ap_poll_thread_stop();
+	}
 	return count;
 }
 static ssize_t apmask_store(struct bus_type *bus, const char *buf,
 			    size_t count)
 {
-	int rc;
+	int rc, changes = 0;
 	DECLARE_BITMAP(newapm, AP_DEVICES);
 	if (mutex_lock_interruptible(&ap_perms_mutex))
 	if (rc)
 		goto done;
-	rc = apmask_commit(newapm);
+	changes = memcmp(ap_perms.apm, newapm, APMASKSIZE);
+	if (changes)
+		rc = apmask_commit(newapm);
 done:
 	mutex_unlock(&ap_perms_mutex);
 	if (rc)
 		return rc;
-	ap_bus_revise_bindings();
+	if (changes) {
+		ap_bus_revise_bindings();
+		ap_send_mask_changed_uevent(newapm, NULL);
+	}
 	return count;
 }
 static ssize_t aqmask_store(struct bus_type *bus, const char *buf,
 			    size_t count)
 {
-	int rc;
+	int rc, changes = 0;
 	DECLARE_BITMAP(newaqm, AP_DOMAINS);
 	if (mutex_lock_interruptible(&ap_perms_mutex))
 	if (rc)
 		goto done;
-	rc = aqmask_commit(newaqm);
+	changes = memcmp(ap_perms.aqm, newaqm, APMASKSIZE);
+	if (changes)
+		rc = aqmask_commit(newaqm);
 done:
 	mutex_unlock(&ap_perms_mutex);
 	if (rc)
 		return rc;
-	ap_bus_revise_bindings();
+	if (changes) {
+		ap_bus_revise_bindings();
+		ap_send_mask_changed_uevent(NULL, newaqm);
+	}
 	return count;
 }
 		apinfo.mode = (func >> 26) & 0x07;
 		apinfo.cat = AP_DEVICE_TYPE_CEX8;
 		status = ap_qact(qid, 0, &apinfo);
-		if (status.response_code == AP_RESPONSE_NORMAL
+		if (status.response_code == AP_RESPONSE_NORMAL &&
-		    && apinfo.cat >= AP_DEVICE_TYPE_CEX2A
+		    apinfo.cat >= AP_DEVICE_TYPE_CEX2A &&
-		    && apinfo.cat <= AP_DEVICE_TYPE_CEX8)
+		    apinfo.cat <= AP_DEVICE_TYPE_CEX8)
 			comp_type = apinfo.cat;
 	}
 	if (!comp_type)
  */
 static int __match_card_device_with_id(struct device *dev, const void *data)
 {
-	return is_card_dev(dev) && to_ap_card(dev)->id == (int)(long)(void *) data;
+	return is_card_dev(dev) && to_ap_card(dev)->id == (int)(long)(void *)data;
 }
 /*
  */
 static int __match_queue_device_with_qid(struct device *dev, const void *data)
 {
-	return is_queue_dev(dev) && to_ap_queue(dev)->qid == (int)(long) data;
+	return is_queue_dev(dev) && to_ap_queue(dev)->qid == (int)(long)data;
 }
 /*
  */
 static int __match_queue_device_with_queue_id(struct device *dev, const void *data)
 {
-	return is_queue_dev(dev)
+	return is_queue_dev(dev) &&
-		&& AP_QID_QUEUE(to_ap_queue(dev)->qid) == (int)(long) data;
+		AP_QID_QUEUE(to_ap_queue(dev)->qid) == (int)(long)data;
 }
 /* Helper function for notify_config_changed */
 static inline void ap_scan_rm_card_dev_and_queue_devs(struct ap_card *ac)
 {
 	bus_for_each_dev(&ap_bus_type, NULL,
-			 (void *)(long) ac->id,
+			 (void *)(long)ac->id,
 			 __ap_queue_devices_with_id_unregister);
 	device_unregister(&ac->ap_dev.device);
 }
 	for (dom = 0; dom <= ap_max_domain_id; dom++) {
 		qid = AP_MKQID(ac->id, dom);
 		dev = bus_find_device(&ap_bus_type, NULL,
-				      (void *)(long) qid,
+				      (void *)(long)qid,
 				      __match_queue_device_with_qid);
 		aq = dev ? to_ap_queue(dev) : NULL;
 		if (!ap_test_config_usage_domain(dom)) {
 	/* Is there currently a card device for this adapter ? */
 	dev = bus_find_device(&ap_bus_type, NULL,
-			      (void *)(long) ap,
+			      (void *)(long)ap,
 			      __match_card_device_with_id);
 	ac = dev ? to_ap_card(dev) : NULL;
 	if (ap_domain_index >= 0) {
 		struct device *dev =
 			bus_find_device(&ap_bus_type, NULL,
-					(void *)(long) ap_domain_index,
+					(void *)(long)ap_domain_index,
 					__match_queue_device_with_queue_id);
 		if (dev)
 			put_device(dev);
 static void __init ap_perms_init(void)
 {
-	/* all resources useable if no kernel parameter string given */
+	/* all resources usable if no kernel parameter string given */
 	memset(&ap_perms.ioctlm, 0xFF, sizeof(ap_perms.ioctlm));
 	memset(&ap_perms.apm, 0xFF, sizeof(ap_perms.apm));
 	memset(&ap_perms.aqm, 0xFF, sizeof(ap_perms.aqm));

drivers/s390/crypto/ap_bus.h+1−0

@@ -317,6 +317,7 @@ struct ap_perms { · 316 unmodified lines
317	unsigned long aqm[BITS_TO_LONGS(AP_DOMAINS)];	317	unsigned long aqm[BITS_TO_LONGS(AP_DOMAINS)];
318	unsigned long adm[BITS_TO_LONGS(AP_DOMAINS)];	318	unsigned long adm[BITS_TO_LONGS(AP_DOMAINS)];
319	};	319	};
		320
320	extern struct ap_perms ap_perms;	321	extern struct ap_perms ap_perms;
321	extern struct mutex ap_perms_mutex;	322	extern struct mutex ap_perms_mutex;
322		323

drivers/s390/crypto/ap_queue.c+4−3

 {
 	struct ap_queue_status status;
-	if (msg == NULL)
+	if (!msg)
 		return -EINVAL;
 	status = ap_dqap(qid, psmid, msg, length, NULL, NULL);
 	switch (status.response_code) {
 static DEVICE_ATTR_RO(interrupt);
 static ssize_t config_show(struct device *dev,
-			     struct device_attribute *attr, char *buf)
+			   struct device_attribute *attr, char *buf)
 {
 	struct ap_queue *aq = to_ap_queue(dev);
 	int rc;
 		aq->requestq_count++;
 		aq->total_request_count++;
 		atomic64_inc(&aq->card->total_request_count);
-	} else
+	} else {
 		rc = -ENODEV;
+	}
 	/* Send/receive as many request from the queue as possible. */
 	ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL));

drivers/s390/crypto/pkey_api.c+78−71

 	int i, rc;
 	u16 card, dom;
 	u32 nr_apqns, *apqns = NULL;
-	struct ep11keyblob *kb = (struct ep11keyblob *) key;
+	struct ep11keyblob *kb = (struct ep11keyblob *)key;
 	zcrypt_wait_api_operational();
 			  u16 *pcardnr, u16 *pdomain,
 			  u16 *pkeysize, u32 *pattributes)
 {
-	struct secaeskeytoken *t = (struct secaeskeytoken *) seckey;
+	struct secaeskeytoken *t = (struct secaeskeytoken *)seckey;
 	u16 cardnr, domain;
 	int rc;
 	/* check the secure key for valid AES secure key */
-	rc = cca_check_secaeskeytoken(debug_info, 3, (u8 *) seckey, 0);
+	rc = cca_check_secaeskeytoken(debug_info, 3, (u8 *)seckey, 0);
 	if (rc)
 		goto out;
 	if (pattributes)
 		t = (struct clearaeskeytoken *)key;
 		if (keylen != sizeof(*t) + t->len)
 			goto out;
-		if ((t->keytype == PKEY_KEYTYPE_AES_128 && t->len == 16)
+		if ((t->keytype == PKEY_KEYTYPE_AES_128 && t->len == 16) ||
-		    || (t->keytype == PKEY_KEYTYPE_AES_192 && t->len == 24)
+		    (t->keytype == PKEY_KEYTYPE_AES_192 && t->len == 24) ||
-		    || (t->keytype == PKEY_KEYTYPE_AES_256 && t->len == 32))
+		    (t->keytype == PKEY_KEYTYPE_AES_256 && t->len == 32))
 			memcpy(ckey.clrkey, t->clearkey, t->len);
 		else
 			goto out;
 	DEBUG_DBG("%s rc=%d\n", __func__, rc);
 	return rc;
 }
 EXPORT_SYMBOL(pkey_keyblob2pkey);
 		} else if (ktype == PKEY_TYPE_CCA_DATA) {
 			rc = cca_genseckey(card, dom, ksize, keybuf);
 			*keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
-		} else /* TOKVER_CCA_VLSC */
+		} else {
+			/* TOKVER_CCA_VLSC */
 			rc = cca_gencipherkey(card, dom, ksize, kflags,
 					      keybuf, keybufsize);
+		}
 		if (rc == 0)
 			break;
 	}
 			rc = cca_clr2seckey(card, dom, ksize,
 					    clrkey, keybuf);
 			*keybufsize = (rc ? 0 : SECKEYBLOBSIZE);
-		} else /* TOKVER_CCA_VLSC */
+		} else {
+			/* TOKVER_CCA_VLSC */
 			rc = cca_clr2cipherkey(card, dom, ksize, kflags,
 					       clrkey, keybuf, keybufsize);
+		}
 		if (rc == 0)
 			break;
 	}
 	if (keylen < sizeof(struct keytoken_header))
 		return -EINVAL;
-	if (hdr->type == TOKTYPE_CCA_INTERNAL
+	if (hdr->type == TOKTYPE_CCA_INTERNAL &&
-	    && hdr->version == TOKVER_CCA_AES) {
+	    hdr->version == TOKVER_CCA_AES) {
 		struct secaeskeytoken *t = (struct secaeskeytoken *)key;
 		rc = cca_check_secaeskeytoken(debug_info, 3, key, 0);
 		if (ktype)
 			*ktype = PKEY_TYPE_CCA_DATA;
 		if (ksize)
-			*ksize = (enum pkey_key_size) t->bitsize;
+			*ksize = (enum pkey_key_size)t->bitsize;
 		rc = cca_findcard2(&_apqns, &_nr_apqns, *cardnr, *domain,
 				   ZCRYPT_CEX3C, AES_MK_SET, t->mkvp, 0, 1);
 		*cardnr = ((struct pkey_apqn *)_apqns)->card;
 		*domain = ((struct pkey_apqn *)_apqns)->domain;
-	} else if (hdr->type == TOKTYPE_CCA_INTERNAL
+	} else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
-		   && hdr->version == TOKVER_CCA_VLSC) {
+		   hdr->version == TOKVER_CCA_VLSC) {
 		struct cipherkeytoken *t = (struct cipherkeytoken *)key;
 		rc = cca_check_secaescipherkey(debug_info, 3, key, 0, 1);
 		*cardnr = ((struct pkey_apqn *)_apqns)->card;
 		*domain = ((struct pkey_apqn *)_apqns)->domain;
-	} else if (hdr->type == TOKTYPE_NON_CCA
+	} else if (hdr->type == TOKTYPE_NON_CCA &&
-		   && hdr->version == TOKVER_EP11_AES) {
+		   hdr->version == TOKVER_EP11_AES) {
 		struct ep11keyblob *kb = (struct ep11keyblob *)key;
 		rc = ep11_check_aes_key(debug_info, 3, key, keylen, 1);
 		*cardnr = ((struct pkey_apqn *)_apqns)->card;
 		*domain = ((struct pkey_apqn *)_apqns)->domain;
-	} else
+	} else {
 		rc = -EINVAL;
+	}
 out:
 	kfree(_apqns);
 	for (i = 0, rc = -ENODEV; i < nr_apqns; i++) {
 		card = apqns[i].card;
 		dom = apqns[i].domain;
-		if (hdr->type == TOKTYPE_CCA_INTERNAL
+		if (hdr->type == TOKTYPE_CCA_INTERNAL &&
-		    && hdr->version == TOKVER_CCA_AES)
+		    hdr->version == TOKVER_CCA_AES) {
 			rc = cca_sec2protkey(card, dom, key, pkey->protkey,
 					     &pkey->len, &pkey->type);
-		else if (hdr->type == TOKTYPE_CCA_INTERNAL
+		} else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
-			 && hdr->version == TOKVER_CCA_VLSC)
+			   hdr->version == TOKVER_CCA_VLSC) {
 			rc = cca_cipher2protkey(card, dom, key, pkey->protkey,
 						&pkey->len, &pkey->type);
-		else { /* EP11 AES secure key blob */
+		} else {
-			struct ep11keyblob *kb = (struct ep11keyblob *) key;
+			/* EP11 AES secure key blob */
+			struct ep11keyblob *kb = (struct ep11keyblob *)key;
 			pkey->len = sizeof(pkey->protkey);
 			rc = ep11_kblob2protkey(card, dom, key, kb->head.len,
 	zcrypt_wait_api_operational();
-	if (hdr->type == TOKTYPE_NON_CCA
+	if (hdr->type == TOKTYPE_NON_CCA &&
-	    && (hdr->version == TOKVER_EP11_AES_WITH_HEADER
+	    (hdr->version == TOKVER_EP11_AES_WITH_HEADER ||
-		|| hdr->version == TOKVER_EP11_ECC_WITH_HEADER)
+	     hdr->version == TOKVER_EP11_ECC_WITH_HEADER) &&
-	    && is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
+	    is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
 		int minhwtype = 0, api = 0;
 		struct ep11keyblob *kb = (struct ep11keyblob *)
 			(key + sizeof(struct ep11kblob_header));
 				    minhwtype, api, kb->wkvp);
 		if (rc)
 			goto out;
-	} else if (hdr->type == TOKTYPE_NON_CCA
+	} else if (hdr->type == TOKTYPE_NON_CCA &&
-		   && hdr->version == TOKVER_EP11_AES
+		   hdr->version == TOKVER_EP11_AES &&
-		   && is_ep11_keyblob(key)) {
+		   is_ep11_keyblob(key)) {
 		int minhwtype = 0, api = 0;
-		struct ep11keyblob *kb = (struct ep11keyblob *) key;
+		struct ep11keyblob *kb = (struct ep11keyblob *)key;
 		if (flags != PKEY_FLAGS_MATCH_CUR_MKVP)
 			return -EINVAL;
 				   cur_mkvp, old_mkvp, 1);
 		if (rc)
 			goto out;
-	} else
+	} else {
 		return -EINVAL;
+	}
 	if (apqns) {
 		if (*nr_apqns < _nr_apqns)
 		int minhwtype = ZCRYPT_CEX3C;
 		if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
-			cur_mkvp = *((u64 *) cur_mkvp);
+			cur_mkvp = *((u64 *)cur_mkvp);
 		if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
-			old_mkvp = *((u64 *) alt_mkvp);
+			old_mkvp = *((u64 *)alt_mkvp);
 		if (ktype == PKEY_TYPE_CCA_CIPHER)
 			minhwtype = ZCRYPT_CEX6;
 		rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
 		u64 cur_mkvp = 0, old_mkvp = 0;
 		if (flags & PKEY_FLAGS_MATCH_CUR_MKVP)
-			cur_mkvp = *((u64 *) cur_mkvp);
+			cur_mkvp = *((u64 *)cur_mkvp);
 		if (flags & PKEY_FLAGS_MATCH_ALT_MKVP)
-			old_mkvp = *((u64 *) alt_mkvp);
+			old_mkvp = *((u64 *)alt_mkvp);
 		rc = cca_findcard2(&_apqns, &_nr_apqns, 0xFFFF, 0xFFFF,
 				   ZCRYPT_CEX7, APKA_MK_SET,
 				   cur_mkvp, old_mkvp, 1);
 		if (rc)
 			goto out;
-	} else
+	} else {
 		return -EINVAL;
+	}
 	if (apqns) {
 		if (*nr_apqns < _nr_apqns)
 	if (keylen < sizeof(struct keytoken_header))
 		return -EINVAL;
-	if (hdr->type == TOKTYPE_NON_CCA
+	if (hdr->type == TOKTYPE_NON_CCA &&
-	    && hdr->version == TOKVER_EP11_AES_WITH_HEADER
+	    hdr->version == TOKVER_EP11_AES_WITH_HEADER &&
-	    && is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
+	    is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
 		/* EP11 AES key blob with header */
 		if (ep11_check_aes_key_with_hdr(debug_info, 3, key, keylen, 1))
 			return -EINVAL;
-	} else if (hdr->type == TOKTYPE_NON_CCA
+	} else if (hdr->type == TOKTYPE_NON_CCA &&
-		   && hdr->version == TOKVER_EP11_ECC_WITH_HEADER
+		   hdr->version == TOKVER_EP11_ECC_WITH_HEADER &&
-		   && is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
+		   is_ep11_keyblob(key + sizeof(struct ep11kblob_header))) {
 		/* EP11 ECC key blob with header */
 		if (ep11_check_ecc_key_with_hdr(debug_info, 3, key, keylen, 1))
 			return -EINVAL;
-	} else if (hdr->type == TOKTYPE_NON_CCA
+	} else if (hdr->type == TOKTYPE_NON_CCA &&
-		   && hdr->version == TOKVER_EP11_AES
+		   hdr->version == TOKVER_EP11_AES &&
-		   && is_ep11_keyblob(key)) {
+		   is_ep11_keyblob(key)) {
 		/* EP11 AES key blob with header in session field */
 		if (ep11_check_aes_key(debug_info, 3, key, keylen, 1))
 			return -EINVAL;
 	for (rc = -ENODEV, i = 0; rc && i < nr_apqns; i++) {
 		card = apqns[i].card;
 		dom = apqns[i].domain;
-		if (hdr->type == TOKTYPE_NON_CCA
+		if (hdr->type == TOKTYPE_NON_CCA &&
-		    && (hdr->version == TOKVER_EP11_AES_WITH_HEADER
+		    (hdr->version == TOKVER_EP11_AES_WITH_HEADER ||
-			|| hdr->version == TOKVER_EP11_ECC_WITH_HEADER)
+		     hdr->version == TOKVER_EP11_ECC_WITH_HEADER) &&
-		    && is_ep11_keyblob(key + sizeof(struct ep11kblob_header)))
+		    is_ep11_keyblob(key + sizeof(struct ep11kblob_header)))
 			rc = ep11_kblob2protkey(card, dom, key, hdr->len,
 						protkey, protkeylen, protkeytype);
-		else if (hdr->type == TOKTYPE_NON_CCA
+		else if (hdr->type == TOKTYPE_NON_CCA &&
-			 && hdr->version == TOKVER_EP11_AES
+			 hdr->version == TOKVER_EP11_AES &&
-			 && is_ep11_keyblob(key))
+			 is_ep11_keyblob(key))
 			rc = ep11_kblob2protkey(card, dom, key, hdr->len,
 						protkey, protkeylen, protkeytype);
 		else if (hdr->type == TOKTYPE_CCA_INTERNAL &&
 	switch (cmd) {
 	case PKEY_GENSECK: {
-		struct pkey_genseck __user *ugs = (void __user *) arg;
+		struct pkey_genseck __user *ugs = (void __user *)arg;
 		struct pkey_genseck kgs;
 		if (copy_from_user(&kgs, ugs, sizeof(kgs)))
 		break;
 	}
 	case PKEY_CLR2SECK: {
-		struct pkey_clr2seck __user *ucs = (void __user *) arg;
+		struct pkey_clr2seck __user *ucs = (void __user *)arg;
 		struct pkey_clr2seck kcs;
 		if (copy_from_user(&kcs, ucs, sizeof(kcs)))
 		break;
 	}
 	case PKEY_SEC2PROTK: {
-		struct pkey_sec2protk __user *usp = (void __user *) arg;
+		struct pkey_sec2protk __user *usp = (void __user *)arg;
 		struct pkey_sec2protk ksp;
 		if (copy_from_user(&ksp, usp, sizeof(ksp)))
 		break;
 	}
 	case PKEY_CLR2PROTK: {
-		struct pkey_clr2protk __user *ucp = (void __user *) arg;
+		struct pkey_clr2protk __user *ucp = (void __user *)arg;
 		struct pkey_clr2protk kcp;
 		if (copy_from_user(&kcp, ucp, sizeof(kcp)))
 		break;
 	}
 	case PKEY_FINDCARD: {
-		struct pkey_findcard __user *ufc = (void __user *) arg;
+		struct pkey_findcard __user *ufc = (void __user *)arg;
 		struct pkey_findcard kfc;
 		if (copy_from_user(&kfc, ufc, sizeof(kfc)))
 		break;
 	}
 	case PKEY_SKEY2PKEY: {
-		struct pkey_skey2pkey __user *usp = (void __user *) arg;
+		struct pkey_skey2pkey __user *usp = (void __user *)arg;
 		struct pkey_skey2pkey ksp;
 		if (copy_from_user(&ksp, usp, sizeof(ksp)))
 		break;
 	}
 	case PKEY_VERIFYKEY: {
-		struct pkey_verifykey __user *uvk = (void __user *) arg;
+		struct pkey_verifykey __user *uvk = (void __user *)arg;
 		struct pkey_verifykey kvk;
 		if (copy_from_user(&kvk, uvk, sizeof(kvk)))
 		break;
 	}
 	case PKEY_GENPROTK: {
-		struct pkey_genprotk __user *ugp = (void __user *) arg;
+		struct pkey_genprotk __user *ugp = (void __user *)arg;
 		struct pkey_genprotk kgp;
 		if (copy_from_user(&kgp, ugp, sizeof(kgp)))
 		break;
 	}
 	case PKEY_VERIFYPROTK: {
-		struct pkey_verifyprotk __user *uvp = (void __user *) arg;
+		struct pkey_verifyprotk __user *uvp = (void __user *)arg;
 		struct pkey_verifyprotk kvp;
 		if (copy_from_user(&kvp, uvp, sizeof(kvp)))
 		break;
 	}
 	case PKEY_KBLOB2PROTK: {
-		struct pkey_kblob2pkey __user *utp = (void __user *) arg;
+		struct pkey_kblob2pkey __user *utp = (void __user *)arg;
 		struct pkey_kblob2pkey ktp;
 		u8 *kkey;
 		break;
 	}
 	case PKEY_GENSECK2: {
-		struct pkey_genseck2 __user *ugs = (void __user *) arg;
+		struct pkey_genseck2 __user *ugs = (void __user *)arg;
 		struct pkey_genseck2 kgs;
 		struct pkey_apqn *apqns;
 		size_t klen = KEYBLOBBUFSIZE;
 		break;
 	}
 	case PKEY_CLR2SECK2: {
-		struct pkey_clr2seck2 __user *ucs = (void __user *) arg;
+		struct pkey_clr2seck2 __user *ucs = (void __user *)arg;
 		struct pkey_clr2seck2 kcs;
 		struct pkey_apqn *apqns;
 		size_t klen = KEYBLOBBUFSIZE;
 		break;
 	}
 	case PKEY_VERIFYKEY2: {
-		struct pkey_verifykey2 __user *uvk = (void __user *) arg;
+		struct pkey_verifykey2 __user *uvk = (void __user *)arg;
 		struct pkey_verifykey2 kvk;
 		u8 *kkey;
 		break;
 	}
 	case PKEY_KBLOB2PROTK2: {
-		struct pkey_kblob2pkey2 __user *utp = (void __user *) arg;
+		struct pkey_kblob2pkey2 __user *utp = (void __user *)arg;
 		struct pkey_kblob2pkey2 ktp;
 		struct pkey_apqn *apqns = NULL;
 		u8 *kkey;
 		break;
 	}
 	case PKEY_APQNS4K: {
-		struct pkey_apqns4key __user *uak = (void __user *) arg;
+		struct pkey_apqns4key __user *uak = (void __user *)arg;
 		struct pkey_apqns4key kak;
 		struct pkey_apqn *apqns = NULL;
 		size_t nr_apqns, len;
 		break;
 	}
 	case PKEY_APQNS4KT: {
-		struct pkey_apqns4keytype __user *uat = (void __user *) arg;
+		struct pkey_apqns4keytype __user *uat = (void __user *)arg;
 		struct pkey_apqns4keytype kat;
 		struct pkey_apqn *apqns = NULL;
 		size_t nr_apqns, len;
 		break;
 	}
 	case PKEY_KBLOB2PROTK3: {
-		struct pkey_kblob2pkey3 __user *utp = (void __user *) arg;
+		struct pkey_kblob2pkey3 __user *utp = (void __user *)arg;
 		struct pkey_kblob2pkey3 ktp;
 		struct pkey_apqn *apqns = NULL;
 		u32 protkeylen = PROTKEYBLOBBUFSIZE;
 					  loff_t off, size_t count)
 {
 	int rc;
-	struct pkey_seckey *seckey = (struct pkey_seckey *) buf;
+	struct pkey_seckey *seckey = (struct pkey_seckey *)buf;
 	if (off != 0 || count < sizeof(struct secaeskeytoken))
 		return -EINVAL;

drivers/s390/crypto/vfio_ap_drv.c+0−2

@@ -46,8 +46,6 @@ static struct ap_device_id ap_queue_ids[] = { · 45 unmodified lines
46	{ /* end of sibling */ },	46	{ /* end of sibling */ },
47	};	47	};
48		48
49	MODULE_DEVICE_TABLE(vfio_ap, ap_queue_ids);
50
51	static struct ap_matrix_mdev vfio_ap_mdev_for_queue(struct vfio_ap_queue q)	49	static struct ap_matrix_mdev vfio_ap_mdev_for_queue(struct vfio_ap_queue q)
52	{	50	{
53	struct ap_matrix_mdev *matrix_mdev;	51	struct ap_matrix_mdev *matrix_mdev;

drivers/s390/crypto/zcrypt_api.c+108−107

 	struct zcrypt_ops *zops;
 	list_for_each_entry(zops, &zcrypt_ops_list, list)
-		if ((zops->variant == variant) &&
+		if (zops->variant == variant &&
 		    (!strncmp(zops->name, name, sizeof(zops->name))))
 			return zops;
 	return NULL;
 		strncpy(nodename, name, sizeof(nodename));
 	else
 		snprintf(nodename, sizeof(nodename),
-			 ZCRYPT_NAME "_%d", (int) MINOR(devt));
+			 ZCRYPT_NAME "_%d", (int)MINOR(devt));
-	nodename[sizeof(nodename)-1] = '\0';
+	nodename[sizeof(nodename) - 1] = '\0';
 	if (dev_set_name(&zcdndev->device, nodename)) {
 		rc = -EINVAL;
 		goto unlockout;
 /*
  * zcrypt_write(): Not allowed.
  *
- * Write is is not allowed
+ * Write is not allowed
  */
 static ssize_t zcrypt_write(struct file *filp, const char __user *buf,
 			    size_t count, loff_t *f_pos)
 			perms = &zcdndev->perms;
 	}
 #endif
-	filp->private_data = (void *) perms;
+	filp->private_data = (void *)perms;
 	atomic_inc(&zcrypt_open_count);
 	return stream_open(inode, filp);
 	pref_zq = NULL;
 	spin_lock(&zcrypt_list_lock);
 	for_each_zcrypt_card(zc) {
-		/* Check for useable accelarator or CCA card */
+		/* Check for usable accelarator or CCA card */
 		if (!zc->online || !zc->card->config || zc->card->chkstop ||
 		    !(zc->card->functions & 0x18000000))
 			continue;
 		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))
 			continue;
 		for_each_zcrypt_queue(zq, zc) {
-			/* check if device is useable and eligible */
+			/* check if device is usable and eligible */
 			if (!zq->online || !zq->ops->rsa_modexpo ||
 			    !zq->queue->config || zq->queue->chkstop)
 				continue;
 	pref_zq = NULL;
 	spin_lock(&zcrypt_list_lock);
 	for_each_zcrypt_card(zc) {
-		/* Check for useable accelarator or CCA card */
+		/* Check for usable accelarator or CCA card */
 		if (!zc->online || !zc->card->config || zc->card->chkstop ||
 		    !(zc->card->functions & 0x18000000))
 			continue;
 		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))
 			continue;
 		for_each_zcrypt_queue(zq, zc) {
-			/* check if device is useable and eligible */
+			/* check if device is usable and eligible */
 			if (!zq->online || !zq->ops->rsa_modexpo_crt ||
 			    !zq->queue->config || zq->queue->chkstop)
 				continue;
 static long _zcrypt_send_cprb(bool userspace, struct ap_perms *perms,
 			      struct zcrypt_track *tr,
-			      struct ica_xcRB *xcRB)
+			      struct ica_xcRB *xcrb)
 {
 	struct zcrypt_card *zc, *pref_zc;
 	struct zcrypt_queue *zq, *pref_zq;
 	int cpen, qpen, qid = 0, rc = -ENODEV;
 	struct module *mod;
-	trace_s390_zcrypt_req(xcRB, TB_ZSECSENDCPRB);
+	trace_s390_zcrypt_req(xcrb, TB_ZSECSENDCPRB);
-	xcRB->status = 0;
+	xcrb->status = 0;
 	ap_init_message(&ap_msg);
 #ifdef CONFIG_ZCRYPT_DEBUG
 	if (tr && tr->fi.action == AP_FI_ACTION_CCA_AGENT_FF) {
 		ZCRYPT_DBF_WARN("%s fi cmd 0x%04x: forcing invalid agent_ID 'FF'\n",
 				__func__, tr->fi.cmd);
-		xcRB->agent_ID = 0x4646;
+		xcrb->agent_ID = 0x4646;
 	}
 #endif
-	rc = prep_cca_ap_msg(userspace, xcRB, &ap_msg, &func_code, &domain);
+	rc = prep_cca_ap_msg(userspace, xcrb, &ap_msg, &func_code, &domain);
 	if (rc)
 		goto out;
 	pref_zq = NULL;
 	spin_lock(&zcrypt_list_lock);
 	for_each_zcrypt_card(zc) {
-		/* Check for useable CCA card */
+		/* Check for usable CCA card */
 		if (!zc->online || !zc->card->config || zc->card->chkstop ||
 		    !(zc->card->functions & 0x10000000))
 			continue;
 		/* Check for user selected CCA card */
-		if (xcRB->user_defined != AUTOSELECT &&
+		if (xcrb->user_defined != AUTOSELECT &&
-		    xcRB->user_defined != zc->card->id)
+		    xcrb->user_defined != zc->card->id)
 			continue;
 		/* check if request size exceeds card max msg size */
 		if (ap_msg.len > zc->card->maxmsgsize)
 		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))
 			continue;
 		for_each_zcrypt_queue(zq, zc) {
-			/* check for device useable and eligible */
+			/* check for device usable and eligible */
 			if (!zq->online || !zq->ops->send_cprb ||
 			    !zq->queue->config || zq->queue->chkstop ||
 			    (tdom != AUTOSEL_DOM &&
 	if (!pref_zq) {
 		ZCRYPT_DBF_DBG("%s no match for address %02x.%04x => ENODEV\n",
-			       __func__, xcRB->user_defined, *domain);
+			       __func__, xcrb->user_defined, *domain);
 		rc = -ENODEV;
 		goto out;
 	}
 	}
 #endif
-	rc = pref_zq->ops->send_cprb(userspace, pref_zq, xcRB, &ap_msg);
+	rc = pref_zq->ops->send_cprb(userspace, pref_zq, xcrb, &ap_msg);
 	spin_lock(&zcrypt_list_lock);
 	zcrypt_drop_queue(pref_zc, pref_zq, mod, wgt);
 		tr->last_rc = rc;
 		tr->last_qid = qid;
 	}
-	trace_s390_zcrypt_rep(xcRB, func_code, rc,
+	trace_s390_zcrypt_rep(xcrb, func_code, rc,
 			      AP_QID_CARD(qid), AP_QID_QUEUE(qid));
 	return rc;
 }
-long zcrypt_send_cprb(struct ica_xcRB *xcRB)
+long zcrypt_send_cprb(struct ica_xcRB *xcrb)
 {
-	return _zcrypt_send_cprb(false, &ap_perms, NULL, xcRB);
+	return _zcrypt_send_cprb(false, &ap_perms, NULL, xcrb);
 }
 EXPORT_SYMBOL(zcrypt_send_cprb);
 		ap_msg.fi.cmd = tr->fi.cmd;
 #endif
-	target_num = (unsigned short) xcrb->targets_num;
+	target_num = (unsigned short)xcrb->targets_num;
 	/* empty list indicates autoselect (all available targets) */
 	targets = NULL;
 			goto out;
 		}
-		uptr = (struct ep11_target_dev __force __user *) xcrb->targets;
+		uptr = (struct ep11_target_dev __force __user *)xcrb->targets;
 		if (z_copy_from_user(userspace, targets, uptr,
-				   target_num * sizeof(*targets))) {
+				     target_num * sizeof(*targets))) {
 			func_code = 0;
 			rc = -EFAULT;
 			goto out_free;
 	pref_zq = NULL;
 	spin_lock(&zcrypt_list_lock);
 	for_each_zcrypt_card(zc) {
-		/* Check for useable EP11 card */
+		/* Check for usable EP11 card */
 		if (!zc->online || !zc->card->config || zc->card->chkstop ||
 		    !(zc->card->functions & 0x04000000))
 			continue;
 		if (!zcrypt_card_compare(zc, pref_zc, wgt + cpen, pref_wgt))
 			continue;
 		for_each_zcrypt_queue(zq, zc) {
-			/* check if device is useable and eligible */
+			/* check if device is usable and eligible */
 			if (!zq->online || !zq->ops->send_ep11_cprb ||
 			    !zq->queue->config || zq->queue->chkstop ||
 			    (targets &&
 	if (!pref_zq) {
 		if (targets && target_num == 1) {
 			ZCRYPT_DBF_DBG("%s no match for address %02x.%04x => ENODEV\n",
-				       __func__, (int) targets->ap_id,
+				       __func__, (int)targets->ap_id,
-				       (int) targets->dom_id);
+				       (int)targets->dom_id);
 		} else if (targets) {
 			ZCRYPT_DBF_DBG("%s no match for %d target addrs => ENODEV\n",
-				       __func__, (int) target_num);
+				       __func__, (int)target_num);
 		} else {
 			ZCRYPT_DBF_DBG("%s no match for address ff.ffff => ENODEV\n",
 				       __func__);
 	pref_zq = NULL;
 	spin_lock(&zcrypt_list_lock);
 	for_each_zcrypt_card(zc) {
-		/* Check for useable CCA card */
+		/* Check for usable CCA card */
 		if (!zc->online || !zc->card->config || zc->card->chkstop ||
 		    !(zc->card->functions & 0x10000000))
 			continue;
 		if (!zcrypt_card_compare(zc, pref_zc, wgt, pref_wgt))
 			continue;
 		for_each_zcrypt_queue(zq, zc) {
-			/* check if device is useable and eligible */
+			/* check if device is usable and eligible */
 			if (!zq->online || !zq->ops->rng ||
 			    !zq->queue->config || zq->queue->chkstop)
 				continue;
 	if (!pref_zq) {
 		ZCRYPT_DBF_DBG("%s no matching queue found => ENODEV\n",
-			__func__);
+			       __func__);
 		rc = -ENODEV;
 		goto out;
 	}
 	for_each_zcrypt_card(zc) {
 		for_each_zcrypt_queue(zq, zc) {
 			card = AP_QID_CARD(zq->queue->qid);
-			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
+			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index ||
-			    || card >= max_adapters)
+			    card >= max_adapters)
 				continue;
 			status[card] = zc->online ? zc->user_space_type : 0x0d;
 		}
 	for_each_zcrypt_card(zc) {
 		for_each_zcrypt_queue(zq, zc) {
 			card = AP_QID_CARD(zq->queue->qid);
-			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
+			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index ||
-			    || card >= max_adapters)
+			    card >= max_adapters)
 				continue;
 			spin_lock(&zq->queue->lock);
 			qdepth[card] =
 	for_each_zcrypt_card(zc) {
 		for_each_zcrypt_queue(zq, zc) {
 			card = AP_QID_CARD(zq->queue->qid);
-			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index
+			if (AP_QID_QUEUE(zq->queue->qid) != ap_domain_index ||
-			    || card >= max_adapters)
+			    card >= max_adapters)
 				continue;
 			spin_lock(&zq->queue->lock);
 			cnt = zq->queue->total_request_count;
 			spin_unlock(&zq->queue->lock);
-			reqcnt[card] = (cnt < UINT_MAX) ? (u32) cnt : UINT_MAX;
+			reqcnt[card] = (cnt < UINT_MAX) ? (u32)cnt : UINT_MAX;
 		}
 	}
 	local_bh_enable();
 	int rc;
 	struct zcrypt_track tr;
 	struct ica_rsa_modexpo mex;
-	struct ica_rsa_modexpo __user *umex = (void __user *) arg;
+	struct ica_rsa_modexpo __user *umex = (void __user *)arg;
 	memset(&tr, 0, sizeof(tr));
 	if (copy_from_user(&mex, umex, sizeof(mex)))
 	int rc;
 	struct zcrypt_track tr;
 	struct ica_rsa_modexpo_crt crt;
-	struct ica_rsa_modexpo_crt __user *ucrt = (void __user *) arg;
+	struct ica_rsa_modexpo_crt __user *ucrt = (void __user *)arg;
 	memset(&tr, 0, sizeof(tr));
 	if (copy_from_user(&crt, ucrt, sizeof(crt)))
 static int zsecsendcprb_ioctl(struct ap_perms *perms, unsigned long arg)
 {
 	int rc;
-	struct ica_xcRB xcRB;
+	struct ica_xcRB xcrb;
 	struct zcrypt_track tr;
-	struct ica_xcRB __user *uxcRB = (void __user *) arg;
+	struct ica_xcRB __user *uxcrb = (void __user *)arg;
 	memset(&tr, 0, sizeof(tr));
-	if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))
+	if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb)))
 		return -EFAULT;
 #ifdef CONFIG_ZCRYPT_DEBUG
-	if ((xcRB.status & 0x8000FFFF) == 0x80004649 /* 'FI' */) {
+	if ((xcrb.status & 0x8000FFFF) == 0x80004649 /* 'FI' */) {
 		if (!capable(CAP_SYS_ADMIN))
 			return -EPERM;
-		tr.fi.cmd = (u16)(xcRB.status >> 16);
+		tr.fi.cmd = (u16)(xcrb.status >> 16);
 	}
-	xcRB.status = 0;
+	xcrb.status = 0;
 #endif
 	do {
-		rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB);
+		rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb);
 		if (rc == -EAGAIN)
 			tr.again_counter++;
 #ifdef CONFIG_ZCRYPT_DEBUG
 	/* on failure: retry once again after a requested rescan */
 	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 		do {
-			rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB);
+			rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb);
 			if (rc == -EAGAIN)
 				tr.again_counter++;
 		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);
 		rc = -EIO;
 	if (rc)
 		ZCRYPT_DBF_DBG("ioctl ZSENDCPRB rc=%d status=0x%x\n",
-			       rc, xcRB.status);
+			       rc, xcrb.status);
-	if (copy_to_user(uxcRB, &xcRB, sizeof(xcRB)))
+	if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb)))
 		return -EFAULT;
 	return rc;
 }
 {
 	int rc;
 	struct ap_perms *perms =
-		(struct ap_perms *) filp->private_data;
+		(struct ap_perms *)filp->private_data;
 	rc = zcrypt_check_ioctl(perms, cmd);
 	if (rc)
 		if (!device_status)
 			return -ENOMEM;
 		zcrypt_device_status_mask_ext(device_status);
-		if (copy_to_user((char __user *) arg, device_status,
+		if (copy_to_user((char __user *)arg, device_status,
 				 total_size))
 			rc = -EFAULT;
 		kfree(device_status);
 		char status[AP_DEVICES];
 		zcrypt_status_mask(status, AP_DEVICES);
-		if (copy_to_user((char __user *) arg, status, sizeof(status)))
+		if (copy_to_user((char __user *)arg, status, sizeof(status)))
 			return -EFAULT;
 		return 0;
 	}
 		char qdepth[AP_DEVICES];
 		zcrypt_qdepth_mask(qdepth, AP_DEVICES);
-		if (copy_to_user((char __user *) arg, qdepth, sizeof(qdepth)))
+		if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth)))
 			return -EFAULT;
 		return 0;
 	}
 		if (!reqcnt)
 			return -ENOMEM;
 		zcrypt_perdev_reqcnt(reqcnt, AP_DEVICES);
-		if (copy_to_user((int __user *) arg, reqcnt,
+		if (copy_to_user((int __user *)arg, reqcnt,
 				 sizeof(u32) * AP_DEVICES))
 			rc = -EFAULT;
 		kfree(reqcnt);
 		return rc;
 	}
 	case Z90STAT_REQUESTQ_COUNT:
-		return put_user(zcrypt_requestq_count(), (int __user *) arg);
+		return put_user(zcrypt_requestq_count(), (int __user *)arg);
 	case Z90STAT_PENDINGQ_COUNT:
-		return put_user(zcrypt_pendingq_count(), (int __user *) arg);
+		return put_user(zcrypt_pendingq_count(), (int __user *)arg);
 	case Z90STAT_TOTALOPEN_COUNT:
 		return put_user(atomic_read(&zcrypt_open_count),
-				(int __user *) arg);
+				(int __user *)arg);
 	case Z90STAT_DOMAIN_INDEX:
-		return put_user(ap_domain_index, (int __user *) arg);
+		return put_user(ap_domain_index, (int __user *)arg);
 	/*
 	 * Deprecated ioctls
 	 */
 		if (!device_status)
 			return -ENOMEM;
 		zcrypt_device_status_mask(device_status);
-		if (copy_to_user((char __user *) arg, device_status,
+		if (copy_to_user((char __user *)arg, device_status,
 				 total_size))
 			rc = -EFAULT;
 		kfree(device_status);
 		char status[MAX_ZDEV_CARDIDS];
 		zcrypt_status_mask(status, MAX_ZDEV_CARDIDS);
-		if (copy_to_user((char __user *) arg, status, sizeof(status)))
+		if (copy_to_user((char __user *)arg, status, sizeof(status)))
 			return -EFAULT;
 		return 0;
 	}
 		char qdepth[MAX_ZDEV_CARDIDS];
 		zcrypt_qdepth_mask(qdepth, MAX_ZDEV_CARDIDS);
-		if (copy_to_user((char __user *) arg, qdepth, sizeof(qdepth)))
+		if (copy_to_user((char __user *)arg, qdepth, sizeof(qdepth)))
 			return -EFAULT;
 		return 0;
 	}
 		u32 reqcnt[MAX_ZDEV_CARDIDS];
 		zcrypt_perdev_reqcnt(reqcnt, MAX_ZDEV_CARDIDS);
-		if (copy_to_user((int __user *) arg, reqcnt, sizeof(reqcnt)))
+		if (copy_to_user((int __user *)arg, reqcnt, sizeof(reqcnt)))
 			return -EFAULT;
 		return 0;
 	}
 			&ucrt32->outputdatalength);
 }
-struct compat_ica_xcRB {
+struct compat_ica_xcrb {
 	unsigned short	agent_ID;
 	unsigned int	user_defined;
 	unsigned short	request_ID;
 	unsigned int	status;
 } __packed;
-static long trans_xcRB32(struct ap_perms *perms, struct file *filp,
+static long trans_xcrb32(struct ap_perms *perms, struct file *filp,
 			 unsigned int cmd, unsigned long arg)
 {
-	struct compat_ica_xcRB __user *uxcRB32 = compat_ptr(arg);
+	struct compat_ica_xcrb __user *uxcrb32 = compat_ptr(arg);
-	struct compat_ica_xcRB xcRB32;
+	struct compat_ica_xcrb xcrb32;
 	struct zcrypt_track tr;
-	struct ica_xcRB xcRB64;
+	struct ica_xcRB xcrb64;
 	long rc;
 	memset(&tr, 0, sizeof(tr));
-	if (copy_from_user(&xcRB32, uxcRB32, sizeof(xcRB32)))
+	if (copy_from_user(&xcrb32, uxcrb32, sizeof(xcrb32)))
 		return -EFAULT;
-	xcRB64.agent_ID = xcRB32.agent_ID;
+	xcrb64.agent_ID = xcrb32.agent_ID;
-	xcRB64.user_defined = xcRB32.user_defined;
+	xcrb64.user_defined = xcrb32.user_defined;
-	xcRB64.request_ID = xcRB32.request_ID;
+	xcrb64.request_ID = xcrb32.request_ID;
-	xcRB64.request_control_blk_length =
+	xcrb64.request_control_blk_length =
-		xcRB32.request_control_blk_length;
+		xcrb32.request_control_blk_length;
-	xcRB64.request_control_blk_addr =
+	xcrb64.request_control_blk_addr =
-		compat_ptr(xcRB32.request_control_blk_addr);
+		compat_ptr(xcrb32.request_control_blk_addr);
-	xcRB64.request_data_length =
+	xcrb64.request_data_length =
-		xcRB32.request_data_length;
+		xcrb32.request_data_length;
-	xcRB64.request_data_address =
+	xcrb64.request_data_address =
-		compat_ptr(xcRB32.request_data_address);
+		compat_ptr(xcrb32.request_data_address);
-	xcRB64.reply_control_blk_length =
+	xcrb64.reply_control_blk_length =
-		xcRB32.reply_control_blk_length;
+		xcrb32.reply_control_blk_length;
-	xcRB64.reply_control_blk_addr =
+	xcrb64.reply_control_blk_addr =
-		compat_ptr(xcRB32.reply_control_blk_addr);
+		compat_ptr(xcrb32.reply_control_blk_addr);
-	xcRB64.reply_data_length = xcRB32.reply_data_length;
+	xcrb64.reply_data_length = xcrb32.reply_data_length;
-	xcRB64.reply_data_addr =
+	xcrb64.reply_data_addr =
-		compat_ptr(xcRB32.reply_data_addr);
+		compat_ptr(xcrb32.reply_data_addr);
-	xcRB64.priority_window = xcRB32.priority_window;
+	xcrb64.priority_window = xcrb32.priority_window;
-	xcRB64.status = xcRB32.status;
+	xcrb64.status = xcrb32.status;
 	do {
-		rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB64);
+		rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb64);
 		if (rc == -EAGAIN)
 			tr.again_counter++;
 	} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);
 	/* on failure: retry once again after a requested rescan */
 	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
 		do {
-			rc = _zcrypt_send_cprb(true, perms, &tr, &xcRB64);
+			rc = _zcrypt_send_cprb(true, perms, &tr, &xcrb64);
 			if (rc == -EAGAIN)
 				tr.again_counter++;
 		} while (rc == -EAGAIN && tr.again_counter < TRACK_AGAIN_MAX);
 	if (rc == -EAGAIN && tr.again_counter >= TRACK_AGAIN_MAX)
 		rc = -EIO;
-	xcRB32.reply_control_blk_length = xcRB64.reply_control_blk_length;
+	xcrb32.reply_control_blk_length = xcrb64.reply_control_blk_length;
-	xcRB32.reply_data_length = xcRB64.reply_data_length;
+	xcrb32.reply_data_length = xcrb64.reply_data_length;
-	xcRB32.status = xcRB64.status;
+	xcrb32.status = xcrb64.status;
-	if (copy_to_user(uxcRB32, &xcRB32, sizeof(xcRB32)))
+	if (copy_to_user(uxcrb32, &xcrb32, sizeof(xcrb32)))
 		return -EFAULT;
 	return rc;
 }
 static long zcrypt_compat_ioctl(struct file *filp, unsigned int cmd,
-			 unsigned long arg)
+				unsigned long arg)
 {
 	int rc;
 	struct ap_perms *perms =
-		(struct ap_perms *) filp->private_data;
+		(struct ap_perms *)filp->private_data;
 	rc = zcrypt_check_ioctl(perms, cmd);
 	if (rc)
 	if (cmd == ICARSACRT)
 		return trans_modexpo_crt32(perms, filp, cmd, arg);
 	if (cmd == ZSECSENDCPRB)
-		return trans_xcRB32(perms, filp, cmd, arg);
+		return trans_xcrb32(perms, filp, cmd, arg);
 	return zcrypt_unlocked_ioctl(filp, cmd, arg);
 }
 #endif
 	 * read method calls.
 	 */
 	if (zcrypt_rng_buffer_index == 0) {
-		rc = zcrypt_rng((char *) zcrypt_rng_buffer);
+		rc = zcrypt_rng((char *)zcrypt_rng_buffer);
 		/* on failure: retry once again after a requested rescan */
 		if ((rc == -ENODEV) && (zcrypt_process_rescan()))
-			rc = zcrypt_rng((char *) zcrypt_rng_buffer);
+			rc = zcrypt_rng((char *)zcrypt_rng_buffer);
 		if (rc < 0)
 			return -EIO;
 		zcrypt_rng_buffer_index = rc / sizeof(*data);
 	mutex_lock(&zcrypt_rng_mutex);
 	if (zcrypt_rng_device_count == 0) {
-		zcrypt_rng_buffer = (u32 *) get_zeroed_page(GFP_KERNEL);
+		zcrypt_rng_buffer = (u32 *)get_zeroed_page(GFP_KERNEL);
 		if (!zcrypt_rng_buffer) {
 			rc = -ENOMEM;
 			goto out;
 		if (rc)
 			goto out_free;
 		zcrypt_rng_device_count = 1;
-	} else
+	} else {
 		zcrypt_rng_device_count++;
+	}
 	mutex_unlock(&zcrypt_rng_mutex);
 	return 0;
 out_free:
-	free_page((unsigned long) zcrypt_rng_buffer);
+	free_page((unsigned long)zcrypt_rng_buffer);
 out:
 	mutex_unlock(&zcrypt_rng_mutex);
 	return rc;
 	zcrypt_rng_device_count--;
 	if (zcrypt_rng_device_count == 0) {
 		hwrng_unregister(&zcrypt_rng_dev);
-		free_page((unsigned long) zcrypt_rng_buffer);
+		free_page((unsigned long)zcrypt_rng_buffer);
 	}
 	mutex_unlock(&zcrypt_rng_mutex);
 }

drivers/s390/crypto/zcrypt_api.h+2−2

@@ -170,7 +170,7 @@ static inline unsigned long z_copy_from_user(bool userspace, · 169 unmodified lines
170	{	170	{
171	if (likely(userspace))	171	if (likely(userspace))
172	return copy_from_user(to, from, n);	172	return copy_from_user(to, from, n);
173	memcpy(to, (void __force *) from, n);	173	memcpy(to, (void __force *)from, n);
174	return 0;	174	return 0;
175	}	175	}
176		176
@@ -181,7 +181,7 @@ static inline unsigned long z_copy_to_user(bool userspace, · 4 unmodified lines
181	{	181	{
182	if (likely(userspace))	182	if (likely(userspace))
183	return copy_to_user(to, from, n);	183	return copy_to_user(to, from, n);
184	memcpy((void __force *) to, from, n);	184	memcpy((void __force *)to, from, n);
185	return 0;	185	return 0;
186	}	186	}
187		187

drivers/s390/crypto/zcrypt_card.c+1−1

@@ -138,7 +138,7 @@ struct zcrypt_card *zcrypt_card_alloc(void) · 137 unmodified lines
138	{	138	{
139	struct zcrypt_card *zc;	139	struct zcrypt_card *zc;
140		140
141	zc = kzalloc(sizeof(struct zcrypt_card), GFP_KERNEL);	141	zc = kzalloc(sizeof(*zc), GFP_KERNEL);
142	if (!zc)	142	if (!zc)
143	return NULL;	143	return NULL;
144	INIT_LIST_HEAD(&zc->list);	144	INIT_LIST_HEAD(&zc->list);

drivers/s390/crypto/zcrypt_cca_key.h+29−29

@@ -11,7 +11,7 @@ · 10 unmodified lines
11	#ifndef _ZCRYPT_CCA_KEY_H_	11	#ifndef _ZCRYPT_CCA_KEY_H_
12	#define _ZCRYPT_CCA_KEY_H_	12	#define _ZCRYPT_CCA_KEY_H_
13		13
14	struct T6_keyBlock_hdr {	14	struct t6_keyblock_hdr {
15	unsigned short blen;	15	unsigned short blen;
16	unsigned short ulen;	16	unsigned short ulen;
17	unsigned short flags;	17	unsigned short flags;
@@ -63,7 +63,7 @@ struct cca_public_sec { · 45 unmodified lines
63	* complement of the residue modulo 8 of the sum of	63	* complement of the residue modulo 8 of the sum of
64	* (p_len + q_len + dp_len + dq_len + u_len).	64	* (p_len + q_len + dp_len + dq_len + u_len).
65	*/	65	*/
66	struct cca_pvt_ext_CRT_sec {	66	struct cca_pvt_ext_crt_sec {
67	unsigned char section_identifier;	67	unsigned char section_identifier;
68	unsigned char version;	68	unsigned char version;
69	unsigned short section_length;	69	unsigned short section_length;
@@ -108,9 +108,9 @@ static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo mex, void p) · 38 unmodified lines
108	.section_identifier = 0x04,	108	.section_identifier = 0x04,
109	};	109	};
110	struct {	110	struct {
111	struct T6_keyBlock_hdr t6_hdr;	111	struct t6_keyblock_hdr t6_hdr;
112	struct cca_token_hdr pubHdr;	112	struct cca_token_hdr pubhdr;
113	struct cca_public_sec pubSec;	113	struct cca_public_sec pubsec;
114	char exponent[0];	114	char exponent[0];
115	} __packed *key = p;	115	} __packed *key = p;
116	unsigned char *temp;	116	unsigned char *temp;
@@ -127,8 +127,8 @@ static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo mex, void p) · 10 unmodified lines
127		127
128	memset(key, 0, sizeof(*key));	128	memset(key, 0, sizeof(*key));
129		129
130	key->pubHdr = static_pub_hdr;	130	key->pubhdr = static_pub_hdr;
131	key->pubSec = static_pub_sec;	131	key->pubsec = static_pub_sec;
132		132
133	/* key parameter block */	133	/* key parameter block */
134	temp = key->exponent;	134	temp = key->exponent;
@@ -146,16 +146,16 @@ static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo mex, void p) · 11 unmodified lines
146	if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))	146	if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
147	return -EFAULT;	147	return -EFAULT;
148		148
149	key->pubSec.modulus_bit_len = 8 * mex->inputdatalength;	149	key->pubsec.modulus_bit_len = 8 * mex->inputdatalength;
150	key->pubSec.modulus_byte_len = mex->inputdatalength;	150	key->pubsec.modulus_byte_len = mex->inputdatalength;
151	key->pubSec.exponent_len = mex->inputdatalength - i;	151	key->pubsec.exponent_len = mex->inputdatalength - i;
152	key->pubSec.section_length = sizeof(key->pubSec) +	152	key->pubsec.section_length = sizeof(key->pubsec) +
153	2*mex->inputdatalength - i;	153	2 * mex->inputdatalength - i;
154	key->pubHdr.token_length =	154	key->pubhdr.token_length =
155	key->pubSec.section_length + sizeof(key->pubHdr);	155	key->pubsec.section_length + sizeof(key->pubhdr);
156	key->t6_hdr.ulen = key->pubHdr.token_length + 4;	156	key->t6_hdr.ulen = key->pubhdr.token_length + 4;
157	key->t6_hdr.blen = key->pubHdr.token_length + 6;	157	key->t6_hdr.blen = key->pubhdr.token_length + 6;
158	return sizeof(key) + 2mex->inputdatalength - i;	158	return sizeof(key) + 2 mex->inputdatalength - i;
159	}	159	}
160		160
161	/**	161	/**
@@ -177,9 +177,9 @@ static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt crt, void p) · 15 unmodified lines
177	};	177	};
178	static char pk_exponent[3] = { 0x01, 0x00, 0x01 };	178	static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
179	struct {	179	struct {
180	struct T6_keyBlock_hdr t6_hdr;	180	struct t6_keyblock_hdr t6_hdr;
181	struct cca_token_hdr token;	181	struct cca_token_hdr token;
182	struct cca_pvt_ext_CRT_sec pvt;	182	struct cca_pvt_ext_crt_sec pvt;
183	char key_parts[0];	183	char key_parts[0];
184	} __packed *key = p;	184	} __packed *key = p;
185	struct cca_public_sec *pub;	185	struct cca_public_sec *pub;
@@ -198,8 +198,8 @@ static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt crt, void p) · 12 unmodified lines
198		198
199	short_len = (crt->inputdatalength + 1) / 2;	199	short_len = (crt->inputdatalength + 1) / 2;
200	long_len = short_len + 8;	200	long_len = short_len + 8;
201	pad_len = -(3long_len + 2short_len) & 7;	201	pad_len = -(3 * long_len + 2 * short_len) & 7;
202	key_len = 3long_len + 2short_len + pad_len + crt->inputdatalength;	202	key_len = 3 * long_len + 2 * short_len + pad_len + crt->inputdatalength;
203	size = sizeof(key) + key_len + sizeof(pub) + 3;	203	size = sizeof(key) + key_len + sizeof(pub) + 3;
204		204
205	/* parameter block.key block */	205	/* parameter block.key block */
@@ -223,15 +223,15 @@ static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt crt, void p) · 17 unmodified lines
223	/* key parts */	223	/* key parts */
224	if (copy_from_user(key->key_parts, crt->np_prime, long_len) \|\|	224	if (copy_from_user(key->key_parts, crt->np_prime, long_len) \|\|
225	copy_from_user(key->key_parts + long_len,	225	copy_from_user(key->key_parts + long_len,
226	crt->nq_prime, short_len) \|\|	226	crt->nq_prime, short_len) \|\|
227	copy_from_user(key->key_parts + long_len + short_len,	227	copy_from_user(key->key_parts + long_len + short_len,
228	crt->bp_key, long_len) \|\|	228	crt->bp_key, long_len) \|\|
229	copy_from_user(key->key_parts + 2*long_len + short_len,	229	copy_from_user(key->key_parts + 2 * long_len + short_len,
230	crt->bq_key, short_len) \|\|	230	crt->bq_key, short_len) \|\|
231	copy_from_user(key->key_parts + 2long_len + 2short_len,	231	copy_from_user(key->key_parts + 2 * long_len + 2 * short_len,
232	crt->u_mult_inv, long_len))	232	crt->u_mult_inv, long_len))
233	return -EFAULT;	233	return -EFAULT;
234	memset(key->key_parts + 3long_len + 2short_len + pad_len,	234	memset(key->key_parts + 3 * long_len + 2 * short_len + pad_len,
235	0xff, crt->inputdatalength);	235	0xff, crt->inputdatalength);
236	pub = (struct cca_public_sec *)(key->key_parts + key_len);	236	pub = (struct cca_public_sec *)(key->key_parts + key_len);
237	*pub = static_cca_pub_sec;	237	*pub = static_cca_pub_sec;
@@ -241,7 +241,7 @@ static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt crt, void p) · 3 unmodified lines
241	* section. So, an arbitrary public exponent of 0x010001 will be	241	* section. So, an arbitrary public exponent of 0x010001 will be
242	* used.	242	* used.
243	*/	243	*/
244	memcpy((char *) (pub + 1), pk_exponent, 3);	244	memcpy((char *)(pub + 1), pk_exponent, 3);
245	return size;	245	return size;
246	}	246	}
247		247

drivers/s390/crypto/zcrypt_ccamisc.c+141−131

 int cca_check_secaeskeytoken(debug_info_t *dbg, int dbflvl,
 			     const u8 *token, int keybitsize)
 {
-	struct secaeskeytoken *t = (struct secaeskeytoken *) token;
+	struct secaeskeytoken *t = (struct secaeskeytoken *)token;
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (t->type != TOKTYPE_CCA_INTERNAL) {
 		if (dbg)
 			DBF("%s token check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) t->type, TOKTYPE_CCA_INTERNAL);
+			    __func__, (int)t->type, TOKTYPE_CCA_INTERNAL);
 		return -EINVAL;
 	}
 	if (t->version != TOKVER_CCA_AES) {
 		if (dbg)
 			DBF("%s token check failed, version 0x%02x != 0x%02x\n",
-			    __func__, (int) t->version, TOKVER_CCA_AES);
+			    __func__, (int)t->version, TOKVER_CCA_AES);
 		return -EINVAL;
 	}
 	if (keybitsize > 0 && t->bitsize != keybitsize) {
 		if (dbg)
 			DBF("%s token check failed, bitsize %d != %d\n",
-			    __func__, (int) t->bitsize, keybitsize);
+			    __func__, (int)t->bitsize, keybitsize);
 		return -EINVAL;
 	}
 			      const u8 *token, int keybitsize,
 			      int checkcpacfexport)
 {
-	struct cipherkeytoken *t = (struct cipherkeytoken *) token;
+	struct cipherkeytoken *t = (struct cipherkeytoken *)token;
 	bool keybitsizeok = true;
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (t->type != TOKTYPE_CCA_INTERNAL) {
 		if (dbg)
 			DBF("%s token check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) t->type, TOKTYPE_CCA_INTERNAL);
+			    __func__, (int)t->type, TOKTYPE_CCA_INTERNAL);
 		return -EINVAL;
 	}
 	if (t->version != TOKVER_CCA_VLSC) {
 		if (dbg)
 			DBF("%s token check failed, version 0x%02x != 0x%02x\n",
-			    __func__, (int) t->version, TOKVER_CCA_VLSC);
+			    __func__, (int)t->version, TOKVER_CCA_VLSC);
 		return -EINVAL;
 	}
 	if (t->algtype != 0x02) {
 		if (dbg)
 			DBF("%s token check failed, algtype 0x%02x != 0x02\n",
-			    __func__, (int) t->algtype);
+			    __func__, (int)t->algtype);
 		return -EINVAL;
 	}
 	if (t->keytype != 0x0001) {
 		if (dbg)
 			DBF("%s token check failed, keytype 0x%04x != 0x0001\n",
-			    __func__, (int) t->keytype);
+			    __func__, (int)t->keytype);
 		return -EINVAL;
 	}
 	if (t->plfver != 0x00 && t->plfver != 0x01) {
 		if (dbg)
 			DBF("%s token check failed, unknown plfver 0x%02x\n",
-			    __func__, (int) t->plfver);
+			    __func__, (int)t->plfver);
 		return -EINVAL;
 	}
 	if (t->wpllen != 512 && t->wpllen != 576 && t->wpllen != 640) {
 		if (dbg)
 			DBF("%s token check failed, unknown wpllen %d\n",
-			    __func__, (int) t->wpllen);
+			    __func__, (int)t->wpllen);
 		return -EINVAL;
 	}
 	if (keybitsize > 0) {
 			     const u8 *token, size_t keysize,
 			     int checkcpacfexport)
 {
-	struct eccprivkeytoken *t = (struct eccprivkeytoken *) token;
+	struct eccprivkeytoken *t = (struct eccprivkeytoken *)token;
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (t->type != TOKTYPE_CCA_INTERNAL_PKA) {
 		if (dbg)
 			DBF("%s token check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) t->type, TOKTYPE_CCA_INTERNAL_PKA);
+			    __func__, (int)t->type, TOKTYPE_CCA_INTERNAL_PKA);
 		return -EINVAL;
 	}
 	if (t->len > keysize) {
 		if (dbg)
 			DBF("%s token check failed, len %d > keysize %zu\n",
-			    __func__, (int) t->len, keysize);
+			    __func__, (int)t->len, keysize);
 		return -EINVAL;
 	}
 	if (t->secid != 0x20) {
 		if (dbg)
 			DBF("%s token check failed, secid 0x%02x != 0x20\n",
-			    __func__, (int) t->secid);
+			    __func__, (int)t->secid);
 		return -EINVAL;
 	}
 	if (checkcpacfexport && !(t->kutc & 0x01)) {
  * on failure.
  */
 static int alloc_and_prep_cprbmem(size_t paramblen,
-				  u8 **pcprbmem,
+				  u8 **p_cprb_mem,
-				  struct CPRBX **preqCPRB,
+				  struct CPRBX **p_req_cprb,
-				  struct CPRBX **prepCPRB)
+				  struct CPRBX **p_rep_cprb)
 {
 	u8 *cprbmem;
 	size_t cprbplusparamblen = sizeof(struct CPRBX) + paramblen;
 	if (!cprbmem)
 		return -ENOMEM;
-	preqcblk = (struct CPRBX *) cprbmem;
+	preqcblk = (struct CPRBX *)cprbmem;
-	prepcblk = (struct CPRBX *) (cprbmem + cprbplusparamblen);
+	prepcblk = (struct CPRBX *)(cprbmem + cprbplusparamblen);
 	/* fill request cprb struct */
 	preqcblk->cprb_len = sizeof(struct CPRBX);
 	preqcblk->rpl_msgbl = cprbplusparamblen;
 	if (paramblen) {
 		preqcblk->req_parmb =
-			((u8 __user *) preqcblk) + sizeof(struct CPRBX);
+			((u8 __user *)preqcblk) + sizeof(struct CPRBX);
 		preqcblk->rpl_parmb =
-			((u8 __user *) prepcblk) + sizeof(struct CPRBX);
+			((u8 __user *)prepcblk) + sizeof(struct CPRBX);
 	}
-	*pcprbmem = cprbmem;
+	*p_cprb_mem = cprbmem;
-	*preqCPRB = preqcblk;
+	*p_req_cprb = preqcblk;
-	*prepCPRB = prepcblk;
+	*p_rep_cprb = prepcblk;
 	return 0;
 }
 	pxcrb->user_defined = (cardnr == 0xFFFF ? AUTOSELECT : cardnr);
 	pxcrb->request_control_blk_length =
 		preqcblk->cprb_len + preqcblk->req_parml;
-	pxcrb->request_control_blk_addr = (void __user *) preqcblk;
+	pxcrb->request_control_blk_addr = (void __user *)preqcblk;
 	pxcrb->reply_control_blk_length = preqcblk->rpl_msgbl;
-	pxcrb->reply_control_blk_addr = (void __user *) prepcblk;
+	pxcrb->reply_control_blk_addr = (void __user *)prepcblk;
 }
 /*
 	preqcblk->domain = domain;
 	/* fill request cprb param block with KG request */
-	preqparm = (struct kgreqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct kgreqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "KG", 2);
 	preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
 	preqparm->lv1.len = sizeof(struct lv1);
 	rc = zcrypt_send_cprb(&xcrb);
 	if (rc) {
 		DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, errno %d\n",
-			  __func__, (int) cardnr, (int) domain, rc);
+			  __func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 	if (prepcblk->ccp_rtcode != 0) {
 		DEBUG_ERR("%s secure key generate failure, card response %d/%d\n",
 			  __func__,
-			  (int) prepcblk->ccp_rtcode,
+			  (int)prepcblk->ccp_rtcode,
-			  (int) prepcblk->ccp_rscode);
+			  (int)prepcblk->ccp_rscode);
 		rc = -EIO;
 		goto out;
 	}
 	/* process response cprb param block */
-	ptr =  ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr =  ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct kgrepparm *) ptr;
+	prepparm = (struct kgrepparm *)ptr;
 	/* check length of the returned secure key token */
 	seckeysize = prepparm->lv3.keyblock.toklen
 	/* check secure key token */
 	rc = cca_check_secaeskeytoken(zcrypt_dbf_info, DBF_ERR,
-				      prepparm->lv3.keyblock.tok, 8*keysize);
+				      prepparm->lv3.keyblock.tok, 8 * keysize);
 	if (rc) {
 		rc = -EIO;
 		goto out;
 	preqcblk->domain = domain;
 	/* fill request cprb param block with CM request */
-	preqparm = (struct cmreqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct cmreqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "CM", 2);
 	memcpy(preqparm->rule_array, "AES     ", 8);
 	preqparm->rule_array_len =
 	}
 	preqparm->lv1.len = sizeof(struct lv1) + keysize;
 	memcpy(preqparm->lv1.clrkey, clrkey, keysize);
-	plv2 = (struct lv2 *) (((u8 *) &preqparm->lv2) + keysize);
+	plv2 = (struct lv2 *)(((u8 *)&preqparm->lv2) + keysize);
 	plv2->len = sizeof(struct lv2);
 	plv2->keyid.len = sizeof(struct keyid);
 	plv2->keyid.attr = 0x30;
 	rc = zcrypt_send_cprb(&xcrb);
 	if (rc) {
 		DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			  __func__, (int) cardnr, (int) domain, rc);
+			  __func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 	if (prepcblk->ccp_rtcode != 0) {
 		DEBUG_ERR("%s clear key import failure, card response %d/%d\n",
 			  __func__,
-			  (int) prepcblk->ccp_rtcode,
+			  (int)prepcblk->ccp_rtcode,
-			  (int) prepcblk->ccp_rscode);
+			  (int)prepcblk->ccp_rscode);
 		rc = -EIO;
 		goto out;
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct cmrepparm *) ptr;
+	prepparm = (struct cmrepparm *)ptr;
 	/* check length of the returned secure key token */
 	seckeysize = prepparm->lv3.keyblock.toklen
 	/* check secure key token */
 	rc = cca_check_secaeskeytoken(zcrypt_dbf_info, DBF_ERR,
-				      prepparm->lv3.keyblock.tok, 8*keysize);
+				      prepparm->lv3.keyblock.tok, 8 * keysize);
 	if (rc) {
 		rc = -EIO;
 		goto out;
 	preqcblk->domain = domain;
 	/* fill request cprb param block with USK request */
-	preqparm = (struct uskreqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct uskreqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "US", 2);
 	preqparm->rule_array_len = sizeof(preqparm->rule_array_len);
 	preqparm->lv1.len = sizeof(struct lv1);
 	rc = zcrypt_send_cprb(&xcrb);
 	if (rc) {
 		DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			  __func__, (int) cardnr, (int) domain, rc);
+			  __func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 	if (prepcblk->ccp_rtcode != 0) {
 		DEBUG_ERR("%s unwrap secure key failure, card response %d/%d\n",
 			  __func__,
-			  (int) prepcblk->ccp_rtcode,
+			  (int)prepcblk->ccp_rtcode,
-			  (int) prepcblk->ccp_rscode);
+			  (int)prepcblk->ccp_rscode);
 		if (prepcblk->ccp_rtcode == 8 && prepcblk->ccp_rscode == 2290)
 			rc = -EAGAIN;
 		else
 	if (prepcblk->ccp_rscode != 0) {
 		DEBUG_WARN("%s unwrap secure key warning, card response %d/%d\n",
 			   __func__,
-			   (int) prepcblk->ccp_rtcode,
+			   (int)prepcblk->ccp_rtcode,
-			   (int) prepcblk->ccp_rscode);
+			   (int)prepcblk->ccp_rscode);
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct uskrepparm *) ptr;
+	prepparm = (struct uskrepparm *)ptr;
 	/* check the returned keyblock */
 	if (prepparm->lv3.ckb.version != 0x01 &&
 	    prepparm->lv3.ckb.version != 0x02) {
 		DEBUG_ERR("%s reply param keyblock version mismatch 0x%02x\n",
-			  __func__, (int) prepparm->lv3.ckb.version);
+			  __func__, (int)prepparm->lv3.ckb.version);
 		rc = -EIO;
 		goto out;
 	}
 	/* copy the tanslated protected key */
 	switch (prepparm->lv3.ckb.len) {
-	case 16+32:
+	case 16 + 32:
 		/* AES 128 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_128;
 		break;
-	case 24+32:
+	case 24 + 32:
 		/* AES 192 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_192;
 		break;
-	case 32+32:
+	case 32 + 32:
 		/* AES 256 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_256;
 	struct gkreqparm {
 		u8  subfunc_code[2];
 		u16 rule_array_len;
-		char rule_array[2*8];
+		char rule_array[2 * 8];
 		struct {
 			u16 len;
 			u8  key_type_1[8];
 	preqcblk->req_parml = sizeof(struct gkreqparm);
 	/* prepare request param block with GK request */
-	preqparm = (struct gkreqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct gkreqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "GK", 2);
 	preqparm->rule_array_len =  sizeof(uint16_t) + 2 * 8;
-	memcpy(preqparm->rule_array, "AES     OP      ", 2*8);
+	memcpy(preqparm->rule_array, "AES     OP      ", 2 * 8);
 	/* prepare vud block */
 	preqparm->vud.len = sizeof(preqparm->vud);
 	/* patch the skeleton key token export flags inside the kb block */
 	if (keygenflags) {
-		t = (struct cipherkeytoken *) preqparm->kb.tlv3.gen_key_id_1;
+		t = (struct cipherkeytoken *)preqparm->kb.tlv3.gen_key_id_1;
-		t->kmf1 |= (u16) (keygenflags & 0x0000FF00);
+		t->kmf1 |= (u16)(keygenflags & 0x0000FF00);
-		t->kmf1 &= (u16) ~(keygenflags & 0x000000FF);
+		t->kmf1 &= (u16)~(keygenflags & 0x000000FF);
 	}
 	/* prepare xcrb struct */
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			__func__, (int) cardnr, (int) domain, rc);
+			__func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 		DEBUG_ERR(
 			"%s cipher key generate failure, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 		rc = -EIO;
 		goto out;
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct gkrepparm *) ptr;
+	prepparm = (struct gkrepparm *)ptr;
 	/* do some plausibility checks on the key block */
 	if (prepparm->kb.len < 120 + 5 * sizeof(uint16_t) ||
 	}
 	/* copy the generated vlsc key token */
-	t = (struct cipherkeytoken *) prepparm->kb.tlv1.gen_key;
+	t = (struct cipherkeytoken *)prepparm->kb.tlv1.gen_key;
 	if (keybuf) {
 		if (*keybufsize >= t->len)
 			memcpy(keybuf, t, t->len);
 	preqcblk->req_parml = 0;
 	/* prepare request param block with IP request */
-	preq_ra_block = (struct rule_array_block __force *) preqcblk->req_parmb;
+	preq_ra_block = (struct rule_array_block __force *)preqcblk->req_parmb;
 	memcpy(preq_ra_block->subfunc_code, "IP", 2);
 	preq_ra_block->rule_array_len =  sizeof(uint16_t) + 2 * 8;
 	memcpy(preq_ra_block->rule_array, rule_array_1, 8);
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			__func__, (int) cardnr, (int) domain, rc);
+			__func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 		DEBUG_ERR(
 			"%s CSNBKPI2 failure, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 		rc = -EIO;
 		goto out;
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct iprepparm *) ptr;
+	prepparm = (struct iprepparm *)ptr;
 	/* do some plausibility checks on the key block */
 	if (prepparm->kb.len < 120 + 3 * sizeof(uint16_t) ||
 	/* do not check the key here, it may be incomplete */
 	/* copy the vlsc key token back */
-	t = (struct cipherkeytoken *) prepparm->kb.tlv1.key_token;
+	t = (struct cipherkeytoken *)prepparm->kb.tlv1.key_token;
 	memcpy(key_token, t, t->len);
 	*key_token_size = t->len;
 	/* patch the skeleton key token export flags */
 	if (keygenflags) {
-		t = (struct cipherkeytoken *) token;
+		t = (struct cipherkeytoken *)token;
-		t->kmf1 |= (u16) (keygenflags & 0x0000FF00);
+		t->kmf1 |= (u16)(keygenflags & 0x0000FF00);
-		t->kmf1 &= (u16) ~(keygenflags & 0x000000FF);
+		t->kmf1 &= (u16)~(keygenflags & 0x000000FF);
 	}
 	/*
 	preqcblk->domain = domain;
 	/* fill request cprb param block with AU request */
-	preqparm = (struct aureqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct aureqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "AU", 2);
 	preqparm->rule_array_len =
 		sizeof(preqparm->rule_array_len)
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			__func__, (int) cardnr, (int) domain, rc);
+			__func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 		DEBUG_ERR(
 			"%s unwrap secure key failure, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 		if (prepcblk->ccp_rtcode == 8 && prepcblk->ccp_rscode == 2290)
 			rc = -EAGAIN;
 		else
 		DEBUG_WARN(
 			"%s unwrap secure key warning, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct aurepparm *) ptr;
+	prepparm = (struct aurepparm *)ptr;
 	/* check the returned keyblock */
 	if (prepparm->vud.ckb.version != 0x01 &&
 	    prepparm->vud.ckb.version != 0x02) {
 		DEBUG_ERR("%s reply param keyblock version mismatch 0x%02x\n",
-			  __func__, (int) prepparm->vud.ckb.version);
+			  __func__, (int)prepparm->vud.ckb.version);
 		rc = -EIO;
 		goto out;
 	}
 	if (prepparm->vud.ckb.algo != 0x02) {
 		DEBUG_ERR(
 			"%s reply param keyblock algo mismatch 0x%02x != 0x02\n",
-			__func__, (int) prepparm->vud.ckb.algo);
+			__func__, (int)prepparm->vud.ckb.algo);
 		rc = -EIO;
 		goto out;
 	}
 	/* copy the translated protected key */
 	switch (prepparm->vud.ckb.keylen) {
-	case 16+32:
+	case 16 + 32:
 		/* AES 128 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_128;
 		break;
-	case 24+32:
+	case 24 + 32:
 		/* AES 192 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_192;
 		break;
-	case 32+32:
+	case 32 + 32:
 		/* AES 256 protected key */
 		if (protkeytype)
 			*protkeytype = PKEY_KEYTYPE_AES_256;
 	preqcblk->domain = domain;
 	/* fill request cprb param block with AU request */
-	preqparm = (struct aureqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct aureqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "AU", 2);
 	preqparm->rule_array_len =
 		sizeof(preqparm->rule_array_len)
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			__func__, (int) cardnr, (int) domain, rc);
+			__func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 		DEBUG_ERR(
 			"%s unwrap secure key failure, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 		if (prepcblk->ccp_rtcode == 8 && prepcblk->ccp_rscode == 2290)
 			rc = -EAGAIN;
 		else
 		DEBUG_WARN(
 			"%s unwrap secure key warning, card response %d/%d\n",
 			__func__,
-			(int) prepcblk->ccp_rtcode,
+			(int)prepcblk->ccp_rtcode,
-			(int) prepcblk->ccp_rscode);
+			(int)prepcblk->ccp_rscode);
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct aurepparm *) ptr;
+	prepparm = (struct aurepparm *)ptr;
 	/* check the returned keyblock */
 	if (prepparm->vud.ckb.version != 0x02) {
 		DEBUG_ERR("%s reply param keyblock version mismatch 0x%02x != 0x02\n",
-			  __func__, (int) prepparm->vud.ckb.version);
+			  __func__, (int)prepparm->vud.ckb.version);
 		rc = -EIO;
 		goto out;
 	}
 	if (prepparm->vud.ckb.algo != 0x81) {
 		DEBUG_ERR(
 			"%s reply param keyblock algo mismatch 0x%02x != 0x81\n",
-			__func__, (int) prepparm->vud.ckb.algo);
+			__func__, (int)prepparm->vud.ckb.algo);
 		rc = -EIO;
 		goto out;
 	}
 	preqcblk->domain = domain;
 	/* fill request cprb param block with FQ request */
-	preqparm = (struct fqreqparm __force *) preqcblk->req_parmb;
+	preqparm = (struct fqreqparm __force *)preqcblk->req_parmb;
 	memcpy(preqparm->subfunc_code, "FQ", 2);
 	memcpy(preqparm->rule_array, keyword, sizeof(preqparm->rule_array));
 	preqparm->rule_array_len =
 	rc = zcrypt_send_cprb(&xcrb);
 	if (rc) {
 		DEBUG_ERR("%s zcrypt_send_cprb (cardnr=%d domain=%d) failed, rc=%d\n",
-			  __func__, (int) cardnr, (int) domain, rc);
+			  __func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 	if (prepcblk->ccp_rtcode != 0) {
 		DEBUG_ERR("%s unwrap secure key failure, card response %d/%d\n",
 			  __func__,
-			  (int) prepcblk->ccp_rtcode,
+			  (int)prepcblk->ccp_rtcode,
-			  (int) prepcblk->ccp_rscode);
+			  (int)prepcblk->ccp_rscode);
 		rc = -EIO;
 		goto out;
 	}
 	/* process response cprb param block */
-	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *)prepcblk) + sizeof(struct CPRBX);
-	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepcblk->rpl_parmb = (u8 __user *)ptr;
-	prepparm = (struct fqrepparm *) ptr;
+	prepparm = (struct fqrepparm *)ptr;
 	ptr = prepparm->lvdata;
 	/* check and possibly copy reply rule array */
-	len = *((u16 *) ptr);
+	len = *((u16 *)ptr);
 	if (len > sizeof(u16)) {
 		ptr += sizeof(u16);
 		len -= sizeof(u16);
 		ptr += len;
 	}
 	/* check and possible copy reply var array */
-	len = *((u16 *) ptr);
+	len = *((u16 *)ptr);
 	if (len > sizeof(u16)) {
 		ptr += sizeof(u16);
 		len -= sizeof(u16);
 	ci->hwtype = devstat.hwtype;
 	/* prep page for rule array and var array use */
-	pg = (u8 *) __get_free_page(GFP_KERNEL);
+	pg = (u8 *)__get_free_page(GFP_KERNEL);
 	if (!pg)
 		return -ENOMEM;
 	rarray = pg;
-	varray = pg + PAGE_SIZE/2;
+	varray = pg + PAGE_SIZE / 2;
-	rlen = vlen = PAGE_SIZE/2;
+	rlen = vlen = PAGE_SIZE / 2;
 	/* QF for this card/domain */
 	rc = cca_query_crypto_facility(cardnr, domain, "STATICSA",
 				       rarray, &rlen, varray, &vlen);
-	if (rc == 0 && rlen >= 10*8 && vlen >= 204) {
+	if (rc == 0 && rlen >= 10 * 8 && vlen >= 204) {
 		memcpy(ci->serial, rarray, 8);
-		ci->new_aes_mk_state = (char) rarray[7*8];
+		ci->new_asym_mk_state = (char)rarray[4 * 8];
-		ci->cur_aes_mk_state = (char) rarray[8*8];
+		ci->cur_asym_mk_state = (char)rarray[5 * 8];
-		ci->old_aes_mk_state = (char) rarray[9*8];
+		ci->old_asym_mk_state = (char)rarray[6 * 8];
+		if (ci->old_asym_mk_state == '2')
+			memcpy(ci->old_asym_mkvp, varray + 64, 16);
+		if (ci->cur_asym_mk_state == '2')
+			memcpy(ci->cur_asym_mkvp, varray + 84, 16);
+		if (ci->new_asym_mk_state == '3')
+			memcpy(ci->new_asym_mkvp, varray + 104, 16);
+		ci->new_aes_mk_state = (char)rarray[7 * 8];
+		ci->cur_aes_mk_state = (char)rarray[8 * 8];
+		ci->old_aes_mk_state = (char)rarray[9 * 8];
 		if (ci->old_aes_mk_state == '2')
 			memcpy(&ci->old_aes_mkvp, varray + 172, 8);
 		if (ci->cur_aes_mk_state == '2')
 	}
 	if (!found)
 		goto out;
-	rlen = vlen = PAGE_SIZE/2;
+	rlen = vlen = PAGE_SIZE / 2;
 	rc = cca_query_crypto_facility(cardnr, domain, "STATICSB",
 				       rarray, &rlen, varray, &vlen);
-	if (rc == 0 && rlen >= 13*8 && vlen >= 240) {
+	if (rc == 0 && rlen >= 13 * 8 && vlen >= 240) {
-		ci->new_apka_mk_state = (char) rarray[10*8];
+		ci->new_apka_mk_state = (char)rarray[10 * 8];
-		ci->cur_apka_mk_state = (char) rarray[11*8];
+		ci->cur_apka_mk_state = (char)rarray[11 * 8];
-		ci->old_apka_mk_state = (char) rarray[12*8];
+		ci->old_apka_mk_state = (char)rarray[12 * 8];
 		if (ci->old_apka_mk_state == '2')
 			memcpy(&ci->old_apka_mkvp, varray + 208, 8);
 		if (ci->cur_apka_mk_state == '2')
 	}
 out:
-	free_page((unsigned long) pg);
+	free_page((unsigned long)pg);
 	return found == 2 ? 0 : -ENOENT;
 }
 		if (pdomain)
 			*pdomain = dom;
 		rc = (i < MAX_ZDEV_ENTRIES_EXT ? 0 : 1);
-	} else
+	} else {
 		rc = -ENODEV;
+	}
 	kvfree(device_status);
 	return rc;
 {
 	u64 mkvp;
 	int minhwtype = 0;
-	const struct keytoken_header *hdr = (struct keytoken_header *) key;
+	const struct keytoken_header *hdr = (struct keytoken_header *)key;
 	if (hdr->type != TOKTYPE_CCA_INTERNAL)
 		return -EINVAL;
 		}
 		/* apqn passed all filtering criterons, add to the array */
 		if (_nr_apqns < 256)
-			_apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16) dom);
+			_apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16)dom);
 	}
 	/* nothing found ? */

drivers/s390/crypto/zcrypt_ccamisc.h+6−0

 	char new_apka_mk_state; /* '1' empty, '2' partially full, '3' full */
 	char cur_apka_mk_state; /* '1' invalid, '2' valid */
 	char old_apka_mk_state; /* '1' invalid, '2' valid */
+	char new_asym_mk_state;	/* '1' empty, '2' partially full, '3' full */
+	char cur_asym_mk_state;	/* '1' invalid, '2' valid */
+	char old_asym_mk_state;	/* '1' invalid, '2' valid */
 	u64  new_aes_mkvp;	/* truncated sha256 of new aes master key */
 	u64  cur_aes_mkvp;	/* truncated sha256 of current aes master key */
 	u64  old_aes_mkvp;	/* truncated sha256 of old aes master key */
 	u64  new_apka_mkvp;	/* truncated sha256 of new apka master key */
 	u64  cur_apka_mkvp;	/* truncated sha256 of current apka mk */
 	u64  old_apka_mkvp;	/* truncated sha256 of old apka mk */
+	u8   new_asym_mkvp[16];	/* verify pattern of new asym master key */
+	u8   cur_asym_mkvp[16];	/* verify pattern of current asym master key */
+	u8   old_asym_mkvp[16];	/* verify pattern of old asym master key */
 	char serial[9];		/* serial number (8 ascii numbers + 0x00) */
 };

drivers/s390/crypto/zcrypt_cex2a.c+5−6

 #define CEX3A_MAX_RESPONSE_SIZE	0x210	/* 512 bit modulus
 					 * (max outputdatalength) +
-					 * type80_hdr*/
+					 * type80_hdr
+					 */
 #define CEX3A_MAX_MESSAGE_SIZE	sizeof(struct type50_crb3_msg)
-#define CEX2A_CLEANUP_TIME	(15*HZ)
+#define CEX2A_CLEANUP_TIME	(15 * HZ)
 #define CEX3A_CLEANUP_TIME	CEX2A_CLEANUP_TIME
 MODULE_AUTHOR("IBM Corporation");
 	zc->online = 1;
 	rc = zcrypt_card_register(zc);
-	if (rc) {
+	if (rc)
 		zcrypt_card_free(zc);
-	}
 	return rc;
 }
 	aq->request_timeout = CEX2A_CLEANUP_TIME;
 	dev_set_drvdata(&ap_dev->device, zq);
 	rc = zcrypt_queue_register(zq);
-	if (rc) {
+	if (rc)
 		zcrypt_queue_free(zq);
-	}
 	return rc;
 }

drivers/s390/crypto/zcrypt_cex2c.c+5−5

@@ -31,8 +31,8 @@ · 30 unmodified lines
31	#define CEX2C_MAX_MOD_SIZE 256 /* 2048 bits */	31	#define CEX2C_MAX_MOD_SIZE 256 /* 2048 bits */
32	#define CEX3C_MIN_MOD_SIZE 16 /* 128 bits */	32	#define CEX3C_MIN_MOD_SIZE 16 /* 128 bits */
33	#define CEX3C_MAX_MOD_SIZE 512 /* 4096 bits */	33	#define CEX3C_MAX_MOD_SIZE 512 /* 4096 bits */
34	#define CEX2C_MAX_XCRB_MESSAGE_SIZE (12*1024)	34	#define CEX2C_MAX_XCRB_MESSAGE_SIZE (12 * 1024)
35	#define CEX2C_CLEANUP_TIME (15*HZ)	35	#define CEX2C_CLEANUP_TIME (15 * HZ)
36		36
37	MODULE_AUTHOR("IBM Corporation");	37	MODULE_AUTHOR("IBM Corporation");
38	MODULE_DESCRIPTION("CEX2C/CEX3C Cryptographic Coprocessor device driver, " \	38	MODULE_DESCRIPTION("CEX2C/CEX3C Cryptographic Coprocessor device driver, " \
@@ -200,11 +200,11 @@ static int zcrypt_cex2c_rng_supported(struct ap_queue *aq) · 161 unmodified lines
200	int rc, i;	200	int rc, i;
201		201
202	ap_init_message(&ap_msg);	202	ap_init_message(&ap_msg);
203	ap_msg.msg = (void *) get_zeroed_page(GFP_KERNEL);	203	ap_msg.msg = (void *)get_zeroed_page(GFP_KERNEL);
204	if (!ap_msg.msg)	204	if (!ap_msg.msg)
205	return -ENOMEM;	205	return -ENOMEM;
206		206
207	rng_type6CPRB_msgX(&ap_msg, 4, &domain);	207	rng_type6cprb_msgx(&ap_msg, 4, &domain);
208		208
209	msg = ap_msg.msg;	209	msg = ap_msg.msg;
210	msg->cprbx.domain = AP_QID_QUEUE(aq->qid);	210	msg->cprbx.domain = AP_QID_QUEUE(aq->qid);
@@ -233,7 +233,7 @@ static int zcrypt_cex2c_rng_supported(struct ap_queue *aq) · 22 unmodified lines
233	else	233	else
234	rc = 0;	234	rc = 0;
235	out_free:	235	out_free:
236	free_page((unsigned long) ap_msg.msg);	236	free_page((unsigned long)ap_msg.msg);
237	return rc;	237	return rc;
238	}	238	}
239		239

drivers/s390/crypto/zcrypt_cex4.c+37−7

  * But the maximum time limit managed by the stomper code is set to 60sec.
  * Hence we have to wait at least that time period.
  */
-#define CEX4_CLEANUP_TIME	(900*HZ)
+#define CEX4_CLEANUP_TIME	(900 * HZ)
 MODULE_AUTHOR("IBM Corporation");
 MODULE_DESCRIPTION("CEX[45678] Cryptographic Card device driver, " \
 		     &ci, zq->online);
 	if (ci.new_aes_mk_state >= '1' && ci.new_aes_mk_state <= '3')
-		n = scnprintf(buf, PAGE_SIZE, "AES NEW: %s 0x%016llx\n",
+		n += scnprintf(buf + n, PAGE_SIZE,
-			      new_state[ci.new_aes_mk_state - '1'],
+			       "AES NEW: %s 0x%016llx\n",
-			      ci.new_aes_mkvp);
+			       new_state[ci.new_aes_mk_state - '1'],
+			       ci.new_aes_mkvp);
 	else
-		n = scnprintf(buf, PAGE_SIZE, "AES NEW: - -\n");
+		n += scnprintf(buf + n, PAGE_SIZE, "AES NEW: - -\n");
 	if (ci.cur_aes_mk_state >= '1' && ci.cur_aes_mk_state <= '2')
 		n += scnprintf(buf + n, PAGE_SIZE - n,
 	else
 		n += scnprintf(buf + n, PAGE_SIZE - n, "APKA OLD: - -\n");
+	if (ci.new_asym_mk_state >= '1' && ci.new_asym_mk_state <= '3')
+		n += scnprintf(buf + n, PAGE_SIZE,
+			       "ASYM NEW: %s 0x%016llx%016llx\n",
+			       new_state[ci.new_asym_mk_state - '1'],
+			       *((u64 *)(ci.new_asym_mkvp)),
+			       *((u64 *)(ci.new_asym_mkvp + sizeof(u64))));
+	else
+		n += scnprintf(buf + n, PAGE_SIZE, "ASYM NEW: - -\n");
+	if (ci.cur_asym_mk_state >= '1' && ci.cur_asym_mk_state <= '2')
+		n += scnprintf(buf + n, PAGE_SIZE - n,
+			       "ASYM CUR: %s 0x%016llx%016llx\n",
+			       cao_state[ci.cur_asym_mk_state - '1'],
+			       *((u64 *)(ci.cur_asym_mkvp)),
+			       *((u64 *)(ci.cur_asym_mkvp + sizeof(u64))));
+	else
+		n += scnprintf(buf + n, PAGE_SIZE - n, "ASYM CUR: - -\n");
+	if (ci.old_asym_mk_state >= '1' && ci.old_asym_mk_state <= '2')
+		n += scnprintf(buf + n, PAGE_SIZE - n,
+			       "ASYM OLD: %s 0x%016llx%016llx\n",
+			       cao_state[ci.old_asym_mk_state - '1'],
+			       *((u64 *)(ci.old_asym_mkvp)),
+			       *((u64 *)(ci.old_asym_mkvp + sizeof(u64))));
+	else
+		n += scnprintf(buf + n, PAGE_SIZE - n, "ASYM OLD: - -\n");
 	return n;
 }
 		bin2hex(buf + n, di.cur_wkvp, sizeof(di.cur_wkvp));
 		n += 2 * sizeof(di.cur_wkvp);
 		n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
-	} else
+	} else {
 		n = scnprintf(buf, PAGE_SIZE, "WK CUR: - -\n");
+	}
 	if (di.new_wk_state == '0') {
 		n += scnprintf(buf + n, PAGE_SIZE - n, "WK NEW: %s -\n",
 		bin2hex(buf + n, di.new_wkvp, sizeof(di.new_wkvp));
 		n += 2 * sizeof(di.new_wkvp);
 		n += scnprintf(buf + n, PAGE_SIZE - n, "\n");
-	} else
+	} else {
 		n += scnprintf(buf + n, PAGE_SIZE - n, "WK NEW: - -\n");
+	}
 	return n;
 }

drivers/s390/crypto/zcrypt_ep11misc.c+84−84

 int ep11_check_aes_key_with_hdr(debug_info_t *dbg, int dbflvl,
 				const u8 *key, size_t keylen, int checkcpacfexp)
 {
-	struct ep11kblob_header *hdr = (struct ep11kblob_header *) key;
+	struct ep11kblob_header *hdr = (struct ep11kblob_header *)key;
-	struct ep11keyblob *kb = (struct ep11keyblob *) (key + sizeof(*hdr));
+	struct ep11keyblob *kb = (struct ep11keyblob *)(key + sizeof(*hdr));
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (hdr->type != TOKTYPE_NON_CCA) {
 		if (dbg)
 			DBF("%s key check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) hdr->type, TOKTYPE_NON_CCA);
+			    __func__, (int)hdr->type, TOKTYPE_NON_CCA);
 		return -EINVAL;
 	}
 	if (hdr->hver != 0x00) {
 		if (dbg)
 			DBF("%s key check failed, header version 0x%02x != 0x00\n",
-			    __func__, (int) hdr->hver);
+			    __func__, (int)hdr->hver);
 		return -EINVAL;
 	}
 	if (hdr->version != TOKVER_EP11_AES_WITH_HEADER) {
 		if (dbg)
 			DBF("%s key check failed, version 0x%02x != 0x%02x\n",
-			    __func__, (int) hdr->version, TOKVER_EP11_AES_WITH_HEADER);
+			    __func__, (int)hdr->version, TOKVER_EP11_AES_WITH_HEADER);
 		return -EINVAL;
 	}
 	if (hdr->len > keylen) {
 		if (dbg)
 			DBF("%s key check failed, header len %d keylen %zu mismatch\n",
-			    __func__, (int) hdr->len, keylen);
+			    __func__, (int)hdr->len, keylen);
 		return -EINVAL;
 	}
 	if (hdr->len < sizeof(*hdr) + sizeof(*kb)) {
 		if (dbg)
 			DBF("%s key check failed, header len %d < %zu\n",
-			    __func__, (int) hdr->len, sizeof(*hdr) + sizeof(*kb));
+			    __func__, (int)hdr->len, sizeof(*hdr) + sizeof(*kb));
 		return -EINVAL;
 	}
 	if (kb->version != EP11_STRUCT_MAGIC) {
 		if (dbg)
 			DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
-			    __func__, (int) kb->version, EP11_STRUCT_MAGIC);
+			    __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 		return -EINVAL;
 	}
 	if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 int ep11_check_ecc_key_with_hdr(debug_info_t *dbg, int dbflvl,
 				const u8 *key, size_t keylen, int checkcpacfexp)
 {
-	struct ep11kblob_header *hdr = (struct ep11kblob_header *) key;
+	struct ep11kblob_header *hdr = (struct ep11kblob_header *)key;
-	struct ep11keyblob *kb = (struct ep11keyblob *) (key + sizeof(*hdr));
+	struct ep11keyblob *kb = (struct ep11keyblob *)(key + sizeof(*hdr));
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (hdr->type != TOKTYPE_NON_CCA) {
 		if (dbg)
 			DBF("%s key check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) hdr->type, TOKTYPE_NON_CCA);
+			    __func__, (int)hdr->type, TOKTYPE_NON_CCA);
 		return -EINVAL;
 	}
 	if (hdr->hver != 0x00) {
 		if (dbg)
 			DBF("%s key check failed, header version 0x%02x != 0x00\n",
-			    __func__, (int) hdr->hver);
+			    __func__, (int)hdr->hver);
 		return -EINVAL;
 	}
 	if (hdr->version != TOKVER_EP11_ECC_WITH_HEADER) {
 		if (dbg)
 			DBF("%s key check failed, version 0x%02x != 0x%02x\n",
-			    __func__, (int) hdr->version, TOKVER_EP11_ECC_WITH_HEADER);
+			    __func__, (int)hdr->version, TOKVER_EP11_ECC_WITH_HEADER);
 		return -EINVAL;
 	}
 	if (hdr->len > keylen) {
 		if (dbg)
 			DBF("%s key check failed, header len %d keylen %zu mismatch\n",
-			    __func__, (int) hdr->len, keylen);
+			    __func__, (int)hdr->len, keylen);
 		return -EINVAL;
 	}
 	if (hdr->len < sizeof(*hdr) + sizeof(*kb)) {
 		if (dbg)
 			DBF("%s key check failed, header len %d < %zu\n",
-			    __func__, (int) hdr->len, sizeof(*hdr) + sizeof(*kb));
+			    __func__, (int)hdr->len, sizeof(*hdr) + sizeof(*kb));
 		return -EINVAL;
 	}
 	if (kb->version != EP11_STRUCT_MAGIC) {
 		if (dbg)
 			DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
-			    __func__, (int) kb->version, EP11_STRUCT_MAGIC);
+			    __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 		return -EINVAL;
 	}
 	if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 int ep11_check_aes_key(debug_info_t *dbg, int dbflvl,
 		       const u8 *key, size_t keylen, int checkcpacfexp)
 {
-	struct ep11keyblob *kb = (struct ep11keyblob *) key;
+	struct ep11keyblob *kb = (struct ep11keyblob *)key;
 #define DBF(...) debug_sprintf_event(dbg, dbflvl, ##__VA_ARGS__)
 	if (kb->head.type != TOKTYPE_NON_CCA) {
 		if (dbg)
 			DBF("%s key check failed, type 0x%02x != 0x%02x\n",
-			    __func__, (int) kb->head.type, TOKTYPE_NON_CCA);
+			    __func__, (int)kb->head.type, TOKTYPE_NON_CCA);
 		return -EINVAL;
 	}
 	if (kb->head.version != TOKVER_EP11_AES) {
 		if (dbg)
 			DBF("%s key check failed, version 0x%02x != 0x%02x\n",
-			    __func__, (int) kb->head.version, TOKVER_EP11_AES);
+			    __func__, (int)kb->head.version, TOKVER_EP11_AES);
 		return -EINVAL;
 	}
 	if (kb->head.len > keylen) {
 		if (dbg)
 			DBF("%s key check failed, header len %d keylen %zu mismatch\n",
-			    __func__, (int) kb->head.len, keylen);
+			    __func__, (int)kb->head.len, keylen);
 		return -EINVAL;
 	}
 	if (kb->head.len < sizeof(*kb)) {
 		if (dbg)
 			DBF("%s key check failed, header len %d < %zu\n",
-			    __func__, (int) kb->head.len, sizeof(*kb));
+			    __func__, (int)kb->head.len, sizeof(*kb));
 		return -EINVAL;
 	}
 	if (kb->version != EP11_STRUCT_MAGIC) {
 		if (dbg)
 			DBF("%s key check failed, blob magic 0x%04x != 0x%04x\n",
-			    __func__, (int) kb->version, EP11_STRUCT_MAGIC);
+			    __func__, (int)kb->version, EP11_STRUCT_MAGIC);
 		return -EINVAL;
 	}
 	if (checkcpacfexp && !(kb->attr & EP11_BLOB_PKEY_EXTRACTABLE)) {
 	}
 	if (valuelen > 127) {
 		ptr[1] = 0x81;
-		ptr[2] = (u8) valuelen;
+		ptr[2] = (u8)valuelen;
 		memcpy(ptr + 3, pvalue, valuelen);
 		return 3 + valuelen;
 	}
-	ptr[1] = (u8) valuelen;
+	ptr[1] = (u8)valuelen;
 	memcpy(ptr + 2, pvalue, valuelen);
 	return 2 + valuelen;
 }
 			    struct ep11_cprb *req, size_t req_len,
 			    struct ep11_cprb *rep, size_t rep_len)
 {
-	u->targets = (u8 __user *) t;
+	u->targets = (u8 __user *)t;
 	u->targets_num = nt;
-	u->req = (u8 __user *) req;
+	u->req = (u8 __user *)req;
 	u->req_len = req_len;
-	u->resp = (u8 __user *) rep;
+	u->resp = (u8 __user *)rep;
 	u->resp_len = rep_len;
 }
 	return 0;
 }
 /*
  * Helper function which does an ep11 query with given query type.
  */
 	req = alloc_cprb(sizeof(struct ep11_info_req_pl));
 	if (!req)
 		goto out;
-	req_pl = (struct ep11_info_req_pl *) (((u8 *) req) + sizeof(*req));
+	req_pl = (struct ep11_info_req_pl *)(((u8 *)req) + sizeof(*req));
 	prep_head(&req_pl->head, sizeof(*req_pl), api, 38); /* get xcp info */
 	req_pl->query_type_tag = 0x04;
 	req_pl->query_type_len = sizeof(u32);
 	rep = alloc_cprb(sizeof(struct ep11_info_rep_pl) + buflen);
 	if (!rep)
 		goto out;
-	rep_pl = (struct ep11_info_rep_pl *) (((u8 *) rep) + sizeof(*rep));
+	rep_pl = (struct ep11_info_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 	/* urb and target */
-	urb = kmalloc(sizeof(struct ep11_urb), GFP_KERNEL);
+	urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 	if (!urb)
 		goto out;
 	target.ap_id = cardnr;
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
-			__func__, (int) cardnr, (int) domain, rc);
+			__func__, (int)cardnr, (int)domain, rc);
 		goto out;
 	}
 		goto out;
 	}
-	memcpy(buf, ((u8 *) rep_pl) + sizeof(*rep_pl), rep_pl->data_len);
+	memcpy(buf, ((u8 *)rep_pl) + sizeof(*rep_pl), rep_pl->data_len);
 out:
 	kfree(req);
 			return -ENOMEM;
 		rc = ep11_query_info(card, AUTOSEL_DOM,
 				     0x01 /* module info query */,
-				     sizeof(*pmqi), (u8 *) pmqi);
+				     sizeof(*pmqi), (u8 *)pmqi);
 		if (rc) {
 			if (rc == -ENODEV)
 				card_cache_scrub(card);
 		return -ENOMEM;
 	rc = ep11_query_info(card, domain, 0x03 /* domain info query */,
-			     sizeof(*p_dom_info), (u8 *) p_dom_info);
+			     sizeof(*p_dom_info), (u8 *)p_dom_info);
 	if (rc)
 		goto out;
 			info->cur_wk_state = '1';
 			memcpy(info->cur_wkvp, p_dom_info->cur_WK_VP, 32);
 		}
-		if (p_dom_info->dom_flags & 0x04 /* new wk present */
+		if (p_dom_info->dom_flags & 0x04 || /* new wk present */
-		    || p_dom_info->dom_flags & 0x08 /* new wk committed */) {
+		    p_dom_info->dom_flags & 0x08 /* new wk committed */) {
 			info->new_wk_state =
 				p_dom_info->dom_flags & 0x08 ? '2' : '1';
 			memcpy(info->new_wkvp, p_dom_info->new_WK_VP, 32);
 	req = alloc_cprb(sizeof(struct keygen_req_pl));
 	if (!req)
 		goto out;
-	req_pl = (struct keygen_req_pl *) (((u8 *) req) + sizeof(*req));
+	req_pl = (struct keygen_req_pl *)(((u8 *)req) + sizeof(*req));
 	api = (!keygenflags || keygenflags & 0x00200000) ? 4 : 1;
 	prep_head(&req_pl->head, sizeof(*req_pl), api, 21); /* GenerateKey */
 	req_pl->var_tag = 0x04;
 	rep = alloc_cprb(sizeof(struct keygen_rep_pl));
 	if (!rep)
 		goto out;
-	rep_pl = (struct keygen_rep_pl *) (((u8 *) rep) + sizeof(*rep));
+	rep_pl = (struct keygen_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 	/* urb and target */
-	urb = kmalloc(sizeof(struct ep11_urb), GFP_KERNEL);
+	urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 	if (!urb)
 		goto out;
 	target.ap_id = card;
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
-			__func__, (int) card, (int) domain, rc);
+			__func__, (int)card, (int)domain, rc);
 		goto out;
 	}
 	/* copy key blob and set header values */
 	memcpy(keybuf, rep_pl->data, rep_pl->data_len);
 	*keybufsize = rep_pl->data_len;
-	kb = (struct ep11keyblob *) keybuf;
+	kb = (struct ep11keyblob *)keybuf;
 	kb->head.type = TOKTYPE_NON_CCA;
 	kb->head.len = rep_pl->data_len;
 	kb->head.version = TOKVER_EP11_AES;
 	req = alloc_cprb(req_pl_size);
 	if (!req)
 		goto out;
-	req_pl = (struct crypt_req_pl *) (((u8 *) req) + sizeof(*req));
+	req_pl = (struct crypt_req_pl *)(((u8 *)req) + sizeof(*req));
 	prep_head(&req_pl->head, req_pl_size, api, (mode ? 20 : 19));
 	req_pl->var_tag = 0x04;
 	req_pl->var_len = sizeof(u32);
 	req_pl->mech_tag = 0x04;
 	req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
 	req_pl->mech = (mech ? mech : 0x00001085); /* CKM_AES_CBC_PAD */
-	p = ((u8 *) req_pl) + sizeof(*req_pl);
+	p = ((u8 *)req_pl) + sizeof(*req_pl);
 	if (iv) {
 		memcpy(p, iv, 16);
 		p += 16;
 	rep = alloc_cprb(rep_pl_size);
 	if (!rep)
 		goto out;
-	rep_pl = (struct crypt_rep_pl *) (((u8 *) rep) + sizeof(*rep));
+	rep_pl = (struct crypt_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 	/* urb and target */
-	urb = kmalloc(sizeof(struct ep11_urb), GFP_KERNEL);
+	urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 	if (!urb)
 		goto out;
 	target.ap_id = card;
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
-			__func__, (int) card, (int) domain, rc);
+			__func__, (int)card, (int)domain, rc);
 		goto out;
 	}
 		rc = -EIO;
 		goto out;
 	}
-	p = ((u8 *) rep_pl) + sizeof(*rep_pl);
+	p = ((u8 *)rep_pl) + sizeof(*rep_pl);
-	if (rep_pl->data_lenfmt <= 127)
+	if (rep_pl->data_lenfmt <= 127) {
 		n = rep_pl->data_lenfmt;
-	else if (rep_pl->data_lenfmt == 0x81)
+	} else if (rep_pl->data_lenfmt == 0x81) {
 		n = *p++;
-	else if (rep_pl->data_lenfmt == 0x82) {
+	} else if (rep_pl->data_lenfmt == 0x82) {
-		n = *((u16 *) p);
+		n = *((u16 *)p);
 		p += 2;
 	} else {
 		DEBUG_ERR("%s unknown reply data length format 0x%02hhx\n",
 	req = alloc_cprb(req_pl_size);
 	if (!req)
 		goto out;
-	req_pl = (struct uw_req_pl *) (((u8 *) req) + sizeof(*req));
+	req_pl = (struct uw_req_pl *)(((u8 *)req) + sizeof(*req));
 	api = (!keygenflags || keygenflags & 0x00200000) ? 4 : 1;
 	prep_head(&req_pl->head, req_pl_size, api, 34); /* UnwrapKey */
 	req_pl->attr_tag = 0x04;
 	req_pl->mech_tag = 0x04;
 	req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
 	req_pl->mech = (mech ? mech : 0x00001085); /* CKM_AES_CBC_PAD */
-	p = ((u8 *) req_pl) + sizeof(*req_pl);
+	p = ((u8 *)req_pl) + sizeof(*req_pl);
 	if (iv) {
 		memcpy(p, iv, 16);
 		p += 16;
 	rep = alloc_cprb(sizeof(struct uw_rep_pl));
 	if (!rep)
 		goto out;
-	rep_pl = (struct uw_rep_pl *) (((u8 *) rep) + sizeof(*rep));
+	rep_pl = (struct uw_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 	/* urb and target */
-	urb = kmalloc(sizeof(struct ep11_urb), GFP_KERNEL);
+	urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 	if (!urb)
 		goto out;
 	target.ap_id = card;
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
-			__func__, (int) card, (int) domain, rc);
+			__func__, (int)card, (int)domain, rc);
 		goto out;
 	}
 	/* copy key blob and set header values */
 	memcpy(keybuf, rep_pl->data, rep_pl->data_len);
 	*keybufsize = rep_pl->data_len;
-	kb = (struct ep11keyblob *) keybuf;
+	kb = (struct ep11keyblob *)keybuf;
 	kb->head.type = TOKTYPE_NON_CCA;
 	kb->head.len = rep_pl->data_len;
 	kb->head.version = TOKVER_EP11_AES;
 	u8 *p;
 	/* maybe the session field holds a header with key info */
-	kb = (struct ep11keyblob *) key;
+	kb = (struct ep11keyblob *)key;
 	if (kb->head.type == TOKTYPE_NON_CCA &&
 	    kb->head.version == TOKVER_EP11_AES) {
 		has_header = true;
 		goto out;
 	if (!mech || mech == 0x80060001)
 		req->flags |= 0x20; /* CPACF_WRAP needs special bit */
-	req_pl = (struct wk_req_pl *) (((u8 *) req) + sizeof(*req));
+	req_pl = (struct wk_req_pl *)(((u8 *)req) + sizeof(*req));
 	api = (!mech || mech == 0x80060001) ? 4 : 1; /* CKM_IBM_CPACF_WRAP */
 	prep_head(&req_pl->head, req_pl_size, api, 33); /* WrapKey */
 	req_pl->var_tag = 0x04;
 	req_pl->mech_tag = 0x04;
 	req_pl->mech_len = sizeof(u32) + (iv ? 16 : 0);
 	req_pl->mech = (mech ? mech : 0x80060001); /* CKM_IBM_CPACF_WRAP */
-	p = ((u8 *) req_pl) + sizeof(*req_pl);
+	p = ((u8 *)req_pl) + sizeof(*req_pl);
 	if (iv) {
 		memcpy(p, iv, 16);
 		p += 16;
 	rep = alloc_cprb(sizeof(struct wk_rep_pl));
 	if (!rep)
 		goto out;
-	rep_pl = (struct wk_rep_pl *) (((u8 *) rep) + sizeof(*rep));
+	rep_pl = (struct wk_rep_pl *)(((u8 *)rep) + sizeof(*rep));
 	/* urb and target */
-	urb = kmalloc(sizeof(struct ep11_urb), GFP_KERNEL);
+	urb = kmalloc(sizeof(*urb), GFP_KERNEL);
 	if (!urb)
 		goto out;
 	target.ap_id = card;
 	if (rc) {
 		DEBUG_ERR(
 			"%s zcrypt_send_ep11_cprb(card=%d dom=%d) failed, rc=%d\n",
-			__func__, (int) card, (int) domain, rc);
+			__func__, (int)card, (int)domain, rc);
 		goto out;
 	}
 	u8 encbuf[64], *kek = NULL;
 	size_t clrkeylen, keklen, encbuflen = sizeof(encbuf);
-	if (keybitsize == 128 || keybitsize == 192 || keybitsize == 256)
+	if (keybitsize == 128 || keybitsize == 192 || keybitsize == 256) {
 		clrkeylen = keybitsize / 8;
-	else {
+	} else {
 		DEBUG_ERR(
 			"%s unknown/unsupported keybitsize %d\n",
 			__func__, keybitsize);
 			__func__, rc);
 		goto out;
 	}
-	kb = (struct ep11keyblob *) kek;
+	kb = (struct ep11keyblob *)kek;
 	memset(&kb->head, 0, sizeof(kb->head));
 	/* Step 2: encrypt clear key value with the kek key */
 	struct ep11kblob_header *hdr;
 	/* key with or without header ? */
-	hdr = (struct ep11kblob_header *) keyblob;
+	hdr = (struct ep11kblob_header *)keyblob;
-	if (hdr->type == TOKTYPE_NON_CCA
+	if (hdr->type == TOKTYPE_NON_CCA &&
-	    && (hdr->version == TOKVER_EP11_AES_WITH_HEADER
+	    (hdr->version == TOKVER_EP11_AES_WITH_HEADER ||
-		|| hdr->version == TOKVER_EP11_ECC_WITH_HEADER)
+	     hdr->version == TOKVER_EP11_ECC_WITH_HEADER) &&
-	    && is_ep11_keyblob(keyblob + sizeof(struct ep11kblob_header))) {
+	    is_ep11_keyblob(keyblob + sizeof(struct ep11kblob_header))) {
 		/* EP11 AES or ECC key with header */
 		key = keyblob + sizeof(struct ep11kblob_header);
 		keylen = hdr->len - sizeof(struct ep11kblob_header);
-	} else if (hdr->type == TOKTYPE_NON_CCA
+	} else if (hdr->type == TOKTYPE_NON_CCA &&
-		   && hdr->version == TOKVER_EP11_AES
+		   hdr->version == TOKVER_EP11_AES &&
-		   && is_ep11_keyblob(keyblob)) {
+		   is_ep11_keyblob(keyblob)) {
 		/* EP11 AES key (old style) */
 		key = keyblob;
 		keylen = hdr->len;
 		/* raw EP11 key blob */
 		key = keyblob;
 		keylen = keybloblen;
-	} else
+	} else {
 		return -EINVAL;
+	}
 	/* alloc temp working buffer */
 	wkbuflen = (keylen + AES_BLOCK_SIZE) & (~(AES_BLOCK_SIZE - 1));
 			__func__, rc);
 		goto out;
 	}
-	wki = (struct wk_info *) wkbuf;
+	wki = (struct wk_info *)wkbuf;
 	/* check struct version and pkey type */
 	if (wki->version != 1 || wki->pkeytype < 1 || wki->pkeytype > 5) {
 		DEBUG_ERR("%s wk info version %d or pkeytype %d mismatch.\n",
-			  __func__, (int) wki->version, (int) wki->pkeytype);
+			  __func__, (int)wki->version, (int)wki->pkeytype);
 		rc = -EIO;
 		goto out;
 	}
 	switch (wki->pkeytype) {
 	case 1: /* AES */
 		switch (wki->pkeysize) {
-		case 16+32:
+		case 16 + 32:
 			/* AES 128 protected key */
 			if (protkeytype)
 				*protkeytype = PKEY_KEYTYPE_AES_128;
 			break;
-		case 24+32:
+		case 24 + 32:
 			/* AES 192 protected key */
 			if (protkeytype)
 				*protkeytype = PKEY_KEYTYPE_AES_192;
 			break;
-		case 32+32:
+		case 32 + 32:
 			/* AES 256 protected key */
 			if (protkeytype)
 				*protkeytype = PKEY_KEYTYPE_AES_256;
 			break;
 		default:
 			DEBUG_ERR("%s unknown/unsupported AES pkeysize %d\n",
-				  __func__, (int) wki->pkeysize);
+				  __func__, (int)wki->pkeysize);
 			rc = -EIO;
 			goto out;
 		}
 	case 2: /* TDES */
 	default:
 		DEBUG_ERR("%s unknown/unsupported key type %d\n",
-			  __func__, (int) wki->pkeytype);
+			  __func__, (int)wki->pkeytype);
 		rc = -EIO;
 		goto out;
 	}
 		}
 		/* apqn passed all filtering criterons, add to the array */
 		if (_nr_apqns < 256)
-			_apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16) dom);
+			_apqns[_nr_apqns++] = (((u16)card) << 16) | ((u16)dom);
 	}
 	/* nothing found ? */

drivers/s390/crypto/zcrypt_ep11misc.h+1−1

@@ -50,7 +50,7 @@ struct ep11keyblob { · 49 unmodified lines
50	/* check ep11 key magic to find out if this is an ep11 key blob */	50	/* check ep11 key magic to find out if this is an ep11 key blob */
51	static inline bool is_ep11_keyblob(const u8 *key)	51	static inline bool is_ep11_keyblob(const u8 *key)
52	{	52	{
53	struct ep11keyblob kb = (struct ep11keyblob ) key;	53	struct ep11keyblob kb = (struct ep11keyblob )key;
54		54
55	return (kb->version == EP11_STRUCT_MAGIC);	55	return (kb->version == EP11_STRUCT_MAGIC);
56	}	56	}

drivers/s390/crypto/zcrypt_error.h+2−1

 			ZCRYPT_DBF_WARN(
 				"%s dev=%02x.%04x RY=0x%02x apfs=0x%x => bus rescan, rc=EAGAIN\n",
 				__func__, card, queue, ehdr->reply_code, apfs);
-		} else
+		} else {
 			ZCRYPT_DBF_WARN("%s dev=%02x.%04x RY=0x%02x => bus rescan, rc=EAGAIN\n",
 					__func__, card, queue,
 					ehdr->reply_code);
+		}
 		return -EAGAIN;
 	default:
 		/* Assume request is valid and a retry will be worth it */

drivers/s390/crypto/zcrypt_msgtype50.c+18−13

 int get_rsa_modex_fc(struct ica_rsa_modexpo *mex, int *fcode)
 {
 	if (!mex->inputdatalength)
 		return -EINVAL;
 int get_rsa_crt_fc(struct ica_rsa_modexpo_crt *crt, int *fcode)
 {
 	if (!crt->inputdatalength)
 		return -EINVAL;
 		mod = meb3->modulus + sizeof(meb3->modulus) - mod_len;
 		exp = meb3->exponent + sizeof(meb3->exponent) - mod_len;
 		inp = meb3->message + sizeof(meb3->message) - mod_len;
-	} else
+	} else {
 		return -EINVAL;
+	}
 	if (copy_from_user(mod, mex->n_modulus, mod_len) ||
 	    copy_from_user(exp, mex->b_key, mod_len) ||
 		dq = crb3->dq + sizeof(crb3->dq) - short_len;
 		u = crb3->u + sizeof(crb3->u) - short_len;
 		inp = crb3->message + sizeof(crb3->message) - mod_len;
-	} else
+	} else {
 		return -EINVAL;
+	}
 	/*
 	 * correct the offset of p, bp and mult_inv according zcrypt.h
 				  unsigned int outputdatalength)
 {
 	/* Response type byte is the second byte in the response. */
-	unsigned char rtype = ((unsigned char *) reply->msg)[1];
+	unsigned char rtype = ((unsigned char *)reply->msg)[1];
 	switch (rtype) {
 	case TYPE82_RSP_CODE:
 		pr_err("Crypto dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) rtype);
+		       (int)rtype);
 		ZCRYPT_DBF_ERR(
 			"%s dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 			__func__, AP_QID_CARD(zq->queue->qid),
-			AP_QID_QUEUE(zq->queue->qid), (int) rtype);
+			AP_QID_QUEUE(zq->queue->qid), (int)rtype);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
 			memcpy(msg->msg, reply->msg, len);
 			msg->len = len;
 		}
-	} else
+	} else {
 		memcpy(msg->msg, reply->msg, sizeof(error_reply));
+	}
 out:
-	complete((struct completion *) msg->private);
+	complete((struct completion *)msg->private);
 }
 static atomic_t zcrypt_step = ATOMIC_INIT(0);
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_cex2a_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 		atomic_inc_return(&zcrypt_step);
 	ap_msg->private = &work;
 	rc = ICAMEX_msg_to_type50MEX_msg(zq, ap_msg, mex);
 			rc = convert_response_cex2a(zq, ap_msg,
 						    mex->outputdata,
 						    mex->outputdatalength);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out:
 	ap_msg->private = NULL;
 	if (rc)
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_cex2a_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 		atomic_inc_return(&zcrypt_step);
 	ap_msg->private = &work;
 	rc = ICACRT_msg_to_type50CRT_msg(zq, ap_msg, crt);
 			rc = convert_response_cex2a(zq, ap_msg,
 						    crt->outputdata,
 						    crt->outputdatalength);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out:
 	ap_msg->private = NULL;
 	if (rc)

drivers/s390/crypto/zcrypt_msgtype6.c+147−193

 // SPDX-License-Identifier: GPL-2.0+
 /*
- *  Copyright IBM Corp. 2001, 2012
+ *  Copyright IBM Corp. 2001, 2022
  *  Author(s): Robert Burroughs
  *	       Eric Rossman (edrossma@us.ibm.com)
  *
 #define CEXXC_MAX_ICA_RESPONSE_SIZE 0x77c /* max size type86 v2 reply	    */
-#define CEIL4(x) ((((x)+3)/4)*4)
+#define CEIL4(x) ((((x) + 3) / 4) * 4)
 struct response_type {
 	struct completion work;
 	int type;
 };
 #define CEXXC_RESPONSE_TYPE_ICA  0
 #define CEXXC_RESPONSE_TYPE_XCRB 1
 #define CEXXC_RESPONSE_TYPE_EP11 2
 		   "Copyright IBM Corp. 2001, 2012");
 MODULE_LICENSE("GPL");
-/*
- * CPRB
- *	  Note that all shorts, ints and longs are little-endian.
- *	  All pointer fields are 32-bits long, and mean nothing
- *
- *	  A request CPRB is followed by a request_parameter_block.
- *
- *	  The request (or reply) parameter block is organized thus:
- *	    function code
- *	    VUD block
- *	    key block
- */
-struct CPRB {
-	unsigned short cprb_len;	/* CPRB length			 */
-	unsigned char cprb_ver_id;	/* CPRB version id.		 */
-	unsigned char pad_000;		/* Alignment pad byte.		 */
-	unsigned char srpi_rtcode[4];	/* SRPI return code LELONG	 */
-	unsigned char srpi_verb;	/* SRPI verb type		 */
-	unsigned char flags;		/* flags			 */
-	unsigned char func_id[2];	/* function id			 */
-	unsigned char checkpoint_flag;	/*				 */
-	unsigned char resv2;		/* reserved			 */
-	unsigned short req_parml;	/* request parameter buffer	 */
-					/* length 16-bit little endian	 */
-	unsigned char req_parmp[4];	/* request parameter buffer	 *
-					 * pointer (means nothing: the	 *
-					 * parameter buffer follows	 *
-					 * the CPRB).			 */
-	unsigned char req_datal[4];	/* request data buffer		 */
-					/* length	  ULELONG	 */
-	unsigned char req_datap[4];	/* request data buffer		 */
-					/* pointer			 */
-	unsigned short rpl_parml;	/* reply  parameter buffer	 */
-					/* length 16-bit little endian	 */
-	unsigned char pad_001[2];	/* Alignment pad bytes. ULESHORT */
-	unsigned char rpl_parmp[4];	/* reply parameter buffer	 *
-					 * pointer (means nothing: the	 *
-					 * parameter buffer follows	 *
-					 * the CPRB).			 */
-	unsigned char rpl_datal[4];	/* reply data buffer len ULELONG */
-	unsigned char rpl_datap[4];	/* reply data buffer		 */
-					/* pointer			 */
-	unsigned short ccp_rscode;	/* server reason code	ULESHORT */
-	unsigned short ccp_rtcode;	/* server return code	ULESHORT */
-	unsigned char repd_parml[2];	/* replied parameter len ULESHORT*/
-	unsigned char mac_data_len[2];	/* Mac Data Length	ULESHORT */
-	unsigned char repd_datal[4];	/* replied data length	ULELONG	 */
-	unsigned char req_pc[2];	/* PC identifier		 */
-	unsigned char res_origin[8];	/* resource origin		 */
-	unsigned char mac_value[8];	/* Mac Value			 */
-	unsigned char logon_id[8];	/* Logon Identifier		 */
-	unsigned char usage_domain[2];	/* cdx				 */
-	unsigned char resv3[18];	/* reserved for requestor	 */
-	unsigned short svr_namel;	/* server name length  ULESHORT	 */
-	unsigned char svr_name[8];	/* server name			 */
-} __packed;
 struct function_and_rules_block {
 	unsigned char function_code[2];
 	unsigned short ulen;
 	}
 }
 /*
  * Convert a ICAMEX message to a type6 MEX message.
  *
  *
  * Returns 0 on success or negative errno value.
  */
-static int ICAMEX_msg_to_type6MEX_msgX(struct zcrypt_queue *zq,
+static int icamex_msg_to_type6mex_msgx(struct zcrypt_queue *zq,
 				       struct ap_message *ap_msg,
 				       struct ica_rsa_modexpo *mex)
 {
 		return -EFAULT;
 	/* Set up key which is located after the variable length text. */
-	size = zcrypt_type6_mex_key_en(mex, msg->text+mex->inputdatalength);
+	size = zcrypt_type6_mex_key_en(mex, msg->text + mex->inputdatalength);
 	if (size < 0)
 		return size;
 	size += sizeof(*msg) + mex->inputdatalength;
 	/* message header, cprbx and f&r */
 	msg->hdr = static_type6_hdrX;
-	msg->hdr.ToCardLen1 = size - sizeof(msg->hdr);
+	msg->hdr.tocardlen1 = size - sizeof(msg->hdr);
-	msg->hdr.FromCardLen1 = CEXXC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
+	msg->hdr.fromcardlen1 = CEXXC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
 	msg->cprbx = static_cprbx;
 	msg->cprbx.domain = AP_QID_QUEUE(zq->queue->qid);
-	msg->cprbx.rpl_msgbl = msg->hdr.FromCardLen1;
+	msg->cprbx.rpl_msgbl = msg->hdr.fromcardlen1;
 	msg->fr = static_pke_fnr;
  *
  * Returns 0 on success or negative errno value.
  */
-static int ICACRT_msg_to_type6CRT_msgX(struct zcrypt_queue *zq,
+static int icacrt_msg_to_type6crt_msgx(struct zcrypt_queue *zq,
 				       struct ap_message *ap_msg,
 				       struct ica_rsa_modexpo_crt *crt)
 {
 	/* message header, cprbx and f&r */
 	msg->hdr = static_type6_hdrX;
-	msg->hdr.ToCardLen1 = size -  sizeof(msg->hdr);
+	msg->hdr.tocardlen1 = size -  sizeof(msg->hdr);
-	msg->hdr.FromCardLen1 = CEXXC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
+	msg->hdr.fromcardlen1 = CEXXC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
 	msg->cprbx = static_cprbx;
 	msg->cprbx.domain = AP_QID_QUEUE(zq->queue->qid);
 	struct type86_fmt2_ext fmt2;
 } __packed;
-static int XCRB_msg_to_type6CPRB_msgX(bool userspace, struct ap_message *ap_msg,
+static int xcrb_msg_to_type6cprb_msgx(bool userspace, struct ap_message *ap_msg,
-				      struct ica_xcRB *xcRB,
+				      struct ica_xcRB *xcrb,
 				      unsigned int *fcode,
 				      unsigned short **dom)
 {
 		struct CPRBX cprbx;
 	} __packed * msg = ap_msg->msg;
-	int rcblen = CEIL4(xcRB->request_control_blk_length);
+	int rcblen = CEIL4(xcrb->request_control_blk_length);
 	int req_sumlen, resp_sumlen;
 	char *req_data = ap_msg->msg + sizeof(struct type6_hdr) + rcblen;
 	char *function_code;
-	if (CEIL4(xcRB->request_control_blk_length) <
+	if (CEIL4(xcrb->request_control_blk_length) <
-			xcRB->request_control_blk_length)
+			xcrb->request_control_blk_length)
 		return -EINVAL; /* overflow after alignment*/
 	/* length checks */
 	ap_msg->len = sizeof(struct type6_hdr) +
-		CEIL4(xcRB->request_control_blk_length) +
+		CEIL4(xcrb->request_control_blk_length) +
-		xcRB->request_data_length;
+		xcrb->request_data_length;
 	if (ap_msg->len > ap_msg->bufsize)
 		return -EINVAL;
 	 * Overflow check
 	 * sum must be greater (or equal) than the largest operand
 	 */
-	req_sumlen = CEIL4(xcRB->request_control_blk_length) +
+	req_sumlen = CEIL4(xcrb->request_control_blk_length) +
-			xcRB->request_data_length;
+			xcrb->request_data_length;
-	if ((CEIL4(xcRB->request_control_blk_length) <=
+	if ((CEIL4(xcrb->request_control_blk_length) <=
-						xcRB->request_data_length) ?
+	     xcrb->request_data_length) ?
-		(req_sumlen < xcRB->request_data_length) :
+	    req_sumlen < xcrb->request_data_length :
-		(req_sumlen < CEIL4(xcRB->request_control_blk_length))) {
+	    req_sumlen < CEIL4(xcrb->request_control_blk_length)) {
 		return -EINVAL;
 	}
-	if (CEIL4(xcRB->reply_control_blk_length) <
+	if (CEIL4(xcrb->reply_control_blk_length) <
-			xcRB->reply_control_blk_length)
+			xcrb->reply_control_blk_length)
 		return -EINVAL; /* overflow after alignment*/
 	/*
 	 * Overflow check
 	 * sum must be greater (or equal) than the largest operand
 	 */
-	resp_sumlen = CEIL4(xcRB->reply_control_blk_length) +
+	resp_sumlen = CEIL4(xcrb->reply_control_blk_length) +
-			xcRB->reply_data_length;
+			xcrb->reply_data_length;
-	if ((CEIL4(xcRB->reply_control_blk_length) <= xcRB->reply_data_length) ?
+	if ((CEIL4(xcrb->reply_control_blk_length) <=
-		(resp_sumlen < xcRB->reply_data_length) :
+	     xcrb->reply_data_length) ?
-		(resp_sumlen < CEIL4(xcRB->reply_control_blk_length))) {
+	    resp_sumlen < xcrb->reply_data_length :
+	    resp_sumlen < CEIL4(xcrb->reply_control_blk_length)) {
 		return -EINVAL;
 	}
 	/* prepare type6 header */
 	msg->hdr = static_type6_hdrX;
-	memcpy(msg->hdr.agent_id, &(xcRB->agent_ID), sizeof(xcRB->agent_ID));
+	memcpy(msg->hdr.agent_id, &xcrb->agent_ID, sizeof(xcrb->agent_ID));
-	msg->hdr.ToCardLen1 = xcRB->request_control_blk_length;
+	msg->hdr.tocardlen1 = xcrb->request_control_blk_length;
-	if (xcRB->request_data_length) {
+	if (xcrb->request_data_length) {
 		msg->hdr.offset2 = msg->hdr.offset1 + rcblen;
-		msg->hdr.ToCardLen2 = xcRB->request_data_length;
+		msg->hdr.tocardlen2 = xcrb->request_data_length;
 	}
-	msg->hdr.FromCardLen1 = xcRB->reply_control_blk_length;
+	msg->hdr.fromcardlen1 = xcrb->reply_control_blk_length;
-	msg->hdr.FromCardLen2 = xcRB->reply_data_length;
+	msg->hdr.fromcardlen2 = xcrb->reply_data_length;
 	/* prepare CPRB */
-	if (z_copy_from_user(userspace, &(msg->cprbx), xcRB->request_control_blk_addr,
+	if (z_copy_from_user(userspace, &msg->cprbx, xcrb->request_control_blk_addr,
-			     xcRB->request_control_blk_length))
+			     xcrb->request_control_blk_length))
 		return -EFAULT;
 	if (msg->cprbx.cprb_len + sizeof(msg->hdr.function_code) >
-	    xcRB->request_control_blk_length)
+	    xcrb->request_control_blk_length)
 		return -EINVAL;
 	function_code = ((unsigned char *)&msg->cprbx) + msg->cprbx.cprb_len;
 	memcpy(msg->hdr.function_code, function_code,
 	*dom = (unsigned short *)&msg->cprbx.domain;
 	/* check subfunction, US and AU need special flag with NQAP */
-	if (memcmp(function_code, "US", 2) == 0
+	if (memcmp(function_code, "US", 2) == 0 ||
-	    || memcmp(function_code, "AU", 2) == 0)
+	    memcmp(function_code, "AU", 2) == 0)
 		ap_msg->flags |= AP_MSG_FLAG_SPECIAL;
 #ifdef CONFIG_ZCRYPT_DEBUG
 	}
 	/* copy data block */
-	if (xcRB->request_data_length &&
+	if (xcrb->request_data_length &&
-	    z_copy_from_user(userspace, req_data, xcRB->request_data_address,
+	    z_copy_from_user(userspace, req_data, xcrb->request_data_address,
-			     xcRB->request_data_length))
+			     xcrb->request_data_length))
 		return -EFAULT;
 	return 0;
 }
 static int xcrb_msg_to_type6_ep11cprb_msgx(bool userspace, struct ap_message *ap_msg,
-					   struct ep11_urb *xcRB,
+					   struct ep11_urb *xcrb,
 					   unsigned int *fcode,
 					   unsigned int *domain)
 {
 		unsigned int	dom_val;	/* domain id	   */
 	} __packed * payload_hdr = NULL;
-	if (CEIL4(xcRB->req_len) < xcRB->req_len)
+	if (CEIL4(xcrb->req_len) < xcrb->req_len)
 		return -EINVAL; /* overflow after alignment*/
 	/* length checks */
-	ap_msg->len = sizeof(struct type6_hdr) + CEIL4(xcRB->req_len);
+	ap_msg->len = sizeof(struct type6_hdr) + CEIL4(xcrb->req_len);
 	if (ap_msg->len > ap_msg->bufsize)
 		return -EINVAL;
-	if (CEIL4(xcRB->resp_len) < xcRB->resp_len)
+	if (CEIL4(xcrb->resp_len) < xcrb->resp_len)
 		return -EINVAL; /* overflow after alignment*/
 	/* prepare type6 header */
 	msg->hdr = static_type6_ep11_hdr;
-	msg->hdr.ToCardLen1   = xcRB->req_len;
+	msg->hdr.tocardlen1   = xcrb->req_len;
-	msg->hdr.FromCardLen1 = xcRB->resp_len;
+	msg->hdr.fromcardlen1 = xcrb->resp_len;
 	/* Import CPRB data from the ioctl input parameter */
-	if (z_copy_from_user(userspace, &(msg->cprbx.cprb_len),
+	if (z_copy_from_user(userspace, &msg->cprbx.cprb_len,
-			     (char __force __user *)xcRB->req, xcRB->req_len)) {
+			     (char __force __user *)xcrb->req, xcrb->req_len)) {
 		return -EFAULT;
 	}
 	} else {
 		lfmt = 1; /* length format #1 */
 	}
-	payload_hdr = (struct pld_hdr *)((&(msg->pld_lenfmt))+lfmt);
+	payload_hdr = (struct pld_hdr *)((&msg->pld_lenfmt) + lfmt);
 	*fcode = payload_hdr->func_val & 0xFFFF;
 	/* enable special processing based on the cprbs flags special bit */
 } __packed;
 static int convert_type86_ica(struct zcrypt_queue *zq,
-			  struct ap_message *reply,
+			      struct ap_message *reply,
-			  char __user *outputdata,
+			      char __user *outputdata,
-			  unsigned int outputdatalength)
+			      unsigned int outputdatalength)
 {
 	static unsigned char static_pad[] = {
 		0x00, 0x02,
 			ZCRYPT_DBF_WARN("%s dev=%02x.%04x rc/rs=%d/%d => rc=EINVAL\n",
 					__func__, AP_QID_CARD(zq->queue->qid),
 					AP_QID_QUEUE(zq->queue->qid),
-					(int) service_rc, (int) service_rs);
+					(int)service_rc, (int)service_rs);
 			return -EINVAL;
 		}
 		zq->online = 0;
 		pr_err("Crypto dev=%02x.%04x rc/rs=%d/%d online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) service_rc, (int) service_rs);
+		       (int)service_rc, (int)service_rs);
 		ZCRYPT_DBF_ERR("%s dev=%02x.%04x rc/rs=%d/%d => online=0 rc=EAGAIN\n",
 			       __func__, AP_QID_CARD(zq->queue->qid),
 			       AP_QID_QUEUE(zq->queue->qid),
-			       (int) service_rc, (int) service_rs);
+			       (int)service_rc, (int)service_rs);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
  *
  * @zq: crypto device pointer
  * @reply: reply AP message.
- * @xcRB: pointer to XCRB
+ * @xcrb: pointer to XCRB
  *
  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
  */
 static int convert_type86_xcrb(bool userspace, struct zcrypt_queue *zq,
 			       struct ap_message *reply,
-			       struct ica_xcRB *xcRB)
+			       struct ica_xcRB *xcrb)
 {
 	struct type86_fmt2_msg *msg = reply->msg;
 	char *data = reply->msg;
 	/* Copy CPRB to user */
-	if (xcRB->reply_control_blk_length < msg->fmt2.count1) {
+	if (xcrb->reply_control_blk_length < msg->fmt2.count1) {
 		ZCRYPT_DBF_DBG("%s reply_control_blk_length %u < required %u => EMSGSIZE\n",
-			       __func__, xcRB->reply_control_blk_length,
+			       __func__, xcrb->reply_control_blk_length,
 			       msg->fmt2.count1);
 		return -EMSGSIZE;
 	}
-	if (z_copy_to_user(userspace, xcRB->reply_control_blk_addr,
+	if (z_copy_to_user(userspace, xcrb->reply_control_blk_addr,
 			   data + msg->fmt2.offset1, msg->fmt2.count1))
 		return -EFAULT;
-	xcRB->reply_control_blk_length = msg->fmt2.count1;
+	xcrb->reply_control_blk_length = msg->fmt2.count1;
 	/* Copy data buffer to user */
 	if (msg->fmt2.count2) {
-		if (xcRB->reply_data_length < msg->fmt2.count2) {
+		if (xcrb->reply_data_length < msg->fmt2.count2) {
 			ZCRYPT_DBF_DBG("%s reply_data_length %u < required %u => EMSGSIZE\n",
-				       __func__, xcRB->reply_data_length,
+				       __func__, xcrb->reply_data_length,
 				       msg->fmt2.count2);
 			return -EMSGSIZE;
 		}
-		if (z_copy_to_user(userspace, xcRB->reply_data_addr,
+		if (z_copy_to_user(userspace, xcrb->reply_data_addr,
 				   data + msg->fmt2.offset2, msg->fmt2.count2))
 			return -EFAULT;
 	}
-	xcRB->reply_data_length = msg->fmt2.count2;
+	xcrb->reply_data_length = msg->fmt2.count2;
 	return 0;
 }
  *
  * @zq: crypto device pointer
  * @reply: reply AP message.
- * @xcRB: pointer to EP11 user request block
+ * @xcrb: pointer to EP11 user request block
  *
  * Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
  */
 static int convert_type86_ep11_xcrb(bool userspace, struct zcrypt_queue *zq,
 				    struct ap_message *reply,
-				    struct ep11_urb *xcRB)
+				    struct ep11_urb *xcrb)
 {
 	struct type86_fmt2_msg *msg = reply->msg;
 	char *data = reply->msg;
-	if (xcRB->resp_len < msg->fmt2.count1) {
+	if (xcrb->resp_len < msg->fmt2.count1) {
 		ZCRYPT_DBF_DBG("%s resp_len %u < required %u => EMSGSIZE\n",
-			       __func__, (unsigned int)xcRB->resp_len,
+			       __func__, (unsigned int)xcrb->resp_len,
 			       msg->fmt2.count1);
 		return -EMSGSIZE;
 	}
 	/* Copy response CPRB to user */
-	if (z_copy_to_user(userspace, (char __force __user *)xcRB->resp,
+	if (z_copy_to_user(userspace, (char __force __user *)xcrb->resp,
 			   data + msg->fmt2.offset1, msg->fmt2.count1))
 		return -EFAULT;
-	xcRB->resp_len = msg->fmt2.count1;
+	xcrb->resp_len = msg->fmt2.count1;
 	return 0;
 }
 static int convert_type86_rng(struct zcrypt_queue *zq,
-			  struct ap_message *reply,
+			      struct ap_message *reply,
-			  char *buffer)
+			      char *buffer)
 {
 	struct {
 		struct type86_hdr hdr;
 }
 static int convert_response_ica(struct zcrypt_queue *zq,
-			    struct ap_message *reply,
+				struct ap_message *reply,
-			    char __user *outputdata,
+				char __user *outputdata,
-			    unsigned int outputdatalength)
+				unsigned int outputdatalength)
 {
 	struct type86x_reply *msg = reply->msg;
 		return convert_error(zq, reply);
 	case TYPE86_RSP_CODE:
 		if (msg->cprbx.ccp_rtcode &&
-		   (msg->cprbx.ccp_rscode == 0x14f) &&
+		    msg->cprbx.ccp_rscode == 0x14f &&
-		   (outputdatalength > 256)) {
+		    outputdatalength > 256) {
 			if (zq->zcard->max_exp_bit_length <= 17) {
 				zq->zcard->max_exp_bit_length = 17;
 				return -EAGAIN;
-			} else
+			} else {
 				return -EINVAL;
+			}
 		}
 		if (msg->hdr.reply_code)
 			return convert_error(zq, reply);
 		pr_err("Crypto dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) msg->hdr.type);
+		       (int)msg->hdr.type);
 		ZCRYPT_DBF_ERR(
 			"%s dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 			__func__, AP_QID_CARD(zq->queue->qid),
-			AP_QID_QUEUE(zq->queue->qid), (int) msg->hdr.type);
+			AP_QID_QUEUE(zq->queue->qid), (int)msg->hdr.type);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
 static int convert_response_xcrb(bool userspace, struct zcrypt_queue *zq,
 				 struct ap_message *reply,
-				 struct ica_xcRB *xcRB)
+				 struct ica_xcRB *xcrb)
 {
 	struct type86x_reply *msg = reply->msg;
 	switch (msg->hdr.type) {
 	case TYPE82_RSP_CODE:
 	case TYPE88_RSP_CODE:
-		xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
+		xcrb->status = 0x0008044DL; /* HDD_InvalidParm */
 		return convert_error(zq, reply);
 	case TYPE86_RSP_CODE:
 		if (msg->hdr.reply_code) {
-			memcpy(&(xcRB->status), msg->fmt2.apfs, sizeof(u32));
+			memcpy(&xcrb->status, msg->fmt2.apfs, sizeof(u32));
 			return convert_error(zq, reply);
 		}
 		if (msg->cprbx.cprb_ver_id == 0x02)
-			return convert_type86_xcrb(userspace, zq, reply, xcRB);
+			return convert_type86_xcrb(userspace, zq, reply, xcrb);
 		fallthrough;	/* wrong cprb version is an unknown response */
 	default: /* Unknown response type, this should NEVER EVER happen */
-		xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
+		xcrb->status = 0x0008044DL; /* HDD_InvalidParm */
 		zq->online = 0;
 		pr_err("Crypto dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) msg->hdr.type);
+		       (int)msg->hdr.type);
 		ZCRYPT_DBF_ERR(
 			"%s dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 			__func__, AP_QID_CARD(zq->queue->qid),
-			AP_QID_QUEUE(zq->queue->qid), (int) msg->hdr.type);
+			AP_QID_QUEUE(zq->queue->qid), (int)msg->hdr.type);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
 }
 static int convert_response_ep11_xcrb(bool userspace, struct zcrypt_queue *zq,
-				      struct ap_message *reply, struct ep11_urb *xcRB)
+				      struct ap_message *reply, struct ep11_urb *xcrb)
 {
 	struct type86_ep11_reply *msg = reply->msg;
 		if (msg->hdr.reply_code)
 			return convert_error(zq, reply);
 		if (msg->cprbx.cprb_ver_id == 0x04)
-			return convert_type86_ep11_xcrb(userspace, zq, reply, xcRB);
+			return convert_type86_ep11_xcrb(userspace, zq, reply, xcrb);
 		fallthrough;	/* wrong cprb version is an unknown resp */
 	default: /* Unknown response type, this should NEVER EVER happen */
 		zq->online = 0;
 		pr_err("Crypto dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) msg->hdr.type);
+		       (int)msg->hdr.type);
 		ZCRYPT_DBF_ERR(
 			"%s dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 			__func__, AP_QID_CARD(zq->queue->qid),
-			AP_QID_QUEUE(zq->queue->qid), (int) msg->hdr.type);
+			AP_QID_QUEUE(zq->queue->qid), (int)msg->hdr.type);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
 }
 static int convert_response_rng(struct zcrypt_queue *zq,
-				 struct ap_message *reply,
+				struct ap_message *reply,
-				 char *data)
+				char *data)
 {
 	struct type86x_reply *msg = reply->msg;
 		pr_err("Crypto dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 		       AP_QID_CARD(zq->queue->qid),
 		       AP_QID_QUEUE(zq->queue->qid),
-		       (int) msg->hdr.type);
+		       (int)msg->hdr.type);
 		ZCRYPT_DBF_ERR(
 			"%s dev=%02x.%04x unknown response type 0x%02x => online=0 rc=EAGAIN\n",
 			__func__, AP_QID_CARD(zq->queue->qid),
-			AP_QID_QUEUE(zq->queue->qid), (int) msg->hdr.type);
+			AP_QID_QUEUE(zq->queue->qid), (int)msg->hdr.type);
 		ap_send_online_uevent(&zq->queue->ap_dev, zq->online);
 		return -EAGAIN;
 	}
  * @reply: pointer to the AP reply message
  */
 static void zcrypt_msgtype6_receive(struct ap_queue *aq,
-				  struct ap_message *msg,
+				    struct ap_message *msg,
-				  struct ap_message *reply)
+				    struct ap_message *reply)
 {
 	static struct error_hdr error_reply = {
 		.type = TYPE82_RSP_CODE,
 		.reply_code = REP82_ERROR_MACHINE_FAILURE,
 	};
 	struct response_type *resp_type =
-		(struct response_type *) msg->private;
+		(struct response_type *)msg->private;
 	struct type86x_reply *t86r;
 	int len;
 		goto out;	/* ap_msg->rc indicates the error */
 	t86r = reply->msg;
 	if (t86r->hdr.type == TYPE86_RSP_CODE &&
-		 t86r->cprbx.cprb_ver_id == 0x02) {
+	    t86r->cprbx.cprb_ver_id == 0x02) {
 		switch (resp_type->type) {
 		case CEXXC_RESPONSE_TYPE_ICA:
 			len = sizeof(struct type86x_reply) + t86r->length - 2;
 		default:
 			memcpy(msg->msg, &error_reply, sizeof(error_reply));
 		}
-	} else
+	} else {
 		memcpy(msg->msg, reply->msg, sizeof(error_reply));
+	}
 out:
-	complete(&(resp_type->work));
+	complete(&resp_type->work);
 }
 /*
 		memcpy(msg->msg, reply->msg, sizeof(error_reply));
 	}
 out:
-	complete(&(resp_type->work));
+	complete(&resp_type->work);
 }
 static atomic_t zcrypt_step = ATOMIC_INIT(0);
 	};
 	int rc;
-	ap_msg->msg = (void *) get_zeroed_page(GFP_KERNEL);
+	ap_msg->msg = (void *)get_zeroed_page(GFP_KERNEL);
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->bufsize = PAGE_SIZE;
 	ap_msg->receive = zcrypt_msgtype6_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 		atomic_inc_return(&zcrypt_step);
 	ap_msg->private = &resp_type;
-	rc = ICAMEX_msg_to_type6MEX_msgX(zq, ap_msg, mex);
+	rc = icamex_msg_to_type6mex_msgx(zq, ap_msg, mex);
 	if (rc)
 		goto out_free;
 	init_completion(&resp_type.work);
 			rc = convert_response_ica(zq, ap_msg,
 						  mex->outputdata,
 						  mex->outputdatalength);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out_free:
-	free_page((unsigned long) ap_msg->msg);
+	free_page((unsigned long)ap_msg->msg);
 	ap_msg->private = NULL;
 	ap_msg->msg = NULL;
 	return rc;
 	};
 	int rc;
-	ap_msg->msg = (void *) get_zeroed_page(GFP_KERNEL);
+	ap_msg->msg = (void *)get_zeroed_page(GFP_KERNEL);
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->bufsize = PAGE_SIZE;
 	ap_msg->receive = zcrypt_msgtype6_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 		atomic_inc_return(&zcrypt_step);
 	ap_msg->private = &resp_type;
-	rc = ICACRT_msg_to_type6CRT_msgX(zq, ap_msg, crt);
+	rc = icacrt_msg_to_type6crt_msgx(zq, ap_msg, crt);
 	if (rc)
 		goto out_free;
 	init_completion(&resp_type.work);
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
 	}
 out_free:
-	free_page((unsigned long) ap_msg->msg);
+	free_page((unsigned long)ap_msg->msg);
 	ap_msg->private = NULL;
 	ap_msg->msg = NULL;
 	return rc;
  * by the caller with ap_init_message(). Also the caller has to
  * make sure ap_release_message() is always called even on failure.
  */
-int prep_cca_ap_msg(bool userspace, struct ica_xcRB *xcRB,
+int prep_cca_ap_msg(bool userspace, struct ica_xcRB *xcrb,
 		    struct ap_message *ap_msg,
 		    unsigned int *func_code, unsigned short **dom)
 {
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 				atomic_inc_return(&zcrypt_step);
 	ap_msg->private = kmemdup(&resp_type, sizeof(resp_type), GFP_KERNEL);
 	if (!ap_msg->private)
 		return -ENOMEM;
-	return XCRB_msg_to_type6CPRB_msgX(userspace, ap_msg, xcRB, func_code, dom);
+	return xcrb_msg_to_type6cprb_msgx(userspace, ap_msg, xcrb, func_code, dom);
 }
 /*
  * device to handle a send_cprb request.
  * @zq: pointer to zcrypt_queue structure that identifies the
  *	CEXxC device to the request distributor
- * @xcRB: pointer to the send_cprb request buffer
+ * @xcrb: pointer to the send_cprb request buffer
  */
 static long zcrypt_msgtype6_send_cprb(bool userspace, struct zcrypt_queue *zq,
-				      struct ica_xcRB *xcRB,
+				      struct ica_xcRB *xcrb,
 				      struct ap_message *ap_msg)
 {
 	int rc;
 	 * Set the queue's reply buffer length minus 128 byte padding
 	 * as reply limit for the card firmware.
 	 */
-	msg->hdr.FromCardLen1 = min_t(unsigned int, msg->hdr.FromCardLen1,
+	msg->hdr.fromcardlen1 = min_t(unsigned int, msg->hdr.fromcardlen1,
 				      zq->reply.bufsize - 128);
-	if (msg->hdr.FromCardLen2)
+	if (msg->hdr.fromcardlen2)
-		msg->hdr.FromCardLen2 =
+		msg->hdr.fromcardlen2 =
-			zq->reply.bufsize - msg->hdr.FromCardLen1 - 128;
+			zq->reply.bufsize - msg->hdr.fromcardlen1 - 128;
 	init_completion(&rtype->work);
 	rc = ap_queue_message(zq->queue, ap_msg);
 	if (rc == 0) {
 		rc = ap_msg->rc;
 		if (rc == 0)
-			rc = convert_response_xcrb(userspace, zq, ap_msg, xcRB);
+			rc = convert_response_xcrb(userspace, zq, ap_msg, xcrb);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out:
 	if (rc)
 		ZCRYPT_DBF_DBG("%s send cprb at dev=%02x.%04x rc=%d\n",
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive_ep11;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 				atomic_inc_return(&zcrypt_step);
 	ap_msg->private = kmemdup(&resp_type, sizeof(resp_type), GFP_KERNEL);
 	if (!ap_msg->private)
  * device to handle a send_ep11_cprb request.
  * @zq: pointer to zcrypt_queue structure that identifies the
  *	  CEX4P device to the request distributor
- * @xcRB: pointer to the ep11 user request block
+ * @xcrb: pointer to the ep11 user request block
  */
 static long zcrypt_msgtype6_send_ep11_cprb(bool userspace, struct zcrypt_queue *zq,
 					   struct ep11_urb *xcrb,
 		} else {
 			lfmt = 1; /* length format #1 */
 		}
-		payload_hdr = (struct pld_hdr *)((&(msg->pld_lenfmt))+lfmt);
+		payload_hdr = (struct pld_hdr *)((&msg->pld_lenfmt) + lfmt);
 		payload_hdr->dom_val = (unsigned int)
 					AP_QID_QUEUE(zq->queue->qid);
 	}
 	 * Set the queue's reply buffer length minus the two prepend headers
 	 * as reply limit for the card firmware.
 	 */
-	msg->hdr.FromCardLen1 = zq->reply.bufsize -
+	msg->hdr.fromcardlen1 = zq->reply.bufsize -
 		sizeof(struct type86_hdr) - sizeof(struct type86_fmt2_ext);
 	init_completion(&rtype->work);
 		rc = ap_msg->rc;
 		if (rc == 0)
 			rc = convert_response_ep11_xcrb(userspace, zq, ap_msg, xcrb);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out:
 	if (rc)
 		ZCRYPT_DBF_DBG("%s send cprb at dev=%02x.%04x rc=%d\n",
 	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive;
-	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
+	ap_msg->psmid = (((unsigned long long)current->pid) << 32) +
 				atomic_inc_return(&zcrypt_step);
 	ap_msg->private = kmemdup(&resp_type, sizeof(resp_type), GFP_KERNEL);
 	if (!ap_msg->private)
 		return -ENOMEM;
-	rng_type6CPRB_msgX(ap_msg, ZCRYPT_RNG_BUFFER_SIZE, domain);
+	rng_type6cprb_msgx(ap_msg, ZCRYPT_RNG_BUFFER_SIZE, domain);
 	*func_code = HWRNG;
 	return 0;
 		rc = ap_msg->rc;
 		if (rc == 0)
 			rc = convert_response_rng(zq, ap_msg, buffer);
-	} else
+	} else {
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, ap_msg);
+	}
 out:
 	return rc;
 }

drivers/s390/crypto/zcrypt_msgtype6.h+13−13

@@ -45,14 +45,14 @@ struct type6_hdr { · 44 unmodified lines
45	unsigned char reserved5[2]; /* 0x0000 */	45	unsigned char reserved5[2]; /* 0x0000 */
46	unsigned char function_code[2]; /* for PKD, 0x5044 (ascii 'PD') */	46	unsigned char function_code[2]; /* for PKD, 0x5044 (ascii 'PD') */
47	unsigned char reserved6[2]; /* 0x0000 */	47	unsigned char reserved6[2]; /* 0x0000 */
48	unsigned int ToCardLen1; /* (request CPRB len + 3) & -4 */	48	unsigned int tocardlen1; /* (request CPRB len + 3) & -4 */
49	unsigned int ToCardLen2; /* db len 0x00000000 for PKD */	49	unsigned int tocardlen2; /* db len 0x00000000 for PKD */
50	unsigned int ToCardLen3; /* 0x00000000 */	50	unsigned int tocardlen3; /* 0x00000000 */
51	unsigned int ToCardLen4; /* 0x00000000 */	51	unsigned int tocardlen4; /* 0x00000000 */
52	unsigned int FromCardLen1; /* response buffer length */	52	unsigned int fromcardlen1; /* response buffer length */
53	unsigned int FromCardLen2; /* db len 0x00000000 for PKD */	53	unsigned int fromcardlen2; /* db len 0x00000000 for PKD */
54	unsigned int FromCardLen3; /* 0x00000000 */	54	unsigned int fromcardlen3; /* 0x00000000 */
55	unsigned int FromCardLen4; /* 0x00000000 */	55	unsigned int fromcardlen4; /* 0x00000000 */
56	} __packed;	56	} __packed;
57		57
58	/**	58	/**
@@ -116,7 +116,7 @@ int speed_idx_ep11(int); · 57 unmodified lines
116	* @ap_dev: AP device pointer	116	* @ap_dev: AP device pointer
117	* @ap_msg: pointer to AP message	117	* @ap_msg: pointer to AP message
118	*/	118	*/
119	static inline void rng_type6CPRB_msgX(struct ap_message *ap_msg,	119	static inline void rng_type6cprb_msgx(struct ap_message *ap_msg,
120	unsigned int random_number_length,	120	unsigned int random_number_length,
121	unsigned int *domain)	121	unsigned int *domain)
122	{	122	{
@@ -134,8 +134,8 @@ static inline void rng_type6CPRB_msgX(struct ap_message *ap_msg, · 11 unmodified lines
134	.offset1 = 0x00000058,	134	.offset1 = 0x00000058,
135	.agent_id = {'C', 'A'},	135	.agent_id = {'C', 'A'},
136	.function_code = {'R', 'L'},	136	.function_code = {'R', 'L'},
137	.ToCardLen1 = sizeof(*msg) - sizeof(msg->hdr),	137	.tocardlen1 = sizeof(*msg) - sizeof(msg->hdr),
138	.FromCardLen1 = sizeof(*msg) - sizeof(msg->hdr),	138	.fromcardlen1 = sizeof(*msg) - sizeof(msg->hdr),
139	};	139	};
140	static struct CPRBX local_cprbx = {	140	static struct CPRBX local_cprbx = {
141	.cprb_len = 0x00dc,	141	.cprb_len = 0x00dc,
@@ -147,9 +147,9 @@ static inline void rng_type6CPRB_msgX(struct ap_message *ap_msg, · 5 unmodified lines
147	};	147	};
148		148
149	msg->hdr = static_type6_hdrX;	149	msg->hdr = static_type6_hdrX;
150	msg->hdr.FromCardLen2 = random_number_length,	150	msg->hdr.fromcardlen2 = random_number_length;
151	msg->cprbx = local_cprbx;	151	msg->cprbx = local_cprbx;
152	msg->cprbx.rpl_datal = random_number_length,	152	msg->cprbx.rpl_datal = random_number_length;
153	memcpy(msg->function_code, msg->hdr.function_code, 0x02);	153	memcpy(msg->function_code, msg->hdr.function_code, 0x02);
154	msg->rule_length = 0x0a;	154	msg->rule_length = 0x0a;
155	memcpy(msg->rule, "RANDOM ", 8);	155	memcpy(msg->rule, "RANDOM ", 8);

drivers/s390/crypto/zcrypt_queue.c+1−1

@@ -114,7 +114,7 @@ struct zcrypt_queue *zcrypt_queue_alloc(size_t reply_buf_size) · 113 unmodified lines
114	{	114	{
115	struct zcrypt_queue *zq;	115	struct zcrypt_queue *zq;
116		116
117	zq = kzalloc(sizeof(struct zcrypt_queue), GFP_KERNEL);	117	zq = kzalloc(sizeof(*zq), GFP_KERNEL);
118	if (!zq)	118	if (!zq)
119	return NULL;	119	return NULL;
120	zq->reply.msg = kmalloc(reply_buf_size, GFP_KERNEL);	120	zq->reply.msg = kmalloc(reply_buf_size, GFP_KERNEL);

include/linux/entry-common.h+4−4

@@ -63,7 +63,7 @@ · 62 unmodified lines
63	ARCH_EXIT_TO_USER_MODE_WORK)	63	ARCH_EXIT_TO_USER_MODE_WORK)
64		64
65	/**	65	/**
66	* arch_check_user_regs - Architecture specific sanity check for user mode regs	66	* arch_enter_from_user_mode - Architecture specific sanity check for user mode regs
67	* @regs: Pointer to currents pt_regs	67	* @regs: Pointer to currents pt_regs
68	*	68	*
69	* Defaults to an empty implementation. Can be replaced by architecture	69	* Defaults to an empty implementation. Can be replaced by architecture
@@ -73,10 +73,10 @@ · 3 unmodified lines
73	* section. Use __always_inline so the compiler cannot push it out of line	73	* section. Use __always_inline so the compiler cannot push it out of line
74	* and make it instrumentable.	74	* and make it instrumentable.
75	*/	75	*/
76	static __always_inline void arch_check_user_regs(struct pt_regs *regs);	76	static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs);
77		77
78	#ifndef arch_check_user_regs	78	#ifndef arch_enter_from_user_mode
79	static __always_inline void arch_check_user_regs(struct pt_regs *regs) {}	79	static __always_inline void arch_enter_from_user_mode(struct pt_regs *regs) {}
80	#endif	80	#endif
81		81
82	/**	82	/**

kernel/entry/common.c+1−1

@@ -17,7 +17,7 @@ · 16 unmodified lines
17	/* See comment for enter_from_user_mode() in entry-common.h */	17	/* See comment for enter_from_user_mode() in entry-common.h */
18	static __always_inline void __enter_from_user_mode(struct pt_regs *regs)	18	static __always_inline void __enter_from_user_mode(struct pt_regs *regs)
19	{	19	{
20	arch_check_user_regs(regs);	20	arch_enter_from_user_mode(regs);
21	lockdep_hardirqs_off(CALLER_ADDR0);	21	lockdep_hardirqs_off(CALLER_ADDR0);
22		22
23	CT_WARN_ON(ct_state() != CONTEXT_USER);	23	CT_WARN_ON(ct_state() != CONTEXT_USER);

scripts/min-tool-version.sh+1−2

 	echo 16.0.3
 	;;
 llvm)
-	# https://lore.kernel.org/r/YMtib5hKVyNknZt3@osiris/
 	if [ "$SRCARCH" = s390 ]; then
-		echo 13.0.0
+		echo 14.0.0
 	else
 		echo 11.0.0
 	fi

Merge tag 's390-5.19-1' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code