lael-labs/linux

Documentation/s390/s390dbf.rst+4−13

 The content of the directories are files which represent different views
 to the debug log. Each component can decide which views should be
 used through registering them with the function :c:func:`debug_register_view()`.
-Predefined views for hex/ascii, sprintf and raw binary data are provided.
+Predefined views for hex/ascii and sprintf data are provided.
 It is also possible to define other views. The content of
 a view can be inspected simply by reading the corresponding debugfs file.
   extern struct debug_view debug_hex_ascii_view;
-  extern struct debug_view debug_raw_view;
   extern struct debug_view debug_sprintf_view;
 Examples
 .. code-block:: c
   /*
-   * hex_ascii- + raw-view Example
+   * hex_ascii-view Example
    */
   #include <linux/init.h>
       debug_info = debug_register("test", 1, 4, 4 );
       debug_register_view(debug_info, &debug_hex_ascii_view);
-      debug_register_view(debug_info, &debug_raw_view);
       debug_text_event(debug_info, 4 , "one ");
       debug_int_exception(debug_info, 4, 4711);
 Example::
   > ls /sys/kernel/debug/s390dbf/dasd
-  flush  hex_ascii  level pages raw
+  flush  hex_ascii  level pages
   > cat /sys/kernel/debug/s390dbf/dasd/hex_ascii | sort -k2,2 -s
   00 00974733272:680099 2 - 02 0006ad7e  07 ea 4a 90 | ....
   00 00974733272:682210 2 - 02 0006ade6  46 52 45 45 | FREE
 Predefined Views
 ----------------
-There are three predefined views: hex_ascii, raw and sprintf.
+There are two predefined views: hex_ascii and sprintf.
 The hex_ascii view shows the data field in hex and ascii representation
 (e.g. ``45 43 4b 44 | ECKD``).
-The raw view returns a bytestream as the debug areas are stored in memory.
 The sprintf view formats the debug entries in the same way as the sprintf
 function would do. The sprintf event/exception functions write to the
 - Return Address to caller
 - data field
-The format of the raw view is:
-- Header as described in debug.h
-- datafield
 A typical line of the hex_ascii view will look like the following (first line
 is only for explanation and will not be displayed when 'cating' the view)::

arch/s390/Kconfig+2−5

 	select ARCH_INLINE_WRITE_UNLOCK_BH
 	select ARCH_INLINE_WRITE_UNLOCK_IRQ
 	select ARCH_INLINE_WRITE_UNLOCK_IRQRESTORE
-	select ARCH_KEEP_MEMBLOCK
 	select ARCH_STACKWALK
 	select ARCH_SUPPORTS_ATOMIC_RMW
 	select ARCH_SUPPORTS_NUMA_BALANCING
 	select HAVE_ARCH_JUMP_LABEL_RELATIVE
 	select HAVE_ARCH_KASAN
 	select HAVE_ARCH_KASAN_VMALLOC
+	select CLOCKSOURCE_VALIDATE_LAST_CYCLE
 	select CPU_NO_EFFICIENT_FFS if !HAVE_MARCH_Z9_109_FEATURES
 	select HAVE_ARCH_SECCOMP_FILTER
 	select HAVE_ARCH_SOFT_DIRTY
 	select HAVE_EFFICIENT_UNALIGNED_ACCESS
 	select HAVE_FENTRY
 	select HAVE_FTRACE_MCOUNT_RECORD
+	select HAVE_FUNCTION_ERROR_INJECTION
 	select HAVE_FUNCTION_GRAPH_TRACER
 	select HAVE_FUNCTION_TRACER
 	select HAVE_FUTEX_CMPXCHG if FUTEX
 config ARCH_ENABLE_SPLIT_PMD_PTLOCK
 	def_bool y
-config FORCE_MAX_ZONEORDER
-	int
-	default "9"
 config MAX_PHYSMEM_BITS
 	int "Maximum size of supported physical memory in bits (42-53)"
 	range 42 53

arch/s390/appldata/appldata_os.c+2−4

 	os_data->nr_cpus = j;
-	new_size = sizeof(struct appldata_os_data) +
+	new_size = struct_size(os_data, os_cpu, os_data->nr_cpus);
-		   (os_data->nr_cpus * sizeof(struct appldata_os_per_cpu));
 	if (ops.size != new_size) {
 		if (ops.active) {
 			rc = appldata_diag(APPLDATA_RECORD_OS_ID,
 {
 	int rc, max_size;
-	max_size = sizeof(struct appldata_os_data) +
+	max_size = struct_size(appldata_os_data, os_cpu, num_possible_cpus());
-		   (num_possible_cpus() * sizeof(struct appldata_os_per_cpu));
 	if (max_size > APPLDATA_MAX_REC_SIZE) {
 		pr_err("Maximum OS record size %i exceeds the maximum "
 		       "record size %i\n", max_size, APPLDATA_MAX_REC_SIZE);

arch/s390/include/asm/asm-const.h+12−0

@@ -0,0 +1,12 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _ASM_S390_ASM_CONST_H
	3	#define _ASM_S390_ASM_CONST_H
	4
	5	#ifdef __ASSEMBLY__
	6	# define stringify_in_c(...) __VA_ARGS__
	7	#else
	8	/* This version of stringify will deal with commas... */
	9	# define __stringify_in_c(...) #__VA_ARGS__
	10	# define stringify_in_c(...) __stringify_in_c(__VA_ARGS__) " "
	11	#endif
	12	#endif /* _ASM_S390_ASM_CONST_H */

arch/s390/include/asm/debug.h+16−2

 #include <linux/kernel.h>
 #include <linux/time.h>
 #include <linux/refcount.h>
-#include <uapi/asm/debug.h>
+#include <linux/fs.h>
 #define DEBUG_MAX_LEVEL		   6  /* debug levels range from 0 to 6 */
 #define DEBUG_OFF_LEVEL		   -1 /* level where debug is switched off */
 #define DEBUG_DATA(entry) (char *)(entry + 1) /* data is stored behind */
 					      /* the entry information */
+#define __DEBUG_FEATURE_VERSION	   2  /* version of debug feature */
+struct __debug_entry {
+	union {
+		struct {
+			unsigned long clock	: 52;
+			unsigned long exception	:  1;
+			unsigned long level	:  3;
+			unsigned long cpuid	:  8;
+		} fields;
+		unsigned long stck;
+	} id;
+	void *caller;
+} __packed;
 typedef struct __debug_entry debug_entry_t;
 struct debug_view;
 };
 extern struct debug_view debug_hex_ascii_view;
-extern struct debug_view debug_raw_view;
 extern struct debug_view debug_sprintf_view;
 /* do NOT use the _common functions */

arch/s390/include/asm/extable.h+47−5

@@ -1,12 +1,20 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef __S390_EXTABLE_H	2	#ifndef __S390_EXTABLE_H
3	#define __S390_EXTABLE_H	3	#define __S390_EXTABLE_H
		4
		5	#include <asm/ptrace.h>
		6	#include <linux/compiler.h>
		7
4	/*	8	/*
5	* The exception table consists of pairs of addresses: the first is the	9	* The exception table consists of three addresses:
6	* address of an instruction that is allowed to fault, and the second is	10	*
7	* the address at which the program should continue. No registers are	11	* - Address of an instruction that is allowed to fault.
8	* modified, so it is entirely up to the continuation code to figure out	12	* - Address at which the program should continue.
9	* what to do.	13	* - Optional address of handler that takes pt_regs * argument and runs in
		14	* interrupt context.
		15	*
		16	* No registers are modified, so it is entirely up to the continuation code
		17	* to figure out what to do.
10	*	18	*
11	* All the routines below use bits of fixup code that are out of line	19	* All the routines below use bits of fixup code that are out of line
12	* with the main instruction path. This means when everything is well,	20	* with the main instruction path. This means when everything is well,
@@ -17,6 +25,7 @@ · 4 unmodified lines
17	struct exception_table_entry	25	struct exception_table_entry
18	{	26	{
19	int insn, fixup;	27	int insn, fixup;
		28	long handler;
20	};	29	};
21		30
22	extern struct exception_table_entry *__start_dma_ex_table;	31	extern struct exception_table_entry *__start_dma_ex_table;
@@ -29,6 +38,39 @@ static inline unsigned long extable_fixup(const struct exception_table_entry *x) · 6 unmodified lines
29	return (unsigned long)&x->fixup + x->fixup;	38	return (unsigned long)&x->fixup + x->fixup;
30	}	39	}
31		40
		41	typedef bool (ex_handler_t)(const struct exception_table_entry ,
		42	struct pt_regs *);
		43
		44	static inline ex_handler_t
		45	ex_fixup_handler(const struct exception_table_entry *x)
		46	{
		47	if (likely(!x->handler))
		48	return NULL;
		49	return (ex_handler_t)((unsigned long)&x->handler + x->handler);
		50	}
		51
		52	static inline bool ex_handle(const struct exception_table_entry *x,
		53	struct pt_regs *regs)
		54	{
		55	ex_handler_t handler = ex_fixup_handler(x);
		56
		57	if (unlikely(handler))
		58	return handler(x, regs);
		59	regs->psw.addr = extable_fixup(x);
		60	return true;
		61	}
		62
32	#define ARCH_HAS_RELATIVE_EXTABLE	63	#define ARCH_HAS_RELATIVE_EXTABLE
33		64
		65	static inline void swap_ex_entry_fixup(struct exception_table_entry *a,
		66	struct exception_table_entry *b,
		67	struct exception_table_entry tmp,
		68	int delta)
		69	{
		70	a->fixup = b->fixup + delta;
		71	b->fixup = tmp.fixup - delta;
		72	a->handler = b->handler + delta;
		73	b->handler = tmp.handler - delta;
		74	}
		75
34	#endif	76	#endif

arch/s390/include/asm/linkage.h+12−23

 #ifndef __ASM_LINKAGE_H
 #define __ASM_LINKAGE_H
+#include <asm/asm-const.h>
 #include <linux/stringify.h>
 #define __ALIGN .align 4, 0x07
 #define __ALIGN_STR __stringify(__ALIGN)
-#ifndef __ASSEMBLY__
 /*
  * Helper macro for exception table entries
  */
-#define EX_TABLE(_fault, _target)	\
-	".section __ex_table,\"a\"\n"	\
-	".align	4\n"			\
-	".long	(" #_fault ") - .\n"	\
-	".long	(" #_target ") - .\n"	\
-	".previous\n"
-#else /* __ASSEMBLY__ */
-#define EX_TABLE(_fault, _target)	\
+#define __EX_TABLE(_section, _fault, _target)				\
-	.section __ex_table,"a"	;	\
+	stringify_in_c(.section	_section,"a";)				\
-	.align	4 ;			\
+	stringify_in_c(.align	8;)					\
-	.long	(_fault) - . ;		\
+	stringify_in_c(.long	(_fault) - .;)				\
-	.long	(_target) - . ;		\
+	stringify_in_c(.long	(_target) - .;)				\
-	.previous
+	stringify_in_c(.quad	0;)					\
+	stringify_in_c(.previous)
-#define EX_TABLE_DMA(_fault, _target)	\
+#define EX_TABLE(_fault, _target)					\
-	.section .dma.ex_table, "a" ;	\
+	__EX_TABLE(__ex_table, _fault, _target)
-	.align	4 ;			\
+#define EX_TABLE_DMA(_fault, _target)					\
-	.long	(_fault) - . ;		\
+	__EX_TABLE(.dma.ex_table, _fault, _target)
-	.long	(_target) - . ;		\
-	.previous
-#endif /* __ASSEMBLY__ */
 #endif

arch/s390/include/asm/pci_dma.h+0−11

 	*entry |= ZPCI_TABLE_VALID;
 }
-static inline void invalidate_table_entry(unsigned long *entry)
-{
-	*entry &= ~ZPCI_TABLE_VALID_MASK;
-	*entry |= ZPCI_TABLE_INVALID;
-}
 static inline void invalidate_pt_entry(unsigned long *entry)
 {
 	WARN_ON_ONCE((*entry & ZPCI_PTE_VALID_MASK) == ZPCI_PTE_INVALID);
 	return (entry & ZPCI_PTE_VALID_MASK) == ZPCI_PTE_VALID;
 }
-static inline int entry_isprotected(unsigned long entry)
-{
-	return (entry & ZPCI_TABLE_PROT_MASK) == ZPCI_TABLE_PROTECTED;
-}
 static inline unsigned long *get_rt_sto(unsigned long entry)
 {
 	return ((entry & ZPCI_TABLE_TYPE_MASK) == ZPCI_TABLE_TYPE_RTX)

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

@@ -1669,7 +1669,7 @@ static inline swp_entry_t __swp_entry(unsigned long type, unsigned long offset) · 1668 unmodified lines
1669	#define kern_addr_valid(addr) (1)	1669	#define kern_addr_valid(addr) (1)
1670		1670
1671	extern int vmem_add_mapping(unsigned long start, unsigned long size);	1671	extern int vmem_add_mapping(unsigned long start, unsigned long size);
1672	extern int vmem_remove_mapping(unsigned long start, unsigned long size);	1672	extern void vmem_remove_mapping(unsigned long start, unsigned long size);
1673	extern int s390_enable_sie(void);	1673	extern int s390_enable_sie(void);
1674	extern int s390_enable_skey(void);	1674	extern int s390_enable_skey(void);
1675	extern void s390_reset_cmma(struct mm_struct *mm);	1675	extern void s390_reset_cmma(struct mm_struct *mm);

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

 	return regs->gprs[15];
 }
+static inline void regs_set_return_value(struct pt_regs *regs, unsigned long rc)
+{
+	regs->gprs[2] = rc;
+}
 #endif /* __ASSEMBLY__ */
 #endif /* _S390_PTRACE_H */

arch/s390/include/asm/smp.h+4−0

 	return cpu - (cpu % (smp_cpu_mtid + 1));
 }
+static inline void smp_cpus_done(unsigned int max_cpus)
+{
+}
 extern int smp_rescan_cpus(void);
 extern void __noreturn cpu_die(void);
 extern void __cpu_die(unsigned int cpu);

arch/s390/include/asm/syscall_wrapper.h+3−3

arch/s390/include/asm/timex.h+0−5

 	asm volatile("sckc %0" : : "Q" (time));
 }
-static inline void store_clock_comparator(__u64 *time)
-{
-	asm volatile("stckc %0" : "=Q" (*time));
-}
 void clock_comparator_work(void);
 void __init time_early_init(void);

arch/s390/include/uapi/asm/debug.h+0−35

@@ -1,35 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	/*
3	* S/390 debug facility
4	*
5	* Copyright IBM Corp. 1999, 2000
6	*/
7
8	#ifndef _UAPIDEBUG_H
9	#define _UAPIDEBUG_H
10
11	#include <linux/fs.h>
12
13	/* Note:
14	* struct __debug_entry must be defined outside of #ifdef __KERNEL__
15	* in order to allow a user program to analyze the 'raw'-view.
16	*/
17
18	struct __debug_entry{
19	union {
20	struct {
21	unsigned long long clock:52;
22	unsigned long long exception:1;
23	unsigned long long level:3;
24	unsigned long long cpuid:8;
25	} fields;
26
27	unsigned long long stck;
28	} id;
29	void* caller;
30	} __attribute__((packed));
31
32
33	#define __DEBUG_FEATURE_VERSION 2 /* version of debug feature */
34
35	#endif /* _UAPIDEBUG_H */

arch/s390/include/uapi/asm/zcrypt.h+70−70

@@ -36,12 +36,12 @@ · 35 unmodified lines
36	* - length(n_modulus) = inputdatalength	36	* - length(n_modulus) = inputdatalength
37	*/	37	*/
38	struct ica_rsa_modexpo {	38	struct ica_rsa_modexpo {
39	char __user *inputdata;	39	__u8 __user *inputdata;
40	unsigned int inputdatalength;	40	__u32 inputdatalength;
41	char __user *outputdata;	41	__u8 __user *outputdata;
42	unsigned int outputdatalength;	42	__u32 outputdatalength;
43	char __user *b_key;	43	__u8 __user *b_key;
44	char __user *n_modulus;	44	__u8 __user *n_modulus;
45	};	45	};
46		46
47	/**	47	/**
@@ -59,15 +59,15 @@ struct ica_rsa_modexpo { · 11 unmodified lines
59	* - length(u_mult_inv) = inputdatalength/2 + 8	59	* - length(u_mult_inv) = inputdatalength/2 + 8
60	*/	60	*/
61	struct ica_rsa_modexpo_crt {	61	struct ica_rsa_modexpo_crt {
62	char __user *inputdata;	62	__u8 __user *inputdata;
63	unsigned int inputdatalength;	63	__u32 inputdatalength;
64	char __user *outputdata;	64	__u8 __user *outputdata;
65	unsigned int outputdatalength;	65	__u32 outputdatalength;
66	char __user *bp_key;	66	__u8 __user *bp_key;
67	char __user *bq_key;	67	__u8 __user *bq_key;
68	char __user *np_prime;	68	__u8 __user *np_prime;
69	char __user *nq_prime;	69	__u8 __user *nq_prime;
70	char __user *u_mult_inv;	70	__u8 __user *u_mult_inv;
71	};	71	};
72		72
73	/**	73	/**
@@ -83,67 +83,67 @@ struct ica_rsa_modexpo_crt { · 9 unmodified lines
83	* key block	83	* key block
84	*/	84	*/
85	struct CPRBX {	85	struct CPRBX {
86	unsigned short cprb_len; /* CPRB length 220 */	86	__u16 cprb_len; /* CPRB length 220 */
87	unsigned char cprb_ver_id; /* CPRB version id. 0x02 */	87	__u8 cprb_ver_id; /* CPRB version id. 0x02 */
88	unsigned char pad_000[3]; /* Alignment pad bytes */	88	__u8 pad_000[3]; /* Alignment pad bytes */
89	unsigned char func_id[2]; /* function id 0x5432 */	89	__u8 func_id[2]; /* function id 0x5432 */
90	unsigned char cprb_flags[4]; /* Flags */	90	__u8 cprb_flags[4]; /* Flags */
91	unsigned int req_parml; /* request parameter buffer len */	91	__u32 req_parml; /* request parameter buffer len */
92	unsigned int req_datal; /* request data buffer */	92	__u32 req_datal; /* request data buffer */
93	unsigned int rpl_msgbl; /* reply message block length */	93	__u32 rpl_msgbl; /* reply message block length */
94	unsigned int rpld_parml; /* replied parameter block len */	94	__u32 rpld_parml; /* replied parameter block len */
95	unsigned int rpl_datal; /* reply data block len */	95	__u32 rpl_datal; /* reply data block len */
96	unsigned int rpld_datal; /* replied data block len */	96	__u32 rpld_datal; /* replied data block len */
97	unsigned int req_extbl; /* request extension block len */	97	__u32 req_extbl; /* request extension block len */
98	unsigned char pad_001[4]; /* reserved */	98	__u8 pad_001[4]; /* reserved */
99	unsigned int rpld_extbl; /* replied extension block len */	99	__u32 rpld_extbl; /* replied extension block len */
100	unsigned char padx000[16 - sizeof(char *)];	100	__u8 padx000[16 - sizeof(__u8 *)];
101	unsigned char req_parmb; / request parm block 'address' */	101	__u8 __user req_parmb; / request parm block 'address' */
102	unsigned char padx001[16 - sizeof(char *)];	102	__u8 padx001[16 - sizeof(__u8 *)];
103	unsigned char req_datab; / request data block 'address' */	103	__u8 __user req_datab; / request data block 'address' */
104	unsigned char padx002[16 - sizeof(char *)];	104	__u8 padx002[16 - sizeof(__u8 *)];
105	unsigned char rpl_parmb; / reply parm block 'address' */	105	__u8 __user rpl_parmb; / reply parm block 'address' */
106	unsigned char padx003[16 - sizeof(char *)];	106	__u8 padx003[16 - sizeof(__u8 *)];
107	unsigned char rpl_datab; / reply data block 'address' */	107	__u8 __user rpl_datab; / reply data block 'address' */
108	unsigned char padx004[16 - sizeof(char *)];	108	__u8 padx004[16 - sizeof(__u8 *)];
109	unsigned char req_extb; / request extension block 'addr'*/	109	__u8 __user req_extb; / request extension block 'addr'*/
110	unsigned char padx005[16 - sizeof(char *)];	110	__u8 padx005[16 - sizeof(__u8 *)];
111	unsigned char rpl_extb; / reply extension block 'address'*/	111	__u8 __user rpl_extb; / reply extension block 'address'*/
112	unsigned short ccp_rtcode; /* server return code */	112	__u16 ccp_rtcode; /* server return code */
113	unsigned short ccp_rscode; /* server reason code */	113	__u16 ccp_rscode; /* server reason code */
114	unsigned int mac_data_len; /* Mac Data Length */	114	__u32 mac_data_len; /* Mac Data Length */
115	unsigned char logon_id[8]; /* Logon Identifier */	115	__u8 logon_id[8]; /* Logon Identifier */
116	unsigned char mac_value[8]; /* Mac Value */	116	__u8 mac_value[8]; /* Mac Value */
117	unsigned char mac_content_flgs;/* Mac content flag byte */	117	__u8 mac_content_flgs; /* Mac content flag byte */
118	unsigned char pad_002; /* Alignment */	118	__u8 pad_002; /* Alignment */
119	unsigned short domain; /* Domain */	119	__u16 domain; /* Domain */
120	unsigned char usage_domain[4];/* Usage domain */	120	__u8 usage_domain[4]; /* Usage domain */
121	unsigned char cntrl_domain[4];/* Control domain */	121	__u8 cntrl_domain[4]; /* Control domain */
122	unsigned char S390enf_mask[4];/* S/390 enforcement mask */	122	__u8 S390enf_mask[4]; /* S/390 enforcement mask */
123	unsigned char pad_004[36]; /* reserved */	123	__u8 pad_004[36]; /* reserved */
124	} __attribute__((packed));	124	} __attribute__((packed));
125		125
126	/**	126	/**
127	* xcRB	127	* xcRB
128	*/	128	*/
129	struct ica_xcRB {	129	struct ica_xcRB {
130	unsigned short agent_ID;	130	__u16 agent_ID;
131	unsigned int user_defined;	131	__u32 user_defined;
132	unsigned short request_ID;	132	__u16 request_ID;
133	unsigned int request_control_blk_length;	133	__u32 request_control_blk_length;
134	unsigned char padding1[16 - sizeof(char *)];	134	__u8 _padding1[16 - sizeof(__u8 *)];
135	char __user *request_control_blk_addr;	135	__u8 __user *request_control_blk_addr;
136	unsigned int request_data_length;	136	__u32 request_data_length;
137	char padding2[16 - sizeof(char *)];	137	__u8 _padding2[16 - sizeof(__u8 *)];
138	char __user *request_data_address;	138	__u8 __user *request_data_address;
139	unsigned int reply_control_blk_length;	139	__u32 reply_control_blk_length;
140	char padding3[16 - sizeof(char *)];	140	__u8 _padding3[16 - sizeof(__u8 *)];
141	char __user *reply_control_blk_addr;	141	__u8 __user *reply_control_blk_addr;
142	unsigned int reply_data_length;	142	__u32 reply_data_length;
143	char padding4[16 - sizeof(char *)];	143	__u8 __padding4[16 - sizeof(__u8 *)];
144	char __user *reply_data_addr;	144	__u8 __user *reply_data_addr;
145	unsigned short priority_window;	145	__u16 priority_window;
146	unsigned int status;	146	__u32 status;
147	} __attribute__((packed));	147	} __attribute__((packed));
148		148
149	/**	149	/**

arch/s390/kernel/crash_dump.c+2−4

 	int cnt = 0;
 	u64 idx;
-	for_each_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
+	for_each_physmem_range(idx, &oldmem_type, NULL, NULL)
-			   MEMBLOCK_NONE, NULL, NULL, NULL)
 		cnt++;
 	return cnt;
 }
 	phys_addr_t start, end;
 	u64 idx;
-	for_each_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
+	for_each_physmem_range(idx, &oldmem_type, &start, &end) {
-			   MEMBLOCK_NONE, &start, &end, NULL) {
 		phdr->p_filesz = end - start;
 		phdr->p_type = PT_LOAD;
 		phdr->p_offset = start;

arch/s390/kernel/debug.c+0−42

@@ -90,27 +90,11 @@ static int debug_input_flush_fn(debug_info_t id, struct debug_view view, · 89 unmodified lines
90	size_t user_buf_size, loff_t *offset);	90	size_t user_buf_size, loff_t *offset);
91	static int debug_hex_ascii_format_fn(debug_info_t id, struct debug_view view,	91	static int debug_hex_ascii_format_fn(debug_info_t id, struct debug_view view,
92	char out_buf, const char in_buf);	92	char out_buf, const char in_buf);
93	static int debug_raw_format_fn(debug_info_t *id,
94	struct debug_view view, char out_buf,
95	const char *in_buf);
96	static int debug_raw_header_fn(debug_info_t id, struct debug_view view,
97	int area, debug_entry_t entry, char out_buf);
98
99	static int debug_sprintf_format_fn(debug_info_t id, struct debug_view view,	93	static int debug_sprintf_format_fn(debug_info_t id, struct debug_view view,
100	char out_buf, debug_sprintf_entry_t curr_event);	94	char out_buf, debug_sprintf_entry_t curr_event);
101		95
102	/* globals */	96	/* globals */
103		97
104	struct debug_view debug_raw_view = {
105	"raw",
106	NULL,
107	&debug_raw_header_fn,
108	&debug_raw_format_fn,
109	NULL,
110	NULL
111	};
112	EXPORT_SYMBOL(debug_raw_view);
113
114	struct debug_view debug_hex_ascii_view = {	98	struct debug_view debug_hex_ascii_view = {
115	"hex_ascii",	99	"hex_ascii",
116	NULL,	100	NULL,
@@ -1385,32 +1369,6 @@ out: · 1268 unmodified lines
1385	return rc; /* number of input characters */	1369	return rc; /* number of input characters */
1386	}	1370	}
1387		1371
1388	/*
1389	* prints debug header in raw format
1390	*/
1391	static int debug_raw_header_fn(debug_info_t id, struct debug_view view,
1392	int area, debug_entry_t entry, char out_buf)
1393	{
1394	int rc;
1395
1396	rc = sizeof(debug_entry_t);
1397	memcpy(out_buf, entry, sizeof(debug_entry_t));
1398	return rc;
1399	}
1400
1401	/*
1402	* prints debug data in raw format
1403	*/
1404	static int debug_raw_format_fn(debug_info_t id, struct debug_view view,
1405	char out_buf, const char in_buf)
1406	{
1407	int rc;
1408
1409	rc = id->buf_size;
1410	memcpy(out_buf, in_buf, id->buf_size);
1411	return rc;
1412	}
1413
1414	/*	1372	/*
1415	* prints debug data in hex/ascii format	1373	* prints debug data in hex/ascii format
1416	*/	1374	*/

arch/s390/kernel/entry.S+1−1

@@ -370,7 +370,7 @@ EXPORT_SYMBOL(sie_exit) · 369 unmodified lines
370		370
371	/*	371	/*
372	* SVC interrupt handler routine. System calls are synchronous events and	372	* SVC interrupt handler routine. System calls are synchronous events and
373	* are executed with interrupts enabled.	373	* are entered with interrupts disabled.
374	*/	374	*/
375		375
376	ENTRY(system_call)	376	ENTRY(system_call)

arch/s390/kernel/idle.c+3−1

@@ -14,6 +14,7 @@ · 13 unmodified lines
14	#include <linux/init.h>	14	#include <linux/init.h>
15	#include <linux/cpu.h>	15	#include <linux/cpu.h>
16	#include <linux/sched/cputime.h>	16	#include <linux/sched/cputime.h>
		17	#include <trace/events/power.h>
17	#include <asm/nmi.h>	18	#include <asm/nmi.h>
18	#include <asm/smp.h>	19	#include <asm/smp.h>
19	#include "entry.h"	20	#include "entry.h"
@@ -32,11 +33,12 @@ void enabled_wait(void) · 12 unmodified lines
32	PSW_MASK_IO \| PSW_MASK_EXT \| PSW_MASK_MCHECK;	33	PSW_MASK_IO \| PSW_MASK_EXT \| PSW_MASK_MCHECK;
33	clear_cpu_flag(CIF_NOHZ_DELAY);	34	clear_cpu_flag(CIF_NOHZ_DELAY);
34		35
		36	trace_cpu_idle_rcuidle(1, smp_processor_id());
35	local_irq_save(flags);	37	local_irq_save(flags);
36	/* Call the assembler magic in entry.S */	38	/* Call the assembler magic in entry.S */
37	psw_idle(idle, psw_mask);	39	psw_idle(idle, psw_mask);
38	local_irq_restore(flags);	40	local_irq_restore(flags);
39		41	trace_cpu_idle_rcuidle(PWR_EVENT_EXIT, smp_processor_id());
40		42
41	/* Account time spent with enabled wait psw loaded as idle time. */	43	/* Account time spent with enabled wait psw loaded as idle time. */
42	write_seqcount_begin(&idle->seqcount);	44	write_seqcount_begin(&idle->seqcount);

arch/s390/kernel/kprobes.c+1−3

 		 * zero, try to fix up.
 		 */
 		entry = s390_search_extables(regs->psw.addr);
-		if (entry) {
+		if (entry && ex_handle(entry, regs))
-			regs->psw.addr = extable_fixup(entry);
 			return 1;
-		}
 		/*
 		 * fixup_exception() could not handle it,

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

@@ -167,7 +167,7 @@ static struct timer_list lgr_timer; · 166 unmodified lines
167	*/	167	*/
168	static void lgr_timer_set(void)	168	static void lgr_timer_set(void)
169	{	169	{
170	mod_timer(&lgr_timer, jiffies + LGR_TIMER_INTERVAL_SECS * HZ);	170	mod_timer(&lgr_timer, jiffies + msecs_to_jiffies(LGR_TIMER_INTERVAL_SECS * MSEC_PER_SEC));
171	}	171	}
172		172
173	/*	173	/*

arch/s390/kernel/setup.c+0−8

@@ -1127,14 +1127,6 @@ void __init setup_arch(char **cmdline_p) · 1126 unmodified lines
1127	free_mem_detect_info();	1127	free_mem_detect_info();
1128	remove_oldmem();	1128	remove_oldmem();
1129		1129
1130	/*
1131	* Make sure all chunks are MAX_ORDER aligned so we don't need the
1132	* extra checks that HOLES_IN_ZONE would require.
1133	*
1134	* Is this still required?
1135	*/
1136	memblock_trim_memory(1UL << (MAX_ORDER - 1 + PAGE_SHIFT));
1137
1138	if (is_prot_virt_host())	1130	if (is_prot_virt_host())
1139	setup_uv();	1131	setup_uv();
1140	setup_memory_end();	1132	setup_memory_end();

arch/s390/kernel/smp.c+1−4

 	smp_cpu_set_polarization(0, POLARIZATION_UNKNOWN);
 }
-void __init smp_cpus_done(unsigned int max_cpus)
-{
-}
 void __init smp_setup_processor_id(void)
 {
 	pcpu_devices[0].address = stap();
 	return sysfs_create_group(&s->kobj, &cpu_online_attr_group);
 }
 static int smp_cpu_pre_down(unsigned int cpu)
 {
 	struct device *s = &per_cpu(cpu_device, cpu)->dev;

arch/s390/kernel/time.c+25−30

 	preempt_disable(); /* protect from changes to steering parameters */
 	now = get_tod_clock();
 	adj = tod_steering_end - now;
-	if (unlikely((s64) adj >= 0))
+	if (unlikely((s64) adj > 0))
 		/*
 		 * manually steer by 1 cycle every 2^16 cycles. This
 		 * corresponds to shifting the tod delta by 15. 1s is
 	.name		= "tod",
 	.rating		= 400,
 	.read		= read_tod_clock,
-	.mask		= -1ULL,
+	.mask		= CLOCKSOURCE_MASK(64),
 	.mult		= 1000,
 	.shift		= 12,
 	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
 		 * There is a usable clock but the synchonization failed.
 		 * Retry after a second.
 		 */
-		mod_timer(&stp_timer, jiffies + HZ);
+		mod_timer(&stp_timer, jiffies + msecs_to_jiffies(MSEC_PER_SEC));
 out_unlock:
 	mutex_unlock(&stp_work_mutex);
 	.dev_name	= "stp",
 };
-static ssize_t stp_ctn_id_show(struct device *dev,
+static ssize_t ctn_id_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 		       *(unsigned long long *) stp_info.ctnid);
 }
-static DEVICE_ATTR(ctn_id, 0400, stp_ctn_id_show, NULL);
+static DEVICE_ATTR_RO(ctn_id);
-static ssize_t stp_ctn_type_show(struct device *dev,
+static ssize_t ctn_type_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", stp_info.ctn);
 }
-static DEVICE_ATTR(ctn_type, 0400, stp_ctn_type_show, NULL);
+static DEVICE_ATTR_RO(ctn_type);
-static ssize_t stp_dst_offset_show(struct device *dev,
+static ssize_t dst_offset_show(struct device *dev,
 				   struct device_attribute *attr,
 				   char *buf)
 {
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.dsto);
 }
-static DEVICE_ATTR(dst_offset, 0400, stp_dst_offset_show, NULL);
+static DEVICE_ATTR_RO(dst_offset);
-static ssize_t stp_leap_seconds_show(struct device *dev,
+static ssize_t leap_seconds_show(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.leaps);
 }
-static DEVICE_ATTR(leap_seconds, 0400, stp_leap_seconds_show, NULL);
+static DEVICE_ATTR_RO(leap_seconds);
-static ssize_t stp_stratum_show(struct device *dev,
+static ssize_t stratum_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.stratum);
 }
-static DEVICE_ATTR(stratum, 0400, stp_stratum_show, NULL);
+static DEVICE_ATTR_RO(stratum);
-static ssize_t stp_time_offset_show(struct device *dev,
+static ssize_t time_offset_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", (int) stp_info.tto);
 }
-static DEVICE_ATTR(time_offset, 0400, stp_time_offset_show, NULL);
+static DEVICE_ATTR_RO(time_offset);
-static ssize_t stp_time_zone_offset_show(struct device *dev,
+static ssize_t time_zone_offset_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.tzo);
 }
-static DEVICE_ATTR(time_zone_offset, 0400,
+static DEVICE_ATTR_RO(time_zone_offset);
-			 stp_time_zone_offset_show, NULL);
-static ssize_t stp_timing_mode_show(struct device *dev,
+static ssize_t timing_mode_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", stp_info.tmd);
 }
-static DEVICE_ATTR(timing_mode, 0400, stp_timing_mode_show, NULL);
+static DEVICE_ATTR_RO(timing_mode);
-static ssize_t stp_timing_state_show(struct device *dev,
+static ssize_t timing_state_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", stp_info.tst);
 }
-static DEVICE_ATTR(timing_state, 0400, stp_timing_state_show, NULL);
+static DEVICE_ATTR_RO(timing_state);
-static ssize_t stp_online_show(struct device *dev,
+static ssize_t online_show(struct device *dev,
 				struct device_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", stp_online);
 }
-static ssize_t stp_online_store(struct device *dev,
+static ssize_t online_store(struct device *dev,
 				struct device_attribute *attr,
 				const char *buf, size_t count)
 {
  * Can't use DEVICE_ATTR because the attribute should be named
  * stp/online but dev_attr_online already exists in this file ..
  */
-static struct device_attribute dev_attr_stp_online = {
+static DEVICE_ATTR_RW(online);
-	.attr = { .name = "online", .mode = 0600 },
-	.show	= stp_online_show,
-	.store	= stp_online_store,
-};
 static struct device_attribute *stp_attributes[] = {
 	&dev_attr_ctn_id,
 	&dev_attr_ctn_type,
 	&dev_attr_dst_offset,
 	&dev_attr_leap_seconds,
-	&dev_attr_stp_online,
+	&dev_attr_online,
 	&dev_attr_stratum,
 	&dev_attr_time_offset,
 	&dev_attr_time_zone_offset,

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

@@ -356,9 +356,9 @@ static atomic_t topology_poll = ATOMIC_INIT(0); · 355 unmodified lines
356	static void set_topology_timer(void)	356	static void set_topology_timer(void)
357	{	357	{
358	if (atomic_add_unless(&topology_poll, -1, 0))	358	if (atomic_add_unless(&topology_poll, -1, 0))
359	mod_timer(&topology_timer, jiffies + HZ / 10);	359	mod_timer(&topology_timer, jiffies + msecs_to_jiffies(100));
360	else	360	else
361	mod_timer(&topology_timer, jiffies + HZ * 60);	361	mod_timer(&topology_timer, jiffies + msecs_to_jiffies(60 * MSEC_PER_SEC));
362	}	362	}
363		363
364	void topology_expect_change(void)	364	void topology_expect_change(void)

arch/s390/kernel/traps.c+2−5

         } else {
                 const struct exception_table_entry *fixup;
 		fixup = s390_search_extables(regs->psw.addr);
-                if (fixup)
+		if (!fixup || !ex_handle(fixup, regs))
-			regs->psw.addr = extable_fixup(fixup);
-		else {
 			die(regs, str);
-		}
         }
 }
 	case BUG_TRAP_TYPE_NONE:
 		fixup = s390_search_extables(regs->psw.addr);
 		if (fixup)
-			regs->psw.addr = extable_fixup(fixup);
+			ex_handle(fixup, regs);
 		break;
 	case BUG_TRAP_TYPE_WARN:
 		break;

arch/s390/lib/Makefile+2−0

@@ -14,3 +14,5 @@ KASAN_SANITIZE_uaccess.o := n · 13 unmodified lines
14		14
15	obj-$(CONFIG_S390_UNWIND_SELFTEST) += test_unwind.o	15	obj-$(CONFIG_S390_UNWIND_SELFTEST) += test_unwind.o
16	CFLAGS_test_unwind.o += -fno-optimize-sibling-calls	16	CFLAGS_test_unwind.o += -fno-optimize-sibling-calls
		17
		18	lib-$(CONFIG_FUNCTION_ERROR_INJECTION) += error-inject.o

arch/s390/lib/error-inject.c+14−0

@@ -0,0 +1,14 @@
	1	// SPDX-License-Identifier: GPL-2.0+
	2	#include <asm/ptrace.h>
	3	#include <linux/error-injection.h>
	4	#include <linux/kprobes.h>
	5
	6	void override_function_with_return(struct pt_regs *regs)
	7	{
	8	/*
	9	* Emulate 'br 14'. 'regs' is captured by kprobes on entry to some
	10	* kernel function.
	11	*/
	12	regs->psw.addr = regs->gprs[14];
	13	}
	14	NOKPROBE_SYMBOL(override_function_with_return);

arch/s390/mm/cmm.c+1−1

@@ -189,7 +189,7 @@ static void cmm_set_timer(void) · 188 unmodified lines
189	del_timer(&cmm_timer);	189	del_timer(&cmm_timer);
190	return;	190	return;
191	}	191	}
192	mod_timer(&cmm_timer, jiffies + cmm_timeout_seconds * HZ);	192	mod_timer(&cmm_timer, jiffies + msecs_to_jiffies(cmm_timeout_seconds * MSEC_PER_SEC));
193	}	193	}
194		194
195	static void cmm_timer_fn(struct timer_list *unused)	195	static void cmm_timer_fn(struct timer_list *unused)

arch/s390/mm/extmem.c+14−18

 		goto out_free;
 	}
-	rc = vmem_add_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
-	if (rc)
-		goto out_free;
 	seg->res = kzalloc(sizeof(struct resource), GFP_KERNEL);
 	if (seg->res == NULL) {
 		rc = -ENOMEM;
-		goto out_shared;
+		goto out_free;
 	}
 	seg->res->flags = IORESOURCE_BUSY | IORESOURCE_MEM;
 	seg->res->start = seg->start_addr;
 	if (rc == SEG_TYPE_SC ||
 	    ((rc == SEG_TYPE_SR || rc == SEG_TYPE_ER) && !do_nonshared))
 		seg->res->flags |= IORESOURCE_READONLY;
+	/* Check for overlapping resources before adding the mapping. */
 	if (request_resource(&iomem_resource, seg->res)) {
 		rc = -EBUSY;
-		kfree(seg->res);
+		goto out_free_resource;
-		goto out_shared;
 	}
+	rc = vmem_add_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
+	if (rc)
+		goto out_resource;
 	if (do_nonshared)
 		diag_cc = dcss_diag(&loadnsr_scode, seg->dcss_name,
 				&start_addr, &end_addr);
 		dcss_diag(&purgeseg_scode, seg->dcss_name,
 				&dummy, &dummy);
 		rc = diag_cc;
-		goto out_resource;
+		goto out_mapping;
 	}
 	if (diag_cc > 1) {
 		pr_warn("Loading DCSS %s failed with rc=%ld\n", name, end_addr);
 		rc = dcss_diag_translate_rc(end_addr);
 		dcss_diag(&purgeseg_scode, seg->dcss_name,
 				&dummy, &dummy);
-		goto out_resource;
+		goto out_mapping;
 	}
 	seg->start_addr = start_addr;
 	seg->end = end_addr;
 			(void*) seg->end, segtype_string[seg->vm_segtype]);
 	}
 	goto out;
+ out_mapping:
+	vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
  out_resource:
 	release_resource(seg->res);
+ out_free_resource:
 	kfree(seg->res);
- out_shared:
-	vmem_remove_mapping(seg->start_addr, seg->end - seg->start_addr + 1);
  out_free:
 	kfree(seg);
  out:
  * -EIO     : could not perform query or load diagnose
  * -ENOENT  : no such segment
  * -EOPNOTSUPP: multi-part segment cannot be used with linux
- * -ENOSPC  : segment cannot be used (overlaps with storage)
+ * -EBUSY   : segment cannot be used (overlaps with dcss or storage)
- * -EBUSY   : segment can temporarily not be used (overlaps with dcss)
  * -ERANGE  : segment cannot be used (exceeds kernel mapping range)
  * -EPERM   : segment is currently loaded with incompatible permissions
  * -ENOMEM  : out of memory
 		pr_err("DCSS %s has multiple page ranges and cannot be "
 		       "loaded or queried\n", seg_name);
 		break;
-	case -ENOSPC:
-		pr_err("DCSS %s overlaps with used storage and cannot "
-		       "be loaded\n", seg_name);
-		break;
 	case -EBUSY:
 		pr_err("%s needs used memory resources and cannot be "
 		       "loaded or queried\n", seg_name);

arch/s390/mm/fault.c+2−4

 	/* Are we prepared to handle this kernel fault?  */
 	fixup = s390_search_extables(regs->psw.addr);
-	if (fixup) {
+	if (fixup && ex_handle(fixup, regs))
-		regs->psw.addr = extable_fixup(fixup);
 		return;
-	}
 	/*
 	 * Oops. The kernel tried to access some bad page. We'll have to
  * routines.
  *
  * interruption code (int_code):
- *   04       Protection           ->  Write-Protection  (suprression)
+ *   04       Protection           ->  Write-Protection  (suppression)
  *   10       Segment translation  ->  Not present       (nullification)
  *   11       Page translation     ->  Not present       (nullification)
  *   3b       Region third trans.  ->  Not present       (nullification)

arch/s390/mm/vmem.c+417−286

@@ -20,14 +20,6 @@ · 19 unmodified lines
20		20
21	static DEFINE_MUTEX(vmem_mutex);	21	static DEFINE_MUTEX(vmem_mutex);
22		22
23	struct memory_segment {
24	struct list_head list;
25	unsigned long start;
26	unsigned long size;
27	};
28
29	static LIST_HEAD(mem_segs);
30
31	static void __ref *vmem_alloc_pages(unsigned int order)	23	static void __ref *vmem_alloc_pages(unsigned int order)
32	{	24	{
33	unsigned long size = PAGE_SIZE << order;	25	unsigned long size = PAGE_SIZE << order;
@@ -37,6 +29,15 @@ static void __ref *vmem_alloc_pages(unsigned int order) · 3 unmodified lines
37	return (void *) memblock_phys_alloc(size, size);	29	return (void *) memblock_phys_alloc(size, size);
38	}	30	}
39		31
		32	static void vmem_free_pages(unsigned long addr, int order)
		33	{
		34	/* We don't expect boot memory to be removed ever. */
		35	if (!slab_is_available() \|\|
		36	WARN_ON_ONCE(PageReserved(phys_to_page(addr))))
		37	return;
		38	free_pages(addr, order);
		39	}
		40
40	void *vmem_crst_alloc(unsigned long val)	41	void *vmem_crst_alloc(unsigned long val)
41	{	42	{
42	unsigned long *table;	43	unsigned long *table;
@@ -62,332 +63,486 @@ pte_t __ref *vmem_pte_alloc(void) · 19 unmodified lines
62	return pte;	63	return pte;
63	}	64	}
64		65
		66	static void vmem_pte_free(unsigned long *table)
		67	{
		68	/* We don't expect boot memory to be removed ever. */
		69	if (!slab_is_available() \|\|
		70	WARN_ON_ONCE(PageReserved(virt_to_page(table))))
		71	return;
		72	page_table_free(&init_mm, table);
		73	}
		74
		75	#define PAGE_UNUSED 0xFD
		76
65	/*	77	/*
66	* Add a physical memory range to the 1:1 mapping.	78	* The unused vmemmap range, which was not yet memset(PAGE_UNUSED) ranges
		79	* from unused_pmd_start to next PMD_SIZE boundary.
67	*/	80	*/
68	static int vmem_add_mem(unsigned long start, unsigned long size)	81	static unsigned long unused_pmd_start;
		82
		83	static void vmemmap_flush_unused_pmd(void)
69	{	84	{
70	unsigned long pgt_prot, sgt_prot, r3_prot;	85	if (!unused_pmd_start)
71	unsigned long pages4k, pages1m, pages2g;	86	return;
72	unsigned long end = start + size;	87	memset(__va(unused_pmd_start), PAGE_UNUSED,
73	unsigned long address = start;	88	ALIGN(unused_pmd_start, PMD_SIZE) - unused_pmd_start);
74	pgd_t *pg_dir;	89	unused_pmd_start = 0;
75	p4d_t *p4_dir;	90	}
76	pud_t *pu_dir;	91
77	pmd_t *pm_dir;	92	static void __vmemmap_use_sub_pmd(unsigned long start, unsigned long end)
78	pte_t *pt_dir;	93	{
79	int ret = -ENOMEM;	94	/*
		95	* As we expect to add in the same granularity as we remove, it's
		96	* sufficient to mark only some piece used to block the memmap page from
		97	* getting removed (just in case the memmap never gets initialized,
		98	* e.g., because the memory block never gets onlined).
		99	*/
		100	memset(__va(start), 0, sizeof(struct page));
		101	}
80		102
81	pgt_prot = pgprot_val(PAGE_KERNEL);	103	static void vmemmap_use_sub_pmd(unsigned long start, unsigned long end)
82	sgt_prot = pgprot_val(SEGMENT_KERNEL);	104	{
83	r3_prot = pgprot_val(REGION3_KERNEL);	105	/*
84	if (!MACHINE_HAS_NX) {	106	* We only optimize if the new used range directly follows the
85	pgt_prot &= ~_PAGE_NOEXEC;	107	* previously unused range (esp., when populating consecutive sections).
86	sgt_prot &= ~_SEGMENT_ENTRY_NOEXEC;	108	*/
87	r3_prot &= ~_REGION_ENTRY_NOEXEC;	109	if (unused_pmd_start == start) {
		110	unused_pmd_start = end;
		111	if (likely(IS_ALIGNED(unused_pmd_start, PMD_SIZE)))
		112	unused_pmd_start = 0;
		113	return;
88	}	114	}
89	pages4k = pages1m = pages2g = 0;	115	vmemmap_flush_unused_pmd();
90	while (address < end) {	116	__vmemmap_use_sub_pmd(start, end);
91	pg_dir = pgd_offset_k(address);	117	}
92	if (pgd_none(*pg_dir)) {	118
93	p4_dir = vmem_crst_alloc(_REGION2_ENTRY_EMPTY);	119	static void vmemmap_use_new_sub_pmd(unsigned long start, unsigned long end)
94	if (!p4_dir)	120	{
95	goto out;	121	void *page = __va(ALIGN_DOWN(start, PMD_SIZE));
96	pgd_populate(&init_mm, pg_dir, p4_dir);	122
97	}	123	vmemmap_flush_unused_pmd();
98	p4_dir = p4d_offset(pg_dir, address);	124
99	if (p4d_none(*p4_dir)) {	125	/* Could be our memmap page is filled with PAGE_UNUSED already ... */
100	pu_dir = vmem_crst_alloc(_REGION3_ENTRY_EMPTY);	126	__vmemmap_use_sub_pmd(start, end);
101	if (!pu_dir)	127
102	goto out;	128	/* Mark the unused parts of the new memmap page PAGE_UNUSED. */
103	p4d_populate(&init_mm, p4_dir, pu_dir);	129	if (!IS_ALIGNED(start, PMD_SIZE))
104	}	130	memset(page, PAGE_UNUSED, start - __pa(page));
105	pu_dir = pud_offset(p4_dir, address);	131	/*
106	if (MACHINE_HAS_EDAT2 && pud_none(*pu_dir) && address &&	132	* We want to avoid memset(PAGE_UNUSED) when populating the vmemmap of
107	!(address & ~PUD_MASK) && (address + PUD_SIZE <= end) &&	133	* consecutive sections. Remember for the last added PMD the last
108	!debug_pagealloc_enabled()) {	134	* unused range in the populated PMD.
109	pud_val(*pu_dir) = address \| r3_prot;	135	*/
110	address += PUD_SIZE;	136	if (!IS_ALIGNED(end, PMD_SIZE))
111	pages2g++;	137	unused_pmd_start = end;
112	continue;	138	}
113	}	139
114	if (pud_none(*pu_dir)) {	140	/* Returns true if the PMD is completely unused and can be freed. */
115	pm_dir = vmem_crst_alloc(_SEGMENT_ENTRY_EMPTY);	141	static bool vmemmap_unuse_sub_pmd(unsigned long start, unsigned long end)
116	if (!pm_dir)	142	{
117	goto out;	143	void *page = __va(ALIGN_DOWN(start, PMD_SIZE));
118	pud_populate(&init_mm, pu_dir, pm_dir);	144
119	}	145	vmemmap_flush_unused_pmd();
120	pm_dir = pmd_offset(pu_dir, address);	146	memset(__va(start), PAGE_UNUSED, end - start);
121	if (MACHINE_HAS_EDAT1 && pmd_none(*pm_dir) && address &&	147	return !memchr_inv(page, PAGE_UNUSED, PMD_SIZE);
122	!(address & ~PMD_MASK) && (address + PMD_SIZE <= end) &&	148	}
123	!debug_pagealloc_enabled()) {	149
124	pmd_val(*pm_dir) = address \| sgt_prot;	150	/* __ref: we'll only call vmemmap_alloc_block() via vmemmap_populate() */
125	address += PMD_SIZE;	151	static int __ref modify_pte_table(pmd_t *pmd, unsigned long addr,
126	pages1m++;	152	unsigned long end, bool add, bool direct)
		153	{
		154	unsigned long prot, pages = 0;
		155	int ret = -ENOMEM;
		156	pte_t *pte;
		157
		158	prot = pgprot_val(PAGE_KERNEL);
		159	if (!MACHINE_HAS_NX)
		160	prot &= ~_PAGE_NOEXEC;
		161
		162	pte = pte_offset_kernel(pmd, addr);
		163	for (; addr < end; addr += PAGE_SIZE, pte++) {
		164	if (!add) {
		165	if (pte_none(*pte))
		166	continue;
		167	if (!direct)
		168	vmem_free_pages(pfn_to_phys(pte_pfn(*pte)), 0);
		169	pte_clear(&init_mm, addr, pte);
		170	} else if (pte_none(*pte)) {
		171	if (!direct) {
		172	void *new_page = vmemmap_alloc_block(PAGE_SIZE, NUMA_NO_NODE);
		173
		174	if (!new_page)
		175	goto out;
		176	pte_val(*pte) = __pa(new_page) \| prot;
		177	} else {
		178	pte_val(*pte) = addr \| prot;
		179	}
		180	} else {
127	continue;	181	continue;
128	}	182	}
129	if (pmd_none(*pm_dir)) {	183	pages++;
130	pt_dir = vmem_pte_alloc();
131	if (!pt_dir)
132	goto out;
133	pmd_populate(&init_mm, pm_dir, pt_dir);
134	}
135
136	pt_dir = pte_offset_kernel(pm_dir, address);
137	pte_val(*pt_dir) = address \| pgt_prot;
138	address += PAGE_SIZE;
139	pages4k++;
140	}	184	}
141	ret = 0;	185	ret = 0;
142	out:	186	out:
143	update_page_count(PG_DIRECT_MAP_4K, pages4k);	187	if (direct)
144	update_page_count(PG_DIRECT_MAP_1M, pages1m);	188	update_page_count(PG_DIRECT_MAP_4K, add ? pages : -pages);
145	update_page_count(PG_DIRECT_MAP_2G, pages2g);
146	return ret;	189	return ret;
147	}	190	}
148		191
149	/*	192	static void try_free_pte_table(pmd_t *pmd, unsigned long start)
150	* Remove a physical memory range from the 1:1 mapping.
151	* Currently only invalidates page table entries.
152	*/
153	static void vmem_remove_range(unsigned long start, unsigned long size)
154	{	193	{
155	unsigned long pages4k, pages1m, pages2g;	194	pte_t *pte;
156	unsigned long end = start + size;	195	int i;
157	unsigned long address = start;	196
158	pgd_t *pg_dir;	197	/* We can safely assume this is fully in 1:1 mapping & vmemmap area */
159	p4d_t *p4_dir;	198	pte = pte_offset_kernel(pmd, start);
160	pud_t *pu_dir;	199	for (i = 0; i < PTRS_PER_PTE; i++, pte++) {
161	pmd_t *pm_dir;	200	if (!pte_none(*pte))
162	pte_t *pt_dir;	201	return;
163
164	pages4k = pages1m = pages2g = 0;
165	while (address < end) {
166	pg_dir = pgd_offset_k(address);
167	if (pgd_none(*pg_dir)) {
168	address += PGDIR_SIZE;
169	continue;
170	}
171	p4_dir = p4d_offset(pg_dir, address);
172	if (p4d_none(*p4_dir)) {
173	address += P4D_SIZE;
174	continue;
175	}
176	pu_dir = pud_offset(p4_dir, address);
177	if (pud_none(*pu_dir)) {
178	address += PUD_SIZE;
179	continue;
180	}
181	if (pud_large(*pu_dir)) {
182	pud_clear(pu_dir);
183	address += PUD_SIZE;
184	pages2g++;
185	continue;
186	}
187	pm_dir = pmd_offset(pu_dir, address);
188	if (pmd_none(*pm_dir)) {
189	address += PMD_SIZE;
190	continue;
191	}
192	if (pmd_large(*pm_dir)) {
193	pmd_clear(pm_dir);
194	address += PMD_SIZE;
195	pages1m++;
196	continue;
197	}
198	pt_dir = pte_offset_kernel(pm_dir, address);
199	pte_clear(&init_mm, address, pt_dir);
200	address += PAGE_SIZE;
201	pages4k++;
202	}	202	}
203	flush_tlb_kernel_range(start, end);	203	vmem_pte_free(__va(pmd_deref(*pmd)));
204	update_page_count(PG_DIRECT_MAP_4K, -pages4k);	204	pmd_clear(pmd);
205	update_page_count(PG_DIRECT_MAP_1M, -pages1m);
206	update_page_count(PG_DIRECT_MAP_2G, -pages2g);
207	}	205	}
208		206
209	/*	207	/* __ref: we'll only call vmemmap_alloc_block() via vmemmap_populate() */
210	* Add a backed mem_map array to the virtual mem_map array.	208	static int __ref modify_pmd_table(pud_t *pud, unsigned long addr,
211	*/	209	unsigned long end, bool add, bool direct)
212	int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
213	struct vmem_altmap *altmap)
214	{	210	{
215	unsigned long pgt_prot, sgt_prot;	211	unsigned long next, prot, pages = 0;
216	unsigned long address = start;
217	pgd_t *pg_dir;
218	p4d_t *p4_dir;
219	pud_t *pu_dir;
220	pmd_t *pm_dir;
221	pte_t *pt_dir;
222	int ret = -ENOMEM;	212	int ret = -ENOMEM;
		213	pmd_t *pmd;
		214	pte_t *pte;
223		215
224	pgt_prot = pgprot_val(PAGE_KERNEL);	216	prot = pgprot_val(SEGMENT_KERNEL);
225	sgt_prot = pgprot_val(SEGMENT_KERNEL);	217	if (!MACHINE_HAS_NX)
226	if (!MACHINE_HAS_NX) {	218	prot &= ~_SEGMENT_ENTRY_NOEXEC;
227	pgt_prot &= ~_PAGE_NOEXEC;
228	sgt_prot &= ~_SEGMENT_ENTRY_NOEXEC;
229	}
230	for (address = start; address < end;) {
231	pg_dir = pgd_offset_k(address);
232	if (pgd_none(*pg_dir)) {
233	p4_dir = vmem_crst_alloc(_REGION2_ENTRY_EMPTY);
234	if (!p4_dir)
235	goto out;
236	pgd_populate(&init_mm, pg_dir, p4_dir);
237	}
238		219
239	p4_dir = p4d_offset(pg_dir, address);	220	pmd = pmd_offset(pud, addr);
240	if (p4d_none(*p4_dir)) {	221	for (; addr < end; addr = next, pmd++) {
241	pu_dir = vmem_crst_alloc(_REGION3_ENTRY_EMPTY);	222	next = pmd_addr_end(addr, end);
242	if (!pu_dir)	223	if (!add) {
243	goto out;	224	if (pmd_none(*pmd))
244	p4d_populate(&init_mm, p4_dir, pu_dir);	225	continue;
245	}	226	if (pmd_large(*pmd) && !add) {
		227	if (IS_ALIGNED(addr, PMD_SIZE) &&
		228	IS_ALIGNED(next, PMD_SIZE)) {
		229	if (!direct)
		230	vmem_free_pages(pmd_deref(*pmd), get_order(PMD_SIZE));
		231	pmd_clear(pmd);
		232	pages++;
		233	} else if (!direct && vmemmap_unuse_sub_pmd(addr, next)) {
		234	vmem_free_pages(pmd_deref(*pmd), get_order(PMD_SIZE));
		235	pmd_clear(pmd);
		236	}
		237	continue;
		238	}
		239	} else if (pmd_none(*pmd)) {
		240	if (IS_ALIGNED(addr, PMD_SIZE) &&
		241	IS_ALIGNED(next, PMD_SIZE) &&
		242	MACHINE_HAS_EDAT1 && addr && direct &&
		243	!debug_pagealloc_enabled()) {
		244	pmd_val(*pmd) = addr \| prot;
		245	pages++;
		246	continue;
		247	} else if (!direct && MACHINE_HAS_EDAT1) {
		248	void *new_page;
246		249
247	pu_dir = pud_offset(p4_dir, address);	250	/*
248	if (pud_none(*pu_dir)) {	251	* Use 1MB frames for vmemmap if available. We
249	pm_dir = vmem_crst_alloc(_SEGMENT_ENTRY_EMPTY);	252	* always use large frames even if they are only
250	if (!pm_dir)	253	* partially used. Otherwise we would have also
		254	* page tables since vmemmap_populate gets
		255	* called for each section separately.
		256	*/
		257	new_page = vmemmap_alloc_block(PMD_SIZE, NUMA_NO_NODE);
		258	if (new_page) {
		259	pmd_val(*pmd) = __pa(new_page) \| prot;
		260	if (!IS_ALIGNED(addr, PMD_SIZE) \|\|
		261	!IS_ALIGNED(next, PMD_SIZE)) {
		262	vmemmap_use_new_sub_pmd(addr, next);
		263	}
		264	continue;
		265	}
		266	}
		267	pte = vmem_pte_alloc();
		268	if (!pte)
251	goto out;	269	goto out;
252	pud_populate(&init_mm, pu_dir, pm_dir);	270	pmd_populate(&init_mm, pmd, pte);
		271	} else if (pmd_large(*pmd)) {
		272	if (!direct)
		273	vmemmap_use_sub_pmd(addr, next);
		274	continue;
253	}	275	}
		276	ret = modify_pte_table(pmd, addr, next, add, direct);
		277	if (ret)
		278	goto out;
		279	if (!add)
		280	try_free_pte_table(pmd, addr & PMD_MASK);
		281	}
		282	ret = 0;
		283	out:
		284	if (direct)
		285	update_page_count(PG_DIRECT_MAP_1M, add ? pages : -pages);
		286	return ret;
		287	}
254		288
255	pm_dir = pmd_offset(pu_dir, address);	289	static void try_free_pmd_table(pud_t *pud, unsigned long start)
256	if (pmd_none(*pm_dir)) {	290	{
257	/* Use 1MB frames for vmemmap if available. We always	291	const unsigned long end = start + PUD_SIZE;
258	* use large frames even if they are only partially	292	pmd_t *pmd;
259	* used.	293	int i;
260	* Otherwise we would have also page tables since	294
261	* vmemmap_populate gets called for each section	295	/* Don't mess with any tables not fully in 1:1 mapping & vmemmap area */
262	* separately. */	296	if (end > VMALLOC_START)
263	if (MACHINE_HAS_EDAT1) {	297	return;
264	void *new_page;	298	#ifdef CONFIG_KASAN
		299	if (start < KASAN_SHADOW_END && KASAN_SHADOW_START > end)
		300	return;
		301	#endif
		302	pmd = pmd_offset(pud, start);
		303	for (i = 0; i < PTRS_PER_PMD; i++, pmd++)
		304	if (!pmd_none(*pmd))
		305	return;
		306	vmem_free_pages(pud_deref(*pud), CRST_ALLOC_ORDER);
		307	pud_clear(pud);
		308	}
265		309
266	new_page = vmemmap_alloc_block(PMD_SIZE, node);	310	static int modify_pud_table(p4d_t *p4d, unsigned long addr, unsigned long end,
267	if (!new_page)	311	bool add, bool direct)
268	goto out;	312	{
269	pmd_val(*pm_dir) = __pa(new_page) \| sgt_prot;	313	unsigned long next, prot, pages = 0;
270	address = (address + PMD_SIZE) & PMD_MASK;	314	int ret = -ENOMEM;
		315	pud_t *pud;
		316	pmd_t *pmd;
		317
		318	prot = pgprot_val(REGION3_KERNEL);
		319	if (!MACHINE_HAS_NX)
		320	prot &= ~_REGION_ENTRY_NOEXEC;
		321	pud = pud_offset(p4d, addr);
		322	for (; addr < end; addr = next, pud++) {
		323	next = pud_addr_end(addr, end);
		324	if (!add) {
		325	if (pud_none(*pud))
		326	continue;
		327	if (pud_large(*pud)) {
		328	if (IS_ALIGNED(addr, PUD_SIZE) &&
		329	IS_ALIGNED(next, PUD_SIZE)) {
		330	pud_clear(pud);
		331	pages++;
		332	}
		333	continue;
		334	}
		335	} else if (pud_none(*pud)) {
		336	if (IS_ALIGNED(addr, PUD_SIZE) &&
		337	IS_ALIGNED(next, PUD_SIZE) &&
		338	MACHINE_HAS_EDAT2 && addr && direct &&
		339	!debug_pagealloc_enabled()) {
		340	pud_val(*pud) = addr \| prot;
		341	pages++;
271	continue;	342	continue;
272	}	343	}
273	pt_dir = vmem_pte_alloc();	344	pmd = vmem_crst_alloc(_SEGMENT_ENTRY_EMPTY);
274	if (!pt_dir)	345	if (!pmd)
275	goto out;	346	goto out;
276	pmd_populate(&init_mm, pm_dir, pt_dir);	347	pud_populate(&init_mm, pud, pmd);
277	} else if (pmd_large(*pm_dir)) {	348	} else if (pud_large(*pud)) {
278	address = (address + PMD_SIZE) & PMD_MASK;
279	continue;	349	continue;
280	}	350	}
		351	ret = modify_pmd_table(pud, addr, next, add, direct);
		352	if (ret)
		353	goto out;
		354	if (!add)
		355	try_free_pmd_table(pud, addr & PUD_MASK);
		356	}
		357	ret = 0;
		358	out:
		359	if (direct)
		360	update_page_count(PG_DIRECT_MAP_2G, add ? pages : -pages);
		361	return ret;
		362	}
281		363
282	pt_dir = pte_offset_kernel(pm_dir, address);	364	static void try_free_pud_table(p4d_t *p4d, unsigned long start)
283	if (pte_none(*pt_dir)) {	365	{
284	void *new_page;	366	const unsigned long end = start + P4D_SIZE;
		367	pud_t *pud;
		368	int i;
		369
		370	/* Don't mess with any tables not fully in 1:1 mapping & vmemmap area */
		371	if (end > VMALLOC_START)
		372	return;
		373	#ifdef CONFIG_KASAN
		374	if (start < KASAN_SHADOW_END && KASAN_SHADOW_START > end)
		375	return;
		376	#endif
		377
		378	pud = pud_offset(p4d, start);
		379	for (i = 0; i < PTRS_PER_PUD; i++, pud++) {
		380	if (!pud_none(*pud))
		381	return;
		382	}
		383	vmem_free_pages(p4d_deref(*p4d), CRST_ALLOC_ORDER);
		384	p4d_clear(p4d);
		385	}
285		386
286	new_page = vmemmap_alloc_block(PAGE_SIZE, node);	387	static int modify_p4d_table(pgd_t *pgd, unsigned long addr, unsigned long end,
287	if (!new_page)	388	bool add, bool direct)
		389	{
		390	unsigned long next;
		391	int ret = -ENOMEM;
		392	p4d_t *p4d;
		393	pud_t *pud;
		394
		395	p4d = p4d_offset(pgd, addr);
		396	for (; addr < end; addr = next, p4d++) {
		397	next = p4d_addr_end(addr, end);
		398	if (!add) {
		399	if (p4d_none(*p4d))
		400	continue;
		401	} else if (p4d_none(*p4d)) {
		402	pud = vmem_crst_alloc(_REGION3_ENTRY_EMPTY);
		403	if (!pud)
288	goto out;	404	goto out;
289	pte_val(*pt_dir) = __pa(new_page) \| pgt_prot;
290	}	405	}
291	address += PAGE_SIZE;	406	ret = modify_pud_table(p4d, addr, next, add, direct);
		407	if (ret)
		408	goto out;
		409	if (!add)
		410	try_free_pud_table(p4d, addr & P4D_MASK);
292	}	411	}
293	ret = 0;	412	ret = 0;
294	out:	413	out:
295	return ret;	414	return ret;
296	}	415	}
297		416
298	void vmemmap_free(unsigned long start, unsigned long end,	417	static void try_free_p4d_table(pgd_t *pgd, unsigned long start)
299	struct vmem_altmap *altmap)
300	{	418	{
		419	const unsigned long end = start + PGDIR_SIZE;
		420	p4d_t *p4d;
		421	int i;
		422
		423	/* Don't mess with any tables not fully in 1:1 mapping & vmemmap area */
		424	if (end > VMALLOC_START)
		425	return;
		426	#ifdef CONFIG_KASAN
		427	if (start < KASAN_SHADOW_END && KASAN_SHADOW_START > end)
		428	return;
		429	#endif
		430
		431	p4d = p4d_offset(pgd, start);
		432	for (i = 0; i < PTRS_PER_P4D; i++, p4d++) {
		433	if (!p4d_none(*p4d))
		434	return;
		435	}
		436	vmem_free_pages(pgd_deref(*pgd), CRST_ALLOC_ORDER);
		437	pgd_clear(pgd);
301	}	438	}
302		439
303	/*	440	static int modify_pagetable(unsigned long start, unsigned long end, bool add,
304	* Add memory segment to the segment list if it doesn't overlap with	441	bool direct)
305	* an already present segment.
306	*/
307	static int insert_memory_segment(struct memory_segment *seg)
308	{	442	{
309	struct memory_segment *tmp;	443	unsigned long addr, next;
		444	int ret = -ENOMEM;
		445	pgd_t *pgd;
		446	p4d_t *p4d;
310		447
311	if (seg->start + seg->size > VMEM_MAX_PHYS \|\|	448	if (WARN_ON_ONCE(!PAGE_ALIGNED(start \| end)))
312	seg->start + seg->size < seg->start)	449	return -EINVAL;
313	return -ERANGE;	450	for (addr = start; addr < end; addr = next) {
		451	next = pgd_addr_end(addr, end);
		452	pgd = pgd_offset_k(addr);
314		453
315	list_for_each_entry(tmp, &mem_segs, list) {	454	if (!add) {
316	if (seg->start >= tmp->start + tmp->size)	455	if (pgd_none(*pgd))
317	continue;	456	continue;
318	if (seg->start + seg->size <= tmp->start)	457	} else if (pgd_none(*pgd)) {
319	continue;	458	p4d = vmem_crst_alloc(_REGION2_ENTRY_EMPTY);
320	return -ENOSPC;	459	if (!p4d)
		460	goto out;
		461	pgd_populate(&init_mm, pgd, p4d);
		462	}
		463	ret = modify_p4d_table(pgd, addr, next, add, direct);
		464	if (ret)
		465	goto out;
		466	if (!add)
		467	try_free_p4d_table(pgd, addr & PGDIR_MASK);
321	}	468	}
322	list_add(&seg->list, &mem_segs);	469	ret = 0;
323	return 0;	470	out:
		471	if (!add)
		472	flush_tlb_kernel_range(start, end);
		473	return ret;
		474	}
		475
		476	static int add_pagetable(unsigned long start, unsigned long end, bool direct)
		477	{
		478	return modify_pagetable(start, end, true, direct);
		479	}
		480
		481	static int remove_pagetable(unsigned long start, unsigned long end, bool direct)
		482	{
		483	return modify_pagetable(start, end, false, direct);
324	}	484	}
325		485
326	/*	486	/*
327	* Remove memory segment from the segment list.	487	* Add a physical memory range to the 1:1 mapping.
328	*/	488	*/
329	static void remove_memory_segment(struct memory_segment *seg)	489	static int vmem_add_range(unsigned long start, unsigned long size)
330	{	490	{
331	list_del(&seg->list);	491	return add_pagetable(start, start + size, true);
332	}	492	}
333		493
334	static void __remove_shared_memory(struct memory_segment *seg)	494	/*
		495	* Remove a physical memory range from the 1:1 mapping.
		496	*/
		497	static void vmem_remove_range(unsigned long start, unsigned long size)
335	{	498	{
336	remove_memory_segment(seg);	499	remove_pagetable(start, start + size, true);
337	vmem_remove_range(seg->start, seg->size);
338	}	500	}
339		501
340	int vmem_remove_mapping(unsigned long start, unsigned long size)	502	/*
		503	* Add a backed mem_map array to the virtual mem_map array.
		504	*/
		505	int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
		506	struct vmem_altmap *altmap)
341	{	507	{
342	struct memory_segment *seg;
343	int ret;	508	int ret;
344		509
345	mutex_lock(&vmem_mutex);	510	mutex_lock(&vmem_mutex);
		511	/* We don't care about the node, just use NUMA_NO_NODE on allocations */
		512	ret = add_pagetable(start, end, false);
		513	if (ret)
		514	remove_pagetable(start, end, false);
		515	mutex_unlock(&vmem_mutex);
		516	return ret;
		517	}
346		518
347	ret = -ENOENT;	519	void vmemmap_free(unsigned long start, unsigned long end,
348	list_for_each_entry(seg, &mem_segs, list) {	520	struct vmem_altmap *altmap)
349	if (seg->start == start && seg->size == size)	521	{
350	break;	522	mutex_lock(&vmem_mutex);
351	}	523	remove_pagetable(start, end, false);
352		524	mutex_unlock(&vmem_mutex);
353	if (seg->start != start \|\| seg->size != size)	525	}
354	goto out;
355		526
356	ret = 0;	527	void vmem_remove_mapping(unsigned long start, unsigned long size)
357	__remove_shared_memory(seg);	528	{
358	kfree(seg);	529	mutex_lock(&vmem_mutex);
359	out:	530	vmem_remove_range(start, size);
360	mutex_unlock(&vmem_mutex);	531	mutex_unlock(&vmem_mutex);
361	return ret;
362	}	532	}
363		533
364	int vmem_add_mapping(unsigned long start, unsigned long size)	534	int vmem_add_mapping(unsigned long start, unsigned long size)
365	{	535	{
366	struct memory_segment *seg;
367	int ret;	536	int ret;
368		537
369	mutex_lock(&vmem_mutex);	538	if (start + size > VMEM_MAX_PHYS \|\|
370	ret = -ENOMEM;	539	start + size < start)
371	seg = kzalloc(sizeof(*seg), GFP_KERNEL);	540	return -ERANGE;
372	if (!seg)
373	goto out;
374	seg->start = start;
375	seg->size = size;
376
377	ret = insert_memory_segment(seg);
378	if (ret)
379	goto out_free;
380		541
381	ret = vmem_add_mem(start, size);	542	mutex_lock(&vmem_mutex);
		543	ret = vmem_add_range(start, size);
382	if (ret)	544	if (ret)
383	goto out_remove;	545	vmem_remove_range(start, size);
384	goto out;
385
386	out_remove:
387	__remove_shared_memory(seg);
388	out_free:
389	kfree(seg);
390	out:
391	mutex_unlock(&vmem_mutex);	546	mutex_unlock(&vmem_mutex);
392	return ret;	547	return ret;
393	}	548	}
@@ -402,7 +557,7 @@ void __init vmem_map_init(void) · 8 unmodified lines
402	struct memblock_region *reg;	557	struct memblock_region *reg;
403		558
404	for_each_memblock(memory, reg)	559	for_each_memblock(memory, reg)
405	vmem_add_mem(reg->base, reg->size);	560	vmem_add_range(reg->base, reg->size);
406	__set_memory((unsigned long)_stext,	561	__set_memory((unsigned long)_stext,
407	(unsigned long)(_etext - _stext) >> PAGE_SHIFT,	562	(unsigned long)(_etext - _stext) >> PAGE_SHIFT,
408	SET_MEMORY_RO \| SET_MEMORY_X);	563	SET_MEMORY_RO \| SET_MEMORY_X);
@@ -421,27 +576,3 @@ void __init vmem_map_init(void) · 12 unmodified lines
421	pr_info("Write protected kernel read-only data: %luk\n",	576	pr_info("Write protected kernel read-only data: %luk\n",
422	(unsigned long)(__end_rodata - _stext) >> 10);	577	(unsigned long)(__end_rodata - _stext) >> 10);
423	}	578	}
424
425	/*
426	* Convert memblock.memory to a memory segment list so there is a single
427	* list that contains all memory segments.
428	*/
429	static int __init vmem_convert_memory_chunk(void)
430	{
431	struct memblock_region *reg;
432	struct memory_segment *seg;
433
434	mutex_lock(&vmem_mutex);
435	for_each_memblock(memory, reg) {
436	seg = kzalloc(sizeof(*seg), GFP_KERNEL);
437	if (!seg)
438	panic("Out of memory...\n");
439	seg->start = reg->base;
440	seg->size = reg->size;
441	insert_memory_segment(seg);
442	}
443	mutex_unlock(&vmem_mutex);
444	return 0;
445	}
446
447	core_initcall(vmem_convert_memory_chunk);

arch/s390/net/bpf_jit_comp.c+138−1

@@ -49,6 +49,7 @@ struct bpf_jit { · 48 unmodified lines
49	int r1_thunk_ip; /* Address of expoline thunk for 'br %r1' */	49	int r1_thunk_ip; /* Address of expoline thunk for 'br %r1' */
50	int r14_thunk_ip; /* Address of expoline thunk for 'br %r14' */	50	int r14_thunk_ip; /* Address of expoline thunk for 'br %r14' */
51	int tail_call_start; /* Tail call start offset */	51	int tail_call_start; /* Tail call start offset */
		52	int excnt; /* Number of exception table entries */
52	int labels[1]; /* Labels for local jumps */	53	int labels[1]; /* Labels for local jumps */
53	};	54	};
54		55
@@ -588,6 +589,84 @@ static void bpf_jit_epilogue(struct bpf_jit *jit, u32 stack_depth) · 533 unmodified lines
588	}	589	}
589	}	590	}
590		591
		592	static int get_probe_mem_regno(const u8 *insn)
		593	{
		594	/*
		595	* insn must point to llgc, llgh, llgf or lg, which have destination
		596	* register at the same position.
		597	*/
		598	if (insn[0] != 0xe3) /* common llgc, llgh, llgf and lg prefix */
		599	return -1;
		600	if (insn[5] != 0x90 && /* llgc */
		601	insn[5] != 0x91 && /* llgh */
		602	insn[5] != 0x16 && /* llgf */
		603	insn[5] != 0x04) /* lg */
		604	return -1;
		605	return insn[1] >> 4;
		606	}
		607
		608	static bool ex_handler_bpf(const struct exception_table_entry *x,
		609	struct pt_regs *regs)
		610	{
		611	int regno;
		612	u8 *insn;
		613
		614	regs->psw.addr = extable_fixup(x);
		615	insn = (u8 *)__rewind_psw(regs->psw, regs->int_code >> 16);
		616	regno = get_probe_mem_regno(insn);
		617	if (WARN_ON_ONCE(regno < 0))
		618	/* JIT bug - unexpected instruction. */
		619	return false;
		620	regs->gprs[regno] = 0;
		621	return true;
		622	}
		623
		624	static int bpf_jit_probe_mem(struct bpf_jit jit, struct bpf_prog fp,
		625	int probe_prg, int nop_prg)
		626	{
		627	struct exception_table_entry *ex;
		628	s64 delta;
		629	u8 *insn;
		630	int prg;
		631	int i;
		632
		633	if (!fp->aux->extable)
		634	/* Do nothing during early JIT passes. */
		635	return 0;
		636	insn = jit->prg_buf + probe_prg;
		637	if (WARN_ON_ONCE(get_probe_mem_regno(insn) < 0))
		638	/* JIT bug - unexpected probe instruction. */
		639	return -1;
		640	if (WARN_ON_ONCE(probe_prg + insn_length(*insn) != nop_prg))
		641	/* JIT bug - gap between probe and nop instructions. */
		642	return -1;
		643	for (i = 0; i < 2; i++) {
		644	if (WARN_ON_ONCE(jit->excnt >= fp->aux->num_exentries))
		645	/* Verifier bug - not enough entries. */
		646	return -1;
		647	ex = &fp->aux->extable[jit->excnt];
		648	/* Add extable entries for probe and nop instructions. */
		649	prg = i == 0 ? probe_prg : nop_prg;
		650	delta = jit->prg_buf + prg - (u8 *)&ex->insn;
		651	if (WARN_ON_ONCE(delta < INT_MIN \|\| delta > INT_MAX))
		652	/* JIT bug - code and extable must be close. */
		653	return -1;
		654	ex->insn = delta;
		655	/*
		656	* Always land on the nop. Note that extable infrastructure
		657	* ignores fixup field, it is handled by ex_handler_bpf().
		658	*/
		659	delta = jit->prg_buf + nop_prg - (u8 *)&ex->fixup;
		660	if (WARN_ON_ONCE(delta < INT_MIN \|\| delta > INT_MAX))
		661	/* JIT bug - landing pad and extable must be close. */
		662	return -1;
		663	ex->fixup = delta;
		664	ex->handler = (u8 )ex_handler_bpf - (u8 )&ex->handler;
		665	jit->excnt++;
		666	}
		667	return 0;
		668	}
		669
591	/*	670	/*
592	* Compile one eBPF instruction into s390x code	671	* Compile one eBPF instruction into s390x code
593	*	672	*
@@ -604,7 +683,14 @@ static noinline int bpf_jit_insn(struct bpf_jit jit, struct bpf_prog fp, · 10 unmodified lines
604	u32 *addrs = jit->addrs;	683	u32 *addrs = jit->addrs;
605	s32 imm = insn->imm;	684	s32 imm = insn->imm;
606	s16 off = insn->off;	685	s16 off = insn->off;
		686	int probe_prg = -1;
607	unsigned int mask;	687	unsigned int mask;
		688	int nop_prg;
		689	int err;
		690
		691	if (BPF_CLASS(insn->code) == BPF_LDX &&
		692	BPF_MODE(insn->code) == BPF_PROBE_MEM)
		693	probe_prg = jit->prg;
608		694
609	switch (insn->code) {	695	switch (insn->code) {
610	/*	696	/*
@@ -1119,6 +1205,7 @@ static noinline int bpf_jit_insn(struct bpf_jit jit, struct bpf_prog fp, · 508 unmodified lines
1119	* BPF_LDX	1205	* BPF_LDX
1120	*/	1206	*/
1121	case BPF_LDX \| BPF_MEM \| BPF_B: /* dst = (u8 )(ul) (src + off) */	1207	case BPF_LDX \| BPF_MEM \| BPF_B: /* dst = (u8 )(ul) (src + off) */
		1208	case BPF_LDX \| BPF_PROBE_MEM \| BPF_B:
1122	/* llgc %dst,0(off,%src) */	1209	/* llgc %dst,0(off,%src) */
1123	EMIT6_DISP_LH(0xe3000000, 0x0090, dst_reg, src_reg, REG_0, off);	1210	EMIT6_DISP_LH(0xe3000000, 0x0090, dst_reg, src_reg, REG_0, off);
1124	jit->seen \|= SEEN_MEM;	1211	jit->seen \|= SEEN_MEM;
@@ -1126,6 +1213,7 @@ static noinline int bpf_jit_insn(struct bpf_jit jit, struct bpf_prog fp, · 1 unmodified line
1126	insn_count = 2;	1213	insn_count = 2;
1127	break;	1214	break;
1128	case BPF_LDX \| BPF_MEM \| BPF_H: /* dst = (u16 )(ul) (src + off) */	1215	case BPF_LDX \| BPF_MEM \| BPF_H: /* dst = (u16 )(ul) (src + off) */
		1216	case BPF_LDX \| BPF_PROBE_MEM \| BPF_H:
1129	/* llgh %dst,0(off,%src) */	1217	/* llgh %dst,0(off,%src) */
1130	EMIT6_DISP_LH(0xe3000000, 0x0091, dst_reg, src_reg, REG_0, off);	1218	EMIT6_DISP_LH(0xe3000000, 0x0091, dst_reg, src_reg, REG_0, off);
1131	jit->seen \|= SEEN_MEM;	1219	jit->seen \|= SEEN_MEM;
@@ -1133,6 +1221,7 @@ static noinline int bpf_jit_insn(struct bpf_jit jit, struct bpf_prog fp, · 1 unmodified line
1133	insn_count = 2;	1221	insn_count = 2;
1134	break;	1222	break;
1135	case BPF_LDX \| BPF_MEM \| BPF_W: /* dst = (u32 )(ul) (src + off) */	1223	case BPF_LDX \| BPF_MEM \| BPF_W: /* dst = (u32 )(ul) (src + off) */
		1224	case BPF_LDX \| BPF_PROBE_MEM \| BPF_W:
1136	/* llgf %dst,off(%src) */	1225	/* llgf %dst,off(%src) */
1137	jit->seen \|= SEEN_MEM;	1226	jit->seen \|= SEEN_MEM;
1138	EMIT6_DISP_LH(0xe3000000, 0x0016, dst_reg, src_reg, REG_0, off);	1227	EMIT6_DISP_LH(0xe3000000, 0x0016, dst_reg, src_reg, REG_0, off);
@@ -1140,6 +1229,7 @@ static noinline int bpf_jit_insn(struct bpf_jit jit, struct bpf_prog fp, · 1 unmodified line
1140	insn_count = 2;	1229	insn_count = 2;
1141	break;	1230	break;
1142	case BPF_LDX \| BPF_MEM \| BPF_DW: /* dst = (u64 )(ul) (src + off) */	1231	case BPF_LDX \| BPF_MEM \| BPF_DW: /* dst = (u64 )(ul) (src + off) */
		1232	case BPF_LDX \| BPF_PROBE_MEM \| BPF_DW:
1143	/* lg %dst,0(off,%src) */	1233	/* lg %dst,0(off,%src) */
1144	jit->seen \|= SEEN_MEM;	1234	jit->seen \|= SEEN_MEM;
1145	EMIT6_DISP_LH(0xe3000000, 0x0004, dst_reg, src_reg, REG_0, off);	1235	EMIT6_DISP_LH(0xe3000000, 0x0004, dst_reg, src_reg, REG_0, off);
@@ -1485,6 +1575,23 @@ branch_oc: · 339 unmodified lines
1485	pr_err("Unknown opcode %02x\n", insn->code);	1575	pr_err("Unknown opcode %02x\n", insn->code);
1486	return -1;	1576	return -1;
1487	}	1577	}
		1578
		1579	if (probe_prg != -1) {
		1580	/*
		1581	* Handlers of certain exceptions leave psw.addr pointing to
		1582	* the instruction directly after the failing one. Therefore,
		1583	* create two exception table entries and also add a nop in
		1584	* case two probing instructions come directly after each
		1585	* other.
		1586	*/
		1587	nop_prg = jit->prg;
		1588	/* bcr 0,%0 */
		1589	_EMIT2(0x0700);
		1590	err = bpf_jit_probe_mem(jit, fp, probe_prg, nop_prg);
		1591	if (err < 0)
		1592	return err;
		1593	}
		1594
1488	return insn_count;	1595	return insn_count;
1489	}	1596	}
1490		1597
@@ -1527,6 +1634,7 @@ static int bpf_jit_prog(struct bpf_jit jit, struct bpf_prog fp, · 36 unmodified lines
1527	jit->lit32 = jit->lit32_start;	1634	jit->lit32 = jit->lit32_start;
1528	jit->lit64 = jit->lit64_start;	1635	jit->lit64 = jit->lit64_start;
1529	jit->prg = 0;	1636	jit->prg = 0;
		1637	jit->excnt = 0;
1530		1638
1531	bpf_jit_prologue(jit, stack_depth);	1639	bpf_jit_prologue(jit, stack_depth);
1532	if (bpf_set_addr(jit, 0) < 0)	1640	if (bpf_set_addr(jit, 0) < 0)
@@ -1551,6 +1659,12 @@ static int bpf_jit_prog(struct bpf_jit jit, struct bpf_prog fp, · 18 unmodified lines
1551	jit->lit64_start = ALIGN(jit->lit64_start, 8);	1659	jit->lit64_start = ALIGN(jit->lit64_start, 8);
1552	jit->size = jit->lit64_start + lit64_size;	1660	jit->size = jit->lit64_start + lit64_size;
1553	jit->size_prg = jit->prg;	1661	jit->size_prg = jit->prg;
		1662
		1663	if (WARN_ON_ONCE(fp->aux->extable &&
		1664	jit->excnt != fp->aux->num_exentries))
		1665	/* Verifier bug - too many entries. */
		1666	return -1;
		1667
1554	return 0;	1668	return 0;
1555	}	1669	}
1556		1670
@@ -1565,6 +1679,29 @@ struct s390_jit_data { · 8 unmodified lines
1565	int pass;	1679	int pass;
1566	};	1680	};
1567		1681
		1682	static struct bpf_binary_header bpf_jit_alloc(struct bpf_jit jit,
		1683	struct bpf_prog *fp)
		1684	{
		1685	struct bpf_binary_header *header;
		1686	u32 extable_size;
		1687	u32 code_size;
		1688
		1689	/* We need two entries per insn. */
		1690	fp->aux->num_exentries *= 2;
		1691
		1692	code_size = roundup(jit->size,
		1693	__alignof__(struct exception_table_entry));
		1694	extable_size = fp->aux->num_exentries *
		1695	sizeof(struct exception_table_entry);
		1696	header = bpf_jit_binary_alloc(code_size + extable_size, &jit->prg_buf,
		1697	8, jit_fill_hole);
		1698	if (!header)
		1699	return NULL;
		1700	fp->aux->extable = (struct exception_table_entry *)
		1701	(jit->prg_buf + code_size);
		1702	return header;
		1703	}
		1704
1568	/*	1705	/*
1569	* Compile eBPF program "fp"	1706	* Compile eBPF program "fp"
1570	*/	1707	*/
@@ -1631,7 +1768,7 @@ struct bpf_prog bpf_int_jit_compile(struct bpf_prog fp) · 60 unmodified lines
1631	/*	1768	/*
1632	* Final pass: Allocate and generate program	1769	* Final pass: Allocate and generate program
1633	*/	1770	*/
1634	header = bpf_jit_binary_alloc(jit.size, &jit.prg_buf, 8, jit_fill_hole);	1771	header = bpf_jit_alloc(&jit, fp);
1635	if (!header) {	1772	if (!header) {
1636	fp = orig_fp;	1773	fp = orig_fp;
1637	goto free_addrs;	1774	goto free_addrs;

arch/s390/pci/pci_mmio.c+12−8

 		return -EINVAL;
 	/*
-	 * Only support read access to MIO capable devices on a MIO enabled
+	 * We only support write access to MIO capable devices if we are on
-	 * system. Otherwise we would have to check for every address if it is
+	 * a MIO enabled system. Otherwise we would have to check for every
-	 * a special ZPCI_ADDR and we would have to do a get_pfn() which we
+	 * address if it is a special ZPCI_ADDR and would have to do
-	 * don't need for MIO capable devices.
+	 * a get_pfn() which we don't need for MIO capable devices.  Currently
+	 * ISM devices are the only devices without MIO support and there is no
+	 * known need for accessing these from userspace.
 	 */
 	if (static_branch_likely(&have_mio)) {
 		ret = __memcpy_toio_inuser((void  __iomem *) mmio_addr,
 		return -EINVAL;
 	/*
-	 * Only support write access to MIO capable devices on a MIO enabled
+	 * We only support read access to MIO capable devices if we are on
-	 * system. Otherwise we would have to check for every address if it is
+	 * a MIO enabled system. Otherwise we would have to check for every
-	 * a special ZPCI_ADDR and we would have to do a get_pfn() which we
+	 * address if it is a special ZPCI_ADDR and would have to do
-	 * don't need for MIO capable devices.
+	 * a get_pfn() which we don't need for MIO capable devices.  Currently
+	 * ISM devices are the only devices without MIO support and there is no
+	 * known need for accessing these from userspace.
 	 */
 	if (static_branch_likely(&have_mio)) {
 		ret = __memcpy_fromio_inuser(

drivers/s390/char/tty3270.c+6−6

  * Pass input line to tty.
  */
 static void
-tty3270_read_tasklet(struct raw3270_request *rrq)
+tty3270_read_tasklet(unsigned long data)
 {
+	struct raw3270_request *rrq = (struct raw3270_request *)data;
 	static char kreset_data = TW_KR;
 	struct tty3270 *tp = container_of(rrq->view, struct tty3270, view);
 	char *input;
  * Hang up the tty
  */
 static void
-tty3270_hangup_tasklet(struct tty3270 *tp)
+tty3270_hangup_tasklet(unsigned long data)
 {
+	struct tty3270 *tp = (struct tty3270 *)data;
 	tty_port_tty_hangup(&tp->port, true);
 	raw3270_put_view(&tp->view);
 }
 	tty_port_init(&tp->port);
 	timer_setup(&tp->timer, tty3270_update, 0);
-	tasklet_init(&tp->readlet,
+	tasklet_init(&tp->readlet, tty3270_read_tasklet,
-		     (void (*)(unsigned long)) tty3270_read_tasklet,
 		     (unsigned long) tp->read);
-	tasklet_init(&tp->hanglet,
+	tasklet_init(&tp->hanglet, tty3270_hangup_tasklet,
-		     (void (*)(unsigned long)) tty3270_hangup_tasklet,
 		     (unsigned long) tp);
 	INIT_WORK(&tp->resize_work, tty3270_resize_work);

drivers/s390/char/zcore.c+2−55

@@ -1,8 +1,7 @@
1	// SPDX-License-Identifier: GPL-1.0+	1	// SPDX-License-Identifier: GPL-1.0+
2	/*	2	/*
3	* zcore module to export memory content and register sets for creating system	3	* zcore module to export memory content and register sets for creating system
4	* dumps on SCSI disks (zfcpdump). The "zcore/mem" debugfs file shows the same	4	* dumps on SCSI disks (zfcpdump).
5	* dump format as s390 standalone dumps.
6	*	5	*
7	* For more information please refer to Documentation/s390/zfcpdump.rst	6	* For more information please refer to Documentation/s390/zfcpdump.rst
8	*	7	*
@@ -16,7 +15,6 @@ · 7 unmodified lines
16	#include <linux/init.h>	15	#include <linux/init.h>
17	#include <linux/slab.h>	16	#include <linux/slab.h>
18	#include <linux/debugfs.h>	17	#include <linux/debugfs.h>
19	#include <linux/memblock.h>
20		18
21	#include <asm/asm-offsets.h>	19	#include <asm/asm-offsets.h>
22	#include <asm/ipl.h>	20	#include <asm/ipl.h>
@@ -33,8 +31,6 @@ · 10 unmodified lines
33		31
34	#define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)	32	#define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x)
35		33
36	#define CHUNK_INFO_SIZE 34 /* 2 16-byte char, each followed by blank */
37
38	enum arch_id {	34	enum arch_id {
39	ARCH_S390 = 0,	35	ARCH_S390 = 0,
40	ARCH_S390X = 1,	36	ARCH_S390X = 1,
@@ -48,7 +44,6 @@ struct ipib_info { · 7 unmodified lines
48	static struct debug_info *zcore_dbf;	44	static struct debug_info *zcore_dbf;
49	static int hsa_available;	45	static int hsa_available;
50	static struct dentry *zcore_dir;	46	static struct dentry *zcore_dir;
51	static struct dentry *zcore_memmap_file;
52	static struct dentry *zcore_reipl_file;	47	static struct dentry *zcore_reipl_file;
53	static struct dentry *zcore_hsa_file;	48	static struct dentry *zcore_hsa_file;
54	static struct ipl_parameter_block *zcore_ipl_block;	49	static struct ipl_parameter_block *zcore_ipl_block;
@@ -139,46 +134,6 @@ static void release_hsa(void) · 84 unmodified lines
139	hsa_available = 0;	134	hsa_available = 0;
140	}	135	}
141		136
142	static ssize_t zcore_memmap_read(struct file filp, char __user buf,
143	size_t count, loff_t *ppos)
144	{
145	return simple_read_from_buffer(buf, count, ppos, filp->private_data,
146	memblock.memory.cnt * CHUNK_INFO_SIZE);
147	}
148
149	static int zcore_memmap_open(struct inode inode, struct file filp)
150	{
151	struct memblock_region *reg;
152	char *buf;
153	int i = 0;
154
155	buf = kcalloc(memblock.memory.cnt, CHUNK_INFO_SIZE, GFP_KERNEL);
156	if (!buf) {
157	return -ENOMEM;
158	}
159	for_each_memblock(memory, reg) {
160	sprintf(buf + (i++ * CHUNK_INFO_SIZE), "%016llx %016llx ",
161	(unsigned long long) reg->base,
162	(unsigned long long) reg->size);
163	}
164	filp->private_data = buf;
165	return nonseekable_open(inode, filp);
166	}
167
168	static int zcore_memmap_release(struct inode inode, struct file filp)
169	{
170	kfree(filp->private_data);
171	return 0;
172	}
173
174	static const struct file_operations zcore_memmap_fops = {
175	.owner = THIS_MODULE,
176	.read = zcore_memmap_read,
177	.open = zcore_memmap_open,
178	.release = zcore_memmap_release,
179	.llseek = no_llseek,
180	};
181
182	static ssize_t zcore_reipl_write(struct file filp, const char __user buf,	137	static ssize_t zcore_reipl_write(struct file filp, const char __user buf,
183	size_t count, loff_t *ppos)	138	size_t count, loff_t *ppos)
184	{	139	{
@@ -335,17 +290,11 @@ static int __init zcore_init(void) · 150 unmodified lines
335	rc = -ENOMEM;	290	rc = -ENOMEM;
336	goto fail;	291	goto fail;
337	}	292	}
338	zcore_memmap_file = debugfs_create_file("memmap", S_IRUSR, zcore_dir,
339	NULL, &zcore_memmap_fops);
340	if (!zcore_memmap_file) {
341	rc = -ENOMEM;
342	goto fail_dir;
343	}
344	zcore_reipl_file = debugfs_create_file("reipl", S_IRUSR, zcore_dir,	293	zcore_reipl_file = debugfs_create_file("reipl", S_IRUSR, zcore_dir,
345	NULL, &zcore_reipl_fops);	294	NULL, &zcore_reipl_fops);
346	if (!zcore_reipl_file) {	295	if (!zcore_reipl_file) {
347	rc = -ENOMEM;	296	rc = -ENOMEM;
348	goto fail_memmap_file;	297	goto fail_dir;
349	}	298	}
350	zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR\|S_IWUSR, zcore_dir,	299	zcore_hsa_file = debugfs_create_file("hsa", S_IRUSR\|S_IWUSR, zcore_dir,
351	NULL, &zcore_hsa_fops);	300	NULL, &zcore_hsa_fops);
@@ -357,8 +306,6 @@ static int __init zcore_init(void) · 5 unmodified lines
357		306
358	fail_reipl_file:	307	fail_reipl_file:
359	debugfs_remove(zcore_reipl_file);	308	debugfs_remove(zcore_reipl_file);
360	fail_memmap_file:
361	debugfs_remove(zcore_memmap_file);
362	fail_dir:	309	fail_dir:
363	debugfs_remove(zcore_dir);	310	debugfs_remove(zcore_dir);
364	fail:	311	fail:

drivers/s390/cio/qdio.h+1−8

 #define QDIO_BUSY_BIT_PATIENCE		(100 << 12)	/* 100 microseconds */
 #define QDIO_BUSY_BIT_RETRY_DELAY	10		/* 10 milliseconds */
 #define QDIO_BUSY_BIT_RETRIES		1000		/* = 10s retry time */
-#define QDIO_INPUT_THRESHOLD		(500 << 12)	/* 500 microseconds */
 enum qdio_irq_states {
 	QDIO_IRQ_STATE_INACTIVE,
 } ____cacheline_aligned;
 struct qdio_queue_perf_stat {
-	/*
+	/* Sorted into order-2 buckets: 1, 2-3, 4-7, ... 64-127, 128. */
-	 * Sorted into order-2 buckets: 1, 2-3, 4-7, ... 64-127, 128.
-	 * Since max. 127 SBALs are scanned reuse entry for 128 as queue full
-	 * aka 127 SBALs found.
-	 */
 	unsigned int nr_sbals[8];
 	unsigned int nr_sbal_error;
 	unsigned int nr_sbal_nop;
 	/* Batch of SBALs that we processed while polling the queue: */
 	unsigned int batch_start;
 	unsigned int batch_count;
-	/* last time of noticing incoming data */
-	u64 timestamp;
 };
 struct qdio_output_q {

drivers/s390/cio/qdio_debug.c+1−1

@@ -165,7 +165,7 @@ static int qstat_show(struct seq_file m, void v) · 164 unmodified lines
165	}	165	}
166		166
167	seq_printf(m, "\n1 2.. 4.. 8.. "	167	seq_printf(m, "\n1 2.. 4.. 8.. "
168	"16.. 32.. 64.. 127\n");	168	"16.. 32.. 64.. 128\n");
169	for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)	169	for (i = 0; i < ARRAY_SIZE(q->q_stats.nr_sbals); i++)
170	seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);	170	seq_printf(m, "%-10u ", q->q_stats.nr_sbals[i]);
171	seq_printf(m, "\nError NOP Total\n%-10u %-10u %-10u\n\n",	171	seq_printf(m, "\nError NOP Total\n%-10u %-10u %-10u\n\n",

drivers/s390/cio/qdio_main.c+4−37

@@ -413,15 +413,8 @@ static inline void qdio_stop_polling(struct qdio_q *q) · 412 unmodified lines
413		413
414	static inline void account_sbals(struct qdio_q *q, unsigned int count)	414	static inline void account_sbals(struct qdio_q *q, unsigned int count)
415	{	415	{
416	int pos;
417
418	q->q_stats.nr_sbal_total += count;	416	q->q_stats.nr_sbal_total += count;
419	if (count == QDIO_MAX_BUFFERS_MASK) {	417	q->q_stats.nr_sbals[ilog2(count)]++;
420	q->q_stats.nr_sbals[7]++;
421	return;
422	}
423	pos = ilog2(count);
424	q->q_stats.nr_sbals[pos]++;
425	}	418	}
426		419
427	static void process_buffer_error(struct qdio_q *q, unsigned int start,	420	static void process_buffer_error(struct qdio_q *q, unsigned int start,
@@ -464,11 +457,7 @@ static int get_inbound_buffer_frontier(struct qdio_q *q, unsigned int start) · 36 unmodified lines
464		457
465	q->timestamp = get_tod_clock_fast();	458	q->timestamp = get_tod_clock_fast();
466		459
467	/*	460	count = atomic_read(&q->nr_buf_used);
468	* Don't check 128 buffers, as otherwise qdio_inbound_q_moved
469	* would return 0.
470	*/
471	count = min(atomic_read(&q->nr_buf_used), QDIO_MAX_BUFFERS_MASK);
472	if (!count)	461	if (!count)
473	return 0;	462	return 0;
474		463
@@ -521,14 +510,7 @@ static int get_inbound_buffer_frontier(struct qdio_q *q, unsigned int start) · 46 unmodified lines
521		510
522	static int qdio_inbound_q_moved(struct qdio_q *q, unsigned int start)	511	static int qdio_inbound_q_moved(struct qdio_q *q, unsigned int start)
523	{	512	{
524	int count;	513	return get_inbound_buffer_frontier(q, start);
525
526	count = get_inbound_buffer_frontier(q, start);
527
528	if (count && !is_thinint_irq(q->irq_ptr) && MACHINE_IS_LPAR)
529	q->u.in.timestamp = get_tod_clock();
530
531	return count;
532	}	514	}
533		515
534	static inline int qdio_inbound_q_done(struct qdio_q *q, unsigned int start)	516	static inline int qdio_inbound_q_done(struct qdio_q *q, unsigned int start)
@@ -546,22 +528,7 @@ static inline int qdio_inbound_q_done(struct qdio_q *q, unsigned int start) · 11 unmodified lines
546	/* more work coming */	528	/* more work coming */
547	return 0;	529	return 0;
548		530
549	if (is_thinint_irq(q->irq_ptr))	531	return 1;
550	return 1;
551
552	/* don't poll under z/VM */
553	if (MACHINE_IS_VM)
554	return 1;
555
556	/*
557	* At this point we know, that inbound first_to_check
558	* has (probably) not moved (see qdio_inbound_processing).
559	*/
560	if (get_tod_clock_fast() > q->u.in.timestamp + QDIO_INPUT_THRESHOLD) {
561	DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "in done:%02x", start);
562	return 1;
563	} else
564	return 0;
565	}	532	}
566		533
567	static inline void qdio_handle_aobs(struct qdio_q *q, int start, int count)	534	static inline void qdio_handle_aobs(struct qdio_q *q, int start, int count)

drivers/s390/crypto/ap_bus.c+161−156

 DEFINE_MUTEX(ap_perms_mutex);
 EXPORT_SYMBOL(ap_perms_mutex);
-static struct ap_config_info *ap_configuration;
+static struct ap_config_info *ap_qci_info;
-static bool initialised;
 /*
  * AP bus related debug feature things.
  */
 static unsigned long long poll_timeout = 250000;
-/* Maximum domain id */
+/* Maximum domain id, if not given via qci */
-static int ap_max_domain_id;
+static int ap_max_domain_id = 15;
+/* Maximum adapter id, if not given via qci */
+static int ap_max_adapter_id = 63;
 static struct bus_type ap_bus_type;
 }
 /**
- * ap_configuration_available(): Test if AP configuration
+ * ap_qci_available(): Test if AP configuration
- * information is available.
+ * information can be queried via QCI subfunction.
  *
- * Returns 1 if AP configuration information is available.
+ * Returns 1 if subfunction PQAP(QCI) is available.
  */
-static int ap_configuration_available(void)
+static int ap_qci_available(void)
 {
 	return test_facility(12);
 }
  */
 static inline int ap_qact_available(void)
 {
-	if (ap_configuration)
+	if (ap_qci_info)
-		return ap_configuration->qact;
+		return ap_qci_info->qact;
 	return 0;
 }
 /*
- * ap_query_configuration(): Fetch cryptographic config info
+ * ap_fetch_qci_info(): Fetch cryptographic config info
  *
  * Returns the ap configuration info fetched via PQAP(QCI).
  * On success 0 is returned, on failure a negative errno
  * is returned, e.g. if the PQAP(QCI) instruction is not
  * available, the return value will be -EOPNOTSUPP.
  */
-static inline int ap_query_configuration(struct ap_config_info *info)
+static inline int ap_fetch_qci_info(struct ap_config_info *info)
 {
-	if (!ap_configuration_available())
+	if (!ap_qci_available())
 		return -EOPNOTSUPP;
 	if (!info)
 		return -EINVAL;
 }
 /**
- * ap_init_configuration(): Allocate and query configuration array.
+ * ap_init_qci_info(): Allocate and query qci config info.
+ * Does also update the static variables ap_max_domain_id
+ * and ap_max_adapter_id if this info is available.
  */
-static void ap_init_configuration(void)
+static void __init ap_init_qci_info(void)
 {
-	if (!ap_configuration_available())
+	if (!ap_qci_available()) {
+		AP_DBF(DBF_INFO, "%s QCI not supported\n", __func__);
 		return;
+	}
-	ap_configuration = kzalloc(sizeof(*ap_configuration), GFP_KERNEL);
+	ap_qci_info = kzalloc(sizeof(*ap_qci_info), GFP_KERNEL);
-	if (!ap_configuration)
+	if (!ap_qci_info)
 		return;
-	if (ap_query_configuration(ap_configuration) != 0) {
+	if (ap_fetch_qci_info(ap_qci_info) != 0) {
-		kfree(ap_configuration);
+		kfree(ap_qci_info);
-		ap_configuration = NULL;
+		ap_qci_info = NULL;
 		return;
 	}
+	AP_DBF(DBF_INFO, "%s successful fetched initial qci info\n", __func__);
+	if (ap_qci_info->apxa) {
+		if (ap_qci_info->Na) {
+			ap_max_adapter_id = ap_qci_info->Na;
+			AP_DBF(DBF_INFO, "%s new ap_max_adapter_id is %d\n",
+			       __func__, ap_max_adapter_id);
+		}
+		if (ap_qci_info->Nd) {
+			ap_max_domain_id = ap_qci_info->Nd;
+			AP_DBF(DBF_INFO, "%s new ap_max_domain_id is %d\n",
+			       __func__, ap_max_domain_id);
+		}
+	}
 }
 /*
 /*
  * ap_test_config_card_id(): Test, whether an AP card ID is configured.
- * @id AP card ID
  *
  * Returns 0 if the card is not configured
  *	   1 if the card is configured or
  */
 static inline int ap_test_config_card_id(unsigned int id)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (id > ap_max_adapter_id)
-		/* only ids 0...3F may be probed */
+		return 0;
-		return id < 0x40 ? 1 : 0;
+	if (ap_qci_info)
-	return ap_test_config(ap_configuration->apm, id);
+		return ap_test_config(ap_qci_info->apm, id);
+	return 1;
 }
 /*
  * ap_test_config_usage_domain(): Test, whether an AP usage domain
  * is configured.
- * @domain AP usage domain ID
  *
  * Returns 0 if the usage domain is not configured
  *	   1 if the usage domain is configured or
  */
 int ap_test_config_usage_domain(unsigned int domain)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (domain > ap_max_domain_id)
-		return domain < 16;
+		return 0;
-	return ap_test_config(ap_configuration->aqm, domain);
+	if (ap_qci_info)
+		return ap_test_config(ap_qci_info->aqm, domain);
+	return 1;
 }
 EXPORT_SYMBOL(ap_test_config_usage_domain);
  */
 int ap_test_config_ctrl_domain(unsigned int domain)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (!ap_qci_info || domain > ap_max_domain_id)
 		return 0;
-	return ap_test_config(ap_configuration->adm, domain);
+	return ap_test_config(ap_qci_info->adm, domain);
 }
 EXPORT_SYMBOL(ap_test_config_ctrl_domain);
-/**
+/*
- * ap_query_queue(): Check if an AP queue is available.
+ * ap_queue_info(): Check and get AP queue info.
- * @qid: The AP queue number
+ * Returns true if TAPQ succeeded and the info is filled or
- * @queue_depth: Pointer to queue depth value
+ * false otherwise.
- * @device_type: Pointer to device type value
- * @facilities: Pointer to facility indicator
  */
-static int ap_query_queue(ap_qid_t qid, int *queue_depth, int *device_type,
+static bool ap_queue_info(ap_qid_t qid, int *q_type,
-			  unsigned int *facilities)
+			  unsigned int *q_fac, int *q_depth)
 {
 	struct ap_queue_status status;
-	unsigned long info;
+	unsigned long info = 0;
-	int nd;
-	if (!ap_test_config_card_id(AP_QID_CARD(qid)))
+	/* make sure we don't run into a specifiation exception */
-		return -ENODEV;
+	if (AP_QID_CARD(qid) > ap_max_adapter_id ||
+	    AP_QID_QUEUE(qid) > ap_max_domain_id)
+		return false;
+	/* call TAPQ on this APQN */
 	status = ap_test_queue(qid, ap_apft_available(), &info);
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
-		*queue_depth = (int)(info & 0xff);
+	case AP_RESPONSE_RESET_IN_PROGRESS:
-		*device_type = (int)((info >> 24) & 0xff);
+		/*
-		*facilities = (unsigned int)(info >> 32);
+		 * According to the architecture in all these cases the
-		/* Update maximum domain id */
+		 * info should be filled. All bits 0 is not possible as
-		nd = (info >> 16) & 0xff;
+		 * there is at least one of the mode bits set.
-		/* if N bit is available, z13 and newer */
+		 */
-		if ((info & (1UL << 57)) && nd > 0)
+		if (WARN_ON_ONCE(!info))
-			ap_max_domain_id = nd;
+			return false;
-		else /* older machine types */
+		*q_type = (int)((info >> 24) & 0xff);
-			ap_max_domain_id = 15;
+		*q_fac = (unsigned int)(info >> 32);
-		switch (*device_type) {
+		*q_depth = (int)(info & 0xff);
+		switch (*q_type) {
 			/* For CEX2 and CEX3 the available functions
 			 * are not reflected by the facilities bits.
 			 * Instead it is coded into the type. So here
 			 */
 		case AP_DEVICE_TYPE_CEX2A:
 		case AP_DEVICE_TYPE_CEX3A:
-			*facilities |= 0x08000000;
+			*q_fac |= 0x08000000;
 			break;
 		case AP_DEVICE_TYPE_CEX2C:
 		case AP_DEVICE_TYPE_CEX3C:
-			*facilities |= 0x10000000;
+			*q_fac |= 0x10000000;
 			break;
 		default:
 			break;
 		}
-		return 0;
+		return true;
-	case AP_RESPONSE_Q_NOT_AVAIL:
-	case AP_RESPONSE_DECONFIGURED:
-	case AP_RESPONSE_CHECKSTOPPED:
-	case AP_RESPONSE_INVALID_ADDRESS:
-		return -ENODEV;
-	case AP_RESPONSE_RESET_IN_PROGRESS:
-	case AP_RESPONSE_OTHERWISE_CHANGED:
-	case AP_RESPONSE_BUSY:
-		return -EBUSY;
 	default:
-		BUG();
+		/*
+		 * A response code which indicates, there is no info available.
+		 */
+		return false;
 	}
 }
-void ap_wait(enum ap_wait wait)
+void ap_wait(enum ap_sm_wait wait)
 {
 	ktime_t hr_time;
 	switch (wait) {
-	case AP_WAIT_AGAIN:
+	case AP_SM_WAIT_AGAIN:
-	case AP_WAIT_INTERRUPT:
+	case AP_SM_WAIT_INTERRUPT:
 		if (ap_using_interrupts())
 			break;
 		if (ap_poll_kthread) {
 			break;
 		}
 		fallthrough;
-	case AP_WAIT_TIMEOUT:
+	case AP_SM_WAIT_TIMEOUT:
 		spin_lock_bh(&ap_poll_timer_lock);
 		if (!hrtimer_is_queued(&ap_poll_timer)) {
 			hr_time = poll_timeout;
 		}
 		spin_unlock_bh(&ap_poll_timer_lock);
 		break;
-	case AP_WAIT_NONE:
+	case AP_SM_WAIT_NONE:
 	default:
 		break;
 	}
 	struct ap_queue *aq = from_timer(aq, t, timeout);
 	spin_lock_bh(&aq->lock);
-	ap_wait(ap_sm_event(aq, AP_EVENT_TIMEOUT));
+	ap_wait(ap_sm_event(aq, AP_SM_EVENT_TIMEOUT));
 	spin_unlock_bh(&aq->lock);
 }
 {
 	int bkt;
 	struct ap_queue *aq;
-	enum ap_wait wait = AP_WAIT_NONE;
+	enum ap_sm_wait wait = AP_SM_WAIT_NONE;
 	/* Reset the indicator if interrupts are used. Thus new interrupts can
 	 * be received. Doing it in the beginning of the tasklet is therefor
 	spin_lock_bh(&ap_queues_lock);
 	hash_for_each(ap_queues, bkt, aq, hnode) {
 		spin_lock_bh(&aq->lock);
-		wait = min(wait, ap_sm_event_loop(aq, AP_EVENT_POLL));
+		wait = min(wait, ap_sm_event_loop(aq, AP_SM_EVENT_POLL));
 		spin_unlock_bh(&aq->lock);
 	}
 	spin_unlock_bh(&ap_queues_lock);
 {
 	struct device_driver *drv = &ap_drv->driver;
-	if (!initialised)
-		return -ENODEV;
 	drv->bus = &ap_bus_type;
 	drv->probe = ap_device_probe;
 	drv->remove = ap_device_remove;
 	    domain < 0 || domain > ap_max_domain_id ||
 	    !test_bit_inv(domain, ap_perms.aqm))
 		return -EINVAL;
 	spin_lock_bh(&ap_domain_lock);
 	ap_domain_index = domain;
 	spin_unlock_bh(&ap_domain_lock);
-	AP_DBF(DBF_DEBUG, "stored new default domain=%d\n", domain);
+	AP_DBF(DBF_INFO, "stored new default domain=%d\n", domain);
 	return count;
 }
 static ssize_t ap_control_domain_mask_show(struct bus_type *bus, char *buf)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (!ap_qci_info)	/* QCI not supported */
 		return scnprintf(buf, PAGE_SIZE, "not supported\n");
 	return scnprintf(buf, PAGE_SIZE,
 			 "0x%08x%08x%08x%08x%08x%08x%08x%08x\n",
-			 ap_configuration->adm[0], ap_configuration->adm[1],
+			 ap_qci_info->adm[0], ap_qci_info->adm[1],
-			 ap_configuration->adm[2], ap_configuration->adm[3],
+			 ap_qci_info->adm[2], ap_qci_info->adm[3],
-			 ap_configuration->adm[4], ap_configuration->adm[5],
+			 ap_qci_info->adm[4], ap_qci_info->adm[5],
-			 ap_configuration->adm[6], ap_configuration->adm[7]);
+			 ap_qci_info->adm[6], ap_qci_info->adm[7]);
 }
 static BUS_ATTR_RO(ap_control_domain_mask);
 static ssize_t ap_usage_domain_mask_show(struct bus_type *bus, char *buf)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (!ap_qci_info)	/* QCI not supported */
 		return scnprintf(buf, PAGE_SIZE, "not supported\n");
 	return scnprintf(buf, PAGE_SIZE,
 			 "0x%08x%08x%08x%08x%08x%08x%08x%08x\n",
-			 ap_configuration->aqm[0], ap_configuration->aqm[1],
+			 ap_qci_info->aqm[0], ap_qci_info->aqm[1],
-			 ap_configuration->aqm[2], ap_configuration->aqm[3],
+			 ap_qci_info->aqm[2], ap_qci_info->aqm[3],
-			 ap_configuration->aqm[4], ap_configuration->aqm[5],
+			 ap_qci_info->aqm[4], ap_qci_info->aqm[5],
-			 ap_configuration->aqm[6], ap_configuration->aqm[7]);
+			 ap_qci_info->aqm[6], ap_qci_info->aqm[7]);
 }
 static BUS_ATTR_RO(ap_usage_domain_mask);
 static ssize_t ap_adapter_mask_show(struct bus_type *bus, char *buf)
 {
-	if (!ap_configuration)	/* QCI not supported */
+	if (!ap_qci_info)	/* QCI not supported */
 		return scnprintf(buf, PAGE_SIZE, "not supported\n");
 	return scnprintf(buf, PAGE_SIZE,
 			 "0x%08x%08x%08x%08x%08x%08x%08x%08x\n",
-			 ap_configuration->apm[0], ap_configuration->apm[1],
+			 ap_qci_info->apm[0], ap_qci_info->apm[1],
-			 ap_configuration->apm[2], ap_configuration->apm[3],
+			 ap_qci_info->apm[2], ap_qci_info->apm[3],
-			 ap_configuration->apm[4], ap_configuration->apm[5],
+			 ap_qci_info->apm[4], ap_qci_info->apm[5],
-			 ap_configuration->apm[6], ap_configuration->apm[7]);
+			 ap_qci_info->apm[6], ap_qci_info->apm[7]);
 }
 static BUS_ATTR_RO(ap_adapter_mask);
 static ssize_t ap_max_domain_id_show(struct bus_type *bus, char *buf)
 {
-	int max_domain_id;
+	return scnprintf(buf, PAGE_SIZE, "%d\n", ap_max_domain_id);
-	if (ap_configuration)
-		max_domain_id = ap_max_domain_id ? : -1;
-	else
-		max_domain_id = 15;
-	return scnprintf(buf, PAGE_SIZE, "%d\n", max_domain_id);
 }
 static BUS_ATTR_RO(ap_max_domain_id);
+static ssize_t ap_max_adapter_id_show(struct bus_type *bus, char *buf)
+{
+	return scnprintf(buf, PAGE_SIZE, "%d\n", ap_max_adapter_id);
+}
+static BUS_ATTR_RO(ap_max_adapter_id);
 static ssize_t apmask_show(struct bus_type *bus, char *buf)
 {
 	int rc;
 	&bus_attr_ap_interrupts,
 	&bus_attr_poll_timeout,
 	&bus_attr_ap_max_domain_id,
+	&bus_attr_ap_max_adapter_id,
 	&bus_attr_apmask,
 	&bus_attr_aqmask,
 	NULL,
  */
 static void ap_select_domain(void)
 {
-	int count, max_count, best_domain;
 	struct ap_queue_status status;
-	int i, j;
+	int card, dom;
 	/*
-	 * We want to use a single domain. Either the one specified with
+	 * Choose the default domain. Either the one specified with
-	 * the "domain=" parameter or the domain with the maximum number
+	 * the "domain=" parameter or the first domain with at least
-	 * of devices.
+	 * one valid APQN.
 	 */
 	spin_lock_bh(&ap_domain_lock);
 	if (ap_domain_index >= 0) {
 		/* Domain has already been selected. */
-		spin_unlock_bh(&ap_domain_lock);
+		goto out;
-		return;
 	}
-	best_domain = -1;
+	for (dom = 0; dom <= ap_max_domain_id; dom++) {
-	max_count = 0;
+		if (!ap_test_config_usage_domain(dom) ||
-	for (i = 0; i < AP_DOMAINS; i++) {
+		    !test_bit_inv(dom, ap_perms.aqm))
-		if (!ap_test_config_usage_domain(i) ||
-		    !test_bit_inv(i, ap_perms.aqm))
 			continue;
-		count = 0;
+		for (card = 0; card <= ap_max_adapter_id; card++) {
-		for (j = 0; j < AP_DEVICES; j++) {
+			if (!ap_test_config_card_id(card) ||
-			if (!ap_test_config_card_id(j))
+			    !test_bit_inv(card, ap_perms.apm))
 				continue;
-			status = ap_test_queue(AP_MKQID(j, i),
+			status = ap_test_queue(AP_MKQID(card, dom),
 					       ap_apft_available(),
 					       NULL);
-			if (status.response_code != AP_RESPONSE_NORMAL)
+			if (status.response_code == AP_RESPONSE_NORMAL)
-				continue;
+				break;
-			count++;
-		}
-		if (count > max_count) {
-			max_count = count;
-			best_domain = i;
 		}
+		if (card <= ap_max_adapter_id)
+			break;
 	}
-	if (best_domain >= 0) {
+	if (dom <= ap_max_domain_id) {
-		ap_domain_index = best_domain;
+		ap_domain_index = dom;
-		AP_DBF(DBF_DEBUG, "new ap_domain_index=%d\n", ap_domain_index);
+		AP_DBF(DBF_DEBUG, "%s new default domain is %d\n",
+		       __func__, ap_domain_index);
 	}
+out:
 	spin_unlock_bh(&ap_domain_lock);
 }
  */
 static void _ap_scan_bus_adapter(int id)
 {
+	bool broken;
 	ap_qid_t qid;
 	unsigned int func;
 	struct ap_card *ac;
 	struct device *dev;
 	struct ap_queue *aq;
-	int rc, dom, depth, type, comp_type, borked;
+	int rc, dom, depth, type, comp_type;
 	/* check if there is a card device registered with this id */
 	dev = bus_find_device(&ap_bus_type, NULL,
 		/* find the first valid queue */
 		for (dom = 0; dom < AP_DOMAINS; dom++) {
 			qid = AP_MKQID(id, dom);
-			if (ap_query_queue(qid, &depth, &type, &func) == 0)
+			if (ap_queue_info(qid, &type, &func, &depth))
 				break;
 		}
-		borked = 0;
+		broken = false;
 		if (dom >= AP_DOMAINS) {
 			/* no accessible queue on this card */
-			borked = 1;
+			broken = true;
 		} else if (ac->raw_hwtype != type) {
 			/* card type has changed */
 			AP_DBF(DBF_INFO, "card=%02x type changed.\n", id);
-			borked = 1;
+			broken = true;
 		} else if (ac->functions != func) {
 			/* card functions have changed */
 			AP_DBF(DBF_INFO, "card=%02x functions changed.\n", id);
-			borked = 1;
+			broken = true;
 		}
-		if (borked) {
+		if (broken) {
 			/* unregister card device and associated queues */
 			bus_for_each_dev(&ap_bus_type, NULL,
 					 (void *)(long) id,
 			continue;
 		}
 		/* try to fetch infos about this queue */
-		rc = ap_query_queue(qid, &depth, &type, &func);
+		broken = !ap_queue_info(qid, &type, &func, &depth);
 		if (dev) {
-			if (rc == -ENODEV)
+			if (!broken) {
-				borked = 1;
-			else {
 				spin_lock_bh(&aq->lock);
-				borked = aq->state == AP_STATE_BORKED;
+				broken = aq->sm_state == AP_SM_STATE_BORKED;
 				spin_unlock_bh(&aq->lock);
 			}
-			if (borked) {
+			if (broken) {
 				/* Remove broken device */
 				AP_DBF(DBF_DEBUG,
 				       "removing broken queue=%02x.%04x\n",
 			put_device(dev);
 			continue;
 		}
-		if (rc)
+		if (broken)
 			continue;
 		/* a new queue device is needed, check out comp type */
 		comp_type = ap_get_compatible_type(qid, type, func);
 {
 	int id;
-	AP_DBF(DBF_DEBUG, "%s running\n", __func__);
+	ap_fetch_qci_info(ap_qci_info);
-	ap_query_configuration(ap_configuration);
 	ap_select_domain();
+	AP_DBF(DBF_DEBUG, "%s running\n", __func__);
 	/* loop over all possible adapters */
 	for (id = 0; id < AP_DEVICES; id++)
 		_ap_scan_bus_adapter(id);
  */
 static int __init ap_module_init(void)
 {
-	int max_domain_id;
 	int rc, i;
 	rc = ap_debug_init();
 	ap_perms_init();
 	/* Get AP configuration data if available */
-	ap_init_configuration();
+	ap_init_qci_info();
-	if (ap_configuration)
+	/* check default domain setting */
-		max_domain_id =
+	if (ap_domain_index < -1 || ap_domain_index > ap_max_domain_id ||
-			ap_max_domain_id ? ap_max_domain_id : AP_DOMAINS - 1;
-	else
-		max_domain_id = 15;
-	if (ap_domain_index < -1 || ap_domain_index > max_domain_id ||
 	    (ap_domain_index >= 0 &&
 	     !test_bit_inv(ap_domain_index, ap_perms.aqm))) {
 		pr_warn("%d is not a valid cryptographic domain\n",
 		ap_domain_index = -1;
 	}
+	/* enable interrupts if available */
 	if (ap_interrupts_available()) {
 		rc = register_adapter_interrupt(&ap_airq);
 		ap_airq_flag = (rc == 0);
 	}
 	queue_work(system_long_wq, &ap_scan_work);
-	initialised = true;
 	return 0;
 out:
 	if (ap_using_interrupts())
 		unregister_adapter_interrupt(&ap_airq);
-	kfree(ap_configuration);
+	kfree(ap_qci_info);
 	return rc;
 }
 device_initcall(ap_module_init);

drivers/s390/crypto/ap_bus.h+35−34

@@ -83,39 +83,39 @@ static inline int ap_test_bit(unsigned int *ptr, unsigned int nr) · 82 unmodified lines
83	#define AP_INTR_ENABLED 1 /* AP interrupt enabled */	83	#define AP_INTR_ENABLED 1 /* AP interrupt enabled */
84		84
85	/*	85	/*
86	* AP device states	86	* AP queue state machine states
87	*/	87	*/
88	enum ap_state {	88	enum ap_sm_state {
89	AP_STATE_RESET_START,	89	AP_SM_STATE_RESET_START,
90	AP_STATE_RESET_WAIT,	90	AP_SM_STATE_RESET_WAIT,
91	AP_STATE_SETIRQ_WAIT,	91	AP_SM_STATE_SETIRQ_WAIT,
92	AP_STATE_IDLE,	92	AP_SM_STATE_IDLE,
93	AP_STATE_WORKING,	93	AP_SM_STATE_WORKING,
94	AP_STATE_QUEUE_FULL,	94	AP_SM_STATE_QUEUE_FULL,
95	AP_STATE_REMOVE, /* about to be removed from driver */	95	AP_SM_STATE_REMOVE, /* about to be removed from driver */
96	AP_STATE_UNBOUND, /* momentary not bound to a driver */	96	AP_SM_STATE_UNBOUND, /* momentary not bound to a driver */
97	AP_STATE_BORKED, /* broken */	97	AP_SM_STATE_BORKED, /* broken */
98	NR_AP_STATES	98	NR_AP_SM_STATES
99	};	99	};
100		100
101	/*	101	/*
102	* AP device events	102	* AP queue state machine events
103	*/	103	*/
104	enum ap_event {	104	enum ap_sm_event {
105	AP_EVENT_POLL,	105	AP_SM_EVENT_POLL,
106	AP_EVENT_TIMEOUT,	106	AP_SM_EVENT_TIMEOUT,
107	NR_AP_EVENTS	107	NR_AP_SM_EVENTS
108	};	108	};
109		109
110	/*	110	/*
111	* AP wait behaviour	111	* AP queue state wait behaviour
112	*/	112	*/
113	enum ap_wait {	113	enum ap_sm_wait {
114	AP_WAIT_AGAIN, /* retry immediately */	114	AP_SM_WAIT_AGAIN, /* retry immediately */
115	AP_WAIT_TIMEOUT, /* wait for timeout */	115	AP_SM_WAIT_TIMEOUT, /* wait for timeout */
116	AP_WAIT_INTERRUPT, /* wait for thin interrupt (if available) */	116	AP_SM_WAIT_INTERRUPT, /* wait for thin interrupt (if available) */
117	AP_WAIT_NONE, /* no wait */	117	AP_SM_WAIT_NONE, /* no wait */
118	NR_AP_WAIT	118	NR_AP_SM_WAIT
119	};	119	};
120		120
121	struct ap_device;	121	struct ap_device;
@@ -172,7 +172,7 @@ struct ap_queue { · 50 unmodified lines
172	ap_qid_t qid; /* AP queue id. */	172	ap_qid_t qid; /* AP queue id. */
173	int interrupt; /* indicate if interrupts are enabled */	173	int interrupt; /* indicate if interrupts are enabled */
174	int queue_count; /* # messages currently on AP queue. */	174	int queue_count; /* # messages currently on AP queue. */
175	enum ap_state state; /* State of the AP device. */	175	enum ap_sm_state sm_state; /* ap queue state machine state */
176	int pendingq_count; /* # requests on pendingq list. */	176	int pendingq_count; /* # requests on pendingq list. */
177	int requestq_count; /* # requests on requestq list. */	177	int requestq_count; /* # requests on requestq list. */
178	u64 total_request_count; /* # requests ever for this AP device.*/	178	u64 total_request_count; /* # requests ever for this AP device.*/
@@ -185,22 +185,23 @@ struct ap_queue { · 6 unmodified lines
185		185
186	#define to_ap_queue(x) container_of((x), struct ap_queue, ap_dev.device)	186	#define to_ap_queue(x) container_of((x), struct ap_queue, ap_dev.device)
187		187
188	typedef enum ap_wait (ap_func_t)(struct ap_queue *queue);	188	typedef enum ap_sm_wait (ap_func_t)(struct ap_queue *queue);
189		189
190	struct ap_message {	190	struct ap_message {
191	struct list_head list; /* Request queueing. */	191	struct list_head list; /* Request queueing. */
192	unsigned long long psmid; /* Message id. */	192	unsigned long long psmid; /* Message id. */
193	void message; / Pointer to message buffer. */	193	void msg; / Pointer to message buffer. */
194	size_t length; /* Message length. */	194	unsigned int len; /* Message length. */
		195	u32 flags; /* Flags, see AP_MSG_FLAG_xxx */
195	int rc; /* Return code for this message */	196	int rc; /* Return code for this message */
196
197	void private; / ap driver private pointer. */	197	void private; / ap driver private pointer. */
198	unsigned int special:1; /* Used for special commands. */
199	/* receive is called from tasklet context */	198	/* receive is called from tasklet context */
200	void (receive)(struct ap_queue , struct ap_message *,	199	void (receive)(struct ap_queue , struct ap_message *,
201	struct ap_message *);	200	struct ap_message *);
202	};	201	};
203		202
		203	#define AP_MSG_FLAG_SPECIAL (1 << 16) /* flag msg as 'special' with NQAP */
		204
204	/**	205	/**
205	* ap_init_message() - Initialize ap_message.	206	* ap_init_message() - Initialize ap_message.
206	* Initialize a message before using. Otherwise this might result in	207	* Initialize a message before using. Otherwise this might result in
@@ -218,7 +219,7 @@ static inline void ap_init_message(struct ap_message *ap_msg) · 11 unmodified lines
218	*/	219	*/
219	static inline void ap_release_message(struct ap_message *ap_msg)	220	static inline void ap_release_message(struct ap_message *ap_msg)
220	{	221	{
221	kzfree(ap_msg->message);	222	kzfree(ap_msg->msg);
222	kzfree(ap_msg->private);	223	kzfree(ap_msg->private);
223	}	224	}
224		225
@@ -230,15 +231,15 @@ static inline void ap_release_message(struct ap_message *ap_msg) · 5 unmodified lines
230	int ap_send(ap_qid_t, unsigned long long, void *, size_t);	231	int ap_send(ap_qid_t, unsigned long long, void *, size_t);
231	int ap_recv(ap_qid_t, unsigned long long , void , size_t);	232	int ap_recv(ap_qid_t, unsigned long long , void , size_t);
232		233
233	enum ap_wait ap_sm_event(struct ap_queue *aq, enum ap_event event);	234	enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event);
234	enum ap_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_event event);	235	enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event);
235		236
236	void ap_queue_message(struct ap_queue aq, struct ap_message ap_msg);	237	void ap_queue_message(struct ap_queue aq, struct ap_message ap_msg);
237	void ap_cancel_message(struct ap_queue aq, struct ap_message ap_msg);	238	void ap_cancel_message(struct ap_queue aq, struct ap_message ap_msg);
238	void ap_flush_queue(struct ap_queue *aq);	239	void ap_flush_queue(struct ap_queue *aq);
239		240
240	void *ap_airq_ptr(void);	241	void *ap_airq_ptr(void);
241	void ap_wait(enum ap_wait wait);	242	void ap_wait(enum ap_sm_wait wait);
242	void ap_request_timeout(struct timer_list *t);	243	void ap_request_timeout(struct timer_list *t);
243	void ap_bus_force_rescan(void);	244	void ap_bus_force_rescan(void);
244		245

drivers/s390/crypto/ap_queue.c+105−104

  */
 static inline struct ap_queue_status
 __ap_send(ap_qid_t qid, unsigned long long psmid, void *msg, size_t length,
-	  unsigned int special)
+	  int special)
 {
-	if (special == 1)
+	if (special)
 		qid |= 0x400000UL;
 	return ap_nqap(qid, psmid, msg, length);
 }
 /* State machine definitions and helpers */
-static enum ap_wait ap_sm_nop(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_nop(struct ap_queue *aq)
 {
-	return AP_WAIT_NONE;
+	return AP_SM_WAIT_NONE;
 }
 /**
  *	not change the state of the device.
  * @aq: pointer to the AP queue
  *
- * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT
+ * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
  */
 static struct ap_queue_status ap_sm_recv(struct ap_queue *aq)
 {
 	struct ap_message *ap_msg;
 	status = ap_dqap(aq->qid, &aq->reply->psmid,
-			 aq->reply->message, aq->reply->length);
+			 aq->reply->msg, aq->reply->len);
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
 		aq->queue_count--;
  * ap_sm_read(): Receive pending reply messages from an AP queue.
  * @aq: pointer to the AP queue
  *
- * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT
+ * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
  */
-static enum ap_wait ap_sm_read(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_read(struct ap_queue *aq)
 {
 	struct ap_queue_status status;
 	if (!aq->reply)
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	status = ap_sm_recv(aq);
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
 		if (aq->queue_count > 0) {
-			aq->state = AP_STATE_WORKING;
+			aq->sm_state = AP_SM_STATE_WORKING;
-			return AP_WAIT_AGAIN;
+			return AP_SM_WAIT_AGAIN;
 		}
-		aq->state = AP_STATE_IDLE;
+		aq->sm_state = AP_SM_STATE_IDLE;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	case AP_RESPONSE_NO_PENDING_REPLY:
 		if (aq->queue_count > 0)
-			return AP_WAIT_INTERRUPT;
+			return AP_SM_WAIT_INTERRUPT;
-		aq->state = AP_STATE_IDLE;
+		aq->sm_state = AP_SM_STATE_IDLE;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	default:
-		aq->state = AP_STATE_BORKED;
+		aq->sm_state = AP_SM_STATE_BORKED;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	}
 }
  * ap_sm_write(): Send messages from the request queue to an AP queue.
  * @aq: pointer to the AP queue
  *
- * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT
+ * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
  */
-static enum ap_wait ap_sm_write(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_write(struct ap_queue *aq)
 {
 	struct ap_queue_status status;
 	struct ap_message *ap_msg;
 	if (aq->requestq_count <= 0)
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	/* Start the next request on the queue. */
 	ap_msg = list_entry(aq->requestq.next, struct ap_message, list);
 	status = __ap_send(aq->qid, ap_msg->psmid,
-			   ap_msg->message, ap_msg->length, ap_msg->special);
+			   ap_msg->msg, ap_msg->len,
+			   ap_msg->flags & AP_MSG_FLAG_SPECIAL);
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
 		aq->queue_count++;
 		aq->requestq_count--;
 		aq->pendingq_count++;
 		if (aq->queue_count < aq->card->queue_depth) {
-			aq->state = AP_STATE_WORKING;
+			aq->sm_state = AP_SM_STATE_WORKING;
-			return AP_WAIT_AGAIN;
+			return AP_SM_WAIT_AGAIN;
 		}
 		fallthrough;
 	case AP_RESPONSE_Q_FULL:
-		aq->state = AP_STATE_QUEUE_FULL;
+		aq->sm_state = AP_SM_STATE_QUEUE_FULL;
-		return AP_WAIT_INTERRUPT;
+		return AP_SM_WAIT_INTERRUPT;
 	case AP_RESPONSE_RESET_IN_PROGRESS:
-		aq->state = AP_STATE_RESET_WAIT;
+		aq->sm_state = AP_SM_STATE_RESET_WAIT;
-		return AP_WAIT_TIMEOUT;
+		return AP_SM_WAIT_TIMEOUT;
 	case AP_RESPONSE_MESSAGE_TOO_BIG:
 	case AP_RESPONSE_REQ_FAC_NOT_INST:
 		list_del_init(&ap_msg->list);
 		aq->requestq_count--;
 		ap_msg->rc = -EINVAL;
 		ap_msg->receive(aq, ap_msg, NULL);
-		return AP_WAIT_AGAIN;
+		return AP_SM_WAIT_AGAIN;
 	default:
-		aq->state = AP_STATE_BORKED;
+		aq->sm_state = AP_SM_STATE_BORKED;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	}
 }
  * ap_sm_read_write(): Send and receive messages to/from an AP queue.
  * @aq: pointer to the AP queue
  *
- * Returns AP_WAIT_NONE, AP_WAIT_AGAIN, or AP_WAIT_INTERRUPT
+ * Returns AP_SM_WAIT_NONE, AP_SM_WAIT_AGAIN, or AP_SM_WAIT_INTERRUPT
  */
-static enum ap_wait ap_sm_read_write(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_read_write(struct ap_queue *aq)
 {
 	return min(ap_sm_read(aq), ap_sm_write(aq));
 }
  *
  * Submit the Reset command to an AP queue.
  */
-static enum ap_wait ap_sm_reset(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_reset(struct ap_queue *aq)
 {
 	struct ap_queue_status status;
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
 	case AP_RESPONSE_RESET_IN_PROGRESS:
-		aq->state = AP_STATE_RESET_WAIT;
+		aq->sm_state = AP_SM_STATE_RESET_WAIT;
 		aq->interrupt = AP_INTR_DISABLED;
-		return AP_WAIT_TIMEOUT;
+		return AP_SM_WAIT_TIMEOUT;
 	case AP_RESPONSE_BUSY:
-		return AP_WAIT_TIMEOUT;
+		return AP_SM_WAIT_TIMEOUT;
 	case AP_RESPONSE_Q_NOT_AVAIL:
 	case AP_RESPONSE_DECONFIGURED:
 	case AP_RESPONSE_CHECKSTOPPED:
 	default:
-		aq->state = AP_STATE_BORKED;
+		aq->sm_state = AP_SM_STATE_BORKED;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	}
 }
  *
  * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0.
  */
-static enum ap_wait ap_sm_reset_wait(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_reset_wait(struct ap_queue *aq)
 {
 	struct ap_queue_status status;
 	void *lsi_ptr;
 	case AP_RESPONSE_NORMAL:
 		lsi_ptr = ap_airq_ptr();
 		if (lsi_ptr && ap_queue_enable_interruption(aq, lsi_ptr) == 0)
-			aq->state = AP_STATE_SETIRQ_WAIT;
+			aq->sm_state = AP_SM_STATE_SETIRQ_WAIT;
 		else
-			aq->state = (aq->queue_count > 0) ?
+			aq->sm_state = (aq->queue_count > 0) ?
-				AP_STATE_WORKING : AP_STATE_IDLE;
+				AP_SM_STATE_WORKING : AP_SM_STATE_IDLE;
-		return AP_WAIT_AGAIN;
+		return AP_SM_WAIT_AGAIN;
 	case AP_RESPONSE_BUSY:
 	case AP_RESPONSE_RESET_IN_PROGRESS:
-		return AP_WAIT_TIMEOUT;
+		return AP_SM_WAIT_TIMEOUT;
 	case AP_RESPONSE_Q_NOT_AVAIL:
 	case AP_RESPONSE_DECONFIGURED:
 	case AP_RESPONSE_CHECKSTOPPED:
 	default:
-		aq->state = AP_STATE_BORKED;
+		aq->sm_state = AP_SM_STATE_BORKED;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	}
 }
  *
  * Returns AP_POLL_IMMEDIATELY, AP_POLL_AFTER_TIMEROUT or 0.
  */
-static enum ap_wait ap_sm_setirq_wait(struct ap_queue *aq)
+static enum ap_sm_wait ap_sm_setirq_wait(struct ap_queue *aq)
 {
 	struct ap_queue_status status;
 	if (status.irq_enabled == 1) {
 		/* Irqs are now enabled */
 		aq->interrupt = AP_INTR_ENABLED;
-		aq->state = (aq->queue_count > 0) ?
+		aq->sm_state = (aq->queue_count > 0) ?
-			AP_STATE_WORKING : AP_STATE_IDLE;
+			AP_SM_STATE_WORKING : AP_SM_STATE_IDLE;
 	}
 	switch (status.response_code) {
 	case AP_RESPONSE_NORMAL:
 		if (aq->queue_count > 0)
-			return AP_WAIT_AGAIN;
+			return AP_SM_WAIT_AGAIN;
 		fallthrough;
 	case AP_RESPONSE_NO_PENDING_REPLY:
-		return AP_WAIT_TIMEOUT;
+		return AP_SM_WAIT_TIMEOUT;
 	default:
-		aq->state = AP_STATE_BORKED;
+		aq->sm_state = AP_SM_STATE_BORKED;
-		return AP_WAIT_NONE;
+		return AP_SM_WAIT_NONE;
 	}
 }
 /*
  * AP state machine jump table
  */
-static ap_func_t *ap_jumptable[NR_AP_STATES][NR_AP_EVENTS] = {
+static ap_func_t *ap_jumptable[NR_AP_SM_STATES][NR_AP_SM_EVENTS] = {
-	[AP_STATE_RESET_START] = {
+	[AP_SM_STATE_RESET_START] = {
-		[AP_EVENT_POLL] = ap_sm_reset,
+		[AP_SM_EVENT_POLL] = ap_sm_reset,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_RESET_WAIT] = {
+	[AP_SM_STATE_RESET_WAIT] = {
-		[AP_EVENT_POLL] = ap_sm_reset_wait,
+		[AP_SM_EVENT_POLL] = ap_sm_reset_wait,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_SETIRQ_WAIT] = {
+	[AP_SM_STATE_SETIRQ_WAIT] = {
-		[AP_EVENT_POLL] = ap_sm_setirq_wait,
+		[AP_SM_EVENT_POLL] = ap_sm_setirq_wait,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_IDLE] = {
+	[AP_SM_STATE_IDLE] = {
-		[AP_EVENT_POLL] = ap_sm_write,
+		[AP_SM_EVENT_POLL] = ap_sm_write,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_WORKING] = {
+	[AP_SM_STATE_WORKING] = {
-		[AP_EVENT_POLL] = ap_sm_read_write,
+		[AP_SM_EVENT_POLL] = ap_sm_read_write,
-		[AP_EVENT_TIMEOUT] = ap_sm_reset,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_reset,
 	},
-	[AP_STATE_QUEUE_FULL] = {
+	[AP_SM_STATE_QUEUE_FULL] = {
-		[AP_EVENT_POLL] = ap_sm_read,
+		[AP_SM_EVENT_POLL] = ap_sm_read,
-		[AP_EVENT_TIMEOUT] = ap_sm_reset,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_reset,
 	},
-	[AP_STATE_REMOVE] = {
+	[AP_SM_STATE_REMOVE] = {
-		[AP_EVENT_POLL] = ap_sm_nop,
+		[AP_SM_EVENT_POLL] = ap_sm_nop,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_UNBOUND] = {
+	[AP_SM_STATE_UNBOUND] = {
-		[AP_EVENT_POLL] = ap_sm_nop,
+		[AP_SM_EVENT_POLL] = ap_sm_nop,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
-	[AP_STATE_BORKED] = {
+	[AP_SM_STATE_BORKED] = {
-		[AP_EVENT_POLL] = ap_sm_nop,
+		[AP_SM_EVENT_POLL] = ap_sm_nop,
-		[AP_EVENT_TIMEOUT] = ap_sm_nop,
+		[AP_SM_EVENT_TIMEOUT] = ap_sm_nop,
 	},
 };
-enum ap_wait ap_sm_event(struct ap_queue *aq, enum ap_event event)
+enum ap_sm_wait ap_sm_event(struct ap_queue *aq, enum ap_sm_event event)
 {
-	return ap_jumptable[aq->state][event](aq);
+	return ap_jumptable[aq->sm_state][event](aq);
 }
-enum ap_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_event event)
+enum ap_sm_wait ap_sm_event_loop(struct ap_queue *aq, enum ap_sm_event event)
 {
-	enum ap_wait wait;
+	enum ap_sm_wait wait;
-	while ((wait = ap_sm_event(aq, event)) == AP_WAIT_AGAIN)
+	while ((wait = ap_sm_event(aq, event)) == AP_SM_WAIT_AGAIN)
 		;
 	return wait;
 }
 	int rc = 0;
 	spin_lock_bh(&aq->lock);
-	switch (aq->state) {
+	switch (aq->sm_state) {
-	case AP_STATE_RESET_START:
+	case AP_SM_STATE_RESET_START:
-	case AP_STATE_RESET_WAIT:
+	case AP_SM_STATE_RESET_WAIT:
 		rc = scnprintf(buf, PAGE_SIZE, "Reset in progress.\n");
 		break;
-	case AP_STATE_WORKING:
+	case AP_SM_STATE_WORKING:
-	case AP_STATE_QUEUE_FULL:
+	case AP_SM_STATE_QUEUE_FULL:
 		rc = scnprintf(buf, PAGE_SIZE, "Reset Timer armed.\n");
 		break;
 	default:
 	spin_lock_bh(&aq->lock);
 	__ap_flush_queue(aq);
-	aq->state = AP_STATE_RESET_START;
+	aq->sm_state = AP_SM_STATE_RESET_START;
-	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));
+	ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
 	spin_unlock_bh(&aq->lock);
 	AP_DBF(DBF_INFO, "reset queue=%02x.%04x triggered by user\n",
 	int rc = 0;
 	spin_lock_bh(&aq->lock);
-	if (aq->state == AP_STATE_SETIRQ_WAIT)
+	if (aq->sm_state == AP_SM_STATE_SETIRQ_WAIT)
 		rc = scnprintf(buf, PAGE_SIZE, "Enable Interrupt pending.\n");
 	else if (aq->interrupt == AP_INTR_ENABLED)
 		rc = scnprintf(buf, PAGE_SIZE, "Interrupts enabled.\n");
 	aq->ap_dev.device.type = &ap_queue_type;
 	aq->ap_dev.device_type = device_type;
 	aq->qid = qid;
-	aq->state = AP_STATE_UNBOUND;
+	aq->sm_state = AP_SM_STATE_UNBOUND;
 	aq->interrupt = AP_INTR_DISABLED;
 	spin_lock_init(&aq->lock);
 	INIT_LIST_HEAD(&aq->pendingq);
 	aq->reply = reply;
 	spin_lock_bh(&aq->lock);
-	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));
+	ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
 	spin_unlock_bh(&aq->lock);
 }
 EXPORT_SYMBOL(ap_queue_init_reply);
 	aq->total_request_count++;
 	atomic64_inc(&aq->card->total_request_count);
 	/* Send/receive as many request from the queue as possible. */
-	ap_wait(ap_sm_event_loop(aq, AP_EVENT_POLL));
+	ap_wait(ap_sm_event_loop(aq, AP_SM_EVENT_POLL));
 	spin_unlock_bh(&aq->lock);
 }
 EXPORT_SYMBOL(ap_queue_message);
 	/* flush queue */
 	__ap_flush_queue(aq);
 	/* set REMOVE state to prevent new messages are queued in */
-	aq->state = AP_STATE_REMOVE;
+	aq->sm_state = AP_SM_STATE_REMOVE;
 	spin_unlock_bh(&aq->lock);
 	del_timer_sync(&aq->timeout);
 }
 {
 	/*
 	 * all messages have been flushed and the state is
-	 * AP_STATE_REMOVE. Now reset with zero which also
+	 * AP_SM_STATE_REMOVE. Now reset with zero which also
 	 * clears the irq registration and move the state
-	 * to AP_STATE_UNBOUND to signal that this queue
+	 * to AP_SM_STATE_UNBOUND to signal that this queue
 	 * is not used by any driver currently.
 	 */
 	spin_lock_bh(&aq->lock);
 	ap_zapq(aq->qid);
-	aq->state = AP_STATE_UNBOUND;
+	aq->sm_state = AP_SM_STATE_UNBOUND;
 	spin_unlock_bh(&aq->lock);
 }
 void ap_queue_init_state(struct ap_queue *aq)
 {
 	spin_lock_bh(&aq->lock);
-	aq->state = AP_STATE_RESET_START;
+	aq->sm_state = AP_SM_STATE_RESET_START;
-	ap_wait(ap_sm_event(aq, AP_EVENT_POLL));
+	ap_wait(ap_sm_event(aq, AP_SM_EVENT_POLL));
 	spin_unlock_bh(&aq->lock);
 }
 EXPORT_SYMBOL(ap_queue_init_state);

drivers/s390/crypto/pkey_api.c+2−2

@@ -1603,8 +1603,8 @@ static ssize_t pkey_ccacipher_aes_attr_read(enum pkey_key_size keybits, · 1602 unmodified lines
1603	if (rc == 0)	1603	if (rc == 0)
1604	break;	1604	break;
1605	}	1605	}
1606	if (rc)	1606	if (rc)
1607	return rc;	1607	return rc;
1608		1608
1609	if (is_xts) {	1609	if (is_xts) {
1610	keysize = CCACIPHERTOKENSIZE;	1610	keysize = CCACIPHERTOKENSIZE;

drivers/s390/crypto/zcrypt_api.c+98−78

@@ -634,7 +634,7 @@ static long zcrypt_rsa_modexpo(struct ap_perms *perms, · 633 unmodified lines
634	{	634	{
635	struct zcrypt_card zc, pref_zc;	635	struct zcrypt_card zc, pref_zc;
636	struct zcrypt_queue zq, pref_zq;	636	struct zcrypt_queue zq, pref_zq;
637	unsigned int weight, pref_weight;	637	unsigned int weight = 0, pref_weight = 0;
638	unsigned int func_code;	638	unsigned int func_code;
639	int qid = 0, rc = -ENODEV;	639	int qid = 0, rc = -ENODEV;
640	struct module *mod;	640	struct module *mod;
@@ -718,7 +718,7 @@ static long zcrypt_rsa_crt(struct ap_perms *perms, · 77 unmodified lines
718	{	718	{
719	struct zcrypt_card zc, pref_zc;	719	struct zcrypt_card zc, pref_zc;
720	struct zcrypt_queue zq, pref_zq;	720	struct zcrypt_queue zq, pref_zq;
721	unsigned int weight, pref_weight;	721	unsigned int weight = 0, pref_weight = 0;
722	unsigned int func_code;	722	unsigned int func_code;
723	int qid = 0, rc = -ENODEV;	723	int qid = 0, rc = -ENODEV;
724	struct module *mod;	724	struct module *mod;
@@ -803,7 +803,7 @@ static long _zcrypt_send_cprb(struct ap_perms *perms, · 78 unmodified lines
803	struct zcrypt_card zc, pref_zc;	803	struct zcrypt_card zc, pref_zc;
804	struct zcrypt_queue zq, pref_zq;	804	struct zcrypt_queue zq, pref_zq;
805	struct ap_message ap_msg;	805	struct ap_message ap_msg;
806	unsigned int weight, pref_weight;	806	unsigned int weight = 0, pref_weight = 0;
807	unsigned int func_code;	807	unsigned int func_code;
808	unsigned short *domain, tdom;	808	unsigned short *domain, tdom;
809	int qid = 0, rc = -ENODEV;	809	int qid = 0, rc = -ENODEV;
@@ -822,7 +822,7 @@ static long _zcrypt_send_cprb(struct ap_perms *perms, · 12 unmodified lines
822	* domain but a control only domain, use the default domain as target.	822	* domain but a control only domain, use the default domain as target.
823	*/	823	*/
824	tdom = *domain;	824	tdom = *domain;
825	if (tdom >= 0 && tdom < AP_DOMAINS &&	825	if (tdom < AP_DOMAINS &&
826	!ap_test_config_usage_domain(tdom) &&	826	!ap_test_config_usage_domain(tdom) &&
827	ap_test_config_ctrl_domain(tdom) &&	827	ap_test_config_ctrl_domain(tdom) &&
828	ap_domain_index >= 0)	828	ap_domain_index >= 0)
@@ -931,7 +931,7 @@ static long _zcrypt_send_ep11_cprb(struct ap_perms *perms, · 102 unmodified lines
931	struct zcrypt_queue zq, pref_zq;	931	struct zcrypt_queue zq, pref_zq;
932	struct ep11_target_dev *targets;	932	struct ep11_target_dev *targets;
933	unsigned short target_num;	933	unsigned short target_num;
934	unsigned int weight, pref_weight;	934	unsigned int weight = 0, pref_weight = 0;
935	unsigned int func_code;	935	unsigned int func_code;
936	struct ap_message ap_msg;	936	struct ap_message ap_msg;
937	int qid = 0, rc = -ENODEV;	937	int qid = 0, rc = -ENODEV;
@@ -1040,7 +1040,7 @@ static long zcrypt_rng(char *buffer) · 102 unmodified lines
1040	{	1040	{
1041	struct zcrypt_card zc, pref_zc;	1041	struct zcrypt_card zc, pref_zc;
1042	struct zcrypt_queue zq, pref_zq;	1042	struct zcrypt_queue zq, pref_zq;
1043	unsigned int weight, pref_weight;	1043	unsigned int weight = 0, pref_weight = 0;
1044	unsigned int func_code;	1044	unsigned int func_code;
1045	struct ap_message ap_msg;	1045	struct ap_message ap_msg;
1046	unsigned int domain;	1046	unsigned int domain;
@@ -1298,99 +1298,119 @@ static int zcrypt_requestq_count(void) · 251 unmodified lines
1298	return requestq_count;	1298	return requestq_count;
1299	}	1299	}
1300		1300
1301	static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,	1301	static int icarsamodexpo_ioctl(struct ap_perms *perms, unsigned long arg)
1302	unsigned long arg)
1303	{	1302	{
1304	int rc;	1303	int rc;
1305	struct ap_perms *perms =	1304	struct ica_rsa_modexpo mex;
1306	(struct ap_perms *) filp->private_data;	1305	struct ica_rsa_modexpo __user umex = (void __user ) arg;
1307		1306
1308	rc = zcrypt_check_ioctl(perms, cmd);	1307	if (copy_from_user(&mex, umex, sizeof(mex)))
1309	if (rc)	1308	return -EFAULT;
1310	return rc;	1309	do {
1311		1310	rc = zcrypt_rsa_modexpo(perms, &mex);
1312	switch (cmd) {	1311	} while (rc == -EAGAIN);
1313	case ICARSAMODEXPO: {	1312	/* on failure: retry once again after a requested rescan */
1314	struct ica_rsa_modexpo __user umex = (void __user ) arg;	1313	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1315	struct ica_rsa_modexpo mex;
1316
1317	if (copy_from_user(&mex, umex, sizeof(mex)))
1318	return -EFAULT;
1319	do {	1314	do {
1320	rc = zcrypt_rsa_modexpo(perms, &mex);	1315	rc = zcrypt_rsa_modexpo(perms, &mex);
1321	} while (rc == -EAGAIN);	1316	} while (rc == -EAGAIN);
1322	/* on failure: retry once again after a requested rescan */	1317	if (rc) {
1323	if ((rc == -ENODEV) && (zcrypt_process_rescan()))	1318	ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSAMODEXPO rc=%d\n", rc);
1324	do {	1319	return rc;
1325	rc = zcrypt_rsa_modexpo(perms, &mex);
1326	} while (rc == -EAGAIN);
1327	if (rc) {
1328	ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSAMODEXPO rc=%d\n", rc);
1329	return rc;
1330	}
1331	return put_user(mex.outputdatalength, &umex->outputdatalength);
1332	}	1320	}
1333	case ICARSACRT: {	1321	return put_user(mex.outputdatalength, &umex->outputdatalength);
1334	struct ica_rsa_modexpo_crt __user ucrt = (void __user ) arg;	1322	}
1335	struct ica_rsa_modexpo_crt crt;
1336		1323
1337	if (copy_from_user(&crt, ucrt, sizeof(crt)))	1324	static int icarsacrt_ioctl(struct ap_perms *perms, unsigned long arg)
1338	return -EFAULT;	1325	{
		1326	int rc;
		1327	struct ica_rsa_modexpo_crt crt;
		1328	struct ica_rsa_modexpo_crt __user ucrt = (void __user ) arg;
		1329
		1330	if (copy_from_user(&crt, ucrt, sizeof(crt)))
		1331	return -EFAULT;
		1332	do {
		1333	rc = zcrypt_rsa_crt(perms, &crt);
		1334	} while (rc == -EAGAIN);
		1335	/* on failure: retry once again after a requested rescan */
		1336	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1339	do {	1337	do {
1340	rc = zcrypt_rsa_crt(perms, &crt);	1338	rc = zcrypt_rsa_crt(perms, &crt);
1341	} while (rc == -EAGAIN);	1339	} while (rc == -EAGAIN);
1342	/* on failure: retry once again after a requested rescan */	1340	if (rc) {
1343	if ((rc == -ENODEV) && (zcrypt_process_rescan()))	1341	ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSACRT rc=%d\n", rc);
1344	do {	1342	return rc;
1345	rc = zcrypt_rsa_crt(perms, &crt);
1346	} while (rc == -EAGAIN);
1347	if (rc) {
1348	ZCRYPT_DBF(DBF_DEBUG, "ioctl ICARSACRT rc=%d\n", rc);
1349	return rc;
1350	}
1351	return put_user(crt.outputdatalength, &ucrt->outputdatalength);
1352	}	1343	}
1353	case ZSECSENDCPRB: {	1344	return put_user(crt.outputdatalength, &ucrt->outputdatalength);
1354	struct ica_xcRB __user uxcRB = (void __user ) arg;	1345	}
1355	struct ica_xcRB xcRB;
1356		1346
1357	if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))	1347	static int zsecsendcprb_ioctl(struct ap_perms *perms, unsigned long arg)
1358	return -EFAULT;	1348	{
		1349	int rc;
		1350	struct ica_xcRB xcRB;
		1351	struct ica_xcRB __user uxcRB = (void __user ) arg;
		1352
		1353	if (copy_from_user(&xcRB, uxcRB, sizeof(xcRB)))
		1354	return -EFAULT;
		1355	do {
		1356	rc = _zcrypt_send_cprb(perms, &xcRB);
		1357	} while (rc == -EAGAIN);
		1358	/* on failure: retry once again after a requested rescan */
		1359	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1359	do {	1360	do {
1360	rc = _zcrypt_send_cprb(perms, &xcRB);	1361	rc = _zcrypt_send_cprb(perms, &xcRB);
1361	} while (rc == -EAGAIN);	1362	} while (rc == -EAGAIN);
1362	/* on failure: retry once again after a requested rescan */	1363	if (rc)
1363	if ((rc == -ENODEV) && (zcrypt_process_rescan()))	1364	ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDCPRB rc=%d status=0x%x\n",
1364	do {	1365	rc, xcRB.status);
1365	rc = _zcrypt_send_cprb(perms, &xcRB);	1366	if (copy_to_user(uxcRB, &xcRB, sizeof(xcRB)))
1366	} while (rc == -EAGAIN);	1367	return -EFAULT;
1367	if (rc)	1368	return rc;
1368	ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDCPRB rc=%d status=0x%x\n",	1369	}
1369	rc, xcRB.status);
1370	if (copy_to_user(uxcRB, &xcRB, sizeof(xcRB)))
1371	return -EFAULT;
1372	return rc;
1373	}
1374	case ZSENDEP11CPRB: {
1375	struct ep11_urb __user uxcrb = (void __user )arg;
1376	struct ep11_urb xcrb;
1377		1370
1378	if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb)))	1371	static int zsendep11cprb_ioctl(struct ap_perms *perms, unsigned long arg)
1379	return -EFAULT;	1372	{
		1373	int rc;
		1374	struct ep11_urb xcrb;
		1375	struct ep11_urb __user uxcrb = (void __user )arg;
		1376
		1377	if (copy_from_user(&xcrb, uxcrb, sizeof(xcrb)))
		1378	return -EFAULT;
		1379	do {
		1380	rc = _zcrypt_send_ep11_cprb(perms, &xcrb);
		1381	} while (rc == -EAGAIN);
		1382	/* on failure: retry once again after a requested rescan */
		1383	if ((rc == -ENODEV) && (zcrypt_process_rescan()))
1380	do {	1384	do {
1381	rc = _zcrypt_send_ep11_cprb(perms, &xcrb);	1385	rc = _zcrypt_send_ep11_cprb(perms, &xcrb);
1382	} while (rc == -EAGAIN);	1386	} while (rc == -EAGAIN);
1383	/* on failure: retry once again after a requested rescan */	1387	if (rc)
1384	if ((rc == -ENODEV) && (zcrypt_process_rescan()))	1388	ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDEP11CPRB rc=%d\n", rc);
1385	do {	1389	if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb)))
1386	rc = _zcrypt_send_ep11_cprb(perms, &xcrb);	1390	return -EFAULT;
1387	} while (rc == -EAGAIN);	1391	return rc;
1388	if (rc)	1392	}
1389	ZCRYPT_DBF(DBF_DEBUG, "ioctl ZSENDEP11CPRB rc=%d\n", rc);	1393
1390	if (copy_to_user(uxcrb, &xcrb, sizeof(xcrb)))	1394	static long zcrypt_unlocked_ioctl(struct file *filp, unsigned int cmd,
1391	return -EFAULT;	1395	unsigned long arg)
		1396	{
		1397	int rc;
		1398	struct ap_perms *perms =
		1399	(struct ap_perms *) filp->private_data;
		1400
		1401	rc = zcrypt_check_ioctl(perms, cmd);
		1402	if (rc)
1392	return rc;	1403	return rc;
1393	}	1404
		1405	switch (cmd) {
		1406	case ICARSAMODEXPO:
		1407	return icarsamodexpo_ioctl(perms, arg);
		1408	case ICARSACRT:
		1409	return icarsacrt_ioctl(perms, arg);
		1410	case ZSECSENDCPRB:
		1411	return zsecsendcprb_ioctl(perms, arg);
		1412	case ZSENDEP11CPRB:
		1413	return zsendep11cprb_ioctl(perms, arg);
1394	case ZCRYPT_DEVICE_STATUS: {	1414	case ZCRYPT_DEVICE_STATUS: {
1395	struct zcrypt_device_status_ext *device_status;	1415	struct zcrypt_device_status_ext *device_status;
1396	size_t total_size = MAX_ZDEV_ENTRIES_EXT	1416	size_t total_size = MAX_ZDEV_ENTRIES_EXT

drivers/s390/crypto/zcrypt_ccamisc.c+38−31

 	preqcblk->rpl_msgbl = cprbplusparamblen;
 	if (paramblen) {
 		preqcblk->req_parmb =
-			((u8 *) preqcblk) + sizeof(struct CPRBX);
+			((u8 __user *) preqcblk) + sizeof(struct CPRBX);
 		preqcblk->rpl_parmb =
-			((u8 *) prepcblk) + sizeof(struct CPRBX);
+			((u8 __user *) prepcblk) + sizeof(struct CPRBX);
 	}
 	*pcprbmem = cprbmem;
 {
 	int i, rc, keysize;
 	int seckeysize;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct kgreqparm {
 	preqcblk->domain = domain;
 	/* fill request cprb param block with KG request */
-	preqparm = (struct kgreqparm *) 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);
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr =  ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct kgrepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct kgrepparm *) ptr;
 	/* check length of the returned secure key token */
 	seckeysize = prepparm->lv3.keyblock.toklen
 		   const u8 *clrkey, u8 seckey[SECKEYBLOBSIZE])
 {
 	int rc, keysize, seckeysize;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct cmreqparm {
 	preqcblk->domain = domain;
 	/* fill request cprb param block with CM request */
-	preqparm = (struct cmreqparm *) 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 =
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct cmrepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct cmrepparm *) ptr;
 	/* check length of the returned secure key token */
 	seckeysize = prepparm->lv3.keyblock.toklen
 		    u8 *protkey, u32 *protkeylen, u32 *protkeytype)
 {
 	int rc;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct uskreqparm {
 	preqcblk->domain = domain;
 	/* fill request cprb param block with USK request */
-	preqparm = (struct uskreqparm *) 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);
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct uskrepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct uskrepparm *) ptr;
 	/* check the returned keyblock */
 	if (prepparm->lv3.ckb.version != 0x01 &&
 		     u8 *keybuf, size_t *keybufsize)
 {
 	int rc;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct gkreqparm {
 	preqcblk->req_parml = sizeof(struct gkreqparm);
 	/* prepare request param block with GK request */
-	preqparm = (struct gkreqparm *) 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);
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct gkrepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct gkrepparm *) ptr;
 	/* do some plausibility checks on the key block */
 	if (prepparm->kb.len < 120 + 5 * sizeof(uint16_t) ||
 			   int *key_token_size)
 {
 	int rc, n;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct rule_array_block {
 	preqcblk->req_parml = 0;
 	/* prepare request param block with IP request */
-	preq_ra_block = (struct rule_array_block *) 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);
 	}
 	/* prepare vud block */
-	preq_vud_block = (struct vud_block *)
+	preq_vud_block = (struct vud_block __force *)
 		(preqcblk->req_parmb + preqcblk->req_parml);
 	n = complete ? 0 : (clr_key_bit_size + 7) / 8;
 	preq_vud_block->len = sizeof(struct vud_block) + n;
 	preqcblk->req_parml += preq_vud_block->len;
 	/* prepare key block */
-	preq_key_block = (struct key_block *)
+	preq_key_block = (struct key_block __force *)
 		(preqcblk->req_parmb + preqcblk->req_parml);
 	n = *key_token_size;
 	preq_key_block->len = sizeof(struct key_block) + n;
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct iprepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct iprepparm *) ptr;
 	/* do some plausibility checks on the key block */
 	if (prepparm->kb.len < 120 + 3 * sizeof(uint16_t) ||
 		       u8 *protkey, u32 *protkeylen, u32 *protkeytype)
 {
 	int rc;
-	u8 *mem;
+	u8 *mem, *ptr;
 	struct CPRBX *preqcblk, *prepcblk;
 	struct ica_xcRB xcrb;
 	struct aureqparm {
 	preqcblk->domain = domain;
 	/* fill request cprb param block with AU request */
-	preqparm = (struct aureqparm *) 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)
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct aurepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct aurepparm *) ptr;
 	/* check the returned keyblock */
 	if (prepparm->vud.ckb.version != 0x01 &&
 	preqcblk->domain = domain;
 	/* fill request cprb param block with FQ request */
-	preqparm = (struct fqreqparm *) 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 =
 	}
 	/* process response cprb param block */
-	prepcblk->rpl_parmb = ((u8 *) prepcblk) + sizeof(struct CPRBX);
+	ptr = ((u8 *) prepcblk) + sizeof(struct CPRBX);
-	prepparm = (struct fqrepparm *) prepcblk->rpl_parmb;
+	prepcblk->rpl_parmb = (u8 __user *) ptr;
+	prepparm = (struct fqrepparm *) ptr;
 	ptr = prepparm->lvdata;
 	/* check and possibly copy reply rule array */

drivers/s390/crypto/zcrypt_cex2c.c+121−8

@@ -25,6 +25,7 @@ · 24 unmodified lines
25	#include "zcrypt_msgtype6.h"	25	#include "zcrypt_msgtype6.h"
26	#include "zcrypt_cex2c.h"	26	#include "zcrypt_cex2c.h"
27	#include "zcrypt_cca_key.h"	27	#include "zcrypt_cca_key.h"
		28	#include "zcrypt_ccamisc.h"
28		29
29	#define CEX2C_MIN_MOD_SIZE 16 /* 128 bits */	30	#define CEX2C_MIN_MOD_SIZE 16 /* 128 bits */
30	#define CEX2C_MAX_MOD_SIZE 256 /* 2048 bits */	31	#define CEX2C_MAX_MOD_SIZE 256 /* 2048 bits */
@@ -58,6 +59,91 @@ static struct ap_device_id zcrypt_cex2c_queue_ids[] = { · 27 unmodified lines
58		59
59	MODULE_DEVICE_TABLE(ap, zcrypt_cex2c_queue_ids);	60	MODULE_DEVICE_TABLE(ap, zcrypt_cex2c_queue_ids);
60		61
		62	/*
		63	* CCA card additional device attributes
		64	*/
		65	static ssize_t cca_serialnr_show(struct device *dev,
		66	struct device_attribute *attr,
		67	char *buf)
		68	{
		69	struct cca_info ci;
		70	struct ap_card *ac = to_ap_card(dev);
		71	struct zcrypt_card *zc = ac->private;
		72
		73	memset(&ci, 0, sizeof(ci));
		74
		75	if (ap_domain_index >= 0)
		76	cca_get_info(ac->id, ap_domain_index, &ci, zc->online);
		77
		78	return scnprintf(buf, PAGE_SIZE, "%s\n", ci.serial);
		79	}
		80
		81	static struct device_attribute dev_attr_cca_serialnr =
		82	__ATTR(serialnr, 0444, cca_serialnr_show, NULL);
		83
		84	static struct attribute *cca_card_attrs[] = {
		85	&dev_attr_cca_serialnr.attr,
		86	NULL,
		87	};
		88
		89	static const struct attribute_group cca_card_attr_grp = {
		90	.attrs = cca_card_attrs,
		91	};
		92
		93	/*
		94	* CCA queue additional device attributes
		95	*/
		96	static ssize_t cca_mkvps_show(struct device *dev,
		97	struct device_attribute *attr,
		98	char *buf)
		99	{
		100	int n = 0;
		101	struct cca_info ci;
		102	struct zcrypt_queue *zq = to_ap_queue(dev)->private;
		103	static const char * const cao_state[] = { "invalid", "valid" };
		104	static const char * const new_state[] = { "empty", "partial", "full" };
		105
		106	memset(&ci, 0, sizeof(ci));
		107
		108	cca_get_info(AP_QID_CARD(zq->queue->qid),
		109	AP_QID_QUEUE(zq->queue->qid),
		110	&ci, zq->online);
		111
		112	if (ci.new_mk_state >= '1' && ci.new_mk_state <= '3')
		113	n = scnprintf(buf, PAGE_SIZE, "AES NEW: %s 0x%016llx\n",
		114	new_state[ci.new_mk_state - '1'], ci.new_mkvp);
		115	else
		116	n = scnprintf(buf, PAGE_SIZE, "AES NEW: - -\n");
		117
		118	if (ci.cur_mk_state >= '1' && ci.cur_mk_state <= '2')
		119	n += scnprintf(buf + n, PAGE_SIZE - n,
		120	"AES CUR: %s 0x%016llx\n",
		121	cao_state[ci.cur_mk_state - '1'], ci.cur_mkvp);
		122	else
		123	n += scnprintf(buf + n, PAGE_SIZE - n, "AES CUR: - -\n");
		124
		125	if (ci.old_mk_state >= '1' && ci.old_mk_state <= '2')
		126	n += scnprintf(buf + n, PAGE_SIZE - n,
		127	"AES OLD: %s 0x%016llx\n",
		128	cao_state[ci.old_mk_state - '1'], ci.old_mkvp);
		129	else
		130	n += scnprintf(buf + n, PAGE_SIZE - n, "AES OLD: - -\n");
		131
		132	return n;
		133	}
		134
		135	static struct device_attribute dev_attr_cca_mkvps =
		136	__ATTR(mkvps, 0444, cca_mkvps_show, NULL);
		137
		138	static struct attribute *cca_queue_attrs[] = {
		139	&dev_attr_cca_mkvps.attr,
		140	NULL,
		141	};
		142
		143	static const struct attribute_group cca_queue_attr_grp = {
		144	.attrs = cca_queue_attrs,
		145	};
		146
61	/**	147	/**
62	* Large random number detection function. Its sends a message to a CEX2C/CEX3C	148	* Large random number detection function. Its sends a message to a CEX2C/CEX3C
63	* card to find out if large random numbers are supported.	149	* card to find out if large random numbers are supported.
@@ -87,24 +173,23 @@ static int zcrypt_cex2c_rng_supported(struct ap_queue *aq) · 23 unmodified lines
87	int rc, i;	173	int rc, i;
88		174
89	ap_init_message(&ap_msg);	175	ap_init_message(&ap_msg);
90	ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);	176	ap_msg.msg = (void *) get_zeroed_page(GFP_KERNEL);
91	if (!ap_msg.message)	177	if (!ap_msg.msg)
92	return -ENOMEM;	178	return -ENOMEM;
93		179
94	rng_type6CPRB_msgX(&ap_msg, 4, &domain);	180	rng_type6CPRB_msgX(&ap_msg, 4, &domain);
95		181
96	msg = ap_msg.message;	182	msg = ap_msg.msg;
97	msg->cprbx.domain = AP_QID_QUEUE(aq->qid);	183	msg->cprbx.domain = AP_QID_QUEUE(aq->qid);
98		184
99	rc = ap_send(aq->qid, 0x0102030405060708ULL, ap_msg.message,	185	rc = ap_send(aq->qid, 0x0102030405060708ULL, ap_msg.msg, ap_msg.len);
100	ap_msg.length);
101	if (rc)	186	if (rc)
102	goto out_free;	187	goto out_free;
103		188
104	/* Wait for the test message to complete. */	189	/* Wait for the test message to complete. */
105	for (i = 0; i < 2 * HZ; i++) {	190	for (i = 0; i < 2 * HZ; i++) {
106	msleep(1000 / HZ);	191	msleep(1000 / HZ);
107	rc = ap_recv(aq->qid, &psmid, ap_msg.message, 4096);	192	rc = ap_recv(aq->qid, &psmid, ap_msg.msg, 4096);
108	if (rc == 0 && psmid == 0x0102030405060708ULL)	193	if (rc == 0 && psmid == 0x0102030405060708ULL)
109	break;	194	break;
110	}	195	}
@@ -115,13 +200,13 @@ static int zcrypt_cex2c_rng_supported(struct ap_queue *aq) · 4 unmodified lines
115	goto out_free;	200	goto out_free;
116	}	201	}
117		202
118	reply = ap_msg.message;	203	reply = ap_msg.msg;
119	if (reply->cprbx.ccp_rtcode == 0 && reply->cprbx.ccp_rscode == 0)	204	if (reply->cprbx.ccp_rtcode == 0 && reply->cprbx.ccp_rscode == 0)
120	rc = 1;	205	rc = 1;
121	else	206	else
122	rc = 0;	207	rc = 0;
123	out_free:	208	out_free:
124	free_page((unsigned long) ap_msg.message);	209	free_page((unsigned long) ap_msg.msg);
125	return rc;	210	return rc;
126	}	211	}
127		212
@@ -179,6 +264,17 @@ static int zcrypt_cex2c_card_probe(struct ap_device *ap_dev) · 51 unmodified lines
179	if (rc) {	264	if (rc) {
180	ac->private = NULL;	265	ac->private = NULL;
181	zcrypt_card_free(zc);	266	zcrypt_card_free(zc);
		267	return rc;
		268	}
		269
		270	if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
		271	rc = sysfs_create_group(&ap_dev->device.kobj,
		272	&cca_card_attr_grp);
		273	if (rc) {
		274	zcrypt_card_unregister(zc);
		275	ac->private = NULL;
		276	zcrypt_card_free(zc);
		277	}
182	}	278	}
183		279
184	return rc;	280	return rc;
@@ -190,8 +286,11 @@ static int zcrypt_cex2c_card_probe(struct ap_device *ap_dev) · 5 unmodified lines
190	*/	286	*/
191	static void zcrypt_cex2c_card_remove(struct ap_device *ap_dev)	287	static void zcrypt_cex2c_card_remove(struct ap_device *ap_dev)
192	{	288	{
		289	struct ap_card *ac = to_ap_card(&ap_dev->device);
193	struct zcrypt_card *zc = to_ap_card(&ap_dev->device)->private;	290	struct zcrypt_card *zc = to_ap_card(&ap_dev->device)->private;
194		291
		292	if (ap_test_bit(&ac->functions, AP_FUNC_COPRO))
		293	sysfs_remove_group(&ap_dev->device.kobj, &cca_card_attr_grp);
195	if (zc)	294	if (zc)
196	zcrypt_card_unregister(zc);	295	zcrypt_card_unregister(zc);
197	}	296	}
@@ -240,7 +339,19 @@ static int zcrypt_cex2c_queue_probe(struct ap_device *ap_dev) · 42 unmodified lines
240	if (rc) {	339	if (rc) {
241	aq->private = NULL;	340	aq->private = NULL;
242	zcrypt_queue_free(zq);	341	zcrypt_queue_free(zq);
		342	return rc;
		343	}
		344
		345	if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
		346	rc = sysfs_create_group(&ap_dev->device.kobj,
		347	&cca_queue_attr_grp);
		348	if (rc) {
		349	zcrypt_queue_unregister(zq);
		350	aq->private = NULL;
		351	zcrypt_queue_free(zq);
		352	}
243	}	353	}
		354
244	return rc;	355	return rc;
245	}	356	}
246		357
@@ -253,6 +364,8 @@ static void zcrypt_cex2c_queue_remove(struct ap_device *ap_dev) · 6 unmodified lines
253	struct ap_queue *aq = to_ap_queue(&ap_dev->device);	364	struct ap_queue *aq = to_ap_queue(&ap_dev->device);
254	struct zcrypt_queue *zq = aq->private;	365	struct zcrypt_queue *zq = aq->private;
255		366
		367	if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO))
		368	sysfs_remove_group(&ap_dev->device.kobj, &cca_queue_attr_grp);
256	if (zq)	369	if (zq)
257	zcrypt_queue_unregister(zq);	370	zcrypt_queue_unregister(zq);
258	}	371	}

drivers/s390/crypto/zcrypt_cex4.c+20−10

 	ep11_get_card_info(ac->id, &ci, zc->online);
 	for (i = 0; ep11_op_modes[i].mode_txt; i++) {
-		if (ci.op_mode & (1 << ep11_op_modes[i].mode_bit)) {
+		if (ci.op_mode & (1ULL << ep11_op_modes[i].mode_bit)) {
 			if (n > 0)
 				buf[n++] = ' ';
 			n += scnprintf(buf + n, PAGE_SIZE - n,
 				     &di);
 	for (i = 0; ep11_op_modes[i].mode_txt; i++) {
-		if (di.op_mode & (1 << ep11_op_modes[i].mode_bit)) {
+		if (di.op_mode & (1ULL << ep11_op_modes[i].mode_bit)) {
 			if (n > 0)
 				buf[n++] = ' ';
 			n += scnprintf(buf + n, PAGE_SIZE - n,
 	if (rc) {
 		ac->private = NULL;
 		zcrypt_card_free(zc);
-		goto out;
+		return rc;
 	}
 	if (ap_test_bit(&ac->functions, AP_FUNC_COPRO)) {
 		rc = sysfs_create_group(&ap_dev->device.kobj,
 					&cca_card_attr_grp);
-		if (rc)
+		if (rc) {
 			zcrypt_card_unregister(zc);
+			ac->private = NULL;
+			zcrypt_card_free(zc);
+		}
 	} else if (ap_test_bit(&ac->functions, AP_FUNC_EP11)) {
 		rc = sysfs_create_group(&ap_dev->device.kobj,
 					&ep11_card_attr_grp);
-		if (rc)
+		if (rc) {
 			zcrypt_card_unregister(zc);
+			ac->private = NULL;
+			zcrypt_card_free(zc);
+		}
 	}
-out:
 	return rc;
 }
 	if (rc) {
 		aq->private = NULL;
 		zcrypt_queue_free(zq);
-		goto out;
+		return rc;
 	}
 	if (ap_test_bit(&aq->card->functions, AP_FUNC_COPRO)) {
 		rc = sysfs_create_group(&ap_dev->device.kobj,
 					&cca_queue_attr_grp);
-		if (rc)
+		if (rc) {
 			zcrypt_queue_unregister(zq);
+			aq->private = NULL;
+			zcrypt_queue_free(zq);
+		}
 	} else if (ap_test_bit(&aq->card->functions, AP_FUNC_EP11)) {
 		rc = sysfs_create_group(&ap_dev->device.kobj,
 					&ep11_queue_attr_grp);
-		if (rc)
+		if (rc) {
 			zcrypt_queue_unregister(zq);
+			aq->private = NULL;
+			zcrypt_queue_free(zq);
+		}
 	}
-out:
 	return rc;
 }

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

@@ -80,7 +80,7 @@ struct error_hdr { · 79 unmodified lines
80	static inline int convert_error(struct zcrypt_queue *zq,	80	static inline int convert_error(struct zcrypt_queue *zq,
81	struct ap_message *reply)	81	struct ap_message *reply)
82	{	82	{
83	struct error_hdr *ehdr = reply->message;	83	struct error_hdr *ehdr = reply->msg;
84	int card = AP_QID_CARD(zq->queue->qid);	84	int card = AP_QID_CARD(zq->queue->qid);
85	int queue = AP_QID_QUEUE(zq->queue->qid);	85	int queue = AP_QID_QUEUE(zq->queue->qid);
86		86
@@ -127,7 +127,7 @@ static inline int convert_error(struct zcrypt_queue *zq, · 40 unmodified lines
127	struct {	127	struct {
128	struct type86_hdr hdr;	128	struct type86_hdr hdr;
129	struct type86_fmt2_ext fmt2;	129	struct type86_fmt2_ext fmt2;
130	} __packed * head = reply->message;	130	} __packed * head = reply->msg;
131	unsigned int apfs = ((u32 )head->fmt2.apfs);	131	unsigned int apfs = ((u32 )head->fmt2.apfs);
132		132
133	ZCRYPT_DBF(DBF_ERR,	133	ZCRYPT_DBF(DBF_ERR,

drivers/s390/crypto/zcrypt_msgtype50.c+29−35

 	mod_len = mex->inputdatalength;
 	if (mod_len <= 128) {
-		struct type50_meb1_msg *meb1 = ap_msg->message;
+		struct type50_meb1_msg *meb1 = ap_msg->msg;
 		memset(meb1, 0, sizeof(*meb1));
-		ap_msg->length = sizeof(*meb1);
+		ap_msg->len = sizeof(*meb1);
 		meb1->header.msg_type_code = TYPE50_TYPE_CODE;
 		meb1->header.msg_len = sizeof(*meb1);
 		meb1->keyblock_type = TYPE50_MEB1_FMT;
 		exp = meb1->exponent + sizeof(meb1->exponent) - mod_len;
 		inp = meb1->message + sizeof(meb1->message) - mod_len;
 	} else if (mod_len <= 256) {
-		struct type50_meb2_msg *meb2 = ap_msg->message;
+		struct type50_meb2_msg *meb2 = ap_msg->msg;
 		memset(meb2, 0, sizeof(*meb2));
-		ap_msg->length = sizeof(*meb2);
+		ap_msg->len = sizeof(*meb2);
 		meb2->header.msg_type_code = TYPE50_TYPE_CODE;
 		meb2->header.msg_len = sizeof(*meb2);
 		meb2->keyblock_type = TYPE50_MEB2_FMT;
 		exp = meb2->exponent + sizeof(meb2->exponent) - mod_len;
 		inp = meb2->message + sizeof(meb2->message) - mod_len;
 	} else if (mod_len <= 512) {
-		struct type50_meb3_msg *meb3 = ap_msg->message;
+		struct type50_meb3_msg *meb3 = ap_msg->msg;
 		memset(meb3, 0, sizeof(*meb3));
-		ap_msg->length = sizeof(*meb3);
+		ap_msg->len = sizeof(*meb3);
 		meb3->header.msg_type_code = TYPE50_TYPE_CODE;
 		meb3->header.msg_len = sizeof(*meb3);
 		meb3->keyblock_type = TYPE50_MEB3_FMT;
 	 * 512 byte modulus (4k keys).
 	 */
 	if (mod_len <= 128) {		/* up to 1024 bit key size */
-		struct type50_crb1_msg *crb1 = ap_msg->message;
+		struct type50_crb1_msg *crb1 = ap_msg->msg;
 		memset(crb1, 0, sizeof(*crb1));
-		ap_msg->length = sizeof(*crb1);
+		ap_msg->len = sizeof(*crb1);
 		crb1->header.msg_type_code = TYPE50_TYPE_CODE;
 		crb1->header.msg_len = sizeof(*crb1);
 		crb1->keyblock_type = TYPE50_CRB1_FMT;
 		u = crb1->u + sizeof(crb1->u) - short_len;
 		inp = crb1->message + sizeof(crb1->message) - mod_len;
 	} else if (mod_len <= 256) {	/* up to 2048 bit key size */
-		struct type50_crb2_msg *crb2 = ap_msg->message;
+		struct type50_crb2_msg *crb2 = ap_msg->msg;
 		memset(crb2, 0, sizeof(*crb2));
-		ap_msg->length = sizeof(*crb2);
+		ap_msg->len = sizeof(*crb2);
 		crb2->header.msg_type_code = TYPE50_TYPE_CODE;
 		crb2->header.msg_len = sizeof(*crb2);
 		crb2->keyblock_type = TYPE50_CRB2_FMT;
 		inp = crb2->message + sizeof(crb2->message) - mod_len;
 	} else if ((mod_len <= 512) &&	/* up to 4096 bit key size */
 		   (zq->zcard->max_mod_size == CEX3A_MAX_MOD_SIZE)) {
-		struct type50_crb3_msg *crb3 = ap_msg->message;
+		struct type50_crb3_msg *crb3 = ap_msg->msg;
 		memset(crb3, 0, sizeof(*crb3));
-		ap_msg->length = sizeof(*crb3);
+		ap_msg->len = sizeof(*crb3);
 		crb3->header.msg_type_code = TYPE50_TYPE_CODE;
 		crb3->header.msg_len = sizeof(*crb3);
 		crb3->keyblock_type = TYPE50_CRB3_FMT;
 			  char __user *outputdata,
 			  unsigned int outputdatalength)
 {
-	struct type80_hdr *t80h = reply->message;
+	struct type80_hdr *t80h = reply->msg;
 	unsigned char *data;
 	if (t80h->len < sizeof(*t80h) + outputdatalength) {
 		BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
 	else
 		BUG_ON(t80h->len > CEX3A_MAX_RESPONSE_SIZE);
-	data = reply->message + t80h->len - outputdatalength;
+	data = reply->msg + t80h->len - outputdatalength;
 	if (copy_to_user(outputdata, data, outputdatalength))
 		return -EFAULT;
 	return 0;
 			    unsigned int outputdatalength)
 {
 	/* Response type byte is the second byte in the response. */
-	unsigned char rtype = ((unsigned char *) reply->message)[1];
+	unsigned char rtype = ((unsigned char *) reply->msg)[1];
 	switch (rtype) {
 	case TYPE82_RSP_CODE:
 		.reply_code = REP82_ERROR_MACHINE_FAILURE,
 	};
 	struct type80_hdr *t80h;
-	int length;
+	int len;
 	/* Copy the reply message to the request message buffer. */
 	if (!reply)
 		goto out;	/* ap_msg->rc indicates the error */
-	t80h = reply->message;
+	t80h = reply->msg;
 	if (t80h->type == TYPE80_RSP_CODE) {
 		if (aq->ap_dev.device_type == AP_DEVICE_TYPE_CEX2A)
-			length = min_t(int,
+			len = min_t(int, CEX2A_MAX_RESPONSE_SIZE, t80h->len);
-				       CEX2A_MAX_RESPONSE_SIZE, t80h->len);
 		else
-			length = min_t(int,
+			len = min_t(int, CEX3A_MAX_RESPONSE_SIZE, t80h->len);
-				       CEX3A_MAX_RESPONSE_SIZE, t80h->len);
+		memcpy(msg->msg, reply->msg, len);
-		memcpy(msg->message, reply->message, length);
 	} else
-		memcpy(msg->message, reply->message, sizeof(error_reply));
+		memcpy(msg->msg, reply->msg, sizeof(error_reply));
 out:
 	complete((struct completion *) msg->private);
 }
 	ap_init_message(&ap_msg);
 	if (zq->zcard->user_space_type == ZCRYPT_CEX2A)
-		ap_msg.message = kmalloc(MSGTYPE50_CRB2_MAX_MSG_SIZE,
+		ap_msg.msg = kmalloc(MSGTYPE50_CRB2_MAX_MSG_SIZE, GFP_KERNEL);
-					 GFP_KERNEL);
 	else
-		ap_msg.message = kmalloc(MSGTYPE50_CRB3_MAX_MSG_SIZE,
+		ap_msg.msg = kmalloc(MSGTYPE50_CRB3_MAX_MSG_SIZE, GFP_KERNEL);
-					 GFP_KERNEL);
+	if (!ap_msg.msg)
-	if (!ap_msg.message)
 		return -ENOMEM;
 	ap_msg.receive = zcrypt_cex2a_receive;
 	ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, &ap_msg);
 out_free:
-	kfree(ap_msg.message);
+	kfree(ap_msg.msg);
 	return rc;
 }
 	ap_init_message(&ap_msg);
 	if (zq->zcard->user_space_type == ZCRYPT_CEX2A)
-		ap_msg.message = kmalloc(MSGTYPE50_CRB2_MAX_MSG_SIZE,
+		ap_msg.msg = kmalloc(MSGTYPE50_CRB2_MAX_MSG_SIZE, GFP_KERNEL);
-					 GFP_KERNEL);
 	else
-		ap_msg.message = kmalloc(MSGTYPE50_CRB3_MAX_MSG_SIZE,
+		ap_msg.msg = kmalloc(MSGTYPE50_CRB3_MAX_MSG_SIZE, GFP_KERNEL);
-					 GFP_KERNEL);
+	if (!ap_msg.msg)
-	if (!ap_msg.message)
 		return -ENOMEM;
 	ap_msg.receive = zcrypt_cex2a_receive;
 	ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, &ap_msg);
 out_free:
-	kfree(ap_msg.message);
+	kfree(ap_msg.msg);
 	return rc;
 }

drivers/s390/crypto/zcrypt_msgtype6.c+54−58

 		struct function_and_rules_block fr;
 		unsigned short length;
 		char text[0];
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	int size;
 	/*
 	msg->cprbx.req_parml = size - sizeof(msg->hdr) - sizeof(msg->cprbx);
-	ap_msg->length = size;
+	ap_msg->len = size;
 	return 0;
 }
 		struct function_and_rules_block fr;
 		unsigned short length;
 		char text[0];
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	int size;
 	/*
 	msg->fr = static_pkd_fnr;
-	ap_msg->length = size;
+	ap_msg->len = size;
 	return 0;
 }
 	struct {
 		struct type6_hdr hdr;
 		struct CPRBX cprbx;
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	int rcblen = CEIL4(xcRB->request_control_blk_length);
 	int replylen, req_sumlen, resp_sumlen;
-	char *req_data = ap_msg->message + sizeof(struct type6_hdr) + rcblen;
+	char *req_data = ap_msg->msg + sizeof(struct type6_hdr) + rcblen;
 	char *function_code;
 	if (CEIL4(xcRB->request_control_blk_length) <
 		return -EINVAL; /* overflow after alignment*/
 	/* length checks */
-	ap_msg->length = sizeof(struct type6_hdr) +
+	ap_msg->len = sizeof(struct type6_hdr) +
 		CEIL4(xcRB->request_control_blk_length) +
 		xcRB->request_data_length;
-	if (ap_msg->length > MSGTYPE06_MAX_MSG_SIZE)
+	if (ap_msg->len > MSGTYPE06_MAX_MSG_SIZE)
 		return -EINVAL;
 	/*
 	if (memcmp(function_code, "US", 2) == 0
 	    || memcmp(function_code, "AU", 2) == 0)
-		ap_msg->special = 1;
+		ap_msg->flags |= AP_MSG_FLAG_SPECIAL;
-	else
-		ap_msg->special = 0;
 	/* copy data block */
 	if (xcRB->request_data_length &&
 		struct ep11_cprb cprbx;
 		unsigned char	pld_tag;	/* fixed value 0x30 */
 		unsigned char	pld_lenfmt;	/* payload length format */
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	struct pld_hdr {
 		unsigned char	func_tag;	/* fixed value 0x4 */
 		return -EINVAL; /* overflow after alignment*/
 	/* length checks */
-	ap_msg->length = sizeof(struct type6_hdr) + xcRB->req_len;
+	ap_msg->len = sizeof(struct type6_hdr) + xcRB->req_len;
 	if (CEIL4(xcRB->req_len) > MSGTYPE06_MAX_MSG_SIZE -
 				   (sizeof(struct type6_hdr)))
 		return -EINVAL;
 	/* enable special processing based on the cprbs flags special bit */
 	if (msg->cprbx.flags & 0x20)
-		ap_msg->special = 1;
+		ap_msg->flags |= AP_MSG_FLAG_SPECIAL;
 	return 0;
 }
 		0x35, 0x9D, 0xD3, 0xD3, 0xA7, 0x9D, 0x5D, 0x41,
 		0x6F, 0x65, 0x1B, 0xCF, 0xA9, 0x87, 0x91, 0x09
 	};
-	struct type86x_reply *msg = reply->message;
+	struct type86x_reply *msg = reply->msg;
 	unsigned short service_rc, service_rs;
 	unsigned int reply_len, pad_len;
 	char *data;
 			       struct ap_message *reply,
 			       struct ica_xcRB *xcRB)
 {
-	struct type86_fmt2_msg *msg = reply->message;
+	struct type86_fmt2_msg *msg = reply->msg;
-	char *data = reply->message;
+	char *data = reply->msg;
 	/* Copy CPRB to user */
 	if (copy_to_user(xcRB->reply_control_blk_addr,
 				    struct ap_message *reply,
 				    struct ep11_urb *xcRB)
 {
-	struct type86_fmt2_msg *msg = reply->message;
+	struct type86_fmt2_msg *msg = reply->msg;
-	char *data = reply->message;
+	char *data = reply->msg;
 	if (xcRB->resp_len < msg->fmt2.count1)
 		return -EINVAL;
 		struct type86_hdr hdr;
 		struct type86_fmt2_ext fmt2;
 		struct CPRBX cprbx;
-	} __packed * msg = reply->message;
+	} __packed * msg = reply->msg;
-	char *data = reply->message;
+	char *data = reply->msg;
 	if (msg->cprbx.ccp_rtcode != 0 || msg->cprbx.ccp_rscode != 0)
 		return -EINVAL;
 			    char __user *outputdata,
 			    unsigned int outputdatalength)
 {
-	struct type86x_reply *msg = reply->message;
+	struct type86x_reply *msg = reply->msg;
 	switch (msg->hdr.type) {
 	case TYPE82_RSP_CODE:
 			    struct ap_message *reply,
 			    struct ica_xcRB *xcRB)
 {
-	struct type86x_reply *msg = reply->message;
+	struct type86x_reply *msg = reply->msg;
 	switch (msg->hdr.type) {
 	case TYPE82_RSP_CODE:
 static int convert_response_ep11_xcrb(struct zcrypt_queue *zq,
 	struct ap_message *reply, struct ep11_urb *xcRB)
 {
-	struct type86_ep11_reply *msg = reply->message;
+	struct type86_ep11_reply *msg = reply->msg;
 	switch (msg->hdr.type) {
 	case TYPE82_RSP_CODE:
 				 struct ap_message *reply,
 				 char *data)
 {
-	struct type86x_reply *msg = reply->message;
+	struct type86x_reply *msg = reply->msg;
 	switch (msg->hdr.type) {
 	case TYPE82_RSP_CODE:
 	struct response_type *resp_type =
 		(struct response_type *) msg->private;
 	struct type86x_reply *t86r;
-	int length;
+	int len;
 	/* Copy the reply message to the request message buffer. */
 	if (!reply)
 		goto out;	/* ap_msg->rc indicates the error */
-	t86r = reply->message;
+	t86r = reply->msg;
 	if (t86r->hdr.type == TYPE86_RSP_CODE &&
 		 t86r->cprbx.cprb_ver_id == 0x02) {
 		switch (resp_type->type) {
 		case CEXXC_RESPONSE_TYPE_ICA:
-			length = sizeof(struct type86x_reply)
+			len = sizeof(struct type86x_reply) + t86r->length - 2;
-				+ t86r->length - 2;
+			len = min_t(int, CEXXC_MAX_ICA_RESPONSE_SIZE, len);
-			length = min(CEXXC_MAX_ICA_RESPONSE_SIZE, length);
+			memcpy(msg->msg, reply->msg, len);
-			memcpy(msg->message, reply->message, length);
 			break;
 		case CEXXC_RESPONSE_TYPE_XCRB:
-			length = t86r->fmt2.offset2 + t86r->fmt2.count2;
+			len = t86r->fmt2.offset2 + t86r->fmt2.count2;
-			length = min(MSGTYPE06_MAX_MSG_SIZE, length);
+			len = min_t(int, MSGTYPE06_MAX_MSG_SIZE, len);
-			memcpy(msg->message, reply->message, length);
+			memcpy(msg->msg, reply->msg, len);
 			break;
 		default:
-			memcpy(msg->message, &error_reply,
+			memcpy(msg->msg, &error_reply, sizeof(error_reply));
-			       sizeof(error_reply));
 		}
 	} else
-		memcpy(msg->message, reply->message, sizeof(error_reply));
+		memcpy(msg->msg, reply->msg, sizeof(error_reply));
 out:
 	complete(&(resp_type->work));
 }
 	struct response_type *resp_type =
 		(struct response_type *)msg->private;
 	struct type86_ep11_reply *t86r;
-	int length;
+	int len;
 	/* Copy the reply message to the request message buffer. */
 	if (!reply)
 		goto out;	/* ap_msg->rc indicates the error */
-	t86r = reply->message;
+	t86r = reply->msg;
 	if (t86r->hdr.type == TYPE86_RSP_CODE &&
 	    t86r->cprbx.cprb_ver_id == 0x04) {
 		switch (resp_type->type) {
 		case CEXXC_RESPONSE_TYPE_EP11:
-			length = t86r->fmt2.offset1 + t86r->fmt2.count1;
+			len = t86r->fmt2.offset1 + t86r->fmt2.count1;
-			length = min(MSGTYPE06_MAX_MSG_SIZE, length);
+			len = min_t(int, MSGTYPE06_MAX_MSG_SIZE, len);
-			memcpy(msg->message, reply->message, length);
+			memcpy(msg->msg, reply->msg, len);
 			break;
 		default:
-			memcpy(msg->message, &error_reply, sizeof(error_reply));
+			memcpy(msg->msg, &error_reply, sizeof(error_reply));
 		}
 	} else {
-		memcpy(msg->message, reply->message, sizeof(error_reply));
+		memcpy(msg->msg, reply->msg, sizeof(error_reply));
 	}
 out:
 	complete(&(resp_type->work));
 	int rc;
 	ap_init_message(&ap_msg);
-	ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
+	ap_msg.msg = (void *) get_zeroed_page(GFP_KERNEL);
-	if (!ap_msg.message)
+	if (!ap_msg.msg)
 		return -ENOMEM;
 	ap_msg.receive = zcrypt_msgtype6_receive;
 	ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 		/* Signal pending. */
 		ap_cancel_message(zq->queue, &ap_msg);
 out_free:
-	free_page((unsigned long) ap_msg.message);
+	free_page((unsigned long) ap_msg.msg);
 	return rc;
 }
 	int rc;
 	ap_init_message(&ap_msg);
-	ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
+	ap_msg.msg = (void *) get_zeroed_page(GFP_KERNEL);
-	if (!ap_msg.message)
+	if (!ap_msg.msg)
 		return -ENOMEM;
 	ap_msg.receive = zcrypt_msgtype6_receive;
 	ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
 		ap_cancel_message(zq->queue, &ap_msg);
 	}
 out_free:
-	free_page((unsigned long) ap_msg.message);
+	free_page((unsigned long) ap_msg.msg);
 	return rc;
 }
 		.type = CEXXC_RESPONSE_TYPE_XCRB,
 	};
-	ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
+	ap_msg->msg = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
-	if (!ap_msg->message)
+	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive;
 	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
 		.type = CEXXC_RESPONSE_TYPE_EP11,
 	};
-	ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
+	ap_msg->msg = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
-	if (!ap_msg->message)
+	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive_ep11;
 	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
 		struct ep11_cprb cprbx;
 		unsigned char	pld_tag;	/* fixed value 0x30 */
 		unsigned char	pld_lenfmt;	/* payload length format */
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	struct pld_hdr {
 		unsigned char	func_tag;	/* fixed value 0x4 */
 		unsigned char	func_len;	/* fixed value 0x4 */
 		.type = CEXXC_RESPONSE_TYPE_XCRB,
 	};
-	ap_msg->message = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
+	ap_msg->msg = kmalloc(MSGTYPE06_MAX_MSG_SIZE, GFP_KERNEL);
-	if (!ap_msg->message)
+	if (!ap_msg->msg)
 		return -ENOMEM;
 	ap_msg->receive = zcrypt_msgtype6_receive;
 	ap_msg->psmid = (((unsigned long long) current->pid) << 32) +
 		char rule[8];
 		short int verb_length;
 		short int key_length;
-	} __packed * msg = ap_msg->message;
+	} __packed * msg = ap_msg->msg;
 	struct response_type *rtype = (struct response_type *)(ap_msg->private);
 	int rc;

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

@@ -127,7 +127,7 @@ static inline void rng_type6CPRB_msgX(struct ap_message *ap_msg, · 126 unmodified lines
127	char rule[8];	127	char rule[8];
128	short int verb_length;	128	short int verb_length;
129	short int key_length;	129	short int key_length;
130	} __packed * msg = ap_msg->message;	130	} __packed * msg = ap_msg->msg;
131	static struct type6_hdr static_type6_hdrX = {	131	static struct type6_hdr static_type6_hdrX = {
132	.type = 0x06,	132	.type = 0x06,
133	.offset1 = 0x00000058,	133	.offset1 = 0x00000058,
@@ -154,7 +154,7 @@ static inline void rng_type6CPRB_msgX(struct ap_message *ap_msg, · 20 unmodified lines
154	memcpy(msg->rule, "RANDOM ", 8);	154	memcpy(msg->rule, "RANDOM ", 8);
155	msg->verb_length = 0x02;	155	msg->verb_length = 0x02;
156	msg->key_length = 0x02;	156	msg->key_length = 0x02;
157	ap_msg->length = sizeof(*msg);	157	ap_msg->len = sizeof(*msg);
158	*domain = (unsigned short)msg->cprbx.domain;	158	*domain = (unsigned short)msg->cprbx.domain;
159	}	159	}
160		160

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

@@ -107,10 +107,10 @@ struct zcrypt_queue *zcrypt_queue_alloc(size_t max_response_size) · 106 unmodified lines
107	zq = kzalloc(sizeof(struct zcrypt_queue), GFP_KERNEL);	107	zq = kzalloc(sizeof(struct zcrypt_queue), GFP_KERNEL);
108	if (!zq)	108	if (!zq)
109	return NULL;	109	return NULL;
110	zq->reply.message = kmalloc(max_response_size, GFP_KERNEL);	110	zq->reply.msg = kmalloc(max_response_size, GFP_KERNEL);
111	if (!zq->reply.message)	111	if (!zq->reply.msg)
112	goto out_free;	112	goto out_free;
113	zq->reply.length = max_response_size;	113	zq->reply.len = max_response_size;
114	INIT_LIST_HEAD(&zq->list);	114	INIT_LIST_HEAD(&zq->list);
115	kref_init(&zq->refcount);	115	kref_init(&zq->refcount);
116	return zq;	116	return zq;
@@ -123,7 +123,7 @@ EXPORT_SYMBOL(zcrypt_queue_alloc); · 6 unmodified lines
123		123
124	void zcrypt_queue_free(struct zcrypt_queue *zq)	124	void zcrypt_queue_free(struct zcrypt_queue *zq)
125	{	125	{
126	kfree(zq->reply.message);	126	kfree(zq->reply.msg);
127	kfree(zq);	127	kfree(zq);
128	}	128	}
129	EXPORT_SYMBOL(zcrypt_queue_free);	129	EXPORT_SYMBOL(zcrypt_queue_free);

include/linux/memblock.h+24−4

@@ -77,16 +77,12 @@ struct memblock_type { · 76 unmodified lines
77	* @current_limit: physical address of the current allocation limit	77	* @current_limit: physical address of the current allocation limit
78	* @memory: usable memory regions	78	* @memory: usable memory regions
79	* @reserved: reserved memory regions	79	* @reserved: reserved memory regions
80	* @physmem: all physical memory
81	*/	80	*/
82	struct memblock {	81	struct memblock {
83	bool bottom_up; /* is bottom up direction? */	82	bool bottom_up; /* is bottom up direction? */
84	phys_addr_t current_limit;	83	phys_addr_t current_limit;
85	struct memblock_type memory;	84	struct memblock_type memory;
86	struct memblock_type reserved;	85	struct memblock_type reserved;
87	#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
88	struct memblock_type physmem;
89	#endif
90	};	86	};
91		87
92	extern struct memblock memblock;	88	extern struct memblock memblock;
@@ -145,6 +141,30 @@ void __next_reserved_mem_region(u64 idx, phys_addr_t out_start, · 52 unmodified lines
145		141
146	void __memblock_free_late(phys_addr_t base, phys_addr_t size);	142	void __memblock_free_late(phys_addr_t base, phys_addr_t size);
147		143
		144	#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
		145	static inline void __next_physmem_range(u64 idx, struct memblock_type type,
		146	phys_addr_t *out_start,
		147	phys_addr_t *out_end)
		148	{
		149	extern struct memblock_type physmem;
		150
		151	__next_mem_range(idx, NUMA_NO_NODE, MEMBLOCK_NONE, &physmem, type,
		152	out_start, out_end, NULL);
		153	}
		154
		155	/**
		156	* for_each_physmem_range - iterate through physmem areas not included in type.
		157	* @i: u64 used as loop variable
		158	* @type: ptr to memblock_type which excludes from the iteration, can be %NULL
		159	* @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
		160	* @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
		161	*/
		162	#define for_each_physmem_range(i, type, p_start, p_end) \
		163	for (i = 0, __next_physmem_range(&i, type, p_start, p_end); \
		164	i != (u64)ULLONG_MAX; \
		165	__next_physmem_range(&i, type, p_start, p_end))
		166	#endif /* CONFIG_HAVE_MEMBLOCK_PHYS_MAP */
		167
148	/**	168	/**
149	* for_each_mem_range - iterate through memblock areas from type_a and not	169	* for_each_mem_range - iterate through memblock areas from type_a and not
150	* included in type_b. Or just type_a if type_b is NULL.	170	* included in type_b. Or just type_a if type_b is NULL.

mm/memblock.c+29−28

  *   in the system, for instance when the memory is restricted with
  *   ``mem=`` command line parameter
  * * ``reserved`` - describes the regions that were allocated
- * * ``physmap`` - describes the actual physical memory regardless of
+ * * ``physmem`` - describes the actual physical memory available during
- *   the possible restrictions; the ``physmap`` type is only available
+ *   boot regardless of the possible restrictions and memory hot(un)plug;
- *   on some architectures.
+ *   the ``physmem`` type is only available on some architectures.
  *
  * Each region is represented by :c:type:`struct memblock_region` that
  * defines the region extents, its attributes and NUMA node id on NUMA
  * systems. Every memory type is described by the :c:type:`struct
  * memblock_type` which contains an array of memory regions along with
- * the allocator metadata. The memory types are nicely wrapped with
+ * the allocator metadata. The "memory" and "reserved" types are nicely
- * :c:type:`struct memblock`. This structure is statically initialzed
+ * wrapped with :c:type:`struct memblock`. This structure is statically
- * at build time. The region arrays for the "memory" and "reserved"
+ * initialized at build time. The region arrays are initially sized to
- * types are initially sized to %INIT_MEMBLOCK_REGIONS and for the
+ * %INIT_MEMBLOCK_REGIONS for "memory" and %INIT_MEMBLOCK_RESERVED_REGIONS
- * "physmap" type to %INIT_PHYSMEM_REGIONS.
+ * for "reserved". The region array for "physmem" is initially sized to
+ * %INIT_PHYSMEM_REGIONS.
  * The memblock_allow_resize() enables automatic resizing of the region
  * arrays during addition of new regions. This feature should be used
  * with care so that memory allocated for the region array will not
  * function frees all the memory to the buddy page allocator.
  *
  * Unless an architecture enables %CONFIG_ARCH_KEEP_MEMBLOCK, the
- * memblock data structures will be discarded after the system
+ * memblock data structures (except "physmem") will be discarded after the
- * initialization completes.
+ * system initialization completes.
  */
 #ifndef CONFIG_NEED_MULTIPLE_NODES
 static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS] __initdata_memblock;
 static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_RESERVED_REGIONS] __initdata_memblock;
 #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
-static struct memblock_region memblock_physmem_init_regions[INIT_PHYSMEM_REGIONS] __initdata_memblock;
+static struct memblock_region memblock_physmem_init_regions[INIT_PHYSMEM_REGIONS];
 #endif
 struct memblock memblock __initdata_memblock = {
 	.reserved.max		= INIT_MEMBLOCK_RESERVED_REGIONS,
 	.reserved.name		= "reserved",
-#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
-	.physmem.regions	= memblock_physmem_init_regions,
-	.physmem.cnt		= 1,	/* empty dummy entry */
-	.physmem.max		= INIT_PHYSMEM_REGIONS,
-	.physmem.name		= "physmem",
-#endif
 	.bottom_up		= false,
 	.current_limit		= MEMBLOCK_ALLOC_ANYWHERE,
 };
+#ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
+struct memblock_type physmem = {
+	.regions		= memblock_physmem_init_regions,
+	.cnt			= 1,	/* empty dummy entry */
+	.max			= INIT_PHYSMEM_REGIONS,
+	.name			= "physmem",
+};
+#endif
 int memblock_debug __initdata_memblock;
 static bool system_has_some_mirror __initdata_memblock = false;
 static int memblock_can_resize __initdata_memblock;
 	memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
 		     &base, &end, (void *)_RET_IP_);
-	return memblock_add_range(&memblock.physmem, base, size, MAX_NUMNODES, 0);
+	return memblock_add_range(&physmem, base, size, MAX_NUMNODES, 0);
 }
 #endif
  * As both region arrays are sorted, the function advances the two indices
  * in lockstep and returns each intersection.
  */
-void __init_memblock __next_mem_range(u64 *idx, int nid,
+void __next_mem_range(u64 *idx, int nid, enum memblock_flags flags,
-				      enum memblock_flags flags,
+		      struct memblock_type *type_a,
-				      struct memblock_type *type_a,
+		      struct memblock_type *type_b, phys_addr_t *out_start,
-				      struct memblock_type *type_b,
+		      phys_addr_t *out_end, int *out_nid)
-				      phys_addr_t *out_start,
-				      phys_addr_t *out_end, int *out_nid)
 {
 	int idx_a = *idx & 0xffffffff;
 	int idx_b = *idx >> 32;
 	memblock_dump(&memblock.memory);
 	memblock_dump(&memblock.reserved);
 #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
-	memblock_dump(&memblock.physmem);
+	memblock_dump(&physmem);
 #endif
 }
 	debugfs_create_file("reserved", 0444, root,
 			    &memblock.reserved, &memblock_debug_fops);
 #ifdef CONFIG_HAVE_MEMBLOCK_PHYS_MAP
-	debugfs_create_file("physmem", 0444, root,
+	debugfs_create_file("physmem", 0444, root, &physmem,
-			    &memblock.physmem, &memblock_debug_fops);
+			    &memblock_debug_fops);
 #endif
 	return 0;

scripts/sorttable.c+41−0

@@ -255,6 +255,45 @@ static void x86_sort_relative_table(char *extab_image, int image_size) · 254 unmodified lines
255	}	255	}
256	}	256	}
257		257
		258	static void s390_sort_relative_table(char *extab_image, int image_size)
		259	{
		260	int i;
		261
		262	for (i = 0; i < image_size; i += 16) {
		263	char *loc = extab_image + i;
		264	uint64_t handler;
		265
		266	w(r((uint32_t )loc) + i, (uint32_t )loc);
		267	w(r((uint32_t )(loc + 4)) + (i + 4), (uint32_t )(loc + 4));
		268	/*
		269	* 0 is a special self-relative handler value, which means that
		270	* handler should be ignored. It is safe, because it means that
		271	* handler field points to itself, which should never happen.
		272	* When creating extable-relative values, keep it as 0, since
		273	* this should never occur either: it would mean that handler
		274	* field points to the first extable entry.
		275	*/
		276	handler = r8((uint64_t *)(loc + 8));
		277	if (handler)
		278	handler += i + 8;
		279	w8(handler, (uint64_t *)(loc + 8));
		280	}
		281
		282	qsort(extab_image, image_size / 16, 16, compare_relative_table);
		283
		284	for (i = 0; i < image_size; i += 16) {
		285	char *loc = extab_image + i;
		286	uint64_t handler;
		287
		288	w(r((uint32_t )loc) - i, (uint32_t )loc);
		289	w(r((uint32_t )(loc + 4)) - (i + 4), (uint32_t )(loc + 4));
		290	handler = r8((uint64_t *)(loc + 8));
		291	if (handler)
		292	handler -= i + 8;
		293	w8(handler, (uint64_t *)(loc + 8));
		294	}
		295	}
		296
258	static int do_file(char const const fname, void addr)	297	static int do_file(char const const fname, void addr)
259	{	298	{
260	int rc = -1;	299	int rc = -1;
@@ -297,6 +336,8 @@ static int do_file(char const const fname, void addr) · 36 unmodified lines
297	custom_sort = x86_sort_relative_table;	336	custom_sort = x86_sort_relative_table;
298	break;	337	break;
299	case EM_S390:	338	case EM_S390:
		339	custom_sort = s390_sort_relative_table;
		340	break;
300	case EM_AARCH64:	341	case EM_AARCH64:
301	case EM_PARISC:	342	case EM_PARISC:
302	case EM_PPC:	343	case EM_PPC:

Merge tag 's390-5.9-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

@@ -30,7 +30,7 @@ · 29 unmodified lines
30	})	30	})
31		31
32	#define __S390_SYS_STUBx(x, name, ...) \	32	#define __S390_SYS_STUBx(x, name, ...) \
33	asmlinkage long __s390_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))\	33	asmlinkage long __s390_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));\
34	ALLOW_ERROR_INJECTION(__s390_sys##name, ERRNO); \	34	ALLOW_ERROR_INJECTION(__s390_sys##name, ERRNO); \
35	asmlinkage long __s390_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))\	35	asmlinkage long __s390_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))\
36	{ \	36	{ \
@@ -46,7 +46,7 @@ · 9 unmodified lines
46	#define COMPAT_SYSCALL_DEFINE0(sname) \	46	#define COMPAT_SYSCALL_DEFINE0(sname) \
47	SYSCALL_METADATA(_##sname, 0); \	47	SYSCALL_METADATA(_##sname, 0); \
48	asmlinkage long __s390_compat_sys_##sname(void); \	48	asmlinkage long __s390_compat_sys_##sname(void); \
49	ALLOW_ERROR_INJECTION(__s390_compat__sys_##sname, ERRNO); \	49	ALLOW_ERROR_INJECTION(__s390_compat_sys_##sname, ERRNO); \
50	asmlinkage long __s390_compat_sys_##sname(void)	50	asmlinkage long __s390_compat_sys_##sname(void)
51		51
52	#define SYSCALL_DEFINE0(sname) \	52	#define SYSCALL_DEFINE0(sname) \
@@ -72,7 +72,7 @@ · 19 unmodified lines
72	asmlinkage long __s390_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \	72	asmlinkage long __s390_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)); \
73	asmlinkage long __s390_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) \	73	asmlinkage long __s390_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__)) \
74	__attribute__((alias(__stringify(__se_compat_sys##name)))); \	74	__attribute__((alias(__stringify(__se_compat_sys##name)))); \
75	ALLOW_ERROR_INJECTION(compat_sys##name, ERRNO); \	75	ALLOW_ERROR_INJECTION(__s390_compat_sys##name, ERRNO); \
76	static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\	76	static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));\
77	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \	77	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)); \
78	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \	78	asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__)) \