Eric Lee / smarc-fsl-linux-kernel

Commit d7b250e2a2d7f3cd23cf8d8d6689285e6f51a98d

Authored by Heiko Carstens 14 years ago

Exists in master and in 39 other branches

[S390] irq: merge irq.c and s390_ext.c

Merge irq.c and s390_ext.c into irq.c. That way all external interrupt
related functions are together.

Signed-off-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

Showing 17 changed files with 147 additions and 174 deletions Inline Diff

arch/s390/include/asm/irq.h
arch/s390/include/asm/s390_ext.h
arch/s390/kernel/Makefile
arch/s390/kernel/dis.c
arch/s390/kernel/irq.c
arch/s390/kernel/s390_ext.c
arch/s390/kernel/smp.c
arch/s390/kernel/time.c
arch/s390/kernel/topology.c
arch/s390/kernel/traps.c
arch/s390/kernel/vtime.c
arch/s390/mm/fault.c
arch/s390/oprofile/hwsampler.c
drivers/s390/block/dasd_diag.c
drivers/s390/char/sclp.c
drivers/s390/kvm/kvm_virtio.c
net/iucv/iucv.c

arch/s390/include/asm/irq.h

Diff comments View file @ d7b250e

 #ifndef _ASM_IRQ_H
 #define _ASM_IRQ_H
 #include <linux/hardirq.h>
+#include <linux/types.h>
 enum interruption_class {
 	EXTERNAL_INTERRUPT,
 	IO_INTERRUPT,
 	EXTINT_CLK,
 	EXTINT_IPI,
 	EXTINT_TMR,
 	EXTINT_TLA,
 	EXTINT_PFL,
 	EXTINT_DSD,
 	EXTINT_VRT,
 	EXTINT_SCP,
 	EXTINT_IUC,
 	EXTINT_CPM,
 	IOINT_QAI,
 	IOINT_QDI,
 	IOINT_DAS,
 	IOINT_C15,
 	IOINT_C70,
 	IOINT_TAP,
 	IOINT_VMR,
 	IOINT_LCS,
 	IOINT_CLW,
 	IOINT_CTC,
 	IOINT_APB,
 	NMI_NMI,
 	NR_IRQS,
 };
+typedef void (*ext_int_handler_t)(unsigned int, unsigned int, unsigned long);
+int register_external_interrupt(u16 code, ext_int_handler_t handler);
+int unregister_external_interrupt(u16 code, ext_int_handler_t handler);
+void service_subclass_irq_register(void);
+void service_subclass_irq_unregister(void);
 #endif /* _ASM_IRQ_H */

arch/s390/include/asm/s390_ext.h

View file @ d7b250e

1	/*		File was deleted
2	* Copyright IBM Corp. 1999,2010
3	* Author(s): Holger Smolinski <Holger.Smolinski@de.ibm.com>,
4	* Martin Schwidefsky <schwidefsky@de.ibm.com>,
5	*/
6
7	#ifndef _S390_EXTINT_H
8	#define _S390_EXTINT_H
9
10	#include <linux/types.h>
11
12	typedef void (*ext_int_handler_t)(unsigned int, unsigned int, unsigned long);
13
14	int register_external_interrupt(__u16 code, ext_int_handler_t handler);
15	int unregister_external_interrupt(__u16 code, ext_int_handler_t handler);
16	void service_subclass_irq_register(void);
17	void service_subclass_irq_unregister(void);
18
19	#endif /* _S390_EXTINT_H */
20		1	/*

arch/s390/kernel/Makefile

Diff comments View file @ d7b250e

arch/s390/kernel/dis.c

Diff comments View file @ d7b250e

 /*
  * arch/s390/kernel/dis.c
  *
  * Disassemble s390 instructions.
  *
  * Copyright IBM Corp. 2007
  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  */
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/ptrace.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/kallsyms.h>
 #include <linux/reboot.h>
 #include <linux/kprobes.h>
 #include <linux/kdebug.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
 #include <asm/mathemu.h>
 #include <asm/cpcmd.h>
-#include <asm/s390_ext.h>
 #include <asm/lowcore.h>
 #include <asm/debug.h>
+#include <asm/irq.h>
 #ifndef CONFIG_64BIT
 #define ONELONG "%08lx: "
 #else /* CONFIG_64BIT */
 #define ONELONG "%016lx: "
 #endif /* CONFIG_64BIT */
 #define OPERAND_GPR	0x1	/* Operand printed as %rx */
 #define OPERAND_FPR	0x2	/* Operand printed as %fx */
 #define OPERAND_AR	0x4	/* Operand printed as %ax */
 #define OPERAND_CR	0x8	/* Operand printed as %cx */
 #define OPERAND_DISP	0x10	/* Operand printed as displacement */
 #define OPERAND_BASE	0x20	/* Operand printed as base register */
 #define OPERAND_INDEX	0x40	/* Operand printed as index register */
 #define OPERAND_PCREL	0x80	/* Operand printed as pc-relative symbol */
 #define OPERAND_SIGNED	0x100	/* Operand printed as signed value */
 #define OPERAND_LENGTH	0x200	/* Operand printed as length (+1) */
 enum {
 	UNUSED,	/* Indicates the end of the operand list */
 	R_8,	/* GPR starting at position 8 */
 	R_12,	/* GPR starting at position 12 */
 	R_16,	/* GPR starting at position 16 */
 	R_20,	/* GPR starting at position 20 */
 	R_24,	/* GPR starting at position 24 */
 	R_28,	/* GPR starting at position 28 */
 	R_32,	/* GPR starting at position 32 */
 	F_8,	/* FPR starting at position 8 */
 	F_12,	/* FPR starting at position 12 */
 	F_16,	/* FPR starting at position 16 */
 	F_20,	/* FPR starting at position 16 */
 	F_24,	/* FPR starting at position 24 */
 	F_28,	/* FPR starting at position 28 */
 	F_32,	/* FPR starting at position 32 */
 	A_8,	/* Access reg. starting at position 8 */
 	A_12,	/* Access reg. starting at position 12 */
 	A_24,	/* Access reg. starting at position 24 */
 	A_28,	/* Access reg. starting at position 28 */
 	C_8,	/* Control reg. starting at position 8 */
 	C_12,	/* Control reg. starting at position 12 */
 	B_16,	/* Base register starting at position 16 */
 	B_32,	/* Base register starting at position 32 */
 	X_12,	/* Index register starting at position 12 */
 	D_20,	/* Displacement starting at position 20 */
 	D_36,	/* Displacement starting at position 36 */
 	D20_20,	/* 20 bit displacement starting at 20 */
 	L4_8,	/* 4 bit length starting at position 8 */
 	L4_12,	/* 4 bit length starting at position 12 */
 	L8_8,	/* 8 bit length starting at position 8 */
 	U4_8,	/* 4 bit unsigned value starting at 8 */
 	U4_12,	/* 4 bit unsigned value starting at 12 */
 	U4_16,	/* 4 bit unsigned value starting at 16 */
 	U4_20,	/* 4 bit unsigned value starting at 20 */
 	U4_32,	/* 4 bit unsigned value starting at 32 */
 	U8_8,	/* 8 bit unsigned value starting at 8 */
 	U8_16,	/* 8 bit unsigned value starting at 16 */
 	U8_24,	/* 8 bit unsigned value starting at 24 */
 	U8_32,	/* 8 bit unsigned value starting at 32 */
 	I8_8,	/* 8 bit signed value starting at 8 */
 	I8_32,	/* 8 bit signed value starting at 32 */
 	I16_16,	/* 16 bit signed value starting at 16 */
 	I16_32,	/* 32 bit signed value starting at 16 */
 	U16_16,	/* 16 bit unsigned value starting at 16 */
 	U16_32,	/* 32 bit unsigned value starting at 16 */
 	J16_16,	/* PC relative jump offset at 16 */
 	J32_16,	/* PC relative long offset at 16 */
 	I32_16,	/* 32 bit signed value starting at 16 */
 	U32_16,	/* 32 bit unsigned value starting at 16 */
 	M_16,	/* 4 bit optional mask starting at 16 */
 	RO_28,	/* optional GPR starting at position 28 */
 };
 /*
  * Enumeration of the different instruction formats.
  * For details consult the principles of operation.
  */
 enum {
 	INSTR_INVALID,
 	INSTR_E,
 	INSTR_RIE_R0IU, INSTR_RIE_R0UU, INSTR_RIE_RRP, INSTR_RIE_RRPU,
 	INSTR_RIE_RRUUU, INSTR_RIE_RUPI, INSTR_RIE_RUPU, INSTR_RIE_RRI0,
 	INSTR_RIL_RI, INSTR_RIL_RP, INSTR_RIL_RU, INSTR_RIL_UP,
 	INSTR_RIS_R0RDU, INSTR_RIS_R0UU, INSTR_RIS_RURDI, INSTR_RIS_RURDU,
 	INSTR_RI_RI, INSTR_RI_RP, INSTR_RI_RU, INSTR_RI_UP,
 	INSTR_RRE_00, INSTR_RRE_0R, INSTR_RRE_AA, INSTR_RRE_AR, INSTR_RRE_F0,
 	INSTR_RRE_FF, INSTR_RRE_FR, INSTR_RRE_R0, INSTR_RRE_RA, INSTR_RRE_RF,
 	INSTR_RRE_RR, INSTR_RRE_RR_OPT,
 	INSTR_RRF_0UFF, INSTR_RRF_F0FF, INSTR_RRF_F0FF2, INSTR_RRF_F0FR,
 	INSTR_RRF_FFRU, INSTR_RRF_FUFF, INSTR_RRF_M0RR, INSTR_RRF_R0RR,
 	INSTR_RRF_R0RR2, INSTR_RRF_RURR, INSTR_RRF_U0FF, INSTR_RRF_U0RF,
 	INSTR_RRF_U0RR, INSTR_RRF_UUFF, INSTR_RRR_F0FF, INSTR_RRS_RRRDU,
 	INSTR_RR_FF, INSTR_RR_R0, INSTR_RR_RR, INSTR_RR_U0, INSTR_RR_UR,
 	INSTR_RSE_CCRD, INSTR_RSE_RRRD, INSTR_RSE_RURD,
 	INSTR_RSI_RRP,
 	INSTR_RSL_R0RD,
 	INSTR_RSY_AARD, INSTR_RSY_CCRD, INSTR_RSY_RRRD, INSTR_RSY_RURD,
 	INSTR_RSY_RDRM,
 	INSTR_RS_AARD, INSTR_RS_CCRD, INSTR_RS_R0RD, INSTR_RS_RRRD,
 	INSTR_RS_RURD,
 	INSTR_RXE_FRRD, INSTR_RXE_RRRD,
 	INSTR_RXF_FRRDF,
 	INSTR_RXY_FRRD, INSTR_RXY_RRRD, INSTR_RXY_URRD,
 	INSTR_RX_FRRD, INSTR_RX_RRRD, INSTR_RX_URRD,
 	INSTR_SIL_RDI, INSTR_SIL_RDU,
 	INSTR_SIY_IRD, INSTR_SIY_URD,
 	INSTR_SI_URD,
 	INSTR_SSE_RDRD,
 	INSTR_SSF_RRDRD, INSTR_SSF_RRDRD2,
 	INSTR_SS_L0RDRD, INSTR_SS_LIRDRD, INSTR_SS_LLRDRD, INSTR_SS_RRRDRD,
 	INSTR_SS_RRRDRD2, INSTR_SS_RRRDRD3,
 	INSTR_S_00, INSTR_S_RD,
 };
 struct operand {
 	int bits;		/* The number of bits in the operand. */
 	int shift;		/* The number of bits to shift. */
 	int flags;		/* One bit syntax flags. */
 };
 struct insn {
 	const char name[5];
 	unsigned char opfrag;
 	unsigned char format;
 };
 static const struct operand operands[] =
 {
 	[UNUSED]  = { 0, 0, 0 },
 	[R_8]	 = {  4,  8, OPERAND_GPR },
 	[R_12]	 = {  4, 12, OPERAND_GPR },
 	[R_16]	 = {  4, 16, OPERAND_GPR },
 	[R_20]	 = {  4, 20, OPERAND_GPR },
 	[R_24]	 = {  4, 24, OPERAND_GPR },
 	[R_28]	 = {  4, 28, OPERAND_GPR },
 	[R_32]	 = {  4, 32, OPERAND_GPR },
 	[F_8]	 = {  4,  8, OPERAND_FPR },
 	[F_12]	 = {  4, 12, OPERAND_FPR },
 	[F_16]	 = {  4, 16, OPERAND_FPR },
 	[F_20]	 = {  4, 16, OPERAND_FPR },
 	[F_24]	 = {  4, 24, OPERAND_FPR },
 	[F_28]	 = {  4, 28, OPERAND_FPR },
 	[F_32]	 = {  4, 32, OPERAND_FPR },
 	[A_8]	 = {  4,  8, OPERAND_AR },
 	[A_12]	 = {  4, 12, OPERAND_AR },
 	[A_24]	 = {  4, 24, OPERAND_AR },
 	[A_28]	 = {  4, 28, OPERAND_AR },
 	[C_8]	 = {  4,  8, OPERAND_CR },
 	[C_12]	 = {  4, 12, OPERAND_CR },
 	[B_16]	 = {  4, 16, OPERAND_BASE | OPERAND_GPR },
 	[B_32]	 = {  4, 32, OPERAND_BASE | OPERAND_GPR },
 	[X_12]	 = {  4, 12, OPERAND_INDEX | OPERAND_GPR },
 	[D_20]	 = { 12, 20, OPERAND_DISP },
 	[D_36]	 = { 12, 36, OPERAND_DISP },
 	[D20_20] = { 20, 20, OPERAND_DISP | OPERAND_SIGNED },
 	[L4_8]	 = {  4,  8, OPERAND_LENGTH },
 	[L4_12]  = {  4, 12, OPERAND_LENGTH },
 	[L8_8]	 = {  8,  8, OPERAND_LENGTH },
 	[U4_8]	 = {  4,  8, 0 },
 	[U4_12]  = {  4, 12, 0 },
 	[U4_16]  = {  4, 16, 0 },
 	[U4_20]  = {  4, 20, 0 },
 	[U4_32]  = {  4, 32, 0 },
 	[U8_8]	 = {  8,  8, 0 },
 	[U8_16]  = {  8, 16, 0 },
 	[U8_24]  = {  8, 24, 0 },
 	[U8_32]  = {  8, 32, 0 },
 	[I16_16] = { 16, 16, OPERAND_SIGNED },
 	[U16_16] = { 16, 16, 0 },
 	[U16_32] = { 16, 32, 0 },
 	[J16_16] = { 16, 16, OPERAND_PCREL },
 	[I16_32] = { 16, 32, OPERAND_SIGNED },
 	[J32_16] = { 32, 16, OPERAND_PCREL },
 	[I32_16] = { 32, 16, OPERAND_SIGNED },
 	[U32_16] = { 32, 16, 0 },
 	[M_16]	 = {  4, 16, 0 },
 	[RO_28]  = {  4, 28, OPERAND_GPR }
 };
 static const unsigned char formats[][7] = {
 	[INSTR_E]	  = { 0xff, 0,0,0,0,0,0 },
 	[INSTR_RIE_R0UU]  = { 0xff, R_8,U16_16,U4_32,0,0,0 },
 	[INSTR_RIE_RRPU]  = { 0xff, R_8,R_12,U4_32,J16_16,0,0 },
 	[INSTR_RIE_RRP]	  = { 0xff, R_8,R_12,J16_16,0,0,0 },
 	[INSTR_RIE_RRUUU] = { 0xff, R_8,R_12,U8_16,U8_24,U8_32,0 },
 	[INSTR_RIE_RUPI]  = { 0xff, R_8,I8_32,U4_12,J16_16,0,0 },
 	[INSTR_RIE_RRI0]  = { 0xff, R_8,R_12,I16_16,0,0,0 },
 	[INSTR_RIL_RI]	  = { 0x0f, R_8,I32_16,0,0,0,0 },
 	[INSTR_RIL_RP]	  = { 0x0f, R_8,J32_16,0,0,0,0 },
 	[INSTR_RIL_RU]	  = { 0x0f, R_8,U32_16,0,0,0,0 },
 	[INSTR_RIL_UP]	  = { 0x0f, U4_8,J32_16,0,0,0,0 },
 	[INSTR_RIS_R0RDU] = { 0xff, R_8,U8_32,D_20,B_16,0,0 },
 	[INSTR_RIS_RURDI] = { 0xff, R_8,I8_32,U4_12,D_20,B_16,0 },
 	[INSTR_RIS_RURDU] = { 0xff, R_8,U8_32,U4_12,D_20,B_16,0 },
 	[INSTR_RI_RI]	  = { 0x0f, R_8,I16_16,0,0,0,0 },
 	[INSTR_RI_RP]	  = { 0x0f, R_8,J16_16,0,0,0,0 },
 	[INSTR_RI_RU]	  = { 0x0f, R_8,U16_16,0,0,0,0 },
 	[INSTR_RI_UP]	  = { 0x0f, U4_8,J16_16,0,0,0,0 },
 	[INSTR_RRE_00]	  = { 0xff, 0,0,0,0,0,0 },
 	[INSTR_RRE_0R]	  = { 0xff, R_28,0,0,0,0,0 },
 	[INSTR_RRE_AA]	  = { 0xff, A_24,A_28,0,0,0,0 },
 	[INSTR_RRE_AR]	  = { 0xff, A_24,R_28,0,0,0,0 },
 	[INSTR_RRE_F0]	  = { 0xff, F_24,0,0,0,0,0 },
 	[INSTR_RRE_FF]	  = { 0xff, F_24,F_28,0,0,0,0 },
 	[INSTR_RRE_FR]	  = { 0xff, F_24,R_28,0,0,0,0 },
 	[INSTR_RRE_R0]	  = { 0xff, R_24,0,0,0,0,0 },
 	[INSTR_RRE_RA]	  = { 0xff, R_24,A_28,0,0,0,0 },
 	[INSTR_RRE_RF]	  = { 0xff, R_24,F_28,0,0,0,0 },
 	[INSTR_RRE_RR]	  = { 0xff, R_24,R_28,0,0,0,0 },
 	[INSTR_RRE_RR_OPT]= { 0xff, R_24,RO_28,0,0,0,0 },
 	[INSTR_RRF_0UFF]  = { 0xff, F_24,F_28,U4_20,0,0,0 },
 	[INSTR_RRF_F0FF2] = { 0xff, F_24,F_16,F_28,0,0,0 },
 	[INSTR_RRF_F0FF]  = { 0xff, F_16,F_24,F_28,0,0,0 },
 	[INSTR_RRF_F0FR]  = { 0xff, F_24,F_16,R_28,0,0,0 },
 	[INSTR_RRF_FFRU]  = { 0xff, F_24,F_16,R_28,U4_20,0,0 },
 	[INSTR_RRF_FUFF]  = { 0xff, F_24,F_16,F_28,U4_20,0,0 },
 	[INSTR_RRF_M0RR]  = { 0xff, R_24,R_28,M_16,0,0,0 },
 	[INSTR_RRF_R0RR]  = { 0xff, R_24,R_16,R_28,0,0,0 },
 	[INSTR_RRF_R0RR2] = { 0xff, R_24,R_28,R_16,0,0,0 },
 	[INSTR_RRF_RURR]  = { 0xff, R_24,R_28,R_16,U4_20,0,0 },
 	[INSTR_RRF_U0FF]  = { 0xff, F_24,U4_16,F_28,0,0,0 },
 	[INSTR_RRF_U0RF]  = { 0xff, R_24,U4_16,F_28,0,0,0 },
 	[INSTR_RRF_U0RR]  = { 0xff, R_24,R_28,U4_16,0,0,0 },
 	[INSTR_RRF_UUFF]  = { 0xff, F_24,U4_16,F_28,U4_20,0,0 },
 	[INSTR_RRR_F0FF]  = { 0xff, F_24,F_28,F_16,0,0,0 },
 	[INSTR_RRS_RRRDU] = { 0xff, R_8,R_12,U4_32,D_20,B_16,0 },
 	[INSTR_RR_FF]	  = { 0xff, F_8,F_12,0,0,0,0 },
 	[INSTR_RR_R0]	  = { 0xff, R_8, 0,0,0,0,0 },
 	[INSTR_RR_RR]	  = { 0xff, R_8,R_12,0,0,0,0 },
 	[INSTR_RR_U0]	  = { 0xff, U8_8, 0,0,0,0,0 },
 	[INSTR_RR_UR]	  = { 0xff, U4_8,R_12,0,0,0,0 },
 	[INSTR_RSE_CCRD]  = { 0xff, C_8,C_12,D_20,B_16,0,0 },
 	[INSTR_RSE_RRRD]  = { 0xff, R_8,R_12,D_20,B_16,0,0 },
 	[INSTR_RSE_RURD]  = { 0xff, R_8,U4_12,D_20,B_16,0,0 },
 	[INSTR_RSI_RRP]	  = { 0xff, R_8,R_12,J16_16,0,0,0 },
 	[INSTR_RSL_R0RD]  = { 0xff, D_20,L4_8,B_16,0,0,0 },
 	[INSTR_RSY_AARD]  = { 0xff, A_8,A_12,D20_20,B_16,0,0 },
 	[INSTR_RSY_CCRD]  = { 0xff, C_8,C_12,D20_20,B_16,0,0 },
 	[INSTR_RSY_RRRD]  = { 0xff, R_8,R_12,D20_20,B_16,0,0 },
 	[INSTR_RSY_RURD]  = { 0xff, R_8,U4_12,D20_20,B_16,0,0 },
 	[INSTR_RSY_RDRM]  = { 0xff, R_8,D20_20,B_16,U4_12,0,0 },
 	[INSTR_RS_AARD]	  = { 0xff, A_8,A_12,D_20,B_16,0,0 },
 	[INSTR_RS_CCRD]	  = { 0xff, C_8,C_12,D_20,B_16,0,0 },
 	[INSTR_RS_R0RD]	  = { 0xff, R_8,D_20,B_16,0,0,0 },
 	[INSTR_RS_RRRD]	  = { 0xff, R_8,R_12,D_20,B_16,0,0 },
 	[INSTR_RS_RURD]	  = { 0xff, R_8,U4_12,D_20,B_16,0,0 },
 	[INSTR_RXE_FRRD]  = { 0xff, F_8,D_20,X_12,B_16,0,0 },
 	[INSTR_RXE_RRRD]  = { 0xff, R_8,D_20,X_12,B_16,0,0 },
 	[INSTR_RXF_FRRDF] = { 0xff, F_32,F_8,D_20,X_12,B_16,0 },
 	[INSTR_RXY_FRRD]  = { 0xff, F_8,D20_20,X_12,B_16,0,0 },
 	[INSTR_RXY_RRRD]  = { 0xff, R_8,D20_20,X_12,B_16,0,0 },
 	[INSTR_RXY_URRD]  = { 0xff, U4_8,D20_20,X_12,B_16,0,0 },
 	[INSTR_RX_FRRD]	  = { 0xff, F_8,D_20,X_12,B_16,0,0 },
 	[INSTR_RX_RRRD]	  = { 0xff, R_8,D_20,X_12,B_16,0,0 },
 	[INSTR_RX_URRD]	  = { 0xff, U4_8,D_20,X_12,B_16,0,0 },
 	[INSTR_SIL_RDI]   = { 0xff, D_20,B_16,I16_32,0,0,0 },
 	[INSTR_SIL_RDU]   = { 0xff, D_20,B_16,U16_32,0,0,0 },
 	[INSTR_SIY_IRD]   = { 0xff, D20_20,B_16,I8_8,0,0,0 },
 	[INSTR_SIY_URD]	  = { 0xff, D20_20,B_16,U8_8,0,0,0 },
 	[INSTR_SI_URD]	  = { 0xff, D_20,B_16,U8_8,0,0,0 },
 	[INSTR_SSE_RDRD]  = { 0xff, D_20,B_16,D_36,B_32,0,0 },
 	[INSTR_SSF_RRDRD] = { 0x00, D_20,B_16,D_36,B_32,R_8,0 },
 	[INSTR_SSF_RRDRD2]= { 0x00, R_8,D_20,B_16,D_36,B_32,0 },
 	[INSTR_SS_L0RDRD] = { 0xff, D_20,L8_8,B_16,D_36,B_32,0 },
 	[INSTR_SS_LIRDRD] = { 0xff, D_20,L4_8,B_16,D_36,B_32,U4_12 },
 	[INSTR_SS_LLRDRD] = { 0xff, D_20,L4_8,B_16,D_36,L4_12,B_32 },
 	[INSTR_SS_RRRDRD2]= { 0xff, R_8,D_20,B_16,R_12,D_36,B_32 },
 	[INSTR_SS_RRRDRD3]= { 0xff, R_8,R_12,D_20,B_16,D_36,B_32 },
 	[INSTR_SS_RRRDRD] = { 0xff, D_20,R_8,B_16,D_36,B_32,R_12 },
 	[INSTR_S_00]	  = { 0xff, 0,0,0,0,0,0 },
 	[INSTR_S_RD]	  = { 0xff, D_20,B_16,0,0,0,0 },
 };
 enum {
 	LONG_INSN_ALGHSIK,
 	LONG_INSN_ALHSIK,
 	LONG_INSN_CLFHSI,
 	LONG_INSN_CLGFRL,
 	LONG_INSN_CLGHRL,
 	LONG_INSN_CLGHSI,
 	LONG_INSN_CLHHSI,
 	LONG_INSN_LLGFRL,
 	LONG_INSN_LLGHRL,
 	LONG_INSN_POPCNT,
 	LONG_INSN_RISBHG,
 	LONG_INSN_RISBLG,
 };
 static char *long_insn_name[] = {
 	[LONG_INSN_ALGHSIK] = "alghsik",
 	[LONG_INSN_ALHSIK] = "alhsik",
 	[LONG_INSN_CLFHSI] = "clfhsi",
 	[LONG_INSN_CLGFRL] = "clgfrl",
 	[LONG_INSN_CLGHRL] = "clghrl",
 	[LONG_INSN_CLGHSI] = "clghsi",
 	[LONG_INSN_CLHHSI] = "clhhsi",
 	[LONG_INSN_LLGFRL] = "llgfrl",
 	[LONG_INSN_LLGHRL] = "llghrl",
 	[LONG_INSN_POPCNT] = "popcnt",
 	[LONG_INSN_RISBHG] = "risbhg",
 	[LONG_INSN_RISBLG] = "risblk",
 };
 static struct insn opcode[] = {
 #ifdef CONFIG_64BIT
 	{ "lmd", 0xef, INSTR_SS_RRRDRD3 },
 #endif
 	{ "spm", 0x04, INSTR_RR_R0 },
 	{ "balr", 0x05, INSTR_RR_RR },
 	{ "bctr", 0x06, INSTR_RR_RR },
 	{ "bcr", 0x07, INSTR_RR_UR },
 	{ "svc", 0x0a, INSTR_RR_U0 },
 	{ "bsm", 0x0b, INSTR_RR_RR },
 	{ "bassm", 0x0c, INSTR_RR_RR },
 	{ "basr", 0x0d, INSTR_RR_RR },
 	{ "mvcl", 0x0e, INSTR_RR_RR },
 	{ "clcl", 0x0f, INSTR_RR_RR },
 	{ "lpr", 0x10, INSTR_RR_RR },
 	{ "lnr", 0x11, INSTR_RR_RR },
 	{ "ltr", 0x12, INSTR_RR_RR },
 	{ "lcr", 0x13, INSTR_RR_RR },
 	{ "nr", 0x14, INSTR_RR_RR },
 	{ "clr", 0x15, INSTR_RR_RR },
 	{ "or", 0x16, INSTR_RR_RR },
 	{ "xr", 0x17, INSTR_RR_RR },
 	{ "lr", 0x18, INSTR_RR_RR },
 	{ "cr", 0x19, INSTR_RR_RR },
 	{ "ar", 0x1a, INSTR_RR_RR },
 	{ "sr", 0x1b, INSTR_RR_RR },
 	{ "mr", 0x1c, INSTR_RR_RR },
 	{ "dr", 0x1d, INSTR_RR_RR },
 	{ "alr", 0x1e, INSTR_RR_RR },
 	{ "slr", 0x1f, INSTR_RR_RR },
 	{ "lpdr", 0x20, INSTR_RR_FF },
 	{ "lndr", 0x21, INSTR_RR_FF },
 	{ "ltdr", 0x22, INSTR_RR_FF },
 	{ "lcdr", 0x23, INSTR_RR_FF },
 	{ "hdr", 0x24, INSTR_RR_FF },
 	{ "ldxr", 0x25, INSTR_RR_FF },
 	{ "lrdr", 0x25, INSTR_RR_FF },
 	{ "mxr", 0x26, INSTR_RR_FF },
 	{ "mxdr", 0x27, INSTR_RR_FF },
 	{ "ldr", 0x28, INSTR_RR_FF },
 	{ "cdr", 0x29, INSTR_RR_FF },
 	{ "adr", 0x2a, INSTR_RR_FF },
 	{ "sdr", 0x2b, INSTR_RR_FF },
 	{ "mdr", 0x2c, INSTR_RR_FF },
 	{ "ddr", 0x2d, INSTR_RR_FF },
 	{ "awr", 0x2e, INSTR_RR_FF },
 	{ "swr", 0x2f, INSTR_RR_FF },
 	{ "lper", 0x30, INSTR_RR_FF },
 	{ "lner", 0x31, INSTR_RR_FF },
 	{ "lter", 0x32, INSTR_RR_FF },
 	{ "lcer", 0x33, INSTR_RR_FF },
 	{ "her", 0x34, INSTR_RR_FF },
 	{ "ledr", 0x35, INSTR_RR_FF },
 	{ "lrer", 0x35, INSTR_RR_FF },
 	{ "axr", 0x36, INSTR_RR_FF },
 	{ "sxr", 0x37, INSTR_RR_FF },
 	{ "ler", 0x38, INSTR_RR_FF },
 	{ "cer", 0x39, INSTR_RR_FF },
 	{ "aer", 0x3a, INSTR_RR_FF },
 	{ "ser", 0x3b, INSTR_RR_FF },
 	{ "mder", 0x3c, INSTR_RR_FF },
 	{ "mer", 0x3c, INSTR_RR_FF },
 	{ "der", 0x3d, INSTR_RR_FF },
 	{ "aur", 0x3e, INSTR_RR_FF },
 	{ "sur", 0x3f, INSTR_RR_FF },
 	{ "sth", 0x40, INSTR_RX_RRRD },
 	{ "la", 0x41, INSTR_RX_RRRD },
 	{ "stc", 0x42, INSTR_RX_RRRD },
 	{ "ic", 0x43, INSTR_RX_RRRD },
 	{ "ex", 0x44, INSTR_RX_RRRD },
 	{ "bal", 0x45, INSTR_RX_RRRD },
 	{ "bct", 0x46, INSTR_RX_RRRD },
 	{ "bc", 0x47, INSTR_RX_URRD },
 	{ "lh", 0x48, INSTR_RX_RRRD },
 	{ "ch", 0x49, INSTR_RX_RRRD },
 	{ "ah", 0x4a, INSTR_RX_RRRD },
 	{ "sh", 0x4b, INSTR_RX_RRRD },
 	{ "mh", 0x4c, INSTR_RX_RRRD },
 	{ "bas", 0x4d, INSTR_RX_RRRD },
 	{ "cvd", 0x4e, INSTR_RX_RRRD },
 	{ "cvb", 0x4f, INSTR_RX_RRRD },
 	{ "st", 0x50, INSTR_RX_RRRD },
 	{ "lae", 0x51, INSTR_RX_RRRD },
 	{ "n", 0x54, INSTR_RX_RRRD },
 	{ "cl", 0x55, INSTR_RX_RRRD },
 	{ "o", 0x56, INSTR_RX_RRRD },
 	{ "x", 0x57, INSTR_RX_RRRD },
 	{ "l", 0x58, INSTR_RX_RRRD },
 	{ "c", 0x59, INSTR_RX_RRRD },
 	{ "a", 0x5a, INSTR_RX_RRRD },
 	{ "s", 0x5b, INSTR_RX_RRRD },
 	{ "m", 0x5c, INSTR_RX_RRRD },
 	{ "d", 0x5d, INSTR_RX_RRRD },
 	{ "al", 0x5e, INSTR_RX_RRRD },
 	{ "sl", 0x5f, INSTR_RX_RRRD },
 	{ "std", 0x60, INSTR_RX_FRRD },
 	{ "mxd", 0x67, INSTR_RX_FRRD },
 	{ "ld", 0x68, INSTR_RX_FRRD },
 	{ "cd", 0x69, INSTR_RX_FRRD },
 	{ "ad", 0x6a, INSTR_RX_FRRD },
 	{ "sd", 0x6b, INSTR_RX_FRRD },
 	{ "md", 0x6c, INSTR_RX_FRRD },
 	{ "dd", 0x6d, INSTR_RX_FRRD },
 	{ "aw", 0x6e, INSTR_RX_FRRD },
 	{ "sw", 0x6f, INSTR_RX_FRRD },
 	{ "ste", 0x70, INSTR_RX_FRRD },
 	{ "ms", 0x71, INSTR_RX_RRRD },
 	{ "le", 0x78, INSTR_RX_FRRD },
 	{ "ce", 0x79, INSTR_RX_FRRD },
 	{ "ae", 0x7a, INSTR_RX_FRRD },
 	{ "se", 0x7b, INSTR_RX_FRRD },
 	{ "mde", 0x7c, INSTR_RX_FRRD },
 	{ "me", 0x7c, INSTR_RX_FRRD },
 	{ "de", 0x7d, INSTR_RX_FRRD },
 	{ "au", 0x7e, INSTR_RX_FRRD },
 	{ "su", 0x7f, INSTR_RX_FRRD },
 	{ "ssm", 0x80, INSTR_S_RD },
 	{ "lpsw", 0x82, INSTR_S_RD },
 	{ "diag", 0x83, INSTR_RS_RRRD },
 	{ "brxh", 0x84, INSTR_RSI_RRP },
 	{ "brxle", 0x85, INSTR_RSI_RRP },
 	{ "bxh", 0x86, INSTR_RS_RRRD },
 	{ "bxle", 0x87, INSTR_RS_RRRD },
 	{ "srl", 0x88, INSTR_RS_R0RD },
 	{ "sll", 0x89, INSTR_RS_R0RD },
 	{ "sra", 0x8a, INSTR_RS_R0RD },
 	{ "sla", 0x8b, INSTR_RS_R0RD },
 	{ "srdl", 0x8c, INSTR_RS_R0RD },
 	{ "sldl", 0x8d, INSTR_RS_R0RD },
 	{ "srda", 0x8e, INSTR_RS_R0RD },
 	{ "slda", 0x8f, INSTR_RS_R0RD },
 	{ "stm", 0x90, INSTR_RS_RRRD },
 	{ "tm", 0x91, INSTR_SI_URD },
 	{ "mvi", 0x92, INSTR_SI_URD },
 	{ "ts", 0x93, INSTR_S_RD },
 	{ "ni", 0x94, INSTR_SI_URD },
 	{ "cli", 0x95, INSTR_SI_URD },
 	{ "oi", 0x96, INSTR_SI_URD },
 	{ "xi", 0x97, INSTR_SI_URD },
 	{ "lm", 0x98, INSTR_RS_RRRD },
 	{ "trace", 0x99, INSTR_RS_RRRD },
 	{ "lam", 0x9a, INSTR_RS_AARD },
 	{ "stam", 0x9b, INSTR_RS_AARD },
 	{ "mvcle", 0xa8, INSTR_RS_RRRD },
 	{ "clcle", 0xa9, INSTR_RS_RRRD },
 	{ "stnsm", 0xac, INSTR_SI_URD },
 	{ "stosm", 0xad, INSTR_SI_URD },
 	{ "sigp", 0xae, INSTR_RS_RRRD },
 	{ "mc", 0xaf, INSTR_SI_URD },
 	{ "lra", 0xb1, INSTR_RX_RRRD },
 	{ "stctl", 0xb6, INSTR_RS_CCRD },
 	{ "lctl", 0xb7, INSTR_RS_CCRD },
 	{ "cs", 0xba, INSTR_RS_RRRD },
 	{ "cds", 0xbb, INSTR_RS_RRRD },
 	{ "clm", 0xbd, INSTR_RS_RURD },
 	{ "stcm", 0xbe, INSTR_RS_RURD },
 	{ "icm", 0xbf, INSTR_RS_RURD },
 	{ "mvn", 0xd1, INSTR_SS_L0RDRD },
 	{ "mvc", 0xd2, INSTR_SS_L0RDRD },
 	{ "mvz", 0xd3, INSTR_SS_L0RDRD },
 	{ "nc", 0xd4, INSTR_SS_L0RDRD },
 	{ "clc", 0xd5, INSTR_SS_L0RDRD },
 	{ "oc", 0xd6, INSTR_SS_L0RDRD },
 	{ "xc", 0xd7, INSTR_SS_L0RDRD },
 	{ "mvck", 0xd9, INSTR_SS_RRRDRD },
 	{ "mvcp", 0xda, INSTR_SS_RRRDRD },
 	{ "mvcs", 0xdb, INSTR_SS_RRRDRD },
 	{ "tr", 0xdc, INSTR_SS_L0RDRD },
 	{ "trt", 0xdd, INSTR_SS_L0RDRD },
 	{ "ed", 0xde, INSTR_SS_L0RDRD },
 	{ "edmk", 0xdf, INSTR_SS_L0RDRD },
 	{ "pku", 0xe1, INSTR_SS_L0RDRD },
 	{ "unpku", 0xe2, INSTR_SS_L0RDRD },
 	{ "mvcin", 0xe8, INSTR_SS_L0RDRD },
 	{ "pka", 0xe9, INSTR_SS_L0RDRD },
 	{ "unpka", 0xea, INSTR_SS_L0RDRD },
 	{ "plo", 0xee, INSTR_SS_RRRDRD2 },
 	{ "srp", 0xf0, INSTR_SS_LIRDRD },
 	{ "mvo", 0xf1, INSTR_SS_LLRDRD },
 	{ "pack", 0xf2, INSTR_SS_LLRDRD },
 	{ "unpk", 0xf3, INSTR_SS_LLRDRD },
 	{ "zap", 0xf8, INSTR_SS_LLRDRD },
 	{ "cp", 0xf9, INSTR_SS_LLRDRD },
 	{ "ap", 0xfa, INSTR_SS_LLRDRD },
 	{ "sp", 0xfb, INSTR_SS_LLRDRD },
 	{ "mp", 0xfc, INSTR_SS_LLRDRD },
 	{ "dp", 0xfd, INSTR_SS_LLRDRD },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_01[] = {
 #ifdef CONFIG_64BIT
 	{ "sam64", 0x0e, INSTR_E },
 	{ "pfpo", 0x0a, INSTR_E },
 	{ "ptff", 0x04, INSTR_E },
 #endif
 	{ "pr", 0x01, INSTR_E },
 	{ "upt", 0x02, INSTR_E },
 	{ "sckpf", 0x07, INSTR_E },
 	{ "tam", 0x0b, INSTR_E },
 	{ "sam24", 0x0c, INSTR_E },
 	{ "sam31", 0x0d, INSTR_E },
 	{ "trap2", 0xff, INSTR_E },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_a5[] = {
 #ifdef CONFIG_64BIT
 	{ "iihh", 0x00, INSTR_RI_RU },
 	{ "iihl", 0x01, INSTR_RI_RU },
 	{ "iilh", 0x02, INSTR_RI_RU },
 	{ "iill", 0x03, INSTR_RI_RU },
 	{ "nihh", 0x04, INSTR_RI_RU },
 	{ "nihl", 0x05, INSTR_RI_RU },
 	{ "nilh", 0x06, INSTR_RI_RU },
 	{ "nill", 0x07, INSTR_RI_RU },
 	{ "oihh", 0x08, INSTR_RI_RU },
 	{ "oihl", 0x09, INSTR_RI_RU },
 	{ "oilh", 0x0a, INSTR_RI_RU },
 	{ "oill", 0x0b, INSTR_RI_RU },
 	{ "llihh", 0x0c, INSTR_RI_RU },
 	{ "llihl", 0x0d, INSTR_RI_RU },
 	{ "llilh", 0x0e, INSTR_RI_RU },
 	{ "llill", 0x0f, INSTR_RI_RU },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_a7[] = {
 #ifdef CONFIG_64BIT
 	{ "tmhh", 0x02, INSTR_RI_RU },
 	{ "tmhl", 0x03, INSTR_RI_RU },
 	{ "brctg", 0x07, INSTR_RI_RP },
 	{ "lghi", 0x09, INSTR_RI_RI },
 	{ "aghi", 0x0b, INSTR_RI_RI },
 	{ "mghi", 0x0d, INSTR_RI_RI },
 	{ "cghi", 0x0f, INSTR_RI_RI },
 #endif
 	{ "tmlh", 0x00, INSTR_RI_RU },
 	{ "tmll", 0x01, INSTR_RI_RU },
 	{ "brc", 0x04, INSTR_RI_UP },
 	{ "bras", 0x05, INSTR_RI_RP },
 	{ "brct", 0x06, INSTR_RI_RP },
 	{ "lhi", 0x08, INSTR_RI_RI },
 	{ "ahi", 0x0a, INSTR_RI_RI },
 	{ "mhi", 0x0c, INSTR_RI_RI },
 	{ "chi", 0x0e, INSTR_RI_RI },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_b2[] = {
 #ifdef CONFIG_64BIT
 	{ "sske", 0x2b, INSTR_RRF_M0RR },
 	{ "stckf", 0x7c, INSTR_S_RD },
 	{ "cu21", 0xa6, INSTR_RRF_M0RR },
 	{ "cuutf", 0xa6, INSTR_RRF_M0RR },
 	{ "cu12", 0xa7, INSTR_RRF_M0RR },
 	{ "cutfu", 0xa7, INSTR_RRF_M0RR },
 	{ "stfle", 0xb0, INSTR_S_RD },
 	{ "lpswe", 0xb2, INSTR_S_RD },
 	{ "srnmt", 0xb9, INSTR_S_RD },
 	{ "lfas", 0xbd, INSTR_S_RD },
 #endif
 	{ "stidp", 0x02, INSTR_S_RD },
 	{ "sck", 0x04, INSTR_S_RD },
 	{ "stck", 0x05, INSTR_S_RD },
 	{ "sckc", 0x06, INSTR_S_RD },
 	{ "stckc", 0x07, INSTR_S_RD },
 	{ "spt", 0x08, INSTR_S_RD },
 	{ "stpt", 0x09, INSTR_S_RD },
 	{ "spka", 0x0a, INSTR_S_RD },
 	{ "ipk", 0x0b, INSTR_S_00 },
 	{ "ptlb", 0x0d, INSTR_S_00 },
 	{ "spx", 0x10, INSTR_S_RD },
 	{ "stpx", 0x11, INSTR_S_RD },
 	{ "stap", 0x12, INSTR_S_RD },
 	{ "sie", 0x14, INSTR_S_RD },
 	{ "pc", 0x18, INSTR_S_RD },
 	{ "sac", 0x19, INSTR_S_RD },
 	{ "cfc", 0x1a, INSTR_S_RD },
 	{ "ipte", 0x21, INSTR_RRE_RR },
 	{ "ipm", 0x22, INSTR_RRE_R0 },
 	{ "ivsk", 0x23, INSTR_RRE_RR },
 	{ "iac", 0x24, INSTR_RRE_R0 },
 	{ "ssar", 0x25, INSTR_RRE_R0 },
 	{ "epar", 0x26, INSTR_RRE_R0 },
 	{ "esar", 0x27, INSTR_RRE_R0 },
 	{ "pt", 0x28, INSTR_RRE_RR },
 	{ "iske", 0x29, INSTR_RRE_RR },
 	{ "rrbe", 0x2a, INSTR_RRE_RR },
 	{ "sske", 0x2b, INSTR_RRE_RR },
 	{ "tb", 0x2c, INSTR_RRE_0R },
 	{ "dxr", 0x2d, INSTR_RRE_F0 },
 	{ "pgin", 0x2e, INSTR_RRE_RR },
 	{ "pgout", 0x2f, INSTR_RRE_RR },
 	{ "csch", 0x30, INSTR_S_00 },
 	{ "hsch", 0x31, INSTR_S_00 },
 	{ "msch", 0x32, INSTR_S_RD },
 	{ "ssch", 0x33, INSTR_S_RD },
 	{ "stsch", 0x34, INSTR_S_RD },
 	{ "tsch", 0x35, INSTR_S_RD },
 	{ "tpi", 0x36, INSTR_S_RD },
 	{ "sal", 0x37, INSTR_S_00 },
 	{ "rsch", 0x38, INSTR_S_00 },
 	{ "stcrw", 0x39, INSTR_S_RD },
 	{ "stcps", 0x3a, INSTR_S_RD },
 	{ "rchp", 0x3b, INSTR_S_00 },
 	{ "schm", 0x3c, INSTR_S_00 },
 	{ "bakr", 0x40, INSTR_RRE_RR },
 	{ "cksm", 0x41, INSTR_RRE_RR },
 	{ "sqdr", 0x44, INSTR_RRE_F0 },
 	{ "sqer", 0x45, INSTR_RRE_F0 },
 	{ "stura", 0x46, INSTR_RRE_RR },
 	{ "msta", 0x47, INSTR_RRE_R0 },
 	{ "palb", 0x48, INSTR_RRE_00 },
 	{ "ereg", 0x49, INSTR_RRE_RR },
 	{ "esta", 0x4a, INSTR_RRE_RR },
 	{ "lura", 0x4b, INSTR_RRE_RR },
 	{ "tar", 0x4c, INSTR_RRE_AR },
 	{ "cpya", 0x4d, INSTR_RRE_AA },
 	{ "sar", 0x4e, INSTR_RRE_AR },
 	{ "ear", 0x4f, INSTR_RRE_RA },
 	{ "csp", 0x50, INSTR_RRE_RR },
 	{ "msr", 0x52, INSTR_RRE_RR },
 	{ "mvpg", 0x54, INSTR_RRE_RR },
 	{ "mvst", 0x55, INSTR_RRE_RR },
 	{ "cuse", 0x57, INSTR_RRE_RR },
 	{ "bsg", 0x58, INSTR_RRE_RR },
 	{ "bsa", 0x5a, INSTR_RRE_RR },
 	{ "clst", 0x5d, INSTR_RRE_RR },
 	{ "srst", 0x5e, INSTR_RRE_RR },
 	{ "cmpsc", 0x63, INSTR_RRE_RR },
 	{ "siga", 0x74, INSTR_S_RD },
 	{ "xsch", 0x76, INSTR_S_00 },
 	{ "rp", 0x77, INSTR_S_RD },
 	{ "stcke", 0x78, INSTR_S_RD },
 	{ "sacf", 0x79, INSTR_S_RD },
 	{ "spp", 0x80, INSTR_S_RD },
 	{ "stsi", 0x7d, INSTR_S_RD },
 	{ "srnm", 0x99, INSTR_S_RD },
 	{ "stfpc", 0x9c, INSTR_S_RD },
 	{ "lfpc", 0x9d, INSTR_S_RD },
 	{ "tre", 0xa5, INSTR_RRE_RR },
 	{ "cuutf", 0xa6, INSTR_RRE_RR },
 	{ "cutfu", 0xa7, INSTR_RRE_RR },
 	{ "stfl", 0xb1, INSTR_S_RD },
 	{ "trap4", 0xff, INSTR_S_RD },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_b3[] = {
 #ifdef CONFIG_64BIT
 	{ "maylr", 0x38, INSTR_RRF_F0FF },
 	{ "mylr", 0x39, INSTR_RRF_F0FF },
 	{ "mayr", 0x3a, INSTR_RRF_F0FF },
 	{ "myr", 0x3b, INSTR_RRF_F0FF },
 	{ "mayhr", 0x3c, INSTR_RRF_F0FF },
 	{ "myhr", 0x3d, INSTR_RRF_F0FF },
 	{ "cegbr", 0xa4, INSTR_RRE_RR },
 	{ "cdgbr", 0xa5, INSTR_RRE_RR },
 	{ "cxgbr", 0xa6, INSTR_RRE_RR },
 	{ "cgebr", 0xa8, INSTR_RRF_U0RF },
 	{ "cgdbr", 0xa9, INSTR_RRF_U0RF },
 	{ "cgxbr", 0xaa, INSTR_RRF_U0RF },
 	{ "cfer", 0xb8, INSTR_RRF_U0RF },
 	{ "cfdr", 0xb9, INSTR_RRF_U0RF },
 	{ "cfxr", 0xba, INSTR_RRF_U0RF },
 	{ "cegr", 0xc4, INSTR_RRE_RR },
 	{ "cdgr", 0xc5, INSTR_RRE_RR },
 	{ "cxgr", 0xc6, INSTR_RRE_RR },
 	{ "cger", 0xc8, INSTR_RRF_U0RF },
 	{ "cgdr", 0xc9, INSTR_RRF_U0RF },
 	{ "cgxr", 0xca, INSTR_RRF_U0RF },
 	{ "lpdfr", 0x70, INSTR_RRE_FF },
 	{ "lndfr", 0x71, INSTR_RRE_FF },
 	{ "cpsdr", 0x72, INSTR_RRF_F0FF2 },
 	{ "lcdfr", 0x73, INSTR_RRE_FF },
 	{ "ldgr", 0xc1, INSTR_RRE_FR },
 	{ "lgdr", 0xcd, INSTR_RRE_RF },
 	{ "adtr", 0xd2, INSTR_RRR_F0FF },
 	{ "axtr", 0xda, INSTR_RRR_F0FF },
 	{ "cdtr", 0xe4, INSTR_RRE_FF },
 	{ "cxtr", 0xec, INSTR_RRE_FF },
 	{ "kdtr", 0xe0, INSTR_RRE_FF },
 	{ "kxtr", 0xe8, INSTR_RRE_FF },
 	{ "cedtr", 0xf4, INSTR_RRE_FF },
 	{ "cextr", 0xfc, INSTR_RRE_FF },
 	{ "cdgtr", 0xf1, INSTR_RRE_FR },
 	{ "cxgtr", 0xf9, INSTR_RRE_FR },
 	{ "cdstr", 0xf3, INSTR_RRE_FR },
 	{ "cxstr", 0xfb, INSTR_RRE_FR },
 	{ "cdutr", 0xf2, INSTR_RRE_FR },
 	{ "cxutr", 0xfa, INSTR_RRE_FR },
 	{ "cgdtr", 0xe1, INSTR_RRF_U0RF },
 	{ "cgxtr", 0xe9, INSTR_RRF_U0RF },
 	{ "csdtr", 0xe3, INSTR_RRE_RF },
 	{ "csxtr", 0xeb, INSTR_RRE_RF },
 	{ "cudtr", 0xe2, INSTR_RRE_RF },
 	{ "cuxtr", 0xea, INSTR_RRE_RF },
 	{ "ddtr", 0xd1, INSTR_RRR_F0FF },
 	{ "dxtr", 0xd9, INSTR_RRR_F0FF },
 	{ "eedtr", 0xe5, INSTR_RRE_RF },
 	{ "eextr", 0xed, INSTR_RRE_RF },
 	{ "esdtr", 0xe7, INSTR_RRE_RF },
 	{ "esxtr", 0xef, INSTR_RRE_RF },
 	{ "iedtr", 0xf6, INSTR_RRF_F0FR },
 	{ "iextr", 0xfe, INSTR_RRF_F0FR },
 	{ "ltdtr", 0xd6, INSTR_RRE_FF },
 	{ "ltxtr", 0xde, INSTR_RRE_FF },
 	{ "fidtr", 0xd7, INSTR_RRF_UUFF },
 	{ "fixtr", 0xdf, INSTR_RRF_UUFF },
 	{ "ldetr", 0xd4, INSTR_RRF_0UFF },
 	{ "lxdtr", 0xdc, INSTR_RRF_0UFF },
 	{ "ledtr", 0xd5, INSTR_RRF_UUFF },
 	{ "ldxtr", 0xdd, INSTR_RRF_UUFF },
 	{ "mdtr", 0xd0, INSTR_RRR_F0FF },
 	{ "mxtr", 0xd8, INSTR_RRR_F0FF },
 	{ "qadtr", 0xf5, INSTR_RRF_FUFF },
 	{ "qaxtr", 0xfd, INSTR_RRF_FUFF },
 	{ "rrdtr", 0xf7, INSTR_RRF_FFRU },
 	{ "rrxtr", 0xff, INSTR_RRF_FFRU },
 	{ "sfasr", 0x85, INSTR_RRE_R0 },
 	{ "sdtr", 0xd3, INSTR_RRR_F0FF },
 	{ "sxtr", 0xdb, INSTR_RRR_F0FF },
 #endif
 	{ "lpebr", 0x00, INSTR_RRE_FF },
 	{ "lnebr", 0x01, INSTR_RRE_FF },
 	{ "ltebr", 0x02, INSTR_RRE_FF },
 	{ "lcebr", 0x03, INSTR_RRE_FF },
 	{ "ldebr", 0x04, INSTR_RRE_FF },
 	{ "lxdbr", 0x05, INSTR_RRE_FF },
 	{ "lxebr", 0x06, INSTR_RRE_FF },
 	{ "mxdbr", 0x07, INSTR_RRE_FF },
 	{ "kebr", 0x08, INSTR_RRE_FF },
 	{ "cebr", 0x09, INSTR_RRE_FF },
 	{ "aebr", 0x0a, INSTR_RRE_FF },
 	{ "sebr", 0x0b, INSTR_RRE_FF },
 	{ "mdebr", 0x0c, INSTR_RRE_FF },
 	{ "debr", 0x0d, INSTR_RRE_FF },
 	{ "maebr", 0x0e, INSTR_RRF_F0FF },
 	{ "msebr", 0x0f, INSTR_RRF_F0FF },
 	{ "lpdbr", 0x10, INSTR_RRE_FF },
 	{ "lndbr", 0x11, INSTR_RRE_FF },
 	{ "ltdbr", 0x12, INSTR_RRE_FF },
 	{ "lcdbr", 0x13, INSTR_RRE_FF },
 	{ "sqebr", 0x14, INSTR_RRE_FF },
 	{ "sqdbr", 0x15, INSTR_RRE_FF },
 	{ "sqxbr", 0x16, INSTR_RRE_FF },
 	{ "meebr", 0x17, INSTR_RRE_FF },
 	{ "kdbr", 0x18, INSTR_RRE_FF },
 	{ "cdbr", 0x19, INSTR_RRE_FF },
 	{ "adbr", 0x1a, INSTR_RRE_FF },
 	{ "sdbr", 0x1b, INSTR_RRE_FF },
 	{ "mdbr", 0x1c, INSTR_RRE_FF },
 	{ "ddbr", 0x1d, INSTR_RRE_FF },
 	{ "madbr", 0x1e, INSTR_RRF_F0FF },
 	{ "msdbr", 0x1f, INSTR_RRF_F0FF },
 	{ "lder", 0x24, INSTR_RRE_FF },
 	{ "lxdr", 0x25, INSTR_RRE_FF },
 	{ "lxer", 0x26, INSTR_RRE_FF },
 	{ "maer", 0x2e, INSTR_RRF_F0FF },
 	{ "mser", 0x2f, INSTR_RRF_F0FF },
 	{ "sqxr", 0x36, INSTR_RRE_FF },
 	{ "meer", 0x37, INSTR_RRE_FF },
 	{ "madr", 0x3e, INSTR_RRF_F0FF },
 	{ "msdr", 0x3f, INSTR_RRF_F0FF },
 	{ "lpxbr", 0x40, INSTR_RRE_FF },
 	{ "lnxbr", 0x41, INSTR_RRE_FF },
 	{ "ltxbr", 0x42, INSTR_RRE_FF },
 	{ "lcxbr", 0x43, INSTR_RRE_FF },
 	{ "ledbr", 0x44, INSTR_RRE_FF },
 	{ "ldxbr", 0x45, INSTR_RRE_FF },
 	{ "lexbr", 0x46, INSTR_RRE_FF },
 	{ "fixbr", 0x47, INSTR_RRF_U0FF },
 	{ "kxbr", 0x48, INSTR_RRE_FF },
 	{ "cxbr", 0x49, INSTR_RRE_FF },
 	{ "axbr", 0x4a, INSTR_RRE_FF },
 	{ "sxbr", 0x4b, INSTR_RRE_FF },
 	{ "mxbr", 0x4c, INSTR_RRE_FF },
 	{ "dxbr", 0x4d, INSTR_RRE_FF },
 	{ "tbedr", 0x50, INSTR_RRF_U0FF },
 	{ "tbdr", 0x51, INSTR_RRF_U0FF },
 	{ "diebr", 0x53, INSTR_RRF_FUFF },
 	{ "fiebr", 0x57, INSTR_RRF_U0FF },
 	{ "thder", 0x58, INSTR_RRE_RR },
 	{ "thdr", 0x59, INSTR_RRE_RR },
 	{ "didbr", 0x5b, INSTR_RRF_FUFF },
 	{ "fidbr", 0x5f, INSTR_RRF_U0FF },
 	{ "lpxr", 0x60, INSTR_RRE_FF },
 	{ "lnxr", 0x61, INSTR_RRE_FF },
 	{ "ltxr", 0x62, INSTR_RRE_FF },
 	{ "lcxr", 0x63, INSTR_RRE_FF },
 	{ "lxr", 0x65, INSTR_RRE_RR },
 	{ "lexr", 0x66, INSTR_RRE_FF },
 	{ "fixr", 0x67, INSTR_RRF_U0FF },
 	{ "cxr", 0x69, INSTR_RRE_FF },
 	{ "lzer", 0x74, INSTR_RRE_R0 },
 	{ "lzdr", 0x75, INSTR_RRE_R0 },
 	{ "lzxr", 0x76, INSTR_RRE_R0 },
 	{ "fier", 0x77, INSTR_RRF_U0FF },
 	{ "fidr", 0x7f, INSTR_RRF_U0FF },
 	{ "sfpc", 0x84, INSTR_RRE_RR_OPT },
 	{ "efpc", 0x8c, INSTR_RRE_RR_OPT },
 	{ "cefbr", 0x94, INSTR_RRE_RF },
 	{ "cdfbr", 0x95, INSTR_RRE_RF },
 	{ "cxfbr", 0x96, INSTR_RRE_RF },
 	{ "cfebr", 0x98, INSTR_RRF_U0RF },
 	{ "cfdbr", 0x99, INSTR_RRF_U0RF },
 	{ "cfxbr", 0x9a, INSTR_RRF_U0RF },
 	{ "cefr", 0xb4, INSTR_RRE_RF },
 	{ "cdfr", 0xb5, INSTR_RRE_RF },
 	{ "cxfr", 0xb6, INSTR_RRE_RF },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_b9[] = {
 #ifdef CONFIG_64BIT
 	{ "lpgr", 0x00, INSTR_RRE_RR },
 	{ "lngr", 0x01, INSTR_RRE_RR },
 	{ "ltgr", 0x02, INSTR_RRE_RR },
 	{ "lcgr", 0x03, INSTR_RRE_RR },
 	{ "lgr", 0x04, INSTR_RRE_RR },
 	{ "lurag", 0x05, INSTR_RRE_RR },
 	{ "lgbr", 0x06, INSTR_RRE_RR },
 	{ "lghr", 0x07, INSTR_RRE_RR },
 	{ "agr", 0x08, INSTR_RRE_RR },
 	{ "sgr", 0x09, INSTR_RRE_RR },
 	{ "algr", 0x0a, INSTR_RRE_RR },
 	{ "slgr", 0x0b, INSTR_RRE_RR },
 	{ "msgr", 0x0c, INSTR_RRE_RR },
 	{ "dsgr", 0x0d, INSTR_RRE_RR },
 	{ "eregg", 0x0e, INSTR_RRE_RR },
 	{ "lrvgr", 0x0f, INSTR_RRE_RR },
 	{ "lpgfr", 0x10, INSTR_RRE_RR },
 	{ "lngfr", 0x11, INSTR_RRE_RR },
 	{ "ltgfr", 0x12, INSTR_RRE_RR },
 	{ "lcgfr", 0x13, INSTR_RRE_RR },
 	{ "lgfr", 0x14, INSTR_RRE_RR },
 	{ "llgfr", 0x16, INSTR_RRE_RR },
 	{ "llgtr", 0x17, INSTR_RRE_RR },
 	{ "agfr", 0x18, INSTR_RRE_RR },
 	{ "sgfr", 0x19, INSTR_RRE_RR },
 	{ "algfr", 0x1a, INSTR_RRE_RR },
 	{ "slgfr", 0x1b, INSTR_RRE_RR },
 	{ "msgfr", 0x1c, INSTR_RRE_RR },
 	{ "dsgfr", 0x1d, INSTR_RRE_RR },
 	{ "cgr", 0x20, INSTR_RRE_RR },
 	{ "clgr", 0x21, INSTR_RRE_RR },
 	{ "sturg", 0x25, INSTR_RRE_RR },
 	{ "lbr", 0x26, INSTR_RRE_RR },
 	{ "lhr", 0x27, INSTR_RRE_RR },
 	{ "cgfr", 0x30, INSTR_RRE_RR },
 	{ "clgfr", 0x31, INSTR_RRE_RR },
 	{ "bctgr", 0x46, INSTR_RRE_RR },
 	{ "ngr", 0x80, INSTR_RRE_RR },
 	{ "ogr", 0x81, INSTR_RRE_RR },
 	{ "xgr", 0x82, INSTR_RRE_RR },
 	{ "flogr", 0x83, INSTR_RRE_RR },
 	{ "llgcr", 0x84, INSTR_RRE_RR },
 	{ "llghr", 0x85, INSTR_RRE_RR },
 	{ "mlgr", 0x86, INSTR_RRE_RR },
 	{ "dlgr", 0x87, INSTR_RRE_RR },
 	{ "alcgr", 0x88, INSTR_RRE_RR },
 	{ "slbgr", 0x89, INSTR_RRE_RR },
 	{ "cspg", 0x8a, INSTR_RRE_RR },
 	{ "idte", 0x8e, INSTR_RRF_R0RR },
 	{ "llcr", 0x94, INSTR_RRE_RR },
 	{ "llhr", 0x95, INSTR_RRE_RR },
 	{ "esea", 0x9d, INSTR_RRE_R0 },
 	{ "lptea", 0xaa, INSTR_RRF_RURR },
 	{ "cu14", 0xb0, INSTR_RRF_M0RR },
 	{ "cu24", 0xb1, INSTR_RRF_M0RR },
 	{ "cu41", 0xb2, INSTR_RRF_M0RR },
 	{ "cu42", 0xb3, INSTR_RRF_M0RR },
 	{ "crt", 0x72, INSTR_RRF_U0RR },
 	{ "cgrt", 0x60, INSTR_RRF_U0RR },
 	{ "clrt", 0x73, INSTR_RRF_U0RR },
 	{ "clgrt", 0x61, INSTR_RRF_U0RR },
 	{ "ptf", 0xa2, INSTR_RRE_R0 },
 	{ "pfmf", 0xaf, INSTR_RRE_RR },
 	{ "trte", 0xbf, INSTR_RRF_M0RR },
 	{ "trtre", 0xbd, INSTR_RRF_M0RR },
 	{ "ahhhr", 0xc8, INSTR_RRF_R0RR2 },
 	{ "shhhr", 0xc9, INSTR_RRF_R0RR2 },
 	{ "alhhh", 0xca, INSTR_RRF_R0RR2 },
 	{ "alhhl", 0xca, INSTR_RRF_R0RR2 },
 	{ "slhhh", 0xcb, INSTR_RRF_R0RR2 },
 	{ "chhr ", 0xcd, INSTR_RRE_RR },
 	{ "clhhr", 0xcf, INSTR_RRE_RR },
 	{ "ahhlr", 0xd8, INSTR_RRF_R0RR2 },
 	{ "shhlr", 0xd9, INSTR_RRF_R0RR2 },
 	{ "slhhl", 0xdb, INSTR_RRF_R0RR2 },
 	{ "chlr", 0xdd, INSTR_RRE_RR },
 	{ "clhlr", 0xdf, INSTR_RRE_RR },
 	{ { 0, LONG_INSN_POPCNT }, 0xe1, INSTR_RRE_RR },
 	{ "locgr", 0xe2, INSTR_RRF_M0RR },
 	{ "ngrk", 0xe4, INSTR_RRF_R0RR2 },
 	{ "ogrk", 0xe6, INSTR_RRF_R0RR2 },
 	{ "xgrk", 0xe7, INSTR_RRF_R0RR2 },
 	{ "agrk", 0xe8, INSTR_RRF_R0RR2 },
 	{ "sgrk", 0xe9, INSTR_RRF_R0RR2 },
 	{ "algrk", 0xea, INSTR_RRF_R0RR2 },
 	{ "slgrk", 0xeb, INSTR_RRF_R0RR2 },
 	{ "locr", 0xf2, INSTR_RRF_M0RR },
 	{ "nrk", 0xf4, INSTR_RRF_R0RR2 },
 	{ "ork", 0xf6, INSTR_RRF_R0RR2 },
 	{ "xrk", 0xf7, INSTR_RRF_R0RR2 },
 	{ "ark", 0xf8, INSTR_RRF_R0RR2 },
 	{ "srk", 0xf9, INSTR_RRF_R0RR2 },
 	{ "alrk", 0xfa, INSTR_RRF_R0RR2 },
 	{ "slrk", 0xfb, INSTR_RRF_R0RR2 },
 #endif
 	{ "kmac", 0x1e, INSTR_RRE_RR },
 	{ "lrvr", 0x1f, INSTR_RRE_RR },
 	{ "km", 0x2e, INSTR_RRE_RR },
 	{ "kmc", 0x2f, INSTR_RRE_RR },
 	{ "kimd", 0x3e, INSTR_RRE_RR },
 	{ "klmd", 0x3f, INSTR_RRE_RR },
 	{ "epsw", 0x8d, INSTR_RRE_RR },
 	{ "trtt", 0x90, INSTR_RRE_RR },
 	{ "trtt", 0x90, INSTR_RRF_M0RR },
 	{ "trto", 0x91, INSTR_RRE_RR },
 	{ "trto", 0x91, INSTR_RRF_M0RR },
 	{ "trot", 0x92, INSTR_RRE_RR },
 	{ "trot", 0x92, INSTR_RRF_M0RR },
 	{ "troo", 0x93, INSTR_RRE_RR },
 	{ "troo", 0x93, INSTR_RRF_M0RR },
 	{ "mlr", 0x96, INSTR_RRE_RR },
 	{ "dlr", 0x97, INSTR_RRE_RR },
 	{ "alcr", 0x98, INSTR_RRE_RR },
 	{ "slbr", 0x99, INSTR_RRE_RR },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_c0[] = {
 #ifdef CONFIG_64BIT
 	{ "lgfi", 0x01, INSTR_RIL_RI },
 	{ "xihf", 0x06, INSTR_RIL_RU },
 	{ "xilf", 0x07, INSTR_RIL_RU },
 	{ "iihf", 0x08, INSTR_RIL_RU },
 	{ "iilf", 0x09, INSTR_RIL_RU },
 	{ "nihf", 0x0a, INSTR_RIL_RU },
 	{ "nilf", 0x0b, INSTR_RIL_RU },
 	{ "oihf", 0x0c, INSTR_RIL_RU },
 	{ "oilf", 0x0d, INSTR_RIL_RU },
 	{ "llihf", 0x0e, INSTR_RIL_RU },
 	{ "llilf", 0x0f, INSTR_RIL_RU },
 #endif
 	{ "larl", 0x00, INSTR_RIL_RP },
 	{ "brcl", 0x04, INSTR_RIL_UP },
 	{ "brasl", 0x05, INSTR_RIL_RP },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_c2[] = {
 #ifdef CONFIG_64BIT
 	{ "slgfi", 0x04, INSTR_RIL_RU },
 	{ "slfi", 0x05, INSTR_RIL_RU },
 	{ "agfi", 0x08, INSTR_RIL_RI },
 	{ "afi", 0x09, INSTR_RIL_RI },
 	{ "algfi", 0x0a, INSTR_RIL_RU },
 	{ "alfi", 0x0b, INSTR_RIL_RU },
 	{ "cgfi", 0x0c, INSTR_RIL_RI },
 	{ "cfi", 0x0d, INSTR_RIL_RI },
 	{ "clgfi", 0x0e, INSTR_RIL_RU },
 	{ "clfi", 0x0f, INSTR_RIL_RU },
 	{ "msfi", 0x01, INSTR_RIL_RI },
 	{ "msgfi", 0x00, INSTR_RIL_RI },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_c4[] = {
 #ifdef CONFIG_64BIT
 	{ "lrl", 0x0d, INSTR_RIL_RP },
 	{ "lgrl", 0x08, INSTR_RIL_RP },
 	{ "lgfrl", 0x0c, INSTR_RIL_RP },
 	{ "lhrl", 0x05, INSTR_RIL_RP },
 	{ "lghrl", 0x04, INSTR_RIL_RP },
 	{ { 0, LONG_INSN_LLGFRL }, 0x0e, INSTR_RIL_RP },
 	{ "llhrl", 0x02, INSTR_RIL_RP },
 	{ { 0, LONG_INSN_LLGHRL }, 0x06, INSTR_RIL_RP },
 	{ "strl", 0x0f, INSTR_RIL_RP },
 	{ "stgrl", 0x0b, INSTR_RIL_RP },
 	{ "sthrl", 0x07, INSTR_RIL_RP },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_c6[] = {
 #ifdef CONFIG_64BIT
 	{ "crl", 0x0d, INSTR_RIL_RP },
 	{ "cgrl", 0x08, INSTR_RIL_RP },
 	{ "cgfrl", 0x0c, INSTR_RIL_RP },
 	{ "chrl", 0x05, INSTR_RIL_RP },
 	{ "cghrl", 0x04, INSTR_RIL_RP },
 	{ "clrl", 0x0f, INSTR_RIL_RP },
 	{ "clgrl", 0x0a, INSTR_RIL_RP },
 	{ { 0, LONG_INSN_CLGFRL }, 0x0e, INSTR_RIL_RP },
 	{ "clhrl", 0x07, INSTR_RIL_RP },
 	{ { 0, LONG_INSN_CLGHRL }, 0x06, INSTR_RIL_RP },
 	{ "pfdrl", 0x02, INSTR_RIL_UP },
 	{ "exrl", 0x00, INSTR_RIL_RP },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_c8[] = {
 #ifdef CONFIG_64BIT
 	{ "mvcos", 0x00, INSTR_SSF_RRDRD },
 	{ "ectg", 0x01, INSTR_SSF_RRDRD },
 	{ "csst", 0x02, INSTR_SSF_RRDRD },
 	{ "lpd", 0x04, INSTR_SSF_RRDRD2 },
 	{ "lpdg ", 0x05, INSTR_SSF_RRDRD2 },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_cc[] = {
 #ifdef CONFIG_64BIT
 	{ "brcth", 0x06, INSTR_RIL_RP },
 	{ "aih", 0x08, INSTR_RIL_RI },
 	{ "alsih", 0x0a, INSTR_RIL_RI },
 	{ "alsih", 0x0b, INSTR_RIL_RI },
 	{ "cih", 0x0d, INSTR_RIL_RI },
 	{ "clih ", 0x0f, INSTR_RIL_RI },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_e3[] = {
 #ifdef CONFIG_64BIT
 	{ "ltg", 0x02, INSTR_RXY_RRRD },
 	{ "lrag", 0x03, INSTR_RXY_RRRD },
 	{ "lg", 0x04, INSTR_RXY_RRRD },
 	{ "cvby", 0x06, INSTR_RXY_RRRD },
 	{ "ag", 0x08, INSTR_RXY_RRRD },
 	{ "sg", 0x09, INSTR_RXY_RRRD },
 	{ "alg", 0x0a, INSTR_RXY_RRRD },
 	{ "slg", 0x0b, INSTR_RXY_RRRD },
 	{ "msg", 0x0c, INSTR_RXY_RRRD },
 	{ "dsg", 0x0d, INSTR_RXY_RRRD },
 	{ "cvbg", 0x0e, INSTR_RXY_RRRD },
 	{ "lrvg", 0x0f, INSTR_RXY_RRRD },
 	{ "lt", 0x12, INSTR_RXY_RRRD },
 	{ "lray", 0x13, INSTR_RXY_RRRD },
 	{ "lgf", 0x14, INSTR_RXY_RRRD },
 	{ "lgh", 0x15, INSTR_RXY_RRRD },
 	{ "llgf", 0x16, INSTR_RXY_RRRD },
 	{ "llgt", 0x17, INSTR_RXY_RRRD },
 	{ "agf", 0x18, INSTR_RXY_RRRD },
 	{ "sgf", 0x19, INSTR_RXY_RRRD },
 	{ "algf", 0x1a, INSTR_RXY_RRRD },
 	{ "slgf", 0x1b, INSTR_RXY_RRRD },
 	{ "msgf", 0x1c, INSTR_RXY_RRRD },
 	{ "dsgf", 0x1d, INSTR_RXY_RRRD },
 	{ "cg", 0x20, INSTR_RXY_RRRD },
 	{ "clg", 0x21, INSTR_RXY_RRRD },
 	{ "stg", 0x24, INSTR_RXY_RRRD },
 	{ "cvdy", 0x26, INSTR_RXY_RRRD },
 	{ "cvdg", 0x2e, INSTR_RXY_RRRD },
 	{ "strvg", 0x2f, INSTR_RXY_RRRD },
 	{ "cgf", 0x30, INSTR_RXY_RRRD },
 	{ "clgf", 0x31, INSTR_RXY_RRRD },
 	{ "strvh", 0x3f, INSTR_RXY_RRRD },
 	{ "bctg", 0x46, INSTR_RXY_RRRD },
 	{ "sty", 0x50, INSTR_RXY_RRRD },
 	{ "msy", 0x51, INSTR_RXY_RRRD },
 	{ "ny", 0x54, INSTR_RXY_RRRD },
 	{ "cly", 0x55, INSTR_RXY_RRRD },
 	{ "oy", 0x56, INSTR_RXY_RRRD },
 	{ "xy", 0x57, INSTR_RXY_RRRD },
 	{ "ly", 0x58, INSTR_RXY_RRRD },
 	{ "cy", 0x59, INSTR_RXY_RRRD },
 	{ "ay", 0x5a, INSTR_RXY_RRRD },
 	{ "sy", 0x5b, INSTR_RXY_RRRD },
 	{ "aly", 0x5e, INSTR_RXY_RRRD },
 	{ "sly", 0x5f, INSTR_RXY_RRRD },
 	{ "sthy", 0x70, INSTR_RXY_RRRD },
 	{ "lay", 0x71, INSTR_RXY_RRRD },
 	{ "stcy", 0x72, INSTR_RXY_RRRD },
 	{ "icy", 0x73, INSTR_RXY_RRRD },
 	{ "lb", 0x76, INSTR_RXY_RRRD },
 	{ "lgb", 0x77, INSTR_RXY_RRRD },
 	{ "lhy", 0x78, INSTR_RXY_RRRD },
 	{ "chy", 0x79, INSTR_RXY_RRRD },
 	{ "ahy", 0x7a, INSTR_RXY_RRRD },
 	{ "shy", 0x7b, INSTR_RXY_RRRD },
 	{ "ng", 0x80, INSTR_RXY_RRRD },
 	{ "og", 0x81, INSTR_RXY_RRRD },
 	{ "xg", 0x82, INSTR_RXY_RRRD },
 	{ "mlg", 0x86, INSTR_RXY_RRRD },
 	{ "dlg", 0x87, INSTR_RXY_RRRD },
 	{ "alcg", 0x88, INSTR_RXY_RRRD },
 	{ "slbg", 0x89, INSTR_RXY_RRRD },
 	{ "stpq", 0x8e, INSTR_RXY_RRRD },
 	{ "lpq", 0x8f, INSTR_RXY_RRRD },
 	{ "llgc", 0x90, INSTR_RXY_RRRD },
 	{ "llgh", 0x91, INSTR_RXY_RRRD },
 	{ "llc", 0x94, INSTR_RXY_RRRD },
 	{ "llh", 0x95, INSTR_RXY_RRRD },
 	{ "cgh", 0x34, INSTR_RXY_RRRD },
 	{ "laey", 0x75, INSTR_RXY_RRRD },
 	{ "ltgf", 0x32, INSTR_RXY_RRRD },
 	{ "mfy", 0x5c, INSTR_RXY_RRRD },
 	{ "mhy", 0x7c, INSTR_RXY_RRRD },
 	{ "pfd", 0x36, INSTR_RXY_URRD },
 	{ "lbh", 0xc0, INSTR_RXY_RRRD },
 	{ "llch", 0xc2, INSTR_RXY_RRRD },
 	{ "stch", 0xc3, INSTR_RXY_RRRD },
 	{ "lhh", 0xc4, INSTR_RXY_RRRD },
 	{ "llhh", 0xc6, INSTR_RXY_RRRD },
 	{ "sthh", 0xc7, INSTR_RXY_RRRD },
 	{ "lfh", 0xca, INSTR_RXY_RRRD },
 	{ "stfh", 0xcb, INSTR_RXY_RRRD },
 	{ "chf", 0xcd, INSTR_RXY_RRRD },
 	{ "clhf", 0xcf, INSTR_RXY_RRRD },
 #endif
 	{ "lrv", 0x1e, INSTR_RXY_RRRD },
 	{ "lrvh", 0x1f, INSTR_RXY_RRRD },
 	{ "strv", 0x3e, INSTR_RXY_RRRD },
 	{ "ml", 0x96, INSTR_RXY_RRRD },
 	{ "dl", 0x97, INSTR_RXY_RRRD },
 	{ "alc", 0x98, INSTR_RXY_RRRD },
 	{ "slb", 0x99, INSTR_RXY_RRRD },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_e5[] = {
 #ifdef CONFIG_64BIT
 	{ "strag", 0x02, INSTR_SSE_RDRD },
 	{ "chhsi", 0x54, INSTR_SIL_RDI },
 	{ "chsi", 0x5c, INSTR_SIL_RDI },
 	{ "cghsi", 0x58, INSTR_SIL_RDI },
 	{ { 0, LONG_INSN_CLHHSI }, 0x55, INSTR_SIL_RDU },
 	{ { 0, LONG_INSN_CLFHSI }, 0x5d, INSTR_SIL_RDU },
 	{ { 0, LONG_INSN_CLGHSI }, 0x59, INSTR_SIL_RDU },
 	{ "mvhhi", 0x44, INSTR_SIL_RDI },
 	{ "mvhi", 0x4c, INSTR_SIL_RDI },
 	{ "mvghi", 0x48, INSTR_SIL_RDI },
 #endif
 	{ "lasp", 0x00, INSTR_SSE_RDRD },
 	{ "tprot", 0x01, INSTR_SSE_RDRD },
 	{ "mvcsk", 0x0e, INSTR_SSE_RDRD },
 	{ "mvcdk", 0x0f, INSTR_SSE_RDRD },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_eb[] = {
 #ifdef CONFIG_64BIT
 	{ "lmg", 0x04, INSTR_RSY_RRRD },
 	{ "srag", 0x0a, INSTR_RSY_RRRD },
 	{ "slag", 0x0b, INSTR_RSY_RRRD },
 	{ "srlg", 0x0c, INSTR_RSY_RRRD },
 	{ "sllg", 0x0d, INSTR_RSY_RRRD },
 	{ "tracg", 0x0f, INSTR_RSY_RRRD },
 	{ "csy", 0x14, INSTR_RSY_RRRD },
 	{ "rllg", 0x1c, INSTR_RSY_RRRD },
 	{ "clmh", 0x20, INSTR_RSY_RURD },
 	{ "clmy", 0x21, INSTR_RSY_RURD },
 	{ "stmg", 0x24, INSTR_RSY_RRRD },
 	{ "stctg", 0x25, INSTR_RSY_CCRD },
 	{ "stmh", 0x26, INSTR_RSY_RRRD },
 	{ "stcmh", 0x2c, INSTR_RSY_RURD },
 	{ "stcmy", 0x2d, INSTR_RSY_RURD },
 	{ "lctlg", 0x2f, INSTR_RSY_CCRD },
 	{ "csg", 0x30, INSTR_RSY_RRRD },
 	{ "cdsy", 0x31, INSTR_RSY_RRRD },
 	{ "cdsg", 0x3e, INSTR_RSY_RRRD },
 	{ "bxhg", 0x44, INSTR_RSY_RRRD },
 	{ "bxleg", 0x45, INSTR_RSY_RRRD },
 	{ "tmy", 0x51, INSTR_SIY_URD },
 	{ "mviy", 0x52, INSTR_SIY_URD },
 	{ "niy", 0x54, INSTR_SIY_URD },
 	{ "cliy", 0x55, INSTR_SIY_URD },
 	{ "oiy", 0x56, INSTR_SIY_URD },
 	{ "xiy", 0x57, INSTR_SIY_URD },
 	{ "icmh", 0x80, INSTR_RSE_RURD },
 	{ "icmh", 0x80, INSTR_RSY_RURD },
 	{ "icmy", 0x81, INSTR_RSY_RURD },
 	{ "clclu", 0x8f, INSTR_RSY_RRRD },
 	{ "stmy", 0x90, INSTR_RSY_RRRD },
 	{ "lmh", 0x96, INSTR_RSY_RRRD },
 	{ "lmy", 0x98, INSTR_RSY_RRRD },
 	{ "lamy", 0x9a, INSTR_RSY_AARD },
 	{ "stamy", 0x9b, INSTR_RSY_AARD },
 	{ "asi", 0x6a, INSTR_SIY_IRD },
 	{ "agsi", 0x7a, INSTR_SIY_IRD },
 	{ "alsi", 0x6e, INSTR_SIY_IRD },
 	{ "algsi", 0x7e, INSTR_SIY_IRD },
 	{ "ecag", 0x4c, INSTR_RSY_RRRD },
 	{ "srak", 0xdc, INSTR_RSY_RRRD },
 	{ "slak", 0xdd, INSTR_RSY_RRRD },
 	{ "srlk", 0xde, INSTR_RSY_RRRD },
 	{ "sllk", 0xdf, INSTR_RSY_RRRD },
 	{ "locg", 0xe2, INSTR_RSY_RDRM },
 	{ "stocg", 0xe3, INSTR_RSY_RDRM },
 	{ "lang", 0xe4, INSTR_RSY_RRRD },
 	{ "laog", 0xe6, INSTR_RSY_RRRD },
 	{ "laxg", 0xe7, INSTR_RSY_RRRD },
 	{ "laag", 0xe8, INSTR_RSY_RRRD },
 	{ "laalg", 0xea, INSTR_RSY_RRRD },
 	{ "loc", 0xf2, INSTR_RSY_RDRM },
 	{ "stoc", 0xf3, INSTR_RSY_RDRM },
 	{ "lan", 0xf4, INSTR_RSY_RRRD },
 	{ "lao", 0xf6, INSTR_RSY_RRRD },
 	{ "lax", 0xf7, INSTR_RSY_RRRD },
 	{ "laa", 0xf8, INSTR_RSY_RRRD },
 	{ "laal", 0xfa, INSTR_RSY_RRRD },
 #endif
 	{ "rll", 0x1d, INSTR_RSY_RRRD },
 	{ "mvclu", 0x8e, INSTR_RSY_RRRD },
 	{ "tp", 0xc0, INSTR_RSL_R0RD },
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_ec[] = {
 #ifdef CONFIG_64BIT
 	{ "brxhg", 0x44, INSTR_RIE_RRP },
 	{ "brxlg", 0x45, INSTR_RIE_RRP },
 	{ "crb", 0xf6, INSTR_RRS_RRRDU },
 	{ "cgrb", 0xe4, INSTR_RRS_RRRDU },
 	{ "crj", 0x76, INSTR_RIE_RRPU },
 	{ "cgrj", 0x64, INSTR_RIE_RRPU },
 	{ "cib", 0xfe, INSTR_RIS_RURDI },
 	{ "cgib", 0xfc, INSTR_RIS_RURDI },
 	{ "cij", 0x7e, INSTR_RIE_RUPI },
 	{ "cgij", 0x7c, INSTR_RIE_RUPI },
 	{ "cit", 0x72, INSTR_RIE_R0IU },
 	{ "cgit", 0x70, INSTR_RIE_R0IU },
 	{ "clrb", 0xf7, INSTR_RRS_RRRDU },
 	{ "clgrb", 0xe5, INSTR_RRS_RRRDU },
 	{ "clrj", 0x77, INSTR_RIE_RRPU },
 	{ "clgrj", 0x65, INSTR_RIE_RRPU },
 	{ "clib", 0xff, INSTR_RIS_RURDU },
 	{ "clgib", 0xfd, INSTR_RIS_RURDU },
 	{ "clij", 0x7f, INSTR_RIE_RUPU },
 	{ "clgij", 0x7d, INSTR_RIE_RUPU },
 	{ "clfit", 0x73, INSTR_RIE_R0UU },
 	{ "clgit", 0x71, INSTR_RIE_R0UU },
 	{ "rnsbg", 0x54, INSTR_RIE_RRUUU },
 	{ "rxsbg", 0x57, INSTR_RIE_RRUUU },
 	{ "rosbg", 0x56, INSTR_RIE_RRUUU },
 	{ "risbg", 0x55, INSTR_RIE_RRUUU },
 	{ { 0, LONG_INSN_RISBLG }, 0x51, INSTR_RIE_RRUUU },
 	{ { 0, LONG_INSN_RISBHG }, 0x5D, INSTR_RIE_RRUUU },
 	{ "ahik", 0xd8, INSTR_RIE_RRI0 },
 	{ "aghik", 0xd9, INSTR_RIE_RRI0 },
 	{ { 0, LONG_INSN_ALHSIK }, 0xda, INSTR_RIE_RRI0 },
 	{ { 0, LONG_INSN_ALGHSIK }, 0xdb, INSTR_RIE_RRI0 },
 #endif
 	{ "", 0, INSTR_INVALID }
 };
 static struct insn opcode_ed[] = {
 #ifdef CONFIG_64BIT
 	{ "mayl", 0x38, INSTR_RXF_FRRDF },
 	{ "myl", 0x39, INSTR_RXF_FRRDF },
 	{ "may", 0x3a, INSTR_RXF_FRRDF },
 	{ "my", 0x3b, INSTR_RXF_FRRDF },
 	{ "mayh", 0x3c, INSTR_RXF_FRRDF },
 	{ "myh", 0x3d, INSTR_RXF_FRRDF },
 	{ "ley", 0x64, INSTR_RXY_FRRD },
 	{ "ldy", 0x65, INSTR_RXY_FRRD },
 	{ "stey", 0x66, INSTR_RXY_FRRD },
 	{ "stdy", 0x67, INSTR_RXY_FRRD },
 	{ "sldt", 0x40, INSTR_RXF_FRRDF },
 	{ "slxt", 0x48, INSTR_RXF_FRRDF },
 	{ "srdt", 0x41, INSTR_RXF_FRRDF },
 	{ "srxt", 0x49, INSTR_RXF_FRRDF },
 	{ "tdcet", 0x50, INSTR_RXE_FRRD },
 	{ "tdcdt", 0x54, INSTR_RXE_FRRD },
 	{ "tdcxt", 0x58, INSTR_RXE_FRRD },
 	{ "tdget", 0x51, INSTR_RXE_FRRD },
 	{ "tdgdt", 0x55, INSTR_RXE_FRRD },
 	{ "tdgxt", 0x59, INSTR_RXE_FRRD },
 #endif
 	{ "ldeb", 0x04, INSTR_RXE_FRRD },
 	{ "lxdb", 0x05, INSTR_RXE_FRRD },
 	{ "lxeb", 0x06, INSTR_RXE_FRRD },
 	{ "mxdb", 0x07, INSTR_RXE_FRRD },
 	{ "keb", 0x08, INSTR_RXE_FRRD },
 	{ "ceb", 0x09, INSTR_RXE_FRRD },
 	{ "aeb", 0x0a, INSTR_RXE_FRRD },
 	{ "seb", 0x0b, INSTR_RXE_FRRD },
 	{ "mdeb", 0x0c, INSTR_RXE_FRRD },
 	{ "deb", 0x0d, INSTR_RXE_FRRD },
 	{ "maeb", 0x0e, INSTR_RXF_FRRDF },
 	{ "mseb", 0x0f, INSTR_RXF_FRRDF },
 	{ "tceb", 0x10, INSTR_RXE_FRRD },
 	{ "tcdb", 0x11, INSTR_RXE_FRRD },
 	{ "tcxb", 0x12, INSTR_RXE_FRRD },
 	{ "sqeb", 0x14, INSTR_RXE_FRRD },
 	{ "sqdb", 0x15, INSTR_RXE_FRRD },
 	{ "meeb", 0x17, INSTR_RXE_FRRD },
 	{ "kdb", 0x18, INSTR_RXE_FRRD },
 	{ "cdb", 0x19, INSTR_RXE_FRRD },
 	{ "adb", 0x1a, INSTR_RXE_FRRD },
 	{ "sdb", 0x1b, INSTR_RXE_FRRD },
 	{ "mdb", 0x1c, INSTR_RXE_FRRD },
 	{ "ddb", 0x1d, INSTR_RXE_FRRD },
 	{ "madb", 0x1e, INSTR_RXF_FRRDF },
 	{ "msdb", 0x1f, INSTR_RXF_FRRDF },
 	{ "lde", 0x24, INSTR_RXE_FRRD },
 	{ "lxd", 0x25, INSTR_RXE_FRRD },
 	{ "lxe", 0x26, INSTR_RXE_FRRD },
 	{ "mae", 0x2e, INSTR_RXF_FRRDF },
 	{ "mse", 0x2f, INSTR_RXF_FRRDF },
 	{ "sqe", 0x34, INSTR_RXE_FRRD },
 	{ "sqd", 0x35, INSTR_RXE_FRRD },
 	{ "mee", 0x37, INSTR_RXE_FRRD },
 	{ "mad", 0x3e, INSTR_RXF_FRRDF },
 	{ "msd", 0x3f, INSTR_RXF_FRRDF },
 	{ "", 0, INSTR_INVALID }
 };
 /* Extracts an operand value from an instruction.  */
 static unsigned int extract_operand(unsigned char *code,
 				    const struct operand *operand)
 {
 	unsigned int val;
 	int bits;
 	/* Extract fragments of the operand byte for byte.  */
 	code += operand->shift / 8;
 	bits = (operand->shift & 7) + operand->bits;
 	val = 0;
 	do {
 		val <<= 8;
 		val |= (unsigned int) *code++;
 		bits -= 8;
 	} while (bits > 0);
 	val >>= -bits;
 	val &= ((1U << (operand->bits - 1)) << 1) - 1;
 	/* Check for special long displacement case.  */
 	if (operand->bits == 20 && operand->shift == 20)
 		val = (val & 0xff) << 12 | (val & 0xfff00) >> 8;
 	/* Sign extend value if the operand is signed or pc relative.  */
 	if ((operand->flags & (OPERAND_SIGNED | OPERAND_PCREL)) &&
 	    (val & (1U << (operand->bits - 1))))
 		val |= (-1U << (operand->bits - 1)) << 1;
 	/* Double value if the operand is pc relative.	*/
 	if (operand->flags & OPERAND_PCREL)
 		val <<= 1;
 	/* Length x in an instructions has real length x + 1.  */
 	if (operand->flags & OPERAND_LENGTH)
 		val++;
 	return val;
 }
 static inline int insn_length(unsigned char code)
 {
 	return ((((int) code + 64) >> 7) + 1) << 1;
 }
 static struct insn *find_insn(unsigned char *code)
 {
 	unsigned char opfrag = code[1];
 	unsigned char opmask;
 	struct insn *table;
 	switch (code[0]) {
 	case 0x01:
 		table = opcode_01;
 		break;
 	case 0xa5:
 		table = opcode_a5;
 		break;
 	case 0xa7:
 		table = opcode_a7;
 		break;
 	case 0xb2:
 		table = opcode_b2;
 		break;
 	case 0xb3:
 		table = opcode_b3;
 		break;
 	case 0xb9:
 		table = opcode_b9;
 		break;
 	case 0xc0:
 		table = opcode_c0;
 		break;
 	case 0xc2:
 		table = opcode_c2;
 		break;
 	case 0xc4:
 		table = opcode_c4;
 		break;
 	case 0xc6:
 		table = opcode_c6;
 		break;
 	case 0xc8:
 		table = opcode_c8;
 		break;
 	case 0xcc:
 		table = opcode_cc;
 		break;
 	case 0xe3:
 		table = opcode_e3;
 		opfrag = code[5];
 		break;
 	case 0xe5:
 		table = opcode_e5;
 		break;
 	case 0xeb:
 		table = opcode_eb;
 		opfrag = code[5];
 		break;
 	case 0xec:
 		table = opcode_ec;
 		opfrag = code[5];
 		break;
 	case 0xed:
 		table = opcode_ed;
 		opfrag = code[5];
 		break;
 	default:
 		table = opcode;
 		opfrag = code[0];
 		break;
 	}
 	while (table->format != INSTR_INVALID) {
 		opmask = formats[table->format][0];
 		if (table->opfrag == (opfrag & opmask))
 			return table;
 		table++;
 	}
 	return NULL;
 }
 static int print_insn(char *buffer, unsigned char *code, unsigned long addr)
 {
 	struct insn *insn;
 	const unsigned char *ops;
 	const struct operand *operand;
 	unsigned int value;
 	char separator;
 	char *ptr;
 	int i;
 	ptr = buffer;
 	insn = find_insn(code);
 	if (insn) {
 		if (insn->name[0] == '\0')
 			ptr += sprintf(ptr, "%s\t",
 				       long_insn_name[(int) insn->name[1]]);
 		else
 			ptr += sprintf(ptr, "%.5s\t", insn->name);
 		/* Extract the operands. */
 		separator = 0;
 		for (ops = formats[insn->format] + 1, i = 0;
 		     *ops != 0 && i < 6; ops++, i++) {
 			operand = operands + *ops;
 			value = extract_operand(code, operand);
 			if ((operand->flags & OPERAND_INDEX)  && value == 0)
 				continue;
 			if ((operand->flags & OPERAND_BASE) &&
 			    value == 0 && separator == '(') {
 				separator = ',';
 				continue;
 			}
 			if (separator)
 				ptr += sprintf(ptr, "%c", separator);
 			if (operand->flags & OPERAND_GPR)
 				ptr += sprintf(ptr, "%%r%i", value);
 			else if (operand->flags & OPERAND_FPR)
 				ptr += sprintf(ptr, "%%f%i", value);
 			else if (operand->flags & OPERAND_AR)
 				ptr += sprintf(ptr, "%%a%i", value);
 			else if (operand->flags & OPERAND_CR)
 				ptr += sprintf(ptr, "%%c%i", value);
 			else if (operand->flags & OPERAND_PCREL)
 				ptr += sprintf(ptr, "%lx", (signed int) value
 								      + addr);
 			else if (operand->flags & OPERAND_SIGNED)
 				ptr += sprintf(ptr, "%i", value);
 			else
 				ptr += sprintf(ptr, "%u", value);
 			if (operand->flags & OPERAND_DISP)
 				separator = '(';
 			else if (operand->flags & OPERAND_BASE) {
 				ptr += sprintf(ptr, ")");
 				separator = ',';
 			} else
 				separator = ',';
 		}
 	} else
 		ptr += sprintf(ptr, "unknown");
 	return (int) (ptr - buffer);
 }
 void show_code(struct pt_regs *regs)
 {
 	char *mode = (regs->psw.mask & PSW_MASK_PSTATE) ? "User" : "Krnl";
 	unsigned char code[64];
 	char buffer[64], *ptr;
 	mm_segment_t old_fs;
 	unsigned long addr;
 	int start, end, opsize, hops, i;
 	/* Get a snapshot of the 64 bytes surrounding the fault address. */
 	old_fs = get_fs();
 	set_fs((regs->psw.mask & PSW_MASK_PSTATE) ? USER_DS : KERNEL_DS);
 	for (start = 32; start && regs->psw.addr >= 34 - start; start -= 2) {
 		addr = regs->psw.addr - 34 + start;
 		if (__copy_from_user(code + start - 2,
 				     (char __user *) addr, 2))
 			break;
 	}
 	for (end = 32; end < 64; end += 2) {
 		addr = regs->psw.addr + end - 32;
 		if (__copy_from_user(code + end,
 				     (char __user *) addr, 2))
 			break;
 	}
 	set_fs(old_fs);
 	/* Code snapshot useable ? */
 	if ((regs->psw.addr & 1) || start >= end) {
 		printk("%s Code: Bad PSW.\n", mode);
 		return;
 	}
 	/* Find a starting point for the disassembly. */
 	while (start < 32) {
 		for (i = 0, hops = 0; start + i < 32 && hops < 3; hops++) {
 			if (!find_insn(code + start + i))
 				break;
 			i += insn_length(code[start + i]);
 		}
 		if (start + i == 32)
 			/* Looks good, sequence ends at PSW. */
 			break;
 		start += 2;
 	}
 	/* Decode the instructions. */
 	ptr = buffer;
 	ptr += sprintf(ptr, "%s Code:", mode);
 	hops = 0;
 	while (start < end && hops < 8) {
 		*ptr++ = (start == 32) ? '>' : ' ';
 		addr = regs->psw.addr + start - 32;
 		ptr += sprintf(ptr, ONELONG, addr);
 		opsize = insn_length(code[start]);
 		if (start + opsize >= end)
 			break;
 		for (i = 0; i < opsize; i++)
 			ptr += sprintf(ptr, "%02x", code[start + i]);
 		*ptr++ = '\t';
 		if (i < 6)
 			*ptr++ = '\t';
 		ptr += print_insn(ptr, code + start, addr);
 		start += opsize;
 		printk(buffer);
 		ptr = buffer;
 		ptr += sprintf(ptr, "\n          ");
 		hops++;
 	}
 	printk("\n");
 }

arch/s390/kernel/irq.c

Diff comments View file @ d7b250e

 /*
- *    Copyright IBM Corp. 2004,2010
+ *    Copyright IBM Corp. 2004,2011
- *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
+ *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
- *		 Thomas Spatzier (tspat@de.ibm.com)
+ *		 Holger Smolinski <Holger.Smolinski@de.ibm.com>,
+ *		 Thomas Spatzier <tspat@de.ibm.com>,
  *
  * This file contains interrupt related functions.
  */
-#include <linux/module.h>
-#include <linux/kernel.h>
 #include <linux/kernel_stat.h>
 #include <linux/interrupt.h>
 #include <linux/seq_file.h>
-#include <linux/cpu.h>
 #include <linux/proc_fs.h>
 #include <linux/profile.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/ftrace.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/cpu.h>
+#include <asm/irq_regs.h>
+#include <asm/cputime.h>
+#include <asm/lowcore.h>
+#include <asm/irq.h>
+#include "entry.h"
 struct irq_class {
 	char *name;
 	char *desc;
 };
 static const struct irq_class intrclass_names[] = {
 	{.name = "EXT" },
 	{.name = "I/O" },
 	{.name = "CLK", .desc = "[EXT] Clock Comparator" },
 	{.name = "IPI", .desc = "[EXT] Signal Processor" },
 	{.name = "TMR", .desc = "[EXT] CPU Timer" },
 	{.name = "TAL", .desc = "[EXT] Timing Alert" },
 	{.name = "PFL", .desc = "[EXT] Pseudo Page Fault" },
 	{.name = "DSD", .desc = "[EXT] DASD Diag" },
 	{.name = "VRT", .desc = "[EXT] Virtio" },
 	{.name = "SCP", .desc = "[EXT] Service Call" },
 	{.name = "IUC", .desc = "[EXT] IUCV" },
 	{.name = "CPM", .desc = "[EXT] CPU Measurement" },
 	{.name = "QAI", .desc = "[I/O] QDIO Adapter Interrupt" },
 	{.name = "QDI", .desc = "[I/O] QDIO Interrupt" },
 	{.name = "DAS", .desc = "[I/O] DASD" },
 	{.name = "C15", .desc = "[I/O] 3215" },
 	{.name = "C70", .desc = "[I/O] 3270" },
 	{.name = "TAP", .desc = "[I/O] Tape" },
 	{.name = "VMR", .desc = "[I/O] Unit Record Devices" },
 	{.name = "LCS", .desc = "[I/O] LCS" },
 	{.name = "CLW", .desc = "[I/O] CLAW" },
 	{.name = "CTC", .desc = "[I/O] CTC" },
 	{.name = "APB", .desc = "[I/O] AP Bus" },
 	{.name = "NMI", .desc = "[NMI] Machine Check" },
 };
 /*
  * show_interrupts is needed by /proc/interrupts.
  */
 int show_interrupts(struct seq_file *p, void *v)
 {
 	int i = *(loff_t *) v, j;
 	get_online_cpus();
 	if (i == 0) {
 		seq_puts(p, "           ");
 		for_each_online_cpu(j)
 			seq_printf(p, "CPU%d       ",j);
 		seq_putc(p, '\n');
 	}
 	if (i < NR_IRQS) {
 		seq_printf(p, "%s: ", intrclass_names[i].name);
 #ifndef CONFIG_SMP
 		seq_printf(p, "%10u ", kstat_irqs(i));
 #else
 		for_each_online_cpu(j)
 			seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
 		if (intrclass_names[i].desc)
 			seq_printf(p, "  %s", intrclass_names[i].desc);
                 seq_putc(p, '\n');
         }
 	put_online_cpus();
         return 0;
 }
 /*
  * For compatibilty only. S/390 specific setup of interrupts et al. is done
  * much later in init_channel_subsystem().
  */
-void __init
+void __init init_IRQ(void)
-init_IRQ(void)
 {
 	/* nothing... */
 }
 /*
  * Switch to the asynchronous interrupt stack for softirq execution.
  */
 asmlinkage void do_softirq(void)
 {
 	unsigned long flags, old, new;
 	if (in_interrupt())
 		return;
 	local_irq_save(flags);
 	if (local_softirq_pending()) {
 		/* Get current stack pointer. */
 		asm volatile("la %0,0(15)" : "=a" (old));
 		/* Check against async. stack address range. */
 		new = S390_lowcore.async_stack;
 		if (((new - old) >> (PAGE_SHIFT + THREAD_ORDER)) != 0) {
 			/* Need to switch to the async. stack. */
 			new -= STACK_FRAME_OVERHEAD;
 			((struct stack_frame *) new)->back_chain = old;
 			asm volatile("   la    15,0(%0)\n"
 				     "   basr  14,%2\n"
 				     "   la    15,0(%1)\n"
 				     : : "a" (new), "a" (old),
 				         "a" (__do_softirq)
 				     : "0", "1", "2", "3", "4", "5", "14",
 				       "cc", "memory" );
 		} else
 			/* We are already on the async stack. */
 			__do_softirq();
 	}
 	local_irq_restore(flags);
 }
 #ifdef CONFIG_PROC_FS
 void init_irq_proc(void)
 {
 	struct proc_dir_entry *root_irq_dir;
 	root_irq_dir = proc_mkdir("irq", NULL);
 	create_prof_cpu_mask(root_irq_dir);
 }
 #endif
+/*
+ * ext_int_hash[index] is the start of the list for all external interrupts
+ * that hash to this index. With the current set of external interrupts
+ * (0x1202 external call, 0x1004 cpu timer, 0x2401 hwc console, 0x4000
+ * iucv and 0x2603 pfault) this is always the first element.
+ */
+struct ext_int_info {
+	struct ext_int_info *next;
+	ext_int_handler_t handler;
+	u16 code;
+};
+static struct ext_int_info *ext_int_hash[256];
+static inline int ext_hash(u16 code)
+{
+	return (code + (code >> 9)) & 0xff;
+}
+int register_external_interrupt(u16 code, ext_int_handler_t handler)
+{
+	struct ext_int_info *p;
+	int index;
+	p = kmalloc(sizeof(*p), GFP_ATOMIC);
+	if (!p)
+		return -ENOMEM;
+	p->code = code;
+	p->handler = handler;
+	index = ext_hash(code);
+	p->next = ext_int_hash[index];
+	ext_int_hash[index] = p;
+	return 0;
+}
+EXPORT_SYMBOL(register_external_interrupt);
+int unregister_external_interrupt(u16 code, ext_int_handler_t handler)
+{
+	struct ext_int_info *p, *q;
+	int index;
+	index = ext_hash(code);
+	q = NULL;
+	p = ext_int_hash[index];
+	while (p) {
+		if (p->code == code && p->handler == handler)
+			break;
+		q = p;
+		p = p->next;
+	}
+	if (!p)
+		return -ENOENT;
+	if (q)
+		q->next = p->next;
+	else
+		ext_int_hash[index] = p->next;
+	kfree(p);
+	return 0;
+}
+EXPORT_SYMBOL(unregister_external_interrupt);
+void __irq_entry do_extint(struct pt_regs *regs, unsigned int ext_int_code,
+			   unsigned int param32, unsigned long param64)
+{
+	struct pt_regs *old_regs;
+	unsigned short code;
+	struct ext_int_info *p;
+	int index;
+	code = (unsigned short) ext_int_code;
+	old_regs = set_irq_regs(regs);
+	s390_idle_check(regs, S390_lowcore.int_clock,
+			S390_lowcore.async_enter_timer);
+	irq_enter();
+	if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
+		/* Serve timer interrupts first. */
+		clock_comparator_work();
+	kstat_cpu(smp_processor_id()).irqs[EXTERNAL_INTERRUPT]++;
+	if (code != 0x1004)
+		__get_cpu_var(s390_idle).nohz_delay = 1;
+	index = ext_hash(code);
+	for (p = ext_int_hash[index]; p; p = p->next) {
+		if (likely(p->code == code))
+			p->handler(ext_int_code, param32, param64);
+	}
+	irq_exit();
+	set_irq_regs(old_regs);
+}
+static DEFINE_SPINLOCK(sc_irq_lock);
+static int sc_irq_refcount;
+void service_subclass_irq_register(void)
+{
+	spin_lock(&sc_irq_lock);
+	if (!sc_irq_refcount)
+		ctl_set_bit(0, 9);
+	sc_irq_refcount++;
+	spin_unlock(&sc_irq_lock);
+}
+EXPORT_SYMBOL(service_subclass_irq_register);
+void service_subclass_irq_unregister(void)
+{
+	spin_lock(&sc_irq_lock);
+	sc_irq_refcount--;
+	if (!sc_irq_refcount)
+		ctl_clear_bit(0, 9);

arch/s390/kernel/s390_ext.c

View file @ d7b250e

1	/*		File was deleted
2	* Copyright IBM Corp. 1999,2010
3	* Author(s): Holger Smolinski <Holger.Smolinski@de.ibm.com>,
4	* Martin Schwidefsky <schwidefsky@de.ibm.com>,
5	*/
6
7	#include <linux/kernel_stat.h>
8	#include <linux/interrupt.h>
9	#include <linux/module.h>
10	#include <linux/kernel.h>
11	#include <linux/ftrace.h>
12	#include <linux/errno.h>
13	#include <linux/slab.h>
14	#include <asm/s390_ext.h>
15	#include <asm/irq_regs.h>
16	#include <asm/cputime.h>
17	#include <asm/lowcore.h>
18	#include <asm/irq.h>
19	#include "entry.h"
20
21	struct ext_int_info {
22	struct ext_int_info *next;
23	ext_int_handler_t handler;
24	__u16 code;
25	};
26
27	/*
28	* ext_int_hash[index] is the start of the list for all external interrupts
29	* that hash to this index. With the current set of external interrupts
30	* (0x1202 external call, 0x1004 cpu timer, 0x2401 hwc console, 0x4000
31	* iucv and 0x2603 pfault) this is always the first element.
32	*/
33	static struct ext_int_info *ext_int_hash[256];
34
35	static inline int ext_hash(__u16 code)
36	{
37	return (code + (code >> 9)) & 0xff;
38	}
39
40	int register_external_interrupt(__u16 code, ext_int_handler_t handler)
41	{
42	struct ext_int_info *p;
43	int index;
44
45	p = kmalloc(sizeof(*p), GFP_ATOMIC);
46	if (!p)
47	return -ENOMEM;
48	p->code = code;
49	p->handler = handler;
50	index = ext_hash(code);
51	p->next = ext_int_hash[index];
52	ext_int_hash[index] = p;
53	return 0;
54	}
55	EXPORT_SYMBOL(register_external_interrupt);
56
57	int unregister_external_interrupt(__u16 code, ext_int_handler_t handler)
58	{
59	struct ext_int_info p, q;
60	int index;
61
62	index = ext_hash(code);
63	q = NULL;
64	p = ext_int_hash[index];
65	while (p) {
66	if (p->code == code && p->handler == handler)
67	break;
68	q = p;
69	p = p->next;
70	}
71	if (!p)
72	return -ENOENT;
73	if (q)
74	q->next = p->next;
75	else
76	ext_int_hash[index] = p->next;
77	kfree(p);
78	return 0;
79	}
80	EXPORT_SYMBOL(unregister_external_interrupt);
81
82	void __irq_entry do_extint(struct pt_regs *regs, unsigned int ext_int_code,
83	unsigned int param32, unsigned long param64)
84	{
85	struct pt_regs *old_regs;
86	unsigned short code;
87	struct ext_int_info *p;
88	int index;
89
90	code = (unsigned short) ext_int_code;
91	old_regs = set_irq_regs(regs);
92	s390_idle_check(regs, S390_lowcore.int_clock,
93	S390_lowcore.async_enter_timer);
94	irq_enter();
95	if (S390_lowcore.int_clock >= S390_lowcore.clock_comparator)
96	/* Serve timer interrupts first. */
97	clock_comparator_work();
98	kstat_cpu(smp_processor_id()).irqs[EXTERNAL_INTERRUPT]++;
99	if (code != 0x1004)
100	__get_cpu_var(s390_idle).nohz_delay = 1;
101	index = ext_hash(code);
102	for (p = ext_int_hash[index]; p; p = p->next) {
103	if (likely(p->code == code))
104	p->handler(ext_int_code, param32, param64);
105	}
106	irq_exit();
107	set_irq_regs(old_regs);
108	}
109
110	static DEFINE_SPINLOCK(sc_irq_lock);
111	static int sc_irq_refcount;
112
113	void service_subclass_irq_register(void)
114	{
115	spin_lock(&sc_irq_lock);
116	if (!sc_irq_refcount)
117	ctl_set_bit(0, 9);
118	sc_irq_refcount++;
119	spin_unlock(&sc_irq_lock);
120	}
121	EXPORT_SYMBOL(service_subclass_irq_register);
122
123	void service_subclass_irq_unregister(void)
124	{
125	spin_lock(&sc_irq_lock);
126	sc_irq_refcount--;
127	if (!sc_irq_refcount)
128	ctl_clear_bit(0, 9);
129	spin_unlock(&sc_irq_lock);
130	}
131	EXPORT_SYMBOL(service_subclass_irq_unregister);
132		1	/*

arch/s390/kernel/smp.c

Diff comments View file @ d7b250e

 /*
  *  arch/s390/kernel/smp.c
  *
  *    Copyright IBM Corp. 1999, 2009
  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  *		 Martin Schwidefsky (schwidefsky@de.ibm.com)
  *		 Heiko Carstens (heiko.carstens@de.ibm.com)
  *
  *  based on other smp stuff by
  *    (c) 1995 Alan Cox, CymruNET Ltd  <alan@cymru.net>
  *    (c) 1998 Ingo Molnar
  *
  * We work with logical cpu numbering everywhere we can. The only
  * functions using the real cpu address (got from STAP) are the sigp
  * functions. For all other functions we use the identity mapping.
  * That means that cpu_number_map[i] == i for every cpu. cpu_number_map is
  * used e.g. to find the idle task belonging to a logical cpu. Every array
  * in the kernel is sorted by the logical cpu number and not by the physical
  * one which is causing all the confusion with __cpu_logical_map and
  * cpu_number_map in other architectures.
  */
 #define KMSG_COMPONENT "cpu"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/workqueue.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/err.h>
 #include <linux/spinlock.h>
 #include <linux/kernel_stat.h>
 #include <linux/delay.h>
 #include <linux/cache.h>
 #include <linux/interrupt.h>
 #include <linux/irqflags.h>
 #include <linux/cpu.h>
 #include <linux/timex.h>
 #include <linux/bootmem.h>
 #include <linux/slab.h>
 #include <asm/asm-offsets.h>
 #include <asm/ipl.h>
 #include <asm/setup.h>
 #include <asm/sigp.h>
 #include <asm/pgalloc.h>
 #include <asm/irq.h>
-#include <asm/s390_ext.h>
 #include <asm/cpcmd.h>
 #include <asm/tlbflush.h>
 #include <asm/timer.h>
 #include <asm/lowcore.h>
 #include <asm/sclp.h>
 #include <asm/cputime.h>
 #include <asm/vdso.h>
 #include <asm/cpu.h>
 #include "entry.h"
 /* logical cpu to cpu address */
 unsigned short __cpu_logical_map[NR_CPUS];
 static struct task_struct *current_set[NR_CPUS];
 static u8 smp_cpu_type;
 static int smp_use_sigp_detection;
 enum s390_cpu_state {
 	CPU_STATE_STANDBY,
 	CPU_STATE_CONFIGURED,
 };
 DEFINE_MUTEX(smp_cpu_state_mutex);
 int smp_cpu_polarization[NR_CPUS];
 static int smp_cpu_state[NR_CPUS];
 static int cpu_management;
 static DEFINE_PER_CPU(struct cpu, cpu_devices);
 static void smp_ext_bitcall(int, int);
 static int raw_cpu_stopped(int cpu)
 {
 	u32 status;
 	switch (raw_sigp_ps(&status, 0, cpu, sigp_sense)) {
 	case sigp_status_stored:
 		/* Check for stopped and check stop state */
 		if (status & 0x50)
 			return 1;
 		break;
 	default:
 		break;
 	}
 	return 0;
 }
 static inline int cpu_stopped(int cpu)
 {
 	return raw_cpu_stopped(cpu_logical_map(cpu));
 }
 void smp_switch_to_ipl_cpu(void (*func)(void *), void *data)
 {
 	struct _lowcore *lc, *current_lc;
 	struct stack_frame *sf;
 	struct pt_regs *regs;
 	unsigned long sp;
 	if (smp_processor_id() == 0)
 		func(data);
 	__load_psw_mask(PSW_BASE_BITS | PSW_DEFAULT_KEY);
 	/* Disable lowcore protection */
 	__ctl_clear_bit(0, 28);
 	current_lc = lowcore_ptr[smp_processor_id()];
 	lc = lowcore_ptr[0];
 	if (!lc)
 		lc = current_lc;
 	lc->restart_psw.mask = PSW_BASE_BITS | PSW_DEFAULT_KEY;
 	lc->restart_psw.addr = PSW_ADDR_AMODE | (unsigned long) smp_restart_cpu;
 	if (!cpu_online(0))
 		smp_switch_to_cpu(func, data, 0, stap(), __cpu_logical_map[0]);
 	while (sigp(0, sigp_stop_and_store_status) == sigp_busy)
 		cpu_relax();
 	sp = lc->panic_stack;
 	sp -= sizeof(struct pt_regs);
 	regs = (struct pt_regs *) sp;
 	memcpy(&regs->gprs, &current_lc->gpregs_save_area, sizeof(regs->gprs));
 	regs->psw = lc->psw_save_area;
 	sp -= STACK_FRAME_OVERHEAD;
 	sf = (struct stack_frame *) sp;
 	sf->back_chain = regs->gprs[15];
 	smp_switch_to_cpu(func, data, sp, stap(), __cpu_logical_map[0]);
 }
 void smp_send_stop(void)
 {
 	int cpu, rc;
 	/* Disable all interrupts/machine checks */
 	__load_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK);
 	trace_hardirqs_off();
 	/* stop all processors */
 	for_each_online_cpu(cpu) {
 		if (cpu == smp_processor_id())
 			continue;
 		do {
 			rc = sigp(cpu, sigp_stop);
 		} while (rc == sigp_busy);
 		while (!cpu_stopped(cpu))
 			cpu_relax();
 	}
 }
 /*
  * This is the main routine where commands issued by other
  * cpus are handled.
  */
 static void do_ext_call_interrupt(unsigned int ext_int_code,
 				  unsigned int param32, unsigned long param64)
 {
 	unsigned long bits;
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_IPI]++;
 	/*
 	 * handle bit signal external calls
 	 */
 	bits = xchg(&S390_lowcore.ext_call_fast, 0);
 	if (test_bit(ec_schedule, &bits))
 		scheduler_ipi();
 	if (test_bit(ec_call_function, &bits))
 		generic_smp_call_function_interrupt();
 	if (test_bit(ec_call_function_single, &bits))
 		generic_smp_call_function_single_interrupt();
 }
 /*
  * Send an external call sigp to another cpu and return without waiting
  * for its completion.
  */
 static void smp_ext_bitcall(int cpu, int sig)
 {
 	/*
 	 * Set signaling bit in lowcore of target cpu and kick it
 	 */
 	set_bit(sig, (unsigned long *) &lowcore_ptr[cpu]->ext_call_fast);
 	while (sigp(cpu, sigp_emergency_signal) == sigp_busy)
 		udelay(10);
 }
 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 {
 	int cpu;
 	for_each_cpu(cpu, mask)
 		smp_ext_bitcall(cpu, ec_call_function);
 }
 void arch_send_call_function_single_ipi(int cpu)
 {
 	smp_ext_bitcall(cpu, ec_call_function_single);
 }
 #ifndef CONFIG_64BIT
 /*
  * this function sends a 'purge tlb' signal to another CPU.
  */
 static void smp_ptlb_callback(void *info)
 {
 	__tlb_flush_local();
 }
 void smp_ptlb_all(void)
 {
 	on_each_cpu(smp_ptlb_callback, NULL, 1);
 }
 EXPORT_SYMBOL(smp_ptlb_all);
 #endif /* ! CONFIG_64BIT */
 /*
  * this function sends a 'reschedule' IPI to another CPU.
  * it goes straight through and wastes no time serializing
  * anything. Worst case is that we lose a reschedule ...
  */
 void smp_send_reschedule(int cpu)
 {
 	smp_ext_bitcall(cpu, ec_schedule);
 }
 /*
  * parameter area for the set/clear control bit callbacks
  */
 struct ec_creg_mask_parms {
 	unsigned long orvals[16];
 	unsigned long andvals[16];
 };
 /*
  * callback for setting/clearing control bits
  */
 static void smp_ctl_bit_callback(void *info)
 {
 	struct ec_creg_mask_parms *pp = info;
 	unsigned long cregs[16];
 	int i;
 	__ctl_store(cregs, 0, 15);
 	for (i = 0; i <= 15; i++)
 		cregs[i] = (cregs[i] & pp->andvals[i]) | pp->orvals[i];
 	__ctl_load(cregs, 0, 15);
 }
 /*
  * Set a bit in a control register of all cpus
  */
 void smp_ctl_set_bit(int cr, int bit)
 {
 	struct ec_creg_mask_parms parms;
 	memset(&parms.orvals, 0, sizeof(parms.orvals));
 	memset(&parms.andvals, 0xff, sizeof(parms.andvals));
 	parms.orvals[cr] = 1 << bit;
 	on_each_cpu(smp_ctl_bit_callback, &parms, 1);
 }
 EXPORT_SYMBOL(smp_ctl_set_bit);
 /*
  * Clear a bit in a control register of all cpus
  */
 void smp_ctl_clear_bit(int cr, int bit)
 {
 	struct ec_creg_mask_parms parms;
 	memset(&parms.orvals, 0, sizeof(parms.orvals));
 	memset(&parms.andvals, 0xff, sizeof(parms.andvals));
 	parms.andvals[cr] = ~(1L << bit);
 	on_each_cpu(smp_ctl_bit_callback, &parms, 1);
 }
 EXPORT_SYMBOL(smp_ctl_clear_bit);
 #ifdef CONFIG_ZFCPDUMP
 static void __init smp_get_save_area(unsigned int cpu, unsigned int phy_cpu)
 {
 	if (ipl_info.type != IPL_TYPE_FCP_DUMP)
 		return;
 	if (cpu >= NR_CPUS) {
 		pr_warning("CPU %i exceeds the maximum %i and is excluded from "
 			   "the dump\n", cpu, NR_CPUS - 1);
 		return;
 	}
 	zfcpdump_save_areas[cpu] = kmalloc(sizeof(struct save_area), GFP_KERNEL);
 	while (raw_sigp(phy_cpu, sigp_stop_and_store_status) == sigp_busy)
 		cpu_relax();
 	memcpy_real(zfcpdump_save_areas[cpu],
 		    (void *)(unsigned long) store_prefix() + SAVE_AREA_BASE,
 		    sizeof(struct save_area));
 }
 struct save_area *zfcpdump_save_areas[NR_CPUS + 1];
 EXPORT_SYMBOL_GPL(zfcpdump_save_areas);
 #else
 static inline void smp_get_save_area(unsigned int cpu, unsigned int phy_cpu) { }
 #endif /* CONFIG_ZFCPDUMP */
 static int cpu_known(int cpu_id)
 {
 	int cpu;
 	for_each_present_cpu(cpu) {
 		if (__cpu_logical_map[cpu] == cpu_id)
 			return 1;
 	}
 	return 0;
 }
 static int smp_rescan_cpus_sigp(cpumask_t avail)
 {
 	int cpu_id, logical_cpu;
 	logical_cpu = cpumask_first(&avail);
 	if (logical_cpu >= nr_cpu_ids)
 		return 0;
 	for (cpu_id = 0; cpu_id <= MAX_CPU_ADDRESS; cpu_id++) {
 		if (cpu_known(cpu_id))
 			continue;
 		__cpu_logical_map[logical_cpu] = cpu_id;
 		smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN;
 		if (!cpu_stopped(logical_cpu))
 			continue;
 		set_cpu_present(logical_cpu, true);
 		smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
 		logical_cpu = cpumask_next(logical_cpu, &avail);
 		if (logical_cpu >= nr_cpu_ids)
 			break;
 	}
 	return 0;
 }
 static int smp_rescan_cpus_sclp(cpumask_t avail)
 {
 	struct sclp_cpu_info *info;
 	int cpu_id, logical_cpu, cpu;
 	int rc;
 	logical_cpu = cpumask_first(&avail);
 	if (logical_cpu >= nr_cpu_ids)
 		return 0;
 	info = kmalloc(sizeof(*info), GFP_KERNEL);
 	if (!info)
 		return -ENOMEM;
 	rc = sclp_get_cpu_info(info);
 	if (rc)
 		goto out;
 	for (cpu = 0; cpu < info->combined; cpu++) {
 		if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
 			continue;
 		cpu_id = info->cpu[cpu].address;
 		if (cpu_known(cpu_id))
 			continue;
 		__cpu_logical_map[logical_cpu] = cpu_id;
 		smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN;
 		set_cpu_present(logical_cpu, true);
 		if (cpu >= info->configured)
 			smp_cpu_state[logical_cpu] = CPU_STATE_STANDBY;
 		else
 			smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
 		logical_cpu = cpumask_next(logical_cpu, &avail);
 		if (logical_cpu >= nr_cpu_ids)
 			break;
 	}
 out:
 	kfree(info);
 	return rc;
 }
 static int __smp_rescan_cpus(void)
 {
 	cpumask_t avail;
 	cpumask_xor(&avail, cpu_possible_mask, cpu_present_mask);
 	if (smp_use_sigp_detection)
 		return smp_rescan_cpus_sigp(avail);
 	else
 		return smp_rescan_cpus_sclp(avail);
 }
 static void __init smp_detect_cpus(void)
 {
 	unsigned int cpu, c_cpus, s_cpus;
 	struct sclp_cpu_info *info;
 	u16 boot_cpu_addr, cpu_addr;
 	c_cpus = 1;
 	s_cpus = 0;
 	boot_cpu_addr = __cpu_logical_map[0];
 	info = kmalloc(sizeof(*info), GFP_KERNEL);
 	if (!info)
 		panic("smp_detect_cpus failed to allocate memory\n");
 	/* Use sigp detection algorithm if sclp doesn't work. */
 	if (sclp_get_cpu_info(info)) {
 		smp_use_sigp_detection = 1;
 		for (cpu = 0; cpu <= MAX_CPU_ADDRESS; cpu++) {
 			if (cpu == boot_cpu_addr)
 				continue;
 			if (!raw_cpu_stopped(cpu))
 				continue;
 			smp_get_save_area(c_cpus, cpu);
 			c_cpus++;
 		}
 		goto out;
 	}
 	if (info->has_cpu_type) {
 		for (cpu = 0; cpu < info->combined; cpu++) {
 			if (info->cpu[cpu].address == boot_cpu_addr) {
 				smp_cpu_type = info->cpu[cpu].type;
 				break;
 			}
 		}
 	}
 	for (cpu = 0; cpu < info->combined; cpu++) {
 		if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
 			continue;
 		cpu_addr = info->cpu[cpu].address;
 		if (cpu_addr == boot_cpu_addr)
 			continue;
 		if (!raw_cpu_stopped(cpu_addr)) {
 			s_cpus++;
 			continue;
 		}
 		smp_get_save_area(c_cpus, cpu_addr);
 		c_cpus++;
 	}
 out:
 	kfree(info);
 	pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus, s_cpus);
 	get_online_cpus();
 	__smp_rescan_cpus();
 	put_online_cpus();
 }
 /*
  *	Activate a secondary processor.
  */
 int __cpuinit start_secondary(void *cpuvoid)
 {
 	/* Setup the cpu */
 	cpu_init();
 	preempt_disable();
 	/* Enable TOD clock interrupts on the secondary cpu. */
 	init_cpu_timer();
 	/* Enable cpu timer interrupts on the secondary cpu. */
 	init_cpu_vtimer();
 	/* Enable pfault pseudo page faults on this cpu. */
 	pfault_init();
 	/* call cpu notifiers */
 	notify_cpu_starting(smp_processor_id());
 	/* Mark this cpu as online */
 	ipi_call_lock();
 	set_cpu_online(smp_processor_id(), true);
 	ipi_call_unlock();
 	/* Switch on interrupts */
 	local_irq_enable();
 	/* cpu_idle will call schedule for us */
 	cpu_idle();
 	return 0;
 }
 struct create_idle {
 	struct work_struct work;
 	struct task_struct *idle;
 	struct completion done;
 	int cpu;
 };
 static void __cpuinit smp_fork_idle(struct work_struct *work)
 {
 	struct create_idle *c_idle;
 	c_idle = container_of(work, struct create_idle, work);
 	c_idle->idle = fork_idle(c_idle->cpu);
 	complete(&c_idle->done);
 }
 static int __cpuinit smp_alloc_lowcore(int cpu)
 {
 	unsigned long async_stack, panic_stack;
 	struct _lowcore *lowcore;
 	lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, LC_ORDER);
 	if (!lowcore)
 		return -ENOMEM;
 	async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
 	panic_stack = __get_free_page(GFP_KERNEL);
 	if (!panic_stack || !async_stack)
 		goto out;
 	memcpy(lowcore, &S390_lowcore, 512);
 	memset((char *)lowcore + 512, 0, sizeof(*lowcore) - 512);
 	lowcore->async_stack = async_stack + ASYNC_SIZE;
 	lowcore->panic_stack = panic_stack + PAGE_SIZE;
 #ifndef CONFIG_64BIT
 	if (MACHINE_HAS_IEEE) {
 		unsigned long save_area;
 		save_area = get_zeroed_page(GFP_KERNEL);
 		if (!save_area)
 			goto out;
 		lowcore->extended_save_area_addr = (u32) save_area;
 	}
 #else
 	if (vdso_alloc_per_cpu(cpu, lowcore))
 		goto out;
 #endif
 	lowcore_ptr[cpu] = lowcore;
 	return 0;
 out:
 	free_page(panic_stack);
 	free_pages(async_stack, ASYNC_ORDER);
 	free_pages((unsigned long) lowcore, LC_ORDER);
 	return -ENOMEM;
 }
 static void smp_free_lowcore(int cpu)
 {
 	struct _lowcore *lowcore;
 	lowcore = lowcore_ptr[cpu];
 #ifndef CONFIG_64BIT
 	if (MACHINE_HAS_IEEE)
 		free_page((unsigned long) lowcore->extended_save_area_addr);
 #else
 	vdso_free_per_cpu(cpu, lowcore);
 #endif
 	free_page(lowcore->panic_stack - PAGE_SIZE);
 	free_pages(lowcore->async_stack - ASYNC_SIZE, ASYNC_ORDER);
 	free_pages((unsigned long) lowcore, LC_ORDER);
 	lowcore_ptr[cpu] = NULL;
 }
 /* Upping and downing of CPUs */
 int __cpuinit __cpu_up(unsigned int cpu)
 {
 	struct _lowcore *cpu_lowcore;
 	struct create_idle c_idle;
 	struct task_struct *idle;
 	struct stack_frame *sf;
 	u32 lowcore;
 	int ccode;
 	if (smp_cpu_state[cpu] != CPU_STATE_CONFIGURED)
 		return -EIO;
 	idle = current_set[cpu];
 	if (!idle) {
 		c_idle.done = COMPLETION_INITIALIZER_ONSTACK(c_idle.done);
 		INIT_WORK_ONSTACK(&c_idle.work, smp_fork_idle);
 		c_idle.cpu = cpu;
 		schedule_work(&c_idle.work);
 		wait_for_completion(&c_idle.done);
 		if (IS_ERR(c_idle.idle))
 			return PTR_ERR(c_idle.idle);
 		idle = c_idle.idle;
 		current_set[cpu] = c_idle.idle;
 	}
 	init_idle(idle, cpu);
 	if (smp_alloc_lowcore(cpu))
 		return -ENOMEM;
 	do {
 		ccode = sigp(cpu, sigp_initial_cpu_reset);
 		if (ccode == sigp_busy)
 			udelay(10);
 		if (ccode == sigp_not_operational)
 			goto err_out;
 	} while (ccode == sigp_busy);
 	lowcore = (u32)(unsigned long)lowcore_ptr[cpu];
 	while (sigp_p(lowcore, cpu, sigp_set_prefix) == sigp_busy)
 		udelay(10);
 	cpu_lowcore = lowcore_ptr[cpu];
 	cpu_lowcore->kernel_stack = (unsigned long)
 		task_stack_page(idle) + THREAD_SIZE;
 	cpu_lowcore->thread_info = (unsigned long) task_thread_info(idle);
 	sf = (struct stack_frame *) (cpu_lowcore->kernel_stack
 				     - sizeof(struct pt_regs)
 				     - sizeof(struct stack_frame));
 	memset(sf, 0, sizeof(struct stack_frame));
 	sf->gprs[9] = (unsigned long) sf;
 	cpu_lowcore->save_area[15] = (unsigned long) sf;
 	__ctl_store(cpu_lowcore->cregs_save_area, 0, 15);
 	atomic_inc(&init_mm.context.attach_count);
 	asm volatile(
 		"	stam	0,15,0(%0)"
 		: : "a" (&cpu_lowcore->access_regs_save_area) : "memory");
 	cpu_lowcore->percpu_offset = __per_cpu_offset[cpu];
 	cpu_lowcore->current_task = (unsigned long) idle;
 	cpu_lowcore->cpu_nr = cpu;
 	cpu_lowcore->kernel_asce = S390_lowcore.kernel_asce;
 	cpu_lowcore->machine_flags = S390_lowcore.machine_flags;
 	cpu_lowcore->ftrace_func = S390_lowcore.ftrace_func;
 	memcpy(cpu_lowcore->stfle_fac_list, S390_lowcore.stfle_fac_list,
 	       MAX_FACILITY_BIT/8);
 	eieio();
 	while (sigp(cpu, sigp_restart) == sigp_busy)
 		udelay(10);
 	while (!cpu_online(cpu))
 		cpu_relax();
 	return 0;
 err_out:
 	smp_free_lowcore(cpu);
 	return -EIO;
 }
 static int __init setup_possible_cpus(char *s)
 {
 	int pcpus, cpu;
 	pcpus = simple_strtoul(s, NULL, 0);
 	init_cpu_possible(cpumask_of(0));
 	for (cpu = 1; cpu < pcpus && cpu < nr_cpu_ids; cpu++)
 		set_cpu_possible(cpu, true);
 	return 0;
 }
 early_param("possible_cpus", setup_possible_cpus);
 #ifdef CONFIG_HOTPLUG_CPU
 int __cpu_disable(void)
 {
 	struct ec_creg_mask_parms cr_parms;
 	int cpu = smp_processor_id();
 	set_cpu_online(cpu, false);
 	/* Disable pfault pseudo page faults on this cpu. */
 	pfault_fini();
 	memset(&cr_parms.orvals, 0, sizeof(cr_parms.orvals));
 	memset(&cr_parms.andvals, 0xff, sizeof(cr_parms.andvals));
 	/* disable all external interrupts */
 	cr_parms.orvals[0] = 0;
 	cr_parms.andvals[0] = ~(1 << 15 | 1 << 14 | 1 << 13 | 1 << 11 |
 				1 << 10 | 1 <<	9 | 1 <<  6 | 1 <<  4);
 	/* disable all I/O interrupts */
 	cr_parms.orvals[6] = 0;
 	cr_parms.andvals[6] = ~(1 << 31 | 1 << 30 | 1 << 29 | 1 << 28 |
 				1 << 27 | 1 << 26 | 1 << 25 | 1 << 24);
 	/* disable most machine checks */
 	cr_parms.orvals[14] = 0;
 	cr_parms.andvals[14] = ~(1 << 28 | 1 << 27 | 1 << 26 |
 				 1 << 25 | 1 << 24);
 	smp_ctl_bit_callback(&cr_parms);
 	return 0;
 }
 void __cpu_die(unsigned int cpu)
 {
 	/* Wait until target cpu is down */
 	while (!cpu_stopped(cpu))
 		cpu_relax();
 	while (sigp_p(0, cpu, sigp_set_prefix) == sigp_busy)
 		udelay(10);
 	smp_free_lowcore(cpu);
 	atomic_dec(&init_mm.context.attach_count);
 }
 void __noreturn cpu_die(void)
 {
 	idle_task_exit();
 	while (sigp(smp_processor_id(), sigp_stop) == sigp_busy)
 		cpu_relax();
 	for (;;);
 }
 #endif /* CONFIG_HOTPLUG_CPU */
 void __init smp_prepare_cpus(unsigned int max_cpus)
 {
 #ifndef CONFIG_64BIT
 	unsigned long save_area = 0;
 #endif
 	unsigned long async_stack, panic_stack;
 	struct _lowcore *lowcore;
 	smp_detect_cpus();
 	/* request the 0x1201 emergency signal external interrupt */
 	if (register_external_interrupt(0x1201, do_ext_call_interrupt) != 0)
 		panic("Couldn't request external interrupt 0x1201");
 	/* Reallocate current lowcore, but keep its contents. */
 	lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, LC_ORDER);
 	panic_stack = __get_free_page(GFP_KERNEL);
 	async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
 	BUG_ON(!lowcore || !panic_stack || !async_stack);
 #ifndef CONFIG_64BIT
 	if (MACHINE_HAS_IEEE)
 		save_area = get_zeroed_page(GFP_KERNEL);
 #endif
 	local_irq_disable();
 	local_mcck_disable();
 	lowcore_ptr[smp_processor_id()] = lowcore;
 	*lowcore = S390_lowcore;
 	lowcore->panic_stack = panic_stack + PAGE_SIZE;
 	lowcore->async_stack = async_stack + ASYNC_SIZE;
 #ifndef CONFIG_64BIT
 	if (MACHINE_HAS_IEEE)
 		lowcore->extended_save_area_addr = (u32) save_area;
 #endif
 	set_prefix((u32)(unsigned long) lowcore);
 	local_mcck_enable();
 	local_irq_enable();
 #ifdef CONFIG_64BIT
 	if (vdso_alloc_per_cpu(smp_processor_id(), &S390_lowcore))
 		BUG();
 #endif
 }
 void __init smp_prepare_boot_cpu(void)
 {
 	BUG_ON(smp_processor_id() != 0);
 	current_thread_info()->cpu = 0;
 	set_cpu_present(0, true);
 	set_cpu_online(0, true);
 	S390_lowcore.percpu_offset = __per_cpu_offset[0];
 	current_set[0] = current;
 	smp_cpu_state[0] = CPU_STATE_CONFIGURED;
 	smp_cpu_polarization[0] = POLARIZATION_UNKNWN;
 }
 void __init smp_cpus_done(unsigned int max_cpus)
 {
 }
 void __init smp_setup_processor_id(void)
 {
 	S390_lowcore.cpu_nr = 0;
 	__cpu_logical_map[0] = stap();
 }
 /*
  * the frequency of the profiling timer can be changed
  * by writing a multiplier value into /proc/profile.
  *
  * usually you want to run this on all CPUs ;)
  */
 int setup_profiling_timer(unsigned int multiplier)
 {
 	return 0;
 }
 #ifdef CONFIG_HOTPLUG_CPU
 static ssize_t cpu_configure_show(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	ssize_t count;
 	mutex_lock(&smp_cpu_state_mutex);
 	count = sprintf(buf, "%d\n", smp_cpu_state[dev->id]);
 	mutex_unlock(&smp_cpu_state_mutex);
 	return count;
 }
 static ssize_t cpu_configure_store(struct sys_device *dev,
 				  struct sysdev_attribute *attr,
 				  const char *buf, size_t count)
 {
 	int cpu = dev->id;
 	int val, rc;
 	char delim;
 	if (sscanf(buf, "%d %c", &val, &delim) != 1)
 		return -EINVAL;
 	if (val != 0 && val != 1)
 		return -EINVAL;
 	get_online_cpus();
 	mutex_lock(&smp_cpu_state_mutex);
 	rc = -EBUSY;
 	/* disallow configuration changes of online cpus and cpu 0 */
 	if (cpu_online(cpu) || cpu == 0)
 		goto out;
 	rc = 0;
 	switch (val) {
 	case 0:
 		if (smp_cpu_state[cpu] == CPU_STATE_CONFIGURED) {
 			rc = sclp_cpu_deconfigure(__cpu_logical_map[cpu]);
 			if (!rc) {
 				smp_cpu_state[cpu] = CPU_STATE_STANDBY;
 				smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN;
 			}
 		}
 		break;
 	case 1:
 		if (smp_cpu_state[cpu] == CPU_STATE_STANDBY) {
 			rc = sclp_cpu_configure(__cpu_logical_map[cpu]);
 			if (!rc) {
 				smp_cpu_state[cpu] = CPU_STATE_CONFIGURED;
 				smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN;
 			}
 		}
 		break;
 	default:
 		break;
 	}
 out:
 	mutex_unlock(&smp_cpu_state_mutex);
 	put_online_cpus();
 	return rc ? rc : count;
 }
 static SYSDEV_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store);
 #endif /* CONFIG_HOTPLUG_CPU */
 static ssize_t cpu_polarization_show(struct sys_device *dev,
 				     struct sysdev_attribute *attr, char *buf)
 {
 	int cpu = dev->id;
 	ssize_t count;
 	mutex_lock(&smp_cpu_state_mutex);
 	switch (smp_cpu_polarization[cpu]) {
 	case POLARIZATION_HRZ:
 		count = sprintf(buf, "horizontal\n");
 		break;
 	case POLARIZATION_VL:
 		count = sprintf(buf, "vertical:low\n");
 		break;
 	case POLARIZATION_VM:
 		count = sprintf(buf, "vertical:medium\n");
 		break;
 	case POLARIZATION_VH:
 		count = sprintf(buf, "vertical:high\n");
 		break;
 	default:
 		count = sprintf(buf, "unknown\n");
 		break;
 	}
 	mutex_unlock(&smp_cpu_state_mutex);
 	return count;
 }
 static SYSDEV_ATTR(polarization, 0444, cpu_polarization_show, NULL);
 static ssize_t show_cpu_address(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	return sprintf(buf, "%d\n", __cpu_logical_map[dev->id]);
 }
 static SYSDEV_ATTR(address, 0444, show_cpu_address, NULL);
 static struct attribute *cpu_common_attrs[] = {
 #ifdef CONFIG_HOTPLUG_CPU
 	&attr_configure.attr,
 #endif
 	&attr_address.attr,
 	&attr_polarization.attr,
 	NULL,
 };
 static struct attribute_group cpu_common_attr_group = {
 	.attrs = cpu_common_attrs,
 };
 static ssize_t show_capability(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	unsigned int capability;
 	int rc;
 	rc = get_cpu_capability(&capability);
 	if (rc)
 		return rc;
 	return sprintf(buf, "%u\n", capability);
 }
 static SYSDEV_ATTR(capability, 0444, show_capability, NULL);
 static ssize_t show_idle_count(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	struct s390_idle_data *idle;
 	unsigned long long idle_count;
 	unsigned int sequence;
 	idle = &per_cpu(s390_idle, dev->id);
 repeat:
 	sequence = idle->sequence;
 	smp_rmb();
 	if (sequence & 1)
 		goto repeat;
 	idle_count = idle->idle_count;
 	if (idle->idle_enter)
 		idle_count++;
 	smp_rmb();
 	if (idle->sequence != sequence)
 		goto repeat;
 	return sprintf(buf, "%llu\n", idle_count);
 }
 static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL);
 static ssize_t show_idle_time(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	struct s390_idle_data *idle;
 	unsigned long long now, idle_time, idle_enter;
 	unsigned int sequence;
 	idle = &per_cpu(s390_idle, dev->id);
 	now = get_clock();
 repeat:
 	sequence = idle->sequence;
 	smp_rmb();
 	if (sequence & 1)
 		goto repeat;
 	idle_time = idle->idle_time;
 	idle_enter = idle->idle_enter;
 	if (idle_enter != 0ULL && idle_enter < now)
 		idle_time += now - idle_enter;
 	smp_rmb();
 	if (idle->sequence != sequence)
 		goto repeat;
 	return sprintf(buf, "%llu\n", idle_time >> 12);
 }
 static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL);
 static struct attribute *cpu_online_attrs[] = {
 	&attr_capability.attr,
 	&attr_idle_count.attr,
 	&attr_idle_time_us.attr,
 	NULL,
 };
 static struct attribute_group cpu_online_attr_group = {
 	.attrs = cpu_online_attrs,
 };
 static int __cpuinit smp_cpu_notify(struct notifier_block *self,
 				    unsigned long action, void *hcpu)
 {
 	unsigned int cpu = (unsigned int)(long)hcpu;
 	struct cpu *c = &per_cpu(cpu_devices, cpu);
 	struct sys_device *s = &c->sysdev;
 	struct s390_idle_data *idle;
 	int err = 0;
 	switch (action) {
 	case CPU_ONLINE:
 	case CPU_ONLINE_FROZEN:
 		idle = &per_cpu(s390_idle, cpu);
 		memset(idle, 0, sizeof(struct s390_idle_data));
 		err = sysfs_create_group(&s->kobj, &cpu_online_attr_group);
 		break;
 	case CPU_DEAD:
 	case CPU_DEAD_FROZEN:
 		sysfs_remove_group(&s->kobj, &cpu_online_attr_group);
 		break;
 	}
 	return notifier_from_errno(err);
 }
 static struct notifier_block __cpuinitdata smp_cpu_nb = {
 	.notifier_call = smp_cpu_notify,
 };
 static int __devinit smp_add_present_cpu(int cpu)
 {
 	struct cpu *c = &per_cpu(cpu_devices, cpu);
 	struct sys_device *s = &c->sysdev;
 	int rc;
 	c->hotpluggable = 1;
 	rc = register_cpu(c, cpu);
 	if (rc)
 		goto out;
 	rc = sysfs_create_group(&s->kobj, &cpu_common_attr_group);
 	if (rc)
 		goto out_cpu;
 	if (!cpu_online(cpu))
 		goto out;
 	rc = sysfs_create_group(&s->kobj, &cpu_online_attr_group);
 	if (!rc)
 		return 0;
 	sysfs_remove_group(&s->kobj, &cpu_common_attr_group);
 out_cpu:
 #ifdef CONFIG_HOTPLUG_CPU
 	unregister_cpu(c);
 #endif
 out:
 	return rc;
 }
 #ifdef CONFIG_HOTPLUG_CPU
 int __ref smp_rescan_cpus(void)
 {
 	cpumask_t newcpus;
 	int cpu;
 	int rc;
 	get_online_cpus();
 	mutex_lock(&smp_cpu_state_mutex);
 	cpumask_copy(&newcpus, cpu_present_mask);
 	rc = __smp_rescan_cpus();
 	if (rc)
 		goto out;
 	cpumask_andnot(&newcpus, cpu_present_mask, &newcpus);
 	for_each_cpu(cpu, &newcpus) {
 		rc = smp_add_present_cpu(cpu);
 		if (rc)
 			set_cpu_present(cpu, false);
 	}
 	rc = 0;
 out:
 	mutex_unlock(&smp_cpu_state_mutex);
 	put_online_cpus();
 	if (!cpumask_empty(&newcpus))
 		topology_schedule_update();
 	return rc;
 }
 static ssize_t __ref rescan_store(struct sysdev_class *class,
 				  struct sysdev_class_attribute *attr,
 				  const char *buf,
 				  size_t count)
 {
 	int rc;
 	rc = smp_rescan_cpus();
 	return rc ? rc : count;
 }
 static SYSDEV_CLASS_ATTR(rescan, 0200, NULL, rescan_store);
 #endif /* CONFIG_HOTPLUG_CPU */
 static ssize_t dispatching_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	ssize_t count;
 	mutex_lock(&smp_cpu_state_mutex);
 	count = sprintf(buf, "%d\n", cpu_management);
 	mutex_unlock(&smp_cpu_state_mutex);
 	return count;
 }
 static ssize_t dispatching_store(struct sysdev_class *dev,
 				 struct sysdev_class_attribute *attr,
 				 const char *buf,
 				 size_t count)
 {
 	int val, rc;
 	char delim;
 	if (sscanf(buf, "%d %c", &val, &delim) != 1)
 		return -EINVAL;
 	if (val != 0 && val != 1)
 		return -EINVAL;
 	rc = 0;
 	get_online_cpus();
 	mutex_lock(&smp_cpu_state_mutex);
 	if (cpu_management == val)
 		goto out;
 	rc = topology_set_cpu_management(val);
 	if (!rc)
 		cpu_management = val;
 out:
 	mutex_unlock(&smp_cpu_state_mutex);
 	put_online_cpus();
 	return rc ? rc : count;
 }
 static SYSDEV_CLASS_ATTR(dispatching, 0644, dispatching_show,
 			 dispatching_store);
 static int __init topology_init(void)
 {
 	int cpu;
 	int rc;
 	register_cpu_notifier(&smp_cpu_nb);
 #ifdef CONFIG_HOTPLUG_CPU
 	rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_rescan);
 	if (rc)
 		return rc;
 #endif
 	rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_dispatching);
 	if (rc)
 		return rc;
 	for_each_present_cpu(cpu) {
 		rc = smp_add_present_cpu(cpu);
 		if (rc)
 			return rc;
 	}
 	return 0;
 }
 subsys_initcall(topology_init);

arch/s390/kernel/time.c

Diff comments View file @ d7b250e

 /*
  *  arch/s390/kernel/time.c
  *    Time of day based timer functions.
  *
  *  S390 version
  *    Copyright IBM Corp. 1999, 2008
  *    Author(s): Hartmut Penner (hp@de.ibm.com),
  *               Martin Schwidefsky (schwidefsky@de.ibm.com),
  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
  *
  *  Derived from "arch/i386/kernel/time.c"
  *    Copyright (C) 1991, 1992, 1995  Linus Torvalds
  */
 #define KMSG_COMPONENT "time"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/kernel_stat.h>
 #include <linux/errno.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/param.h>
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/cpu.h>
 #include <linux/stop_machine.h>
 #include <linux/time.h>
 #include <linux/sysdev.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/types.h>
 #include <linux/profile.h>
 #include <linux/timex.h>
 #include <linux/notifier.h>
 #include <linux/clocksource.h>
 #include <linux/clockchips.h>
 #include <linux/gfp.h>
 #include <linux/kprobes.h>
 #include <asm/uaccess.h>
 #include <asm/delay.h>
-#include <asm/s390_ext.h>
 #include <asm/div64.h>
 #include <asm/vdso.h>
 #include <asm/irq.h>
 #include <asm/irq_regs.h>
 #include <asm/timer.h>
 #include <asm/etr.h>
 #include <asm/cio.h>
 /* change this if you have some constant time drift */
 #define USECS_PER_JIFFY     ((unsigned long) 1000000/HZ)
 #define CLK_TICKS_PER_JIFFY ((unsigned long) USECS_PER_JIFFY << 12)
 u64 sched_clock_base_cc = -1;	/* Force to data section. */
 EXPORT_SYMBOL_GPL(sched_clock_base_cc);
 static DEFINE_PER_CPU(struct clock_event_device, comparators);
 /*
  * Scheduler clock - returns current time in nanosec units.
  */
 unsigned long long notrace __kprobes sched_clock(void)
 {
 	return (get_clock_monotonic() * 125) >> 9;
 }
 /*
  * Monotonic_clock - returns # of nanoseconds passed since time_init()
  */
 unsigned long long monotonic_clock(void)
 {
 	return sched_clock();
 }
 EXPORT_SYMBOL(monotonic_clock);
 void tod_to_timeval(__u64 todval, struct timespec *xt)
 {
 	unsigned long long sec;
 	sec = todval >> 12;
 	do_div(sec, 1000000);
 	xt->tv_sec = sec;
 	todval -= (sec * 1000000) << 12;
 	xt->tv_nsec = ((todval * 1000) >> 12);
 }
 EXPORT_SYMBOL(tod_to_timeval);
 void clock_comparator_work(void)
 {
 	struct clock_event_device *cd;
 	S390_lowcore.clock_comparator = -1ULL;
 	set_clock_comparator(S390_lowcore.clock_comparator);
 	cd = &__get_cpu_var(comparators);
 	cd->event_handler(cd);
 }
 /*
  * Fixup the clock comparator.
  */
 static void fixup_clock_comparator(unsigned long long delta)
 {
 	/* If nobody is waiting there's nothing to fix. */
 	if (S390_lowcore.clock_comparator == -1ULL)
 		return;
 	S390_lowcore.clock_comparator += delta;
 	set_clock_comparator(S390_lowcore.clock_comparator);
 }
 static int s390_next_event(unsigned long delta,
 			   struct clock_event_device *evt)
 {
 	S390_lowcore.clock_comparator = get_clock() + delta;
 	set_clock_comparator(S390_lowcore.clock_comparator);
 	return 0;
 }
 static void s390_set_mode(enum clock_event_mode mode,
 			  struct clock_event_device *evt)
 {
 }
 /*
  * Set up lowcore and control register of the current cpu to
  * enable TOD clock and clock comparator interrupts.
  */
 void init_cpu_timer(void)
 {
 	struct clock_event_device *cd;
 	int cpu;
 	S390_lowcore.clock_comparator = -1ULL;
 	set_clock_comparator(S390_lowcore.clock_comparator);
 	cpu = smp_processor_id();
 	cd = &per_cpu(comparators, cpu);
 	cd->name		= "comparator";
 	cd->features		= CLOCK_EVT_FEAT_ONESHOT;
 	cd->mult		= 16777;
 	cd->shift		= 12;
 	cd->min_delta_ns	= 1;
 	cd->max_delta_ns	= LONG_MAX;
 	cd->rating		= 400;
 	cd->cpumask		= cpumask_of(cpu);
 	cd->set_next_event	= s390_next_event;
 	cd->set_mode		= s390_set_mode;
 	clockevents_register_device(cd);
 	/* Enable clock comparator timer interrupt. */
 	__ctl_set_bit(0,11);
 	/* Always allow the timing alert external interrupt. */
 	__ctl_set_bit(0, 4);
 }
 static void clock_comparator_interrupt(unsigned int ext_int_code,
 				       unsigned int param32,
 				       unsigned long param64)
 {
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_CLK]++;
 	if (S390_lowcore.clock_comparator == -1ULL)
 		set_clock_comparator(S390_lowcore.clock_comparator);
 }
 static void etr_timing_alert(struct etr_irq_parm *);
 static void stp_timing_alert(struct stp_irq_parm *);
 static void timing_alert_interrupt(unsigned int ext_int_code,
 				   unsigned int param32, unsigned long param64)
 {
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_TLA]++;
 	if (param32 & 0x00c40000)
 		etr_timing_alert((struct etr_irq_parm *) &param32);
 	if (param32 & 0x00038000)
 		stp_timing_alert((struct stp_irq_parm *) &param32);
 }
 static void etr_reset(void);
 static void stp_reset(void);
 void read_persistent_clock(struct timespec *ts)
 {
 	tod_to_timeval(get_clock() - TOD_UNIX_EPOCH, ts);
 }
 void read_boot_clock(struct timespec *ts)
 {
 	tod_to_timeval(sched_clock_base_cc - TOD_UNIX_EPOCH, ts);
 }
 static cycle_t read_tod_clock(struct clocksource *cs)
 {
 	return get_clock();
 }
 static struct clocksource clocksource_tod = {
 	.name		= "tod",
 	.rating		= 400,
 	.read		= read_tod_clock,
 	.mask		= -1ULL,
 	.mult		= 1000,
 	.shift		= 12,
 	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
 };
 struct clocksource * __init clocksource_default_clock(void)
 {
 	return &clocksource_tod;
 }
 void update_vsyscall(struct timespec *wall_time, struct timespec *wtm,
 			struct clocksource *clock, u32 mult)
 {
 	if (clock != &clocksource_tod)
 		return;
 	/* Make userspace gettimeofday spin until we're done. */
 	++vdso_data->tb_update_count;
 	smp_wmb();
 	vdso_data->xtime_tod_stamp = clock->cycle_last;
 	vdso_data->xtime_clock_sec = wall_time->tv_sec;
 	vdso_data->xtime_clock_nsec = wall_time->tv_nsec;
 	vdso_data->wtom_clock_sec = wtm->tv_sec;
 	vdso_data->wtom_clock_nsec = wtm->tv_nsec;
 	vdso_data->ntp_mult = mult;
 	smp_wmb();
 	++vdso_data->tb_update_count;
 }
 extern struct timezone sys_tz;
 void update_vsyscall_tz(void)
 {
 	/* Make userspace gettimeofday spin until we're done. */
 	++vdso_data->tb_update_count;
 	smp_wmb();
 	vdso_data->tz_minuteswest = sys_tz.tz_minuteswest;
 	vdso_data->tz_dsttime = sys_tz.tz_dsttime;
 	smp_wmb();
 	++vdso_data->tb_update_count;
 }
 /*
  * Initialize the TOD clock and the CPU timer of
  * the boot cpu.
  */
 void __init time_init(void)
 {
 	/* Reset time synchronization interfaces. */
 	etr_reset();
 	stp_reset();
 	/* request the clock comparator external interrupt */
 	if (register_external_interrupt(0x1004, clock_comparator_interrupt))
                 panic("Couldn't request external interrupt 0x1004");
 	/* request the timing alert external interrupt */
 	if (register_external_interrupt(0x1406, timing_alert_interrupt))
 		panic("Couldn't request external interrupt 0x1406");
 	if (clocksource_register(&clocksource_tod) != 0)
 		panic("Could not register TOD clock source");
 	/* Enable TOD clock interrupts on the boot cpu. */
 	init_cpu_timer();
 	/* Enable cpu timer interrupts on the boot cpu. */
 	vtime_init();
 }
 /*
  * The time is "clock". old is what we think the time is.
  * Adjust the value by a multiple of jiffies and add the delta to ntp.
  * "delay" is an approximation how long the synchronization took. If
  * the time correction is positive, then "delay" is subtracted from
  * the time difference and only the remaining part is passed to ntp.
  */
 static unsigned long long adjust_time(unsigned long long old,
 				      unsigned long long clock,
 				      unsigned long long delay)
 {
 	unsigned long long delta, ticks;
 	struct timex adjust;
 	if (clock > old) {
 		/* It is later than we thought. */
 		delta = ticks = clock - old;
 		delta = ticks = (delta < delay) ? 0 : delta - delay;
 		delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
 		adjust.offset = ticks * (1000000 / HZ);
 	} else {
 		/* It is earlier than we thought. */
 		delta = ticks = old - clock;
 		delta -= do_div(ticks, CLK_TICKS_PER_JIFFY);
 		delta = -delta;
 		adjust.offset = -ticks * (1000000 / HZ);
 	}
 	sched_clock_base_cc += delta;
 	if (adjust.offset != 0) {
 		pr_notice("The ETR interface has adjusted the clock "
 			  "by %li microseconds\n", adjust.offset);
 		adjust.modes = ADJ_OFFSET_SINGLESHOT;
 		do_adjtimex(&adjust);
 	}
 	return delta;
 }
 static DEFINE_PER_CPU(atomic_t, clock_sync_word);
 static DEFINE_MUTEX(clock_sync_mutex);
 static unsigned long clock_sync_flags;
 #define CLOCK_SYNC_HAS_ETR	0
 #define CLOCK_SYNC_HAS_STP	1
 #define CLOCK_SYNC_ETR		2
 #define CLOCK_SYNC_STP		3
 /*
  * The synchronous get_clock function. It will write the current clock
  * value to the clock pointer and return 0 if the clock is in sync with
  * the external time source. If the clock mode is local it will return
  * -ENOSYS and -EAGAIN if the clock is not in sync with the external
  * reference.
  */
 int get_sync_clock(unsigned long long *clock)
 {
 	atomic_t *sw_ptr;
 	unsigned int sw0, sw1;
 	sw_ptr = &get_cpu_var(clock_sync_word);
 	sw0 = atomic_read(sw_ptr);
 	*clock = get_clock();
 	sw1 = atomic_read(sw_ptr);
 	put_cpu_var(clock_sync_word);
 	if (sw0 == sw1 && (sw0 & 0x80000000U))
 		/* Success: time is in sync. */
 		return 0;
 	if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags) &&
 	    !test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 		return -ENOSYS;
 	if (!test_bit(CLOCK_SYNC_ETR, &clock_sync_flags) &&
 	    !test_bit(CLOCK_SYNC_STP, &clock_sync_flags))
 		return -EACCES;
 	return -EAGAIN;
 }
 EXPORT_SYMBOL(get_sync_clock);
 /*
  * Make get_sync_clock return -EAGAIN.
  */
 static void disable_sync_clock(void *dummy)
 {
 	atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
 	/*
 	 * Clear the in-sync bit 2^31. All get_sync_clock calls will
 	 * fail until the sync bit is turned back on. In addition
 	 * increase the "sequence" counter to avoid the race of an
 	 * etr event and the complete recovery against get_sync_clock.
 	 */
 	atomic_clear_mask(0x80000000, sw_ptr);
 	atomic_inc(sw_ptr);
 }
 /*
  * Make get_sync_clock return 0 again.
  * Needs to be called from a context disabled for preemption.
  */
 static void enable_sync_clock(void)
 {
 	atomic_t *sw_ptr = &__get_cpu_var(clock_sync_word);
 	atomic_set_mask(0x80000000, sw_ptr);
 }
 /*
  * Function to check if the clock is in sync.
  */
 static inline int check_sync_clock(void)
 {
 	atomic_t *sw_ptr;
 	int rc;
 	sw_ptr = &get_cpu_var(clock_sync_word);
 	rc = (atomic_read(sw_ptr) & 0x80000000U) != 0;
 	put_cpu_var(clock_sync_word);
 	return rc;
 }
 /* Single threaded workqueue used for etr and stp sync events */
 static struct workqueue_struct *time_sync_wq;
 static void __init time_init_wq(void)
 {
 	if (time_sync_wq)
 		return;
 	time_sync_wq = create_singlethread_workqueue("timesync");
 }
 /*
  * External Time Reference (ETR) code.
  */
 static int etr_port0_online;
 static int etr_port1_online;
 static int etr_steai_available;
 static int __init early_parse_etr(char *p)
 {
 	if (strncmp(p, "off", 3) == 0)
 		etr_port0_online = etr_port1_online = 0;
 	else if (strncmp(p, "port0", 5) == 0)
 		etr_port0_online = 1;
 	else if (strncmp(p, "port1", 5) == 0)
 		etr_port1_online = 1;
 	else if (strncmp(p, "on", 2) == 0)
 		etr_port0_online = etr_port1_online = 1;
 	return 0;
 }
 early_param("etr", early_parse_etr);
 enum etr_event {
 	ETR_EVENT_PORT0_CHANGE,
 	ETR_EVENT_PORT1_CHANGE,
 	ETR_EVENT_PORT_ALERT,
 	ETR_EVENT_SYNC_CHECK,
 	ETR_EVENT_SWITCH_LOCAL,
 	ETR_EVENT_UPDATE,
 };
 /*
  * Valid bit combinations of the eacr register are (x = don't care):
  * e0 e1 dp p0 p1 ea es sl
  *  0  0  x  0	0  0  0  0  initial, disabled state
  *  0  0  x  0	1  1  0  0  port 1 online
  *  0  0  x  1	0  1  0  0  port 0 online
  *  0  0  x  1	1  1  0  0  both ports online
  *  0  1  x  0	1  1  0  0  port 1 online and usable, ETR or PPS mode
  *  0  1  x  0	1  1  0  1  port 1 online, usable and ETR mode
  *  0  1  x  0	1  1  1  0  port 1 online, usable, PPS mode, in-sync
  *  0  1  x  0	1  1  1  1  port 1 online, usable, ETR mode, in-sync
  *  0  1  x  1	1  1  0  0  both ports online, port 1 usable
  *  0  1  x  1	1  1  1  0  both ports online, port 1 usable, PPS mode, in-sync
  *  0  1  x  1	1  1  1  1  both ports online, port 1 usable, ETR mode, in-sync
  *  1  0  x  1	0  1  0  0  port 0 online and usable, ETR or PPS mode
  *  1  0  x  1	0  1  0  1  port 0 online, usable and ETR mode
  *  1  0  x  1	0  1  1  0  port 0 online, usable, PPS mode, in-sync
  *  1  0  x  1	0  1  1  1  port 0 online, usable, ETR mode, in-sync
  *  1  0  x  1	1  1  0  0  both ports online, port 0 usable
  *  1  0  x  1	1  1  1  0  both ports online, port 0 usable, PPS mode, in-sync
  *  1  0  x  1	1  1  1  1  both ports online, port 0 usable, ETR mode, in-sync
  *  1  1  x  1	1  1  1  0  both ports online & usable, ETR, in-sync
  *  1  1  x  1	1  1  1  1  both ports online & usable, ETR, in-sync
  */
 static struct etr_eacr etr_eacr;
 static u64 etr_tolec;			/* time of last eacr update */
 static struct etr_aib etr_port0;
 static int etr_port0_uptodate;
 static struct etr_aib etr_port1;
 static int etr_port1_uptodate;
 static unsigned long etr_events;
 static struct timer_list etr_timer;
 static void etr_timeout(unsigned long dummy);
 static void etr_work_fn(struct work_struct *work);
 static DEFINE_MUTEX(etr_work_mutex);
 static DECLARE_WORK(etr_work, etr_work_fn);
 /*
  * Reset ETR attachment.
  */
 static void etr_reset(void)
 {
 	etr_eacr =  (struct etr_eacr) {
 		.e0 = 0, .e1 = 0, ._pad0 = 4, .dp = 0,
 		.p0 = 0, .p1 = 0, ._pad1 = 0, .ea = 0,
 		.es = 0, .sl = 0 };
 	if (etr_setr(&etr_eacr) == 0) {
 		etr_tolec = get_clock();
 		set_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags);
 		if (etr_port0_online && etr_port1_online)
 			set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
 	} else if (etr_port0_online || etr_port1_online) {
 		pr_warning("The real or virtual hardware system does "
 			   "not provide an ETR interface\n");
 		etr_port0_online = etr_port1_online = 0;
 	}
 }
 static int __init etr_init(void)
 {
 	struct etr_aib aib;
 	if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
 		return 0;
 	time_init_wq();
 	/* Check if this machine has the steai instruction. */
 	if (etr_steai(&aib, ETR_STEAI_STEPPING_PORT) == 0)
 		etr_steai_available = 1;
 	setup_timer(&etr_timer, etr_timeout, 0UL);
 	if (etr_port0_online) {
 		set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
 		queue_work(time_sync_wq, &etr_work);
 	}
 	if (etr_port1_online) {
 		set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
 		queue_work(time_sync_wq, &etr_work);
 	}
 	return 0;
 }
 arch_initcall(etr_init);
 /*
  * Two sorts of ETR machine checks. The architecture reads:
  * "When a machine-check niterruption occurs and if a switch-to-local or
  *  ETR-sync-check interrupt request is pending but disabled, this pending
  *  disabled interruption request is indicated and is cleared".
  * Which means that we can get etr_switch_to_local events from the machine
  * check handler although the interruption condition is disabled. Lovely..
  */
 /*
  * Switch to local machine check. This is called when the last usable
  * ETR port goes inactive. After switch to local the clock is not in sync.
  */
 void etr_switch_to_local(void)
 {
 	if (!etr_eacr.sl)
 		return;
 	disable_sync_clock(NULL);
 	if (!test_and_set_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events)) {
 		etr_eacr.es = etr_eacr.sl = 0;
 		etr_setr(&etr_eacr);
 		queue_work(time_sync_wq, &etr_work);
 	}
 }
 /*
  * ETR sync check machine check. This is called when the ETR OTE and the
  * local clock OTE are farther apart than the ETR sync check tolerance.
  * After a ETR sync check the clock is not in sync. The machine check
  * is broadcasted to all cpus at the same time.
  */
 void etr_sync_check(void)
 {
 	if (!etr_eacr.es)
 		return;
 	disable_sync_clock(NULL);
 	if (!test_and_set_bit(ETR_EVENT_SYNC_CHECK, &etr_events)) {
 		etr_eacr.es = 0;
 		etr_setr(&etr_eacr);
 		queue_work(time_sync_wq, &etr_work);
 	}
 }
 /*
  * ETR timing alert. There are two causes:
  * 1) port state change, check the usability of the port
  * 2) port alert, one of the ETR-data-validity bits (v1-v2 bits of the
  *    sldr-status word) or ETR-data word 1 (edf1) or ETR-data word 3 (edf3)
  *    or ETR-data word 4 (edf4) has changed.
  */
 static void etr_timing_alert(struct etr_irq_parm *intparm)
 {
 	if (intparm->pc0)
 		/* ETR port 0 state change. */
 		set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
 	if (intparm->pc1)
 		/* ETR port 1 state change. */
 		set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
 	if (intparm->eai)
 		/*
 		 * ETR port alert on either port 0, 1 or both.
 		 * Both ports are not up-to-date now.
 		 */
 		set_bit(ETR_EVENT_PORT_ALERT, &etr_events);
 	queue_work(time_sync_wq, &etr_work);
 }
 static void etr_timeout(unsigned long dummy)
 {
 	set_bit(ETR_EVENT_UPDATE, &etr_events);
 	queue_work(time_sync_wq, &etr_work);
 }
 /*
  * Check if the etr mode is pss.
  */
 static inline int etr_mode_is_pps(struct etr_eacr eacr)
 {
 	return eacr.es && !eacr.sl;
 }
 /*
  * Check if the etr mode is etr.
  */
 static inline int etr_mode_is_etr(struct etr_eacr eacr)
 {
 	return eacr.es && eacr.sl;
 }
 /*
  * Check if the port can be used for TOD synchronization.
  * For PPS mode the port has to receive OTEs. For ETR mode
  * the port has to receive OTEs, the ETR stepping bit has to
  * be zero and the validity bits for data frame 1, 2, and 3
  * have to be 1.
  */
 static int etr_port_valid(struct etr_aib *aib, int port)
 {
 	unsigned int psc;
 	/* Check that this port is receiving OTEs. */
 	if (aib->tsp == 0)
 		return 0;
 	psc = port ? aib->esw.psc1 : aib->esw.psc0;
 	if (psc == etr_lpsc_pps_mode)
 		return 1;
 	if (psc == etr_lpsc_operational_step)
 		return !aib->esw.y && aib->slsw.v1 &&
 			aib->slsw.v2 && aib->slsw.v3;
 	return 0;
 }
 /*
  * Check if two ports are on the same network.
  */
 static int etr_compare_network(struct etr_aib *aib1, struct etr_aib *aib2)
 {
 	// FIXME: any other fields we have to compare?
 	return aib1->edf1.net_id == aib2->edf1.net_id;
 }
 /*
  * Wrapper for etr_stei that converts physical port states
  * to logical port states to be consistent with the output
  * of stetr (see etr_psc vs. etr_lpsc).
  */
 static void etr_steai_cv(struct etr_aib *aib, unsigned int func)
 {
 	BUG_ON(etr_steai(aib, func) != 0);
 	/* Convert port state to logical port state. */
 	if (aib->esw.psc0 == 1)
 		aib->esw.psc0 = 2;
 	else if (aib->esw.psc0 == 0 && aib->esw.p == 0)
 		aib->esw.psc0 = 1;
 	if (aib->esw.psc1 == 1)
 		aib->esw.psc1 = 2;
 	else if (aib->esw.psc1 == 0 && aib->esw.p == 1)
 		aib->esw.psc1 = 1;
 }
 /*
  * Check if the aib a2 is still connected to the same attachment as
  * aib a1, the etv values differ by one and a2 is valid.
  */
 static int etr_aib_follows(struct etr_aib *a1, struct etr_aib *a2, int p)
 {
 	int state_a1, state_a2;
 	/* Paranoia check: e0/e1 should better be the same. */
 	if (a1->esw.eacr.e0 != a2->esw.eacr.e0 ||
 	    a1->esw.eacr.e1 != a2->esw.eacr.e1)
 		return 0;
 	/* Still connected to the same etr ? */
 	state_a1 = p ? a1->esw.psc1 : a1->esw.psc0;
 	state_a2 = p ? a2->esw.psc1 : a2->esw.psc0;
 	if (state_a1 == etr_lpsc_operational_step) {
 		if (state_a2 != etr_lpsc_operational_step ||
 		    a1->edf1.net_id != a2->edf1.net_id ||
 		    a1->edf1.etr_id != a2->edf1.etr_id ||
 		    a1->edf1.etr_pn != a2->edf1.etr_pn)
 			return 0;
 	} else if (state_a2 != etr_lpsc_pps_mode)
 		return 0;
 	/* The ETV value of a2 needs to be ETV of a1 + 1. */
 	if (a1->edf2.etv + 1 != a2->edf2.etv)
 		return 0;
 	if (!etr_port_valid(a2, p))
 		return 0;
 	return 1;
 }
 struct clock_sync_data {
 	atomic_t cpus;
 	int in_sync;
 	unsigned long long fixup_cc;
 	int etr_port;
 	struct etr_aib *etr_aib;
 };
 static void clock_sync_cpu(struct clock_sync_data *sync)
 {
 	atomic_dec(&sync->cpus);
 	enable_sync_clock();
 	/*
 	 * This looks like a busy wait loop but it isn't. etr_sync_cpus
 	 * is called on all other cpus while the TOD clocks is stopped.
 	 * __udelay will stop the cpu on an enabled wait psw until the
 	 * TOD is running again.
 	 */
 	while (sync->in_sync == 0) {
 		__udelay(1);
 		/*
 		 * A different cpu changes *in_sync. Therefore use
 		 * barrier() to force memory access.
 		 */
 		barrier();
 	}
 	if (sync->in_sync != 1)
 		/* Didn't work. Clear per-cpu in sync bit again. */
 		disable_sync_clock(NULL);
 	/*
 	 * This round of TOD syncing is done. Set the clock comparator
 	 * to the next tick and let the processor continue.
 	 */
 	fixup_clock_comparator(sync->fixup_cc);
 }
 /*
  * Sync the TOD clock using the port referred to by aibp. This port
  * has to be enabled and the other port has to be disabled. The
  * last eacr update has to be more than 1.6 seconds in the past.
  */
 static int etr_sync_clock(void *data)
 {
 	static int first;
 	unsigned long long clock, old_clock, delay, delta;
 	struct clock_sync_data *etr_sync;
 	struct etr_aib *sync_port, *aib;
 	int port;
 	int rc;
 	etr_sync = data;
 	if (xchg(&first, 1) == 1) {
 		/* Slave */
 		clock_sync_cpu(etr_sync);
 		return 0;
 	}
 	/* Wait until all other cpus entered the sync function. */
 	while (atomic_read(&etr_sync->cpus) != 0)
 		cpu_relax();
 	port = etr_sync->etr_port;
 	aib = etr_sync->etr_aib;
 	sync_port = (port == 0) ? &etr_port0 : &etr_port1;
 	enable_sync_clock();
 	/* Set clock to next OTE. */
 	__ctl_set_bit(14, 21);
 	__ctl_set_bit(0, 29);
 	clock = ((unsigned long long) (aib->edf2.etv + 1)) << 32;
 	old_clock = get_clock();
 	if (set_clock(clock) == 0) {
 		__udelay(1);	/* Wait for the clock to start. */
 		__ctl_clear_bit(0, 29);
 		__ctl_clear_bit(14, 21);
 		etr_stetr(aib);
 		/* Adjust Linux timing variables. */
 		delay = (unsigned long long)
 			(aib->edf2.etv - sync_port->edf2.etv) << 32;
 		delta = adjust_time(old_clock, clock, delay);
 		etr_sync->fixup_cc = delta;
 		fixup_clock_comparator(delta);
 		/* Verify that the clock is properly set. */
 		if (!etr_aib_follows(sync_port, aib, port)) {
 			/* Didn't work. */
 			disable_sync_clock(NULL);
 			etr_sync->in_sync = -EAGAIN;
 			rc = -EAGAIN;
 		} else {
 			etr_sync->in_sync = 1;
 			rc = 0;
 		}
 	} else {
 		/* Could not set the clock ?!? */
 		__ctl_clear_bit(0, 29);
 		__ctl_clear_bit(14, 21);
 		disable_sync_clock(NULL);
 		etr_sync->in_sync = -EAGAIN;
 		rc = -EAGAIN;
 	}
 	xchg(&first, 0);
 	return rc;
 }
 static int etr_sync_clock_stop(struct etr_aib *aib, int port)
 {
 	struct clock_sync_data etr_sync;
 	struct etr_aib *sync_port;
 	int follows;
 	int rc;
 	/* Check if the current aib is adjacent to the sync port aib. */
 	sync_port = (port == 0) ? &etr_port0 : &etr_port1;
 	follows = etr_aib_follows(sync_port, aib, port);
 	memcpy(sync_port, aib, sizeof(*aib));
 	if (!follows)
 		return -EAGAIN;
 	memset(&etr_sync, 0, sizeof(etr_sync));
 	etr_sync.etr_aib = aib;
 	etr_sync.etr_port = port;
 	get_online_cpus();
 	atomic_set(&etr_sync.cpus, num_online_cpus() - 1);
 	rc = stop_machine(etr_sync_clock, &etr_sync, cpu_online_mask);
 	put_online_cpus();
 	return rc;
 }
 /*
  * Handle the immediate effects of the different events.
  * The port change event is used for online/offline changes.
  */
 static struct etr_eacr etr_handle_events(struct etr_eacr eacr)
 {
 	if (test_and_clear_bit(ETR_EVENT_SYNC_CHECK, &etr_events))
 		eacr.es = 0;
 	if (test_and_clear_bit(ETR_EVENT_SWITCH_LOCAL, &etr_events))
 		eacr.es = eacr.sl = 0;
 	if (test_and_clear_bit(ETR_EVENT_PORT_ALERT, &etr_events))
 		etr_port0_uptodate = etr_port1_uptodate = 0;
 	if (test_and_clear_bit(ETR_EVENT_PORT0_CHANGE, &etr_events)) {
 		if (eacr.e0)
 			/*
 			 * Port change of an enabled port. We have to
 			 * assume that this can have caused an stepping
 			 * port switch.
 			 */
 			etr_tolec = get_clock();
 		eacr.p0 = etr_port0_online;
 		if (!eacr.p0)
 			eacr.e0 = 0;
 		etr_port0_uptodate = 0;
 	}
 	if (test_and_clear_bit(ETR_EVENT_PORT1_CHANGE, &etr_events)) {
 		if (eacr.e1)
 			/*
 			 * Port change of an enabled port. We have to
 			 * assume that this can have caused an stepping
 			 * port switch.
 			 */
 			etr_tolec = get_clock();
 		eacr.p1 = etr_port1_online;
 		if (!eacr.p1)
 			eacr.e1 = 0;
 		etr_port1_uptodate = 0;
 	}
 	clear_bit(ETR_EVENT_UPDATE, &etr_events);
 	return eacr;
 }
 /*
  * Set up a timer that expires after the etr_tolec + 1.6 seconds if
  * one of the ports needs an update.
  */
 static void etr_set_tolec_timeout(unsigned long long now)
 {
 	unsigned long micros;
 	if ((!etr_eacr.p0 || etr_port0_uptodate) &&
 	    (!etr_eacr.p1 || etr_port1_uptodate))
 		return;
 	micros = (now > etr_tolec) ? ((now - etr_tolec) >> 12) : 0;
 	micros = (micros > 1600000) ? 0 : 1600000 - micros;
 	mod_timer(&etr_timer, jiffies + (micros * HZ) / 1000000 + 1);
 }
 /*
  * Set up a time that expires after 1/2 second.
  */
 static void etr_set_sync_timeout(void)
 {
 	mod_timer(&etr_timer, jiffies + HZ/2);
 }
 /*
  * Update the aib information for one or both ports.
  */
 static struct etr_eacr etr_handle_update(struct etr_aib *aib,
 					 struct etr_eacr eacr)
 {
 	/* With both ports disabled the aib information is useless. */
 	if (!eacr.e0 && !eacr.e1)
 		return eacr;
 	/* Update port0 or port1 with aib stored in etr_work_fn. */
 	if (aib->esw.q == 0) {
 		/* Information for port 0 stored. */
 		if (eacr.p0 && !etr_port0_uptodate) {
 			etr_port0 = *aib;
 			if (etr_port0_online)
 				etr_port0_uptodate = 1;
 		}
 	} else {
 		/* Information for port 1 stored. */
 		if (eacr.p1 && !etr_port1_uptodate) {
 			etr_port1 = *aib;
 			if (etr_port0_online)
 				etr_port1_uptodate = 1;
 		}
 	}
 	/*
 	 * Do not try to get the alternate port aib if the clock
 	 * is not in sync yet.
 	 */
 	if (!eacr.es || !check_sync_clock())
 		return eacr;
 	/*
 	 * If steai is available we can get the information about
 	 * the other port immediately. If only stetr is available the
 	 * data-port bit toggle has to be used.
 	 */
 	if (etr_steai_available) {
 		if (eacr.p0 && !etr_port0_uptodate) {
 			etr_steai_cv(&etr_port0, ETR_STEAI_PORT_0);
 			etr_port0_uptodate = 1;
 		}
 		if (eacr.p1 && !etr_port1_uptodate) {
 			etr_steai_cv(&etr_port1, ETR_STEAI_PORT_1);
 			etr_port1_uptodate = 1;
 		}
 	} else {
 		/*
 		 * One port was updated above, if the other
 		 * port is not uptodate toggle dp bit.
 		 */
 		if ((eacr.p0 && !etr_port0_uptodate) ||
 		    (eacr.p1 && !etr_port1_uptodate))
 			eacr.dp ^= 1;
 		else
 			eacr.dp = 0;
 	}
 	return eacr;
 }
 /*
  * Write new etr control register if it differs from the current one.
  * Return 1 if etr_tolec has been updated as well.
  */
 static void etr_update_eacr(struct etr_eacr eacr)
 {
 	int dp_changed;
 	if (memcmp(&etr_eacr, &eacr, sizeof(eacr)) == 0)
 		/* No change, return. */
 		return;
 	/*
 	 * The disable of an active port of the change of the data port
 	 * bit can/will cause a change in the data port.
 	 */
 	dp_changed = etr_eacr.e0 > eacr.e0 || etr_eacr.e1 > eacr.e1 ||
 		(etr_eacr.dp ^ eacr.dp) != 0;
 	etr_eacr = eacr;
 	etr_setr(&etr_eacr);
 	if (dp_changed)
 		etr_tolec = get_clock();
 }
 /*
  * ETR work. In this function you'll find the main logic. In
  * particular this is the only function that calls etr_update_eacr(),
  * it "controls" the etr control register.
  */
 static void etr_work_fn(struct work_struct *work)
 {
 	unsigned long long now;
 	struct etr_eacr eacr;
 	struct etr_aib aib;
 	int sync_port;
 	/* prevent multiple execution. */
 	mutex_lock(&etr_work_mutex);
 	/* Create working copy of etr_eacr. */
 	eacr = etr_eacr;
 	/* Check for the different events and their immediate effects. */
 	eacr = etr_handle_events(eacr);
 	/* Check if ETR is supposed to be active. */
 	eacr.ea = eacr.p0 || eacr.p1;
 	if (!eacr.ea) {
 		/* Both ports offline. Reset everything. */
 		eacr.dp = eacr.es = eacr.sl = 0;
 		on_each_cpu(disable_sync_clock, NULL, 1);
 		del_timer_sync(&etr_timer);
 		etr_update_eacr(eacr);
 		goto out_unlock;
 	}
 	/* Store aib to get the current ETR status word. */
 	BUG_ON(etr_stetr(&aib) != 0);
 	etr_port0.esw = etr_port1.esw = aib.esw;	/* Copy status word. */
 	now = get_clock();
 	/*
 	 * Update the port information if the last stepping port change
 	 * or data port change is older than 1.6 seconds.
 	 */
 	if (now >= etr_tolec + (1600000 << 12))
 		eacr = etr_handle_update(&aib, eacr);
 	/*
 	 * Select ports to enable. The preferred synchronization mode is PPS.
 	 * If a port can be enabled depends on a number of things:
 	 * 1) The port needs to be online and uptodate. A port is not
 	 *    disabled just because it is not uptodate, but it is only
 	 *    enabled if it is uptodate.
 	 * 2) The port needs to have the same mode (pps / etr).
 	 * 3) The port needs to be usable -> etr_port_valid() == 1
 	 * 4) To enable the second port the clock needs to be in sync.
 	 * 5) If both ports are useable and are ETR ports, the network id
 	 *    has to be the same.
 	 * The eacr.sl bit is used to indicate etr mode vs. pps mode.
 	 */
 	if (eacr.p0 && aib.esw.psc0 == etr_lpsc_pps_mode) {
 		eacr.sl = 0;
 		eacr.e0 = 1;
 		if (!etr_mode_is_pps(etr_eacr))
 			eacr.es = 0;
 		if (!eacr.es || !eacr.p1 || aib.esw.psc1 != etr_lpsc_pps_mode)
 			eacr.e1 = 0;
 		// FIXME: uptodate checks ?
 		else if (etr_port0_uptodate && etr_port1_uptodate)
 			eacr.e1 = 1;
 		sync_port = (etr_port0_uptodate &&
 			     etr_port_valid(&etr_port0, 0)) ? 0 : -1;
 	} else if (eacr.p1 && aib.esw.psc1 == etr_lpsc_pps_mode) {
 		eacr.sl = 0;
 		eacr.e0 = 0;
 		eacr.e1 = 1;
 		if (!etr_mode_is_pps(etr_eacr))
 			eacr.es = 0;
 		sync_port = (etr_port1_uptodate &&
 			     etr_port_valid(&etr_port1, 1)) ? 1 : -1;
 	} else if (eacr.p0 && aib.esw.psc0 == etr_lpsc_operational_step) {
 		eacr.sl = 1;
 		eacr.e0 = 1;
 		if (!etr_mode_is_etr(etr_eacr))
 			eacr.es = 0;
 		if (!eacr.es || !eacr.p1 ||
 		    aib.esw.psc1 != etr_lpsc_operational_alt)
 			eacr.e1 = 0;
 		else if (etr_port0_uptodate && etr_port1_uptodate &&
 			 etr_compare_network(&etr_port0, &etr_port1))
 			eacr.e1 = 1;
 		sync_port = (etr_port0_uptodate &&
 			     etr_port_valid(&etr_port0, 0)) ? 0 : -1;
 	} else if (eacr.p1 && aib.esw.psc1 == etr_lpsc_operational_step) {
 		eacr.sl = 1;
 		eacr.e0 = 0;
 		eacr.e1 = 1;
 		if (!etr_mode_is_etr(etr_eacr))
 			eacr.es = 0;
 		sync_port = (etr_port1_uptodate &&
 			     etr_port_valid(&etr_port1, 1)) ? 1 : -1;
 	} else {
 		/* Both ports not usable. */
 		eacr.es = eacr.sl = 0;
 		sync_port = -1;
 	}
 	/*
 	 * If the clock is in sync just update the eacr and return.
 	 * If there is no valid sync port wait for a port update.
 	 */
 	if ((eacr.es && check_sync_clock()) || sync_port < 0) {
 		etr_update_eacr(eacr);
 		etr_set_tolec_timeout(now);
 		goto out_unlock;
 	}
 	/*
 	 * Prepare control register for clock syncing
 	 * (reset data port bit, set sync check control.
 	 */
 	eacr.dp = 0;
 	eacr.es = 1;
 	/*
 	 * Update eacr and try to synchronize the clock. If the update
 	 * of eacr caused a stepping port switch (or if we have to
 	 * assume that a stepping port switch has occurred) or the
 	 * clock syncing failed, reset the sync check control bit
 	 * and set up a timer to try again after 0.5 seconds
 	 */
 	etr_update_eacr(eacr);
 	if (now < etr_tolec + (1600000 << 12) ||
 	    etr_sync_clock_stop(&aib, sync_port) != 0) {
 		/* Sync failed. Try again in 1/2 second. */
 		eacr.es = 0;
 		etr_update_eacr(eacr);
 		etr_set_sync_timeout();
 	} else
 		etr_set_tolec_timeout(now);
 out_unlock:
 	mutex_unlock(&etr_work_mutex);
 }
 /*
  * Sysfs interface functions
  */
 static struct sysdev_class etr_sysclass = {
 	.name	= "etr",
 };
 static struct sys_device etr_port0_dev = {
 	.id	= 0,
 	.cls	= &etr_sysclass,
 };
 static struct sys_device etr_port1_dev = {
 	.id	= 1,
 	.cls	= &etr_sysclass,
 };
 /*
  * ETR class attributes
  */
 static ssize_t etr_stepping_port_show(struct sysdev_class *class,
 					struct sysdev_class_attribute *attr,
 					char *buf)
 {
 	return sprintf(buf, "%i\n", etr_port0.esw.p);
 }
 static SYSDEV_CLASS_ATTR(stepping_port, 0400, etr_stepping_port_show, NULL);
 static ssize_t etr_stepping_mode_show(struct sysdev_class *class,
 				      	struct sysdev_class_attribute *attr,
 					char *buf)
 {
 	char *mode_str;
 	if (etr_mode_is_pps(etr_eacr))
 		mode_str = "pps";
 	else if (etr_mode_is_etr(etr_eacr))
 		mode_str = "etr";
 	else
 		mode_str = "local";
 	return sprintf(buf, "%s\n", mode_str);
 }
 static SYSDEV_CLASS_ATTR(stepping_mode, 0400, etr_stepping_mode_show, NULL);
 /*
  * ETR port attributes
  */
 static inline struct etr_aib *etr_aib_from_dev(struct sys_device *dev)
 {
 	if (dev == &etr_port0_dev)
 		return etr_port0_online ? &etr_port0 : NULL;
 	else
 		return etr_port1_online ? &etr_port1 : NULL;
 }
 static ssize_t etr_online_show(struct sys_device *dev,
 				struct sysdev_attribute *attr,
 				char *buf)
 {
 	unsigned int online;
 	online = (dev == &etr_port0_dev) ? etr_port0_online : etr_port1_online;
 	return sprintf(buf, "%i\n", online);
 }
 static ssize_t etr_online_store(struct sys_device *dev,
 				struct sysdev_attribute *attr,
 				const char *buf, size_t count)
 {
 	unsigned int value;
 	value = simple_strtoul(buf, NULL, 0);
 	if (value != 0 && value != 1)
 		return -EINVAL;
 	if (!test_bit(CLOCK_SYNC_HAS_ETR, &clock_sync_flags))
 		return -EOPNOTSUPP;
 	mutex_lock(&clock_sync_mutex);
 	if (dev == &etr_port0_dev) {
 		if (etr_port0_online == value)
 			goto out;	/* Nothing to do. */
 		etr_port0_online = value;
 		if (etr_port0_online && etr_port1_online)
 			set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
 		else
 			clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
 		set_bit(ETR_EVENT_PORT0_CHANGE, &etr_events);
 		queue_work(time_sync_wq, &etr_work);
 	} else {
 		if (etr_port1_online == value)
 			goto out;	/* Nothing to do. */
 		etr_port1_online = value;
 		if (etr_port0_online && etr_port1_online)
 			set_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
 		else
 			clear_bit(CLOCK_SYNC_ETR, &clock_sync_flags);
 		set_bit(ETR_EVENT_PORT1_CHANGE, &etr_events);
 		queue_work(time_sync_wq, &etr_work);
 	}
 out:
 	mutex_unlock(&clock_sync_mutex);
 	return count;
 }
 static SYSDEV_ATTR(online, 0600, etr_online_show, etr_online_store);
 static ssize_t etr_stepping_control_show(struct sys_device *dev,
 					struct sysdev_attribute *attr,
 					char *buf)
 {
 	return sprintf(buf, "%i\n", (dev == &etr_port0_dev) ?
 		       etr_eacr.e0 : etr_eacr.e1);
 }
 static SYSDEV_ATTR(stepping_control, 0400, etr_stepping_control_show, NULL);
 static ssize_t etr_mode_code_show(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	if (!etr_port0_online && !etr_port1_online)
 		/* Status word is not uptodate if both ports are offline. */
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (dev == &etr_port0_dev) ?
 		       etr_port0.esw.psc0 : etr_port0.esw.psc1);
 }
 static SYSDEV_ATTR(state_code, 0400, etr_mode_code_show, NULL);
 static ssize_t etr_untuned_show(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v1)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf1.u);
 }
 static SYSDEV_ATTR(untuned, 0400, etr_untuned_show, NULL);
 static ssize_t etr_network_id_show(struct sys_device *dev,
 				struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v1)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf1.net_id);
 }
 static SYSDEV_ATTR(network, 0400, etr_network_id_show, NULL);
 static ssize_t etr_id_show(struct sys_device *dev,
 			struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v1)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf1.etr_id);
 }
 static SYSDEV_ATTR(id, 0400, etr_id_show, NULL);
 static ssize_t etr_port_number_show(struct sys_device *dev,
 			struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v1)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf1.etr_pn);
 }
 static SYSDEV_ATTR(port, 0400, etr_port_number_show, NULL);
 static ssize_t etr_coupled_show(struct sys_device *dev,
 			struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v3)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf3.c);
 }
 static SYSDEV_ATTR(coupled, 0400, etr_coupled_show, NULL);
 static ssize_t etr_local_time_show(struct sys_device *dev,
 			struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v3)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf3.blto);
 }
 static SYSDEV_ATTR(local_time, 0400, etr_local_time_show, NULL);
 static ssize_t etr_utc_offset_show(struct sys_device *dev,
 			struct sysdev_attribute *attr, char *buf)
 {
 	struct etr_aib *aib = etr_aib_from_dev(dev);
 	if (!aib || !aib->slsw.v3)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", aib->edf3.buo);
 }
 static SYSDEV_ATTR(utc_offset, 0400, etr_utc_offset_show, NULL);
 static struct sysdev_attribute *etr_port_attributes[] = {
 	&attr_online,
 	&attr_stepping_control,
 	&attr_state_code,
 	&attr_untuned,
 	&attr_network,
 	&attr_id,
 	&attr_port,
 	&attr_coupled,
 	&attr_local_time,
 	&attr_utc_offset,
 	NULL
 };
 static int __init etr_register_port(struct sys_device *dev)
 {
 	struct sysdev_attribute **attr;
 	int rc;
 	rc = sysdev_register(dev);
 	if (rc)
 		goto out;
 	for (attr = etr_port_attributes; *attr; attr++) {
 		rc = sysdev_create_file(dev, *attr);
 		if (rc)
 			goto out_unreg;
 	}
 	return 0;
 out_unreg:
 	for (; attr >= etr_port_attributes; attr--)
 		sysdev_remove_file(dev, *attr);
 	sysdev_unregister(dev);
 out:
 	return rc;
 }
 static void __init etr_unregister_port(struct sys_device *dev)
 {
 	struct sysdev_attribute **attr;
 	for (attr = etr_port_attributes; *attr; attr++)
 		sysdev_remove_file(dev, *attr);
 	sysdev_unregister(dev);
 }
 static int __init etr_init_sysfs(void)
 {
 	int rc;
 	rc = sysdev_class_register(&etr_sysclass);
 	if (rc)
 		goto out;
 	rc = sysdev_class_create_file(&etr_sysclass, &attr_stepping_port);
 	if (rc)
 		goto out_unreg_class;
 	rc = sysdev_class_create_file(&etr_sysclass, &attr_stepping_mode);
 	if (rc)
 		goto out_remove_stepping_port;
 	rc = etr_register_port(&etr_port0_dev);
 	if (rc)
 		goto out_remove_stepping_mode;
 	rc = etr_register_port(&etr_port1_dev);
 	if (rc)
 		goto out_remove_port0;
 	return 0;
 out_remove_port0:
 	etr_unregister_port(&etr_port0_dev);
 out_remove_stepping_mode:
 	sysdev_class_remove_file(&etr_sysclass, &attr_stepping_mode);
 out_remove_stepping_port:
 	sysdev_class_remove_file(&etr_sysclass, &attr_stepping_port);
 out_unreg_class:
 	sysdev_class_unregister(&etr_sysclass);
 out:
 	return rc;
 }
 device_initcall(etr_init_sysfs);
 /*
  * Server Time Protocol (STP) code.
  */
 static int stp_online;
 static struct stp_sstpi stp_info;
 static void *stp_page;
 static void stp_work_fn(struct work_struct *work);
 static DEFINE_MUTEX(stp_work_mutex);
 static DECLARE_WORK(stp_work, stp_work_fn);
 static struct timer_list stp_timer;
 static int __init early_parse_stp(char *p)
 {
 	if (strncmp(p, "off", 3) == 0)
 		stp_online = 0;
 	else if (strncmp(p, "on", 2) == 0)
 		stp_online = 1;
 	return 0;
 }
 early_param("stp", early_parse_stp);
 /*
  * Reset STP attachment.
  */
 static void __init stp_reset(void)
 {
 	int rc;
 	stp_page = (void *) get_zeroed_page(GFP_ATOMIC);
 	rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
 	if (rc == 0)
 		set_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags);
 	else if (stp_online) {
 		pr_warning("The real or virtual hardware system does "
 			   "not provide an STP interface\n");
 		free_page((unsigned long) stp_page);
 		stp_page = NULL;
 		stp_online = 0;
 	}
 }
 static void stp_timeout(unsigned long dummy)
 {
 	queue_work(time_sync_wq, &stp_work);
 }
 static int __init stp_init(void)
 {
 	if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 		return 0;
 	setup_timer(&stp_timer, stp_timeout, 0UL);
 	time_init_wq();
 	if (!stp_online)
 		return 0;
 	queue_work(time_sync_wq, &stp_work);
 	return 0;
 }
 arch_initcall(stp_init);
 /*
  * STP timing alert. There are three causes:
  * 1) timing status change
  * 2) link availability change
  * 3) time control parameter change
  * In all three cases we are only interested in the clock source state.
  * If a STP clock source is now available use it.
  */
 static void stp_timing_alert(struct stp_irq_parm *intparm)
 {
 	if (intparm->tsc || intparm->lac || intparm->tcpc)
 		queue_work(time_sync_wq, &stp_work);
 }
 /*
  * STP sync check machine check. This is called when the timing state
  * changes from the synchronized state to the unsynchronized state.
  * After a STP sync check the clock is not in sync. The machine check
  * is broadcasted to all cpus at the same time.
  */
 void stp_sync_check(void)
 {
 	disable_sync_clock(NULL);
 	queue_work(time_sync_wq, &stp_work);
 }
 /*
  * STP island condition machine check. This is called when an attached
  * server  attempts to communicate over an STP link and the servers
  * have matching CTN ids and have a valid stratum-1 configuration
  * but the configurations do not match.
  */
 void stp_island_check(void)
 {
 	disable_sync_clock(NULL);
 	queue_work(time_sync_wq, &stp_work);
 }
 static int stp_sync_clock(void *data)
 {
 	static int first;
 	unsigned long long old_clock, delta;
 	struct clock_sync_data *stp_sync;
 	int rc;
 	stp_sync = data;
 	if (xchg(&first, 1) == 1) {
 		/* Slave */
 		clock_sync_cpu(stp_sync);
 		return 0;
 	}
 	/* Wait until all other cpus entered the sync function. */
 	while (atomic_read(&stp_sync->cpus) != 0)
 		cpu_relax();
 	enable_sync_clock();
 	rc = 0;
 	if (stp_info.todoff[0] || stp_info.todoff[1] ||
 	    stp_info.todoff[2] || stp_info.todoff[3] ||
 	    stp_info.tmd != 2) {
 		old_clock = get_clock();
 		rc = chsc_sstpc(stp_page, STP_OP_SYNC, 0);
 		if (rc == 0) {
 			delta = adjust_time(old_clock, get_clock(), 0);
 			fixup_clock_comparator(delta);
 			rc = chsc_sstpi(stp_page, &stp_info,
 					sizeof(struct stp_sstpi));
 			if (rc == 0 && stp_info.tmd != 2)
 				rc = -EAGAIN;
 		}
 	}
 	if (rc) {
 		disable_sync_clock(NULL);
 		stp_sync->in_sync = -EAGAIN;
 	} else
 		stp_sync->in_sync = 1;
 	xchg(&first, 0);
 	return 0;
 }
 /*
  * STP work. Check for the STP state and take over the clock
  * synchronization if the STP clock source is usable.
  */
 static void stp_work_fn(struct work_struct *work)
 {
 	struct clock_sync_data stp_sync;
 	int rc;
 	/* prevent multiple execution. */
 	mutex_lock(&stp_work_mutex);
 	if (!stp_online) {
 		chsc_sstpc(stp_page, STP_OP_CTRL, 0x0000);
 		del_timer_sync(&stp_timer);
 		goto out_unlock;
 	}
 	rc = chsc_sstpc(stp_page, STP_OP_CTRL, 0xb0e0);
 	if (rc)
 		goto out_unlock;
 	rc = chsc_sstpi(stp_page, &stp_info, sizeof(struct stp_sstpi));
 	if (rc || stp_info.c == 0)
 		goto out_unlock;
 	/* Skip synchronization if the clock is already in sync. */
 	if (check_sync_clock())
 		goto out_unlock;
 	memset(&stp_sync, 0, sizeof(stp_sync));
 	get_online_cpus();
 	atomic_set(&stp_sync.cpus, num_online_cpus() - 1);
 	stop_machine(stp_sync_clock, &stp_sync, cpu_online_mask);
 	put_online_cpus();
 	if (!check_sync_clock())
 		/*
 		 * There is a usable clock but the synchonization failed.
 		 * Retry after a second.
 		 */
 		mod_timer(&stp_timer, jiffies + HZ);
 out_unlock:
 	mutex_unlock(&stp_work_mutex);
 }
 /*
  * STP class sysfs interface functions
  */
 static struct sysdev_class stp_sysclass = {
 	.name	= "stp",
 };
 static ssize_t stp_ctn_id_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online)
 		return -ENODATA;
 	return sprintf(buf, "%016llx\n",
 		       *(unsigned long long *) stp_info.ctnid);
 }
 static SYSDEV_CLASS_ATTR(ctn_id, 0400, stp_ctn_id_show, NULL);
 static ssize_t stp_ctn_type_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", stp_info.ctn);
 }
 static SYSDEV_CLASS_ATTR(ctn_type, 0400, stp_ctn_type_show, NULL);
 static ssize_t stp_dst_offset_show(struct sysdev_class *class,
 				   struct sysdev_class_attribute *attr,
 				   char *buf)
 {
 	if (!stp_online || !(stp_info.vbits & 0x2000))
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.dsto);
 }
 static SYSDEV_CLASS_ATTR(dst_offset, 0400, stp_dst_offset_show, NULL);
 static ssize_t stp_leap_seconds_show(struct sysdev_class *class,
 					struct sysdev_class_attribute *attr,
 					char *buf)
 {
 	if (!stp_online || !(stp_info.vbits & 0x8000))
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.leaps);
 }
 static SYSDEV_CLASS_ATTR(leap_seconds, 0400, stp_leap_seconds_show, NULL);
 static ssize_t stp_stratum_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.stratum);
 }
 static SYSDEV_CLASS_ATTR(stratum, 0400, stp_stratum_show, NULL);
 static ssize_t stp_time_offset_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online || !(stp_info.vbits & 0x0800))
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (int) stp_info.tto);
 }
 static SYSDEV_CLASS_ATTR(time_offset, 0400, stp_time_offset_show, NULL);
 static ssize_t stp_time_zone_offset_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online || !(stp_info.vbits & 0x4000))
 		return -ENODATA;
 	return sprintf(buf, "%i\n", (int)(s16) stp_info.tzo);
 }
 static SYSDEV_CLASS_ATTR(time_zone_offset, 0400,
 			 stp_time_zone_offset_show, NULL);
 static ssize_t stp_timing_mode_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", stp_info.tmd);
 }
 static SYSDEV_CLASS_ATTR(timing_mode, 0400, stp_timing_mode_show, NULL);
 static ssize_t stp_timing_state_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	if (!stp_online)
 		return -ENODATA;
 	return sprintf(buf, "%i\n", stp_info.tst);
 }
 static SYSDEV_CLASS_ATTR(timing_state, 0400, stp_timing_state_show, NULL);
 static ssize_t stp_online_show(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				char *buf)
 {
 	return sprintf(buf, "%i\n", stp_online);
 }
 static ssize_t stp_online_store(struct sysdev_class *class,
 				struct sysdev_class_attribute *attr,
 				const char *buf, size_t count)
 {
 	unsigned int value;
 	value = simple_strtoul(buf, NULL, 0);
 	if (value != 0 && value != 1)
 		return -EINVAL;
 	if (!test_bit(CLOCK_SYNC_HAS_STP, &clock_sync_flags))
 		return -EOPNOTSUPP;
 	mutex_lock(&clock_sync_mutex);
 	stp_online = value;
 	if (stp_online)
 		set_bit(CLOCK_SYNC_STP, &clock_sync_flags);
 	else
 		clear_bit(CLOCK_SYNC_STP, &clock_sync_flags);
 	queue_work(time_sync_wq, &stp_work);
 	mutex_unlock(&clock_sync_mutex);
 	return count;
 }
 /*
  * Can't use SYSDEV_CLASS_ATTR because the attribute should be named
  * stp/online but attr_online already exists in this file ..
  */
 static struct sysdev_class_attribute attr_stp_online = {
 	.attr = { .name = "online", .mode = 0600 },
 	.show	= stp_online_show,
 	.store	= stp_online_store,
 };
 static struct sysdev_class_attribute *stp_attributes[] = {
 	&attr_ctn_id,
 	&attr_ctn_type,
 	&attr_dst_offset,
 	&attr_leap_seconds,
 	&attr_stp_online,
 	&attr_stratum,
 	&attr_time_offset,
 	&attr_time_zone_offset,
 	&attr_timing_mode,
 	&attr_timing_state,
 	NULL
 };
 static int __init stp_init_sysfs(void)
 {
 	struct sysdev_class_attribute **attr;
 	int rc;
 	rc = sysdev_class_register(&stp_sysclass);
 	if (rc)
 		goto out;
 	for (attr = stp_attributes; *attr; attr++) {
 		rc = sysdev_class_create_file(&stp_sysclass, *attr);
 		if (rc)
 			goto out_unreg;
 	}
 	return 0;
 out_unreg:
 	for (; attr >= stp_attributes; attr--)
 		sysdev_class_remove_file(&stp_sysclass, *attr);
 	sysdev_class_unregister(&stp_sysclass);
 out:
 	return rc;
 }
 device_initcall(stp_init_sysfs);

arch/s390/kernel/topology.c

Diff comments View file @ d7b250e

 /*
  *    Copyright IBM Corp. 2007
  *    Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
  */
 #define KMSG_COMPONENT "cpu"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/bootmem.h>
 #include <linux/sched.h>
 #include <linux/workqueue.h>
 #include <linux/cpu.h>
 #include <linux/smp.h>
 #include <linux/cpuset.h>
 #include <asm/delay.h>
-#include <asm/s390_ext.h>
 #define PTF_HORIZONTAL	(0UL)
 #define PTF_VERTICAL	(1UL)
 #define PTF_CHECK	(2UL)
 struct mask_info {
 	struct mask_info *next;
 	unsigned char id;
 	cpumask_t mask;
 };
 static int topology_enabled = 1;
 static void topology_work_fn(struct work_struct *work);
 static struct sysinfo_15_1_x *tl_info;
 static struct timer_list topology_timer;
 static void set_topology_timer(void);
 static DECLARE_WORK(topology_work, topology_work_fn);
 /* topology_lock protects the core linked list */
 static DEFINE_SPINLOCK(topology_lock);
 static struct mask_info core_info;
 cpumask_t cpu_core_map[NR_CPUS];
 unsigned char cpu_core_id[NR_CPUS];
 #ifdef CONFIG_SCHED_BOOK
 static struct mask_info book_info;
 cpumask_t cpu_book_map[NR_CPUS];
 unsigned char cpu_book_id[NR_CPUS];
 #endif
 static cpumask_t cpu_group_map(struct mask_info *info, unsigned int cpu)
 {
 	cpumask_t mask;
 	cpumask_clear(&mask);
 	if (!topology_enabled || !MACHINE_HAS_TOPOLOGY) {
 		cpumask_copy(&mask, cpumask_of(cpu));
 		return mask;
 	}
 	while (info) {
 		if (cpumask_test_cpu(cpu, &info->mask)) {
 			mask = info->mask;
 			break;
 		}
 		info = info->next;
 	}
 	if (cpumask_empty(&mask))
 		cpumask_copy(&mask, cpumask_of(cpu));
 	return mask;
 }
 static void add_cpus_to_mask(struct topology_cpu *tl_cpu,
 			     struct mask_info *book, struct mask_info *core)
 {
 	unsigned int cpu;
 	for (cpu = find_first_bit(&tl_cpu->mask[0], TOPOLOGY_CPU_BITS);
 	     cpu < TOPOLOGY_CPU_BITS;
 	     cpu = find_next_bit(&tl_cpu->mask[0], TOPOLOGY_CPU_BITS, cpu + 1))
 	{
 		unsigned int rcpu, lcpu;
 		rcpu = TOPOLOGY_CPU_BITS - 1 - cpu + tl_cpu->origin;
 		for_each_present_cpu(lcpu) {
 			if (cpu_logical_map(lcpu) != rcpu)
 				continue;
 #ifdef CONFIG_SCHED_BOOK
 			cpumask_set_cpu(lcpu, &book->mask);
 			cpu_book_id[lcpu] = book->id;
 #endif
 			cpumask_set_cpu(lcpu, &core->mask);
 			cpu_core_id[lcpu] = core->id;
 			smp_cpu_polarization[lcpu] = tl_cpu->pp;
 		}
 	}
 }
 static void clear_masks(void)
 {
 	struct mask_info *info;
 	info = &core_info;
 	while (info) {
 		cpumask_clear(&info->mask);
 		info = info->next;
 	}
 #ifdef CONFIG_SCHED_BOOK
 	info = &book_info;
 	while (info) {
 		cpumask_clear(&info->mask);
 		info = info->next;
 	}
 #endif
 }
 static union topology_entry *next_tle(union topology_entry *tle)
 {
 	if (!tle->nl)
 		return (union topology_entry *)((struct topology_cpu *)tle + 1);
 	return (union topology_entry *)((struct topology_container *)tle + 1);
 }
 static void tl_to_cores(struct sysinfo_15_1_x *info)
 {
 #ifdef CONFIG_SCHED_BOOK
 	struct mask_info *book = &book_info;
 #else
 	struct mask_info *book = NULL;
 #endif
 	struct mask_info *core = &core_info;
 	union topology_entry *tle, *end;
 	spin_lock_irq(&topology_lock);
 	clear_masks();
 	tle = info->tle;
 	end = (union topology_entry *)((unsigned long)info + info->length);
 	while (tle < end) {
 		switch (tle->nl) {
 #ifdef CONFIG_SCHED_BOOK
 		case 2:
 			book = book->next;
 			book->id = tle->container.id;
 			break;
 #endif
 		case 1:
 			core = core->next;
 			core->id = tle->container.id;
 			break;
 		case 0:
 			add_cpus_to_mask(&tle->cpu, book, core);
 			break;
 		default:
 			clear_masks();
 			goto out;
 		}
 		tle = next_tle(tle);
 	}
 out:
 	spin_unlock_irq(&topology_lock);
 }
 static void topology_update_polarization_simple(void)
 {
 	int cpu;
 	mutex_lock(&smp_cpu_state_mutex);
 	for_each_possible_cpu(cpu)
 		smp_cpu_polarization[cpu] = POLARIZATION_HRZ;
 	mutex_unlock(&smp_cpu_state_mutex);
 }
 static int ptf(unsigned long fc)
 {
 	int rc;
 	asm volatile(
 		"	.insn	rre,0xb9a20000,%1,%1\n"
 		"	ipm	%0\n"
 		"	srl	%0,28\n"
 		: "=d" (rc)
 		: "d" (fc)  : "cc");
 	return rc;
 }
 int topology_set_cpu_management(int fc)
 {
 	int cpu;
 	int rc;
 	if (!MACHINE_HAS_TOPOLOGY)
 		return -EOPNOTSUPP;
 	if (fc)
 		rc = ptf(PTF_VERTICAL);
 	else
 		rc = ptf(PTF_HORIZONTAL);
 	if (rc)
 		return -EBUSY;
 	for_each_possible_cpu(cpu)
 		smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN;
 	return rc;
 }
 static void update_cpu_core_map(void)
 {
 	unsigned long flags;
 	int cpu;
 	spin_lock_irqsave(&topology_lock, flags);
 	for_each_possible_cpu(cpu) {
 		cpu_core_map[cpu] = cpu_group_map(&core_info, cpu);
 #ifdef CONFIG_SCHED_BOOK
 		cpu_book_map[cpu] = cpu_group_map(&book_info, cpu);
 #endif
 	}
 	spin_unlock_irqrestore(&topology_lock, flags);
 }
 void store_topology(struct sysinfo_15_1_x *info)
 {
 #ifdef CONFIG_SCHED_BOOK
 	int rc;
 	rc = stsi(info, 15, 1, 3);
 	if (rc != -ENOSYS)
 		return;
 #endif
 	stsi(info, 15, 1, 2);
 }
 int arch_update_cpu_topology(void)
 {
 	struct sysinfo_15_1_x *info = tl_info;
 	struct sys_device *sysdev;
 	int cpu;
 	if (!MACHINE_HAS_TOPOLOGY) {
 		update_cpu_core_map();
 		topology_update_polarization_simple();
 		return 0;
 	}
 	store_topology(info);
 	tl_to_cores(info);
 	update_cpu_core_map();
 	for_each_online_cpu(cpu) {
 		sysdev = get_cpu_sysdev(cpu);
 		kobject_uevent(&sysdev->kobj, KOBJ_CHANGE);
 	}
 	return 1;
 }
 static void topology_work_fn(struct work_struct *work)
 {
 	rebuild_sched_domains();
 }
 void topology_schedule_update(void)
 {
 	schedule_work(&topology_work);
 }
 static void topology_timer_fn(unsigned long ignored)
 {
 	if (ptf(PTF_CHECK))
 		topology_schedule_update();
 	set_topology_timer();
 }
 static void set_topology_timer(void)
 {
 	topology_timer.function = topology_timer_fn;
 	topology_timer.data = 0;
 	topology_timer.expires = jiffies + 60 * HZ;
 	add_timer(&topology_timer);
 }
 static int __init early_parse_topology(char *p)
 {
 	if (strncmp(p, "off", 3))
 		return 0;
 	topology_enabled = 0;
 	return 0;
 }
 early_param("topology", early_parse_topology);
 static int __init init_topology_update(void)
 {
 	int rc;
 	rc = 0;
 	if (!MACHINE_HAS_TOPOLOGY) {
 		topology_update_polarization_simple();
 		goto out;
 	}
 	init_timer_deferrable(&topology_timer);
 	set_topology_timer();
 out:
 	update_cpu_core_map();
 	return rc;
 }
 __initcall(init_topology_update);
 static void alloc_masks(struct sysinfo_15_1_x *info, struct mask_info *mask,
 			int offset)
 {
 	int i, nr_masks;
 	nr_masks = info->mag[TOPOLOGY_NR_MAG - offset];
 	for (i = 0; i < info->mnest - offset; i++)
 		nr_masks *= info->mag[TOPOLOGY_NR_MAG - offset - 1 - i];
 	nr_masks = max(nr_masks, 1);
 	for (i = 0; i < nr_masks; i++) {
 		mask->next = alloc_bootmem(sizeof(struct mask_info));
 		mask = mask->next;
 	}
 }
 void __init s390_init_cpu_topology(void)
 {
 	struct sysinfo_15_1_x *info;
 	int i;
 	if (!MACHINE_HAS_TOPOLOGY)
 		return;
 	tl_info = alloc_bootmem_pages(PAGE_SIZE);
 	info = tl_info;
 	store_topology(info);
 	pr_info("The CPU configuration topology of the machine is:");
 	for (i = 0; i < TOPOLOGY_NR_MAG; i++)
 		printk(" %d", info->mag[i]);
 	printk(" / %d\n", info->mnest);
 	alloc_masks(info, &core_info, 2);
 #ifdef CONFIG_SCHED_BOOK
 	alloc_masks(info, &book_info, 3);
 #endif
 }

arch/s390/kernel/traps.c

Diff comments View file @ d7b250e

 /*
  *  arch/s390/kernel/traps.c
  *
  *  S390 version
  *    Copyright (C) 1999,2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
  *    Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
  *               Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
  *
  *  Derived from "arch/i386/kernel/traps.c"
  *    Copyright (C) 1991, 1992 Linus Torvalds
  */
 /*
  * 'Traps.c' handles hardware traps and faults after we have saved some
  * state in 'asm.s'.
  */
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/tracehook.h>
 #include <linux/timer.h>
 #include <linux/mm.h>
 #include <linux/smp.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/seq_file.h>
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/kdebug.h>
 #include <linux/kallsyms.h>
 #include <linux/reboot.h>
 #include <linux/kprobes.h>
 #include <linux/bug.h>
 #include <linux/utsname.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 #include <asm/atomic.h>
 #include <asm/mathemu.h>
 #include <asm/cpcmd.h>
-#include <asm/s390_ext.h>
 #include <asm/lowcore.h>
 #include <asm/debug.h>
 #include "entry.h"
 pgm_check_handler_t *pgm_check_table[128];
 int show_unhandled_signals;
 extern pgm_check_handler_t do_protection_exception;
 extern pgm_check_handler_t do_dat_exception;
 extern pgm_check_handler_t do_asce_exception;
 #define stack_pointer ({ void **sp; asm("la %0,0(15)" : "=&d" (sp)); sp; })
 #ifndef CONFIG_64BIT
 #define LONG "%08lx "
 #define FOURLONG "%08lx %08lx %08lx %08lx\n"
 static int kstack_depth_to_print = 12;
 #else /* CONFIG_64BIT */
 #define LONG "%016lx "
 #define FOURLONG "%016lx %016lx %016lx %016lx\n"
 static int kstack_depth_to_print = 20;
 #endif /* CONFIG_64BIT */
 /*
  * For show_trace we have tree different stack to consider:
  *   - the panic stack which is used if the kernel stack has overflown
  *   - the asynchronous interrupt stack (cpu related)
  *   - the synchronous kernel stack (process related)
  * The stack trace can start at any of the three stack and can potentially
  * touch all of them. The order is: panic stack, async stack, sync stack.
  */
 static unsigned long
 __show_trace(unsigned long sp, unsigned long low, unsigned long high)
 {
 	struct stack_frame *sf;
 	struct pt_regs *regs;
 	while (1) {
 		sp = sp & PSW_ADDR_INSN;
 		if (sp < low || sp > high - sizeof(*sf))
 			return sp;
 		sf = (struct stack_frame *) sp;
 		printk("([<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
 		print_symbol("%s)\n", sf->gprs[8] & PSW_ADDR_INSN);
 		/* Follow the backchain. */
 		while (1) {
 			low = sp;
 			sp = sf->back_chain & PSW_ADDR_INSN;
 			if (!sp)
 				break;
 			if (sp <= low || sp > high - sizeof(*sf))
 				return sp;
 			sf = (struct stack_frame *) sp;
 			printk(" [<%016lx>] ", sf->gprs[8] & PSW_ADDR_INSN);
 			print_symbol("%s\n", sf->gprs[8] & PSW_ADDR_INSN);
 		}
 		/* Zero backchain detected, check for interrupt frame. */
 		sp = (unsigned long) (sf + 1);
 		if (sp <= low || sp > high - sizeof(*regs))
 			return sp;
 		regs = (struct pt_regs *) sp;
 		printk(" [<%016lx>] ", regs->psw.addr & PSW_ADDR_INSN);
 		print_symbol("%s\n", regs->psw.addr & PSW_ADDR_INSN);
 		low = sp;
 		sp = regs->gprs[15];
 	}
 }
 static void show_trace(struct task_struct *task, unsigned long *stack)
 {
 	register unsigned long __r15 asm ("15");
 	unsigned long sp;
 	sp = (unsigned long) stack;
 	if (!sp)
 		sp = task ? task->thread.ksp : __r15;
 	printk("Call Trace:\n");
 #ifdef CONFIG_CHECK_STACK
 	sp = __show_trace(sp, S390_lowcore.panic_stack - 4096,
 			  S390_lowcore.panic_stack);
 #endif
 	sp = __show_trace(sp, S390_lowcore.async_stack - ASYNC_SIZE,
 			  S390_lowcore.async_stack);
 	if (task)
 		__show_trace(sp, (unsigned long) task_stack_page(task),
 			     (unsigned long) task_stack_page(task) + THREAD_SIZE);
 	else
 		__show_trace(sp, S390_lowcore.thread_info,
 			     S390_lowcore.thread_info + THREAD_SIZE);
 	if (!task)
 		task = current;
 	debug_show_held_locks(task);
 }
 void show_stack(struct task_struct *task, unsigned long *sp)
 {
 	register unsigned long * __r15 asm ("15");
 	unsigned long *stack;
 	int i;
 	if (!sp)
 		stack = task ? (unsigned long *) task->thread.ksp : __r15;
 	else
 		stack = sp;
 	for (i = 0; i < kstack_depth_to_print; i++) {
 		if (((addr_t) stack & (THREAD_SIZE-1)) == 0)
 			break;
 		if (i && ((i * sizeof (long) % 32) == 0))
 			printk("\n       ");
 		printk(LONG, *stack++);
 	}
 	printk("\n");
 	show_trace(task, sp);
 }
 static void show_last_breaking_event(struct pt_regs *regs)
 {
 #ifdef CONFIG_64BIT
 	printk("Last Breaking-Event-Address:\n");
 	printk(" [<%016lx>] ", regs->args[0] & PSW_ADDR_INSN);
 	print_symbol("%s\n", regs->args[0] & PSW_ADDR_INSN);
 #endif
 }
 /*
  * The architecture-independent dump_stack generator
  */
 void dump_stack(void)
 {
 	printk("CPU: %d %s %s %.*s\n",
 	       task_thread_info(current)->cpu, print_tainted(),
 	       init_utsname()->release,
 	       (int)strcspn(init_utsname()->version, " "),
 	       init_utsname()->version);
 	printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
 	       current->comm, current->pid, current,
 	       (void *) current->thread.ksp);
 	show_stack(NULL, NULL);
 }
 EXPORT_SYMBOL(dump_stack);
 static inline int mask_bits(struct pt_regs *regs, unsigned long bits)
 {
 	return (regs->psw.mask & bits) / ((~bits + 1) & bits);
 }
 void show_registers(struct pt_regs *regs)
 {
 	char *mode;
 	mode = (regs->psw.mask & PSW_MASK_PSTATE) ? "User" : "Krnl";
 	printk("%s PSW : %p %p",
 	       mode, (void *) regs->psw.mask,
 	       (void *) regs->psw.addr);
 	print_symbol(" (%s)\n", regs->psw.addr & PSW_ADDR_INSN);
 	printk("           R:%x T:%x IO:%x EX:%x Key:%x M:%x W:%x "
 	       "P:%x AS:%x CC:%x PM:%x", mask_bits(regs, PSW_MASK_PER),
 	       mask_bits(regs, PSW_MASK_DAT), mask_bits(regs, PSW_MASK_IO),
 	       mask_bits(regs, PSW_MASK_EXT), mask_bits(regs, PSW_MASK_KEY),
 	       mask_bits(regs, PSW_MASK_MCHECK), mask_bits(regs, PSW_MASK_WAIT),
 	       mask_bits(regs, PSW_MASK_PSTATE), mask_bits(regs, PSW_MASK_ASC),
 	       mask_bits(regs, PSW_MASK_CC), mask_bits(regs, PSW_MASK_PM));
 #ifdef CONFIG_64BIT
 	printk(" EA:%x", mask_bits(regs, PSW_BASE_BITS));
 #endif
 	printk("\n%s GPRS: " FOURLONG, mode,
 	       regs->gprs[0], regs->gprs[1], regs->gprs[2], regs->gprs[3]);
 	printk("           " FOURLONG,
 	       regs->gprs[4], regs->gprs[5], regs->gprs[6], regs->gprs[7]);
 	printk("           " FOURLONG,
 	       regs->gprs[8], regs->gprs[9], regs->gprs[10], regs->gprs[11]);
 	printk("           " FOURLONG,
 	       regs->gprs[12], regs->gprs[13], regs->gprs[14], regs->gprs[15]);
 	show_code(regs);
 }
 void show_regs(struct pt_regs *regs)
 {
 	print_modules();
 	printk("CPU: %d %s %s %.*s\n",
 	       task_thread_info(current)->cpu, print_tainted(),
 	       init_utsname()->release,
 	       (int)strcspn(init_utsname()->version, " "),
 	       init_utsname()->version);
 	printk("Process %s (pid: %d, task: %p, ksp: %p)\n",
 	       current->comm, current->pid, current,
 	       (void *) current->thread.ksp);
 	show_registers(regs);
 	/* Show stack backtrace if pt_regs is from kernel mode */
 	if (!(regs->psw.mask & PSW_MASK_PSTATE))
 		show_trace(NULL, (unsigned long *) regs->gprs[15]);
 	show_last_breaking_event(regs);
 }
 static DEFINE_SPINLOCK(die_lock);
 void die(const char * str, struct pt_regs * regs, long err)
 {
 	static int die_counter;
 	oops_enter();
 	debug_stop_all();
 	console_verbose();
 	spin_lock_irq(&die_lock);
 	bust_spinlocks(1);
 	printk("%s: %04lx [#%d] ", str, err & 0xffff, ++die_counter);
 #ifdef CONFIG_PREEMPT
 	printk("PREEMPT ");
 #endif
 #ifdef CONFIG_SMP
 	printk("SMP ");
 #endif
 #ifdef CONFIG_DEBUG_PAGEALLOC
 	printk("DEBUG_PAGEALLOC");
 #endif
 	printk("\n");
 	notify_die(DIE_OOPS, str, regs, err, current->thread.trap_no, SIGSEGV);
 	show_regs(regs);
 	bust_spinlocks(0);
 	add_taint(TAINT_DIE);
 	spin_unlock_irq(&die_lock);
 	if (in_interrupt())
 		panic("Fatal exception in interrupt");
 	if (panic_on_oops)
 		panic("Fatal exception: panic_on_oops");
 	oops_exit();
 	do_exit(SIGSEGV);
 }
 static void inline report_user_fault(struct pt_regs *regs, long int_code,
 				     int signr)
 {
 	if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
 		return;
 	if (!unhandled_signal(current, signr))
 		return;
 	if (!printk_ratelimit())
 		return;
 	printk("User process fault: interruption code 0x%lX ", int_code);
 	print_vma_addr("in ", regs->psw.addr & PSW_ADDR_INSN);
 	printk("\n");
 	show_regs(regs);
 }
 int is_valid_bugaddr(unsigned long addr)
 {
 	return 1;
 }
 static inline void __kprobes do_trap(long pgm_int_code, int signr, char *str,
 				     struct pt_regs *regs, siginfo_t *info)
 {
 	if (notify_die(DIE_TRAP, str, regs, pgm_int_code,
 		       pgm_int_code, signr) == NOTIFY_STOP)
 		return;
         if (regs->psw.mask & PSW_MASK_PSTATE) {
                 struct task_struct *tsk = current;
 		tsk->thread.trap_no = pgm_int_code & 0xffff;
 		force_sig_info(signr, info, tsk);
 		report_user_fault(regs, pgm_int_code, signr);
         } else {
                 const struct exception_table_entry *fixup;
                 fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
                 if (fixup)
                         regs->psw.addr = fixup->fixup | PSW_ADDR_AMODE;
 		else {
 			enum bug_trap_type btt;
 			btt = report_bug(regs->psw.addr & PSW_ADDR_INSN, regs);
 			if (btt == BUG_TRAP_TYPE_WARN)
 				return;
 			die(str, regs, pgm_int_code);
 		}
         }
 }
 static inline void __user *get_psw_address(struct pt_regs *regs,
 					   long pgm_int_code)
 {
 	return (void __user *)
 		((regs->psw.addr - (pgm_int_code >> 16)) & PSW_ADDR_INSN);
 }
 void __kprobes do_per_trap(struct pt_regs *regs)
 {
 	if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0, SIGTRAP) == NOTIFY_STOP)
 		return;
 	if (tracehook_consider_fatal_signal(current, SIGTRAP))
 		force_sig(SIGTRAP, current);
 }
 static void default_trap_handler(struct pt_regs *regs, long pgm_int_code,
 				 unsigned long trans_exc_code)
 {
         if (regs->psw.mask & PSW_MASK_PSTATE) {
 		report_user_fault(regs, pgm_int_code, SIGSEGV);
 		do_exit(SIGSEGV);
 	} else
 		die("Unknown program exception", regs, pgm_int_code);
 }
 #define DO_ERROR_INFO(name, signr, sicode, str) \
 static void name(struct pt_regs *regs, long pgm_int_code, \
 		 unsigned long trans_exc_code) \
 { \
         siginfo_t info; \
         info.si_signo = signr; \
         info.si_errno = 0; \
         info.si_code = sicode; \
 	info.si_addr = get_psw_address(regs, pgm_int_code); \
 	do_trap(pgm_int_code, signr, str, regs, &info);	    \
 }
 DO_ERROR_INFO(addressing_exception, SIGILL, ILL_ILLADR,
 	      "addressing exception")
 DO_ERROR_INFO(execute_exception, SIGILL, ILL_ILLOPN,
 	      "execute exception")
 DO_ERROR_INFO(divide_exception, SIGFPE, FPE_INTDIV,
 	      "fixpoint divide exception")
 DO_ERROR_INFO(overflow_exception, SIGFPE, FPE_INTOVF,
 	      "fixpoint overflow exception")
 DO_ERROR_INFO(hfp_overflow_exception, SIGFPE, FPE_FLTOVF,
 	      "HFP overflow exception")
 DO_ERROR_INFO(hfp_underflow_exception, SIGFPE, FPE_FLTUND,
 	      "HFP underflow exception")
 DO_ERROR_INFO(hfp_significance_exception, SIGFPE, FPE_FLTRES,
 	      "HFP significance exception")
 DO_ERROR_INFO(hfp_divide_exception, SIGFPE, FPE_FLTDIV,
 	      "HFP divide exception")
 DO_ERROR_INFO(hfp_sqrt_exception, SIGFPE, FPE_FLTINV,
 	      "HFP square root exception")
 DO_ERROR_INFO(operand_exception, SIGILL, ILL_ILLOPN,
 	      "operand exception")
 DO_ERROR_INFO(privileged_op, SIGILL, ILL_PRVOPC,
 	      "privileged operation")
 DO_ERROR_INFO(special_op_exception, SIGILL, ILL_ILLOPN,
 	      "special operation exception")
 DO_ERROR_INFO(translation_exception, SIGILL, ILL_ILLOPN,
 	      "translation exception")
 static inline void do_fp_trap(struct pt_regs *regs, void __user *location,
 			      int fpc, long pgm_int_code)
 {
 	siginfo_t si;
 	si.si_signo = SIGFPE;
 	si.si_errno = 0;
 	si.si_addr = location;
 	si.si_code = 0;
 	/* FPC[2] is Data Exception Code */
 	if ((fpc & 0x00000300) == 0) {
 		/* bits 6 and 7 of DXC are 0 iff IEEE exception */
 		if (fpc & 0x8000) /* invalid fp operation */
 			si.si_code = FPE_FLTINV;
 		else if (fpc & 0x4000) /* div by 0 */
 			si.si_code = FPE_FLTDIV;
 		else if (fpc & 0x2000) /* overflow */
 			si.si_code = FPE_FLTOVF;
 		else if (fpc & 0x1000) /* underflow */
 			si.si_code = FPE_FLTUND;
 		else if (fpc & 0x0800) /* inexact */
 			si.si_code = FPE_FLTRES;
 	}
 	do_trap(pgm_int_code, SIGFPE,
 		"floating point exception", regs, &si);
 }
 static void __kprobes illegal_op(struct pt_regs *regs, long pgm_int_code,
 				 unsigned long trans_exc_code)
 {
 	siginfo_t info;
         __u8 opcode[6];
 	__u16 __user *location;
 	int signal = 0;
 	location = get_psw_address(regs, pgm_int_code);
 	if (regs->psw.mask & PSW_MASK_PSTATE) {
 		if (get_user(*((__u16 *) opcode), (__u16 __user *) location))
 			return;
 		if (*((__u16 *) opcode) == S390_BREAKPOINT_U16) {
 			if (tracehook_consider_fatal_signal(current, SIGTRAP))
 				force_sig(SIGTRAP, current);
 			else
 				signal = SIGILL;
 #ifdef CONFIG_MATHEMU
 		} else if (opcode[0] == 0xb3) {
 			if (get_user(*((__u16 *) (opcode+2)), location+1))
 				return;
 			signal = math_emu_b3(opcode, regs);
                 } else if (opcode[0] == 0xed) {
 			if (get_user(*((__u32 *) (opcode+2)),
 				     (__u32 __user *)(location+1)))
 				return;
 			signal = math_emu_ed(opcode, regs);
 		} else if (*((__u16 *) opcode) == 0xb299) {
 			if (get_user(*((__u16 *) (opcode+2)), location+1))
 				return;
 			signal = math_emu_srnm(opcode, regs);
 		} else if (*((__u16 *) opcode) == 0xb29c) {
 			if (get_user(*((__u16 *) (opcode+2)), location+1))
 				return;
 			signal = math_emu_stfpc(opcode, regs);
 		} else if (*((__u16 *) opcode) == 0xb29d) {
 			if (get_user(*((__u16 *) (opcode+2)), location+1))
 				return;
 			signal = math_emu_lfpc(opcode, regs);
 #endif
 		} else
 			signal = SIGILL;
 	} else {
 		/*
 		 * If we get an illegal op in kernel mode, send it through the
 		 * kprobes notifier. If kprobes doesn't pick it up, SIGILL
 		 */
 		if (notify_die(DIE_BPT, "bpt", regs, pgm_int_code,
 			       3, SIGTRAP) != NOTIFY_STOP)
 			signal = SIGILL;
 	}
 #ifdef CONFIG_MATHEMU
         if (signal == SIGFPE)
 		do_fp_trap(regs, location,
 			   current->thread.fp_regs.fpc, pgm_int_code);
         else if (signal == SIGSEGV) {
 		info.si_signo = signal;
 		info.si_errno = 0;
 		info.si_code = SEGV_MAPERR;
 		info.si_addr = (void __user *) location;
 		do_trap(pgm_int_code, signal,
 			"user address fault", regs, &info);
 	} else
 #endif
         if (signal) {
 		info.si_signo = signal;
 		info.si_errno = 0;
 		info.si_code = ILL_ILLOPC;
 		info.si_addr = (void __user *) location;
 		do_trap(pgm_int_code, signal,
 			"illegal operation", regs, &info);
 	}
 }
 #ifdef CONFIG_MATHEMU
 asmlinkage void specification_exception(struct pt_regs *regs,
 					long pgm_int_code,
 					unsigned long trans_exc_code)
 {
         __u8 opcode[6];
 	__u16 __user *location = NULL;
 	int signal = 0;
 	location = (__u16 __user *) get_psw_address(regs, pgm_int_code);
         if (regs->psw.mask & PSW_MASK_PSTATE) {
 		get_user(*((__u16 *) opcode), location);
 		switch (opcode[0]) {
 		case 0x28: /* LDR Rx,Ry   */
 			signal = math_emu_ldr(opcode);
 			break;
 		case 0x38: /* LER Rx,Ry   */
 			signal = math_emu_ler(opcode);
 			break;
 		case 0x60: /* STD R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_std(opcode, regs);
 			break;
 		case 0x68: /* LD R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_ld(opcode, regs);
 			break;
 		case 0x70: /* STE R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_ste(opcode, regs);
 			break;
 		case 0x78: /* LE R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_le(opcode, regs);
 			break;
 		default:
 			signal = SIGILL;
 			break;
                 }
         } else
 		signal = SIGILL;
         if (signal == SIGFPE)
 		do_fp_trap(regs, location,
 			   current->thread.fp_regs.fpc, pgm_int_code);
         else if (signal) {
 		siginfo_t info;
 		info.si_signo = signal;
 		info.si_errno = 0;
 		info.si_code = ILL_ILLOPN;
 		info.si_addr = location;
 		do_trap(pgm_int_code, signal,
 			"specification exception", regs, &info);
 	}
 }
 #else
 DO_ERROR_INFO(specification_exception, SIGILL, ILL_ILLOPN,
 	      "specification exception");
 #endif
 static void data_exception(struct pt_regs *regs, long pgm_int_code,
 			   unsigned long trans_exc_code)
 {
 	__u16 __user *location;
 	int signal = 0;
 	location = get_psw_address(regs, pgm_int_code);
 	if (MACHINE_HAS_IEEE)
 		asm volatile("stfpc %0" : "=m" (current->thread.fp_regs.fpc));
 #ifdef CONFIG_MATHEMU
         else if (regs->psw.mask & PSW_MASK_PSTATE) {
         	__u8 opcode[6];
 		get_user(*((__u16 *) opcode), location);
 		switch (opcode[0]) {
 		case 0x28: /* LDR Rx,Ry   */
 			signal = math_emu_ldr(opcode);
 			break;
 		case 0x38: /* LER Rx,Ry   */
 			signal = math_emu_ler(opcode);
 			break;
 		case 0x60: /* STD R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_std(opcode, regs);
 			break;
 		case 0x68: /* LD R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_ld(opcode, regs);
 			break;
 		case 0x70: /* STE R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_ste(opcode, regs);
 			break;
 		case 0x78: /* LE R,D(X,B) */
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_le(opcode, regs);
 			break;
 		case 0xb3:
 			get_user(*((__u16 *) (opcode+2)), location+1);
 			signal = math_emu_b3(opcode, regs);
 			break;
                 case 0xed:
 			get_user(*((__u32 *) (opcode+2)),
 				 (__u32 __user *)(location+1));
 			signal = math_emu_ed(opcode, regs);
 			break;
 	        case 0xb2:
 			if (opcode[1] == 0x99) {
 				get_user(*((__u16 *) (opcode+2)), location+1);
 				signal = math_emu_srnm(opcode, regs);
 			} else if (opcode[1] == 0x9c) {
 				get_user(*((__u16 *) (opcode+2)), location+1);
 				signal = math_emu_stfpc(opcode, regs);
 			} else if (opcode[1] == 0x9d) {
 				get_user(*((__u16 *) (opcode+2)), location+1);
 				signal = math_emu_lfpc(opcode, regs);
 			} else
 				signal = SIGILL;
 			break;
 		default:
 			signal = SIGILL;
 			break;
                 }
         }
 #endif
 	if (current->thread.fp_regs.fpc & FPC_DXC_MASK)
 		signal = SIGFPE;
 	else
 		signal = SIGILL;
         if (signal == SIGFPE)
 		do_fp_trap(regs, location,
 			   current->thread.fp_regs.fpc, pgm_int_code);
         else if (signal) {
 		siginfo_t info;
 		info.si_signo = signal;
 		info.si_errno = 0;
 		info.si_code = ILL_ILLOPN;
 		info.si_addr = location;
 		do_trap(pgm_int_code, signal, "data exception", regs, &info);
 	}
 }
 static void space_switch_exception(struct pt_regs *regs, long pgm_int_code,
 				   unsigned long trans_exc_code)
 {
         siginfo_t info;
 	/* Set user psw back to home space mode. */
 	if (regs->psw.mask & PSW_MASK_PSTATE)
 		regs->psw.mask |= PSW_ASC_HOME;
 	/* Send SIGILL. */
         info.si_signo = SIGILL;
         info.si_errno = 0;
         info.si_code = ILL_PRVOPC;
 	info.si_addr = get_psw_address(regs, pgm_int_code);
 	do_trap(pgm_int_code, SIGILL, "space switch event", regs, &info);
 }
 asmlinkage void __kprobes kernel_stack_overflow(struct pt_regs * regs)
 {
 	bust_spinlocks(1);
 	printk("Kernel stack overflow.\n");
 	show_regs(regs);
 	bust_spinlocks(0);
 	panic("Corrupt kernel stack, can't continue.");
 }
 /* init is done in lowcore.S and head.S */
 void __init trap_init(void)
 {
         int i;
         for (i = 0; i < 128; i++)
           pgm_check_table[i] = &default_trap_handler;
         pgm_check_table[1] = &illegal_op;
         pgm_check_table[2] = &privileged_op;
         pgm_check_table[3] = &execute_exception;
         pgm_check_table[4] = &do_protection_exception;
         pgm_check_table[5] = &addressing_exception;
         pgm_check_table[6] = &specification_exception;
         pgm_check_table[7] = &data_exception;
         pgm_check_table[8] = &overflow_exception;
         pgm_check_table[9] = &divide_exception;
         pgm_check_table[0x0A] = &overflow_exception;
         pgm_check_table[0x0B] = &divide_exception;
         pgm_check_table[0x0C] = &hfp_overflow_exception;
         pgm_check_table[0x0D] = &hfp_underflow_exception;
         pgm_check_table[0x0E] = &hfp_significance_exception;
         pgm_check_table[0x0F] = &hfp_divide_exception;
         pgm_check_table[0x10] = &do_dat_exception;
         pgm_check_table[0x11] = &do_dat_exception;
         pgm_check_table[0x12] = &translation_exception;
         pgm_check_table[0x13] = &special_op_exception;
 #ifdef CONFIG_64BIT
 	pgm_check_table[0x38] = &do_asce_exception;
 	pgm_check_table[0x39] = &do_dat_exception;
 	pgm_check_table[0x3A] = &do_dat_exception;
         pgm_check_table[0x3B] = &do_dat_exception;
 #endif /* CONFIG_64BIT */
         pgm_check_table[0x15] = &operand_exception;
         pgm_check_table[0x1C] = &space_switch_exception;
         pgm_check_table[0x1D] = &hfp_sqrt_exception;
 	/* Enable machine checks early. */
 	local_mcck_enable();
 }

arch/s390/kernel/vtime.c

Diff comments View file @ d7b250e

 /*
  *  arch/s390/kernel/vtime.c
  *    Virtual cpu timer based timer functions.
  *
  *  S390 version
  *    Copyright (C) 2004 IBM Deutschland Entwicklung GmbH, IBM Corporation
  *    Author(s): Jan Glauber <jan.glauber@de.ibm.com>
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/time.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/types.h>
 #include <linux/timex.h>
 #include <linux/notifier.h>
 #include <linux/kernel_stat.h>
 #include <linux/rcupdate.h>
 #include <linux/posix-timers.h>
 #include <linux/cpu.h>
 #include <linux/kprobes.h>
-#include <asm/s390_ext.h>
 #include <asm/timer.h>
 #include <asm/irq_regs.h>
 #include <asm/cputime.h>
+#include <asm/irq.h>
 static DEFINE_PER_CPU(struct vtimer_queue, virt_cpu_timer);
 DEFINE_PER_CPU(struct s390_idle_data, s390_idle);
 static inline __u64 get_vtimer(void)
 {
 	__u64 timer;
 	asm volatile("STPT %0" : "=m" (timer));
 	return timer;
 }
 static inline void set_vtimer(__u64 expires)
 {
 	__u64 timer;
 	asm volatile ("  STPT %0\n"  /* Store current cpu timer value */
 		      "  SPT %1"     /* Set new value immediately afterwards */
 		      : "=m" (timer) : "m" (expires) );
 	S390_lowcore.system_timer += S390_lowcore.last_update_timer - timer;
 	S390_lowcore.last_update_timer = expires;
 }
 /*
  * Update process times based on virtual cpu times stored by entry.S
  * to the lowcore fields user_timer, system_timer & steal_clock.
  */
 static void do_account_vtime(struct task_struct *tsk, int hardirq_offset)
 {
 	struct thread_info *ti = task_thread_info(tsk);
 	__u64 timer, clock, user, system, steal;
 	timer = S390_lowcore.last_update_timer;
 	clock = S390_lowcore.last_update_clock;
 	asm volatile ("  STPT %0\n"    /* Store current cpu timer value */
 		      "  STCK %1"      /* Store current tod clock value */
 		      : "=m" (S390_lowcore.last_update_timer),
 		        "=m" (S390_lowcore.last_update_clock) );
 	S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
 	S390_lowcore.steal_timer += S390_lowcore.last_update_clock - clock;
 	user = S390_lowcore.user_timer - ti->user_timer;
 	S390_lowcore.steal_timer -= user;
 	ti->user_timer = S390_lowcore.user_timer;
 	account_user_time(tsk, user, user);
 	system = S390_lowcore.system_timer - ti->system_timer;
 	S390_lowcore.steal_timer -= system;
 	ti->system_timer = S390_lowcore.system_timer;
 	account_system_time(tsk, hardirq_offset, system, system);
 	steal = S390_lowcore.steal_timer;
 	if ((s64) steal > 0) {
 		S390_lowcore.steal_timer = 0;
 		account_steal_time(steal);
 	}
 }
 void account_vtime(struct task_struct *prev, struct task_struct *next)
 {
 	struct thread_info *ti;
 	do_account_vtime(prev, 0);
 	ti = task_thread_info(prev);
 	ti->user_timer = S390_lowcore.user_timer;
 	ti->system_timer = S390_lowcore.system_timer;
 	ti = task_thread_info(next);
 	S390_lowcore.user_timer = ti->user_timer;
 	S390_lowcore.system_timer = ti->system_timer;
 }
 void account_process_tick(struct task_struct *tsk, int user_tick)
 {
 	do_account_vtime(tsk, HARDIRQ_OFFSET);
 }
 /*
  * Update process times based on virtual cpu times stored by entry.S
  * to the lowcore fields user_timer, system_timer & steal_clock.
  */
 void account_system_vtime(struct task_struct *tsk)
 {
 	struct thread_info *ti = task_thread_info(tsk);
 	__u64 timer, system;
 	timer = S390_lowcore.last_update_timer;
 	S390_lowcore.last_update_timer = get_vtimer();
 	S390_lowcore.system_timer += timer - S390_lowcore.last_update_timer;
 	system = S390_lowcore.system_timer - ti->system_timer;
 	S390_lowcore.steal_timer -= system;
 	ti->system_timer = S390_lowcore.system_timer;
 	account_system_time(tsk, 0, system, system);
 }
 EXPORT_SYMBOL_GPL(account_system_vtime);
 void __kprobes vtime_start_cpu(__u64 int_clock, __u64 enter_timer)
 {
 	struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
 	struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
 	__u64 idle_time, expires;
 	if (idle->idle_enter == 0ULL)
 		return;
 	/* Account time spent with enabled wait psw loaded as idle time. */
 	idle_time = int_clock - idle->idle_enter;
 	account_idle_time(idle_time);
 	S390_lowcore.steal_timer +=
 		idle->idle_enter - S390_lowcore.last_update_clock;
 	S390_lowcore.last_update_clock = int_clock;
 	/* Account system time spent going idle. */
 	S390_lowcore.system_timer += S390_lowcore.last_update_timer - vq->idle;
 	S390_lowcore.last_update_timer = enter_timer;
 	/* Restart vtime CPU timer */
 	if (vq->do_spt) {
 		/* Program old expire value but first save progress. */
 		expires = vq->idle - enter_timer;
 		expires += get_vtimer();
 		set_vtimer(expires);
 	} else {
 		/* Don't account the CPU timer delta while the cpu was idle. */
 		vq->elapsed -= vq->idle - enter_timer;
 	}
 	idle->sequence++;
 	smp_wmb();
 	idle->idle_time += idle_time;
 	idle->idle_enter = 0ULL;
 	idle->idle_count++;
 	smp_wmb();
 	idle->sequence++;
 }
 void __kprobes vtime_stop_cpu(void)
 {
 	struct s390_idle_data *idle = &__get_cpu_var(s390_idle);
 	struct vtimer_queue *vq = &__get_cpu_var(virt_cpu_timer);
 	psw_t psw;
 	/* Wait for external, I/O or machine check interrupt. */
 	psw.mask = psw_kernel_bits | PSW_MASK_WAIT | PSW_MASK_IO | PSW_MASK_EXT;
 	idle->nohz_delay = 0;
 	/* Check if the CPU timer needs to be reprogrammed. */
 	if (vq->do_spt) {
 		__u64 vmax = VTIMER_MAX_SLICE;
 		/*
 		 * The inline assembly is equivalent to
 		 *	vq->idle = get_cpu_timer();
 		 *	set_cpu_timer(VTIMER_MAX_SLICE);
 		 *	idle->idle_enter = get_clock();
 		 *	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
 		 *			   PSW_MASK_IO | PSW_MASK_EXT);
 		 * The difference is that the inline assembly makes sure that
 		 * the last three instruction are stpt, stck and lpsw in that
 		 * order. This is done to increase the precision.
 		 */
 		asm volatile(
 #ifndef CONFIG_64BIT
 			"	basr	1,0\n"
 			"0:	ahi	1,1f-0b\n"
 			"	st	1,4(%2)\n"
 #else /* CONFIG_64BIT */
 			"	larl	1,1f\n"
 			"	stg	1,8(%2)\n"
 #endif /* CONFIG_64BIT */
 			"	stpt	0(%4)\n"
 			"	spt	0(%5)\n"
 			"	stck	0(%3)\n"
 #ifndef CONFIG_64BIT
 			"	lpsw	0(%2)\n"
 #else /* CONFIG_64BIT */
 			"	lpswe	0(%2)\n"
 #endif /* CONFIG_64BIT */
 			"1:"
 			: "=m" (idle->idle_enter), "=m" (vq->idle)
 			: "a" (&psw), "a" (&idle->idle_enter),
 			  "a" (&vq->idle), "a" (&vmax), "m" (vmax), "m" (psw)
 			: "memory", "cc", "1");
 	} else {
 		/*
 		 * The inline assembly is equivalent to
 		 *	vq->idle = get_cpu_timer();
 		 *	idle->idle_enter = get_clock();
 		 *	__load_psw_mask(psw_kernel_bits | PSW_MASK_WAIT |
 		 *			   PSW_MASK_IO | PSW_MASK_EXT);
 		 * The difference is that the inline assembly makes sure that
 		 * the last three instruction are stpt, stck and lpsw in that
 		 * order. This is done to increase the precision.
 		 */
 		asm volatile(
 #ifndef CONFIG_64BIT
 			"	basr	1,0\n"
 			"0:	ahi	1,1f-0b\n"
 			"	st	1,4(%2)\n"
 #else /* CONFIG_64BIT */
 			"	larl	1,1f\n"
 			"	stg	1,8(%2)\n"
 #endif /* CONFIG_64BIT */
 			"	stpt	0(%4)\n"
 			"	stck	0(%3)\n"
 #ifndef CONFIG_64BIT
 			"	lpsw	0(%2)\n"
 #else /* CONFIG_64BIT */
 			"	lpswe	0(%2)\n"
 #endif /* CONFIG_64BIT */
 			"1:"
 			: "=m" (idle->idle_enter), "=m" (vq->idle)
 			: "a" (&psw), "a" (&idle->idle_enter),
 			  "a" (&vq->idle), "m" (psw)
 			: "memory", "cc", "1");
 	}
 }
 cputime64_t s390_get_idle_time(int cpu)
 {
 	struct s390_idle_data *idle;
 	unsigned long long now, idle_time, idle_enter;
 	unsigned int sequence;
 	idle = &per_cpu(s390_idle, cpu);
 	now = get_clock();
 repeat:
 	sequence = idle->sequence;
 	smp_rmb();
 	if (sequence & 1)
 		goto repeat;
 	idle_time = 0;
 	idle_enter = idle->idle_enter;
 	if (idle_enter != 0ULL && idle_enter < now)
 		idle_time = now - idle_enter;
 	smp_rmb();
 	if (idle->sequence != sequence)
 		goto repeat;
 	return idle_time;
 }
 /*
  * Sorted add to a list. List is linear searched until first bigger
  * element is found.
  */
 static void list_add_sorted(struct vtimer_list *timer, struct list_head *head)
 {
 	struct vtimer_list *event;
 	list_for_each_entry(event, head, entry) {
 		if (event->expires > timer->expires) {
 			list_add_tail(&timer->entry, &event->entry);
 			return;
 		}
 	}
 	list_add_tail(&timer->entry, head);
 }
 /*
  * Do the callback functions of expired vtimer events.
  * Called from within the interrupt handler.
  */
 static void do_callbacks(struct list_head *cb_list)
 {
 	struct vtimer_queue *vq;
 	struct vtimer_list *event, *tmp;
 	if (list_empty(cb_list))
 		return;
 	vq = &__get_cpu_var(virt_cpu_timer);
 	list_for_each_entry_safe(event, tmp, cb_list, entry) {
 		list_del_init(&event->entry);
 		(event->function)(event->data);
 		if (event->interval) {
 			/* Recharge interval timer */
 			event->expires = event->interval + vq->elapsed;
 			spin_lock(&vq->lock);
 			list_add_sorted(event, &vq->list);
 			spin_unlock(&vq->lock);
 		}
 	}
 }
 /*
  * Handler for the virtual CPU timer.
  */
 static void do_cpu_timer_interrupt(unsigned int ext_int_code,
 				   unsigned int param32, unsigned long param64)
 {
 	struct vtimer_queue *vq;
 	struct vtimer_list *event, *tmp;
 	struct list_head cb_list;	/* the callback queue */
 	__u64 elapsed, next;
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_TMR]++;
 	INIT_LIST_HEAD(&cb_list);
 	vq = &__get_cpu_var(virt_cpu_timer);
 	/* walk timer list, fire all expired events */
 	spin_lock(&vq->lock);
 	elapsed = vq->elapsed + (vq->timer - S390_lowcore.async_enter_timer);
 	BUG_ON((s64) elapsed < 0);
 	vq->elapsed = 0;
 	list_for_each_entry_safe(event, tmp, &vq->list, entry) {
 		if (event->expires < elapsed)
 			/* move expired timer to the callback queue */
 			list_move_tail(&event->entry, &cb_list);
 		else
 			event->expires -= elapsed;
 	}
 	spin_unlock(&vq->lock);
 	vq->do_spt = list_empty(&cb_list);
 	do_callbacks(&cb_list);
 	/* next event is first in list */
 	next = VTIMER_MAX_SLICE;
 	spin_lock(&vq->lock);
 	if (!list_empty(&vq->list)) {
 		event = list_first_entry(&vq->list, struct vtimer_list, entry);
 		next = event->expires;
 	} else
 		vq->do_spt = 0;
 	spin_unlock(&vq->lock);
 	/*
 	 * To improve precision add the time spent by the
 	 * interrupt handler to the elapsed time.
 	 * Note: CPU timer counts down and we got an interrupt,
 	 *	 the current content is negative
 	 */
 	elapsed = S390_lowcore.async_enter_timer - get_vtimer();
 	set_vtimer(next - elapsed);
 	vq->timer = next - elapsed;
 	vq->elapsed = elapsed;
 }
 void init_virt_timer(struct vtimer_list *timer)
 {
 	timer->function = NULL;
 	INIT_LIST_HEAD(&timer->entry);
 }
 EXPORT_SYMBOL(init_virt_timer);
 static inline int vtimer_pending(struct vtimer_list *timer)
 {
 	return (!list_empty(&timer->entry));
 }
 /*
  * this function should only run on the specified CPU
  */
 static void internal_add_vtimer(struct vtimer_list *timer)
 {
 	struct vtimer_queue *vq;
 	unsigned long flags;
 	__u64 left, expires;
 	vq = &per_cpu(virt_cpu_timer, timer->cpu);
 	spin_lock_irqsave(&vq->lock, flags);
 	BUG_ON(timer->cpu != smp_processor_id());
 	if (list_empty(&vq->list)) {
 		/* First timer on this cpu, just program it. */
 		list_add(&timer->entry, &vq->list);
 		set_vtimer(timer->expires);
 		vq->timer = timer->expires;
 		vq->elapsed = 0;
 	} else {
 		/* Check progress of old timers. */
 		expires = timer->expires;
 		left = get_vtimer();
 		if (likely((s64) expires < (s64) left)) {
 			/* The new timer expires before the current timer. */
 			set_vtimer(expires);
 			vq->elapsed += vq->timer - left;
 			vq->timer = expires;
 		} else {
 			vq->elapsed += vq->timer - left;
 			vq->timer = left;
 		}
 		/* Insert new timer into per cpu list. */
 		timer->expires += vq->elapsed;
 		list_add_sorted(timer, &vq->list);
 	}
 	spin_unlock_irqrestore(&vq->lock, flags);
 	/* release CPU acquired in prepare_vtimer or mod_virt_timer() */
 	put_cpu();
 }
 static inline void prepare_vtimer(struct vtimer_list *timer)
 {
 	BUG_ON(!timer->function);
 	BUG_ON(!timer->expires || timer->expires > VTIMER_MAX_SLICE);
 	BUG_ON(vtimer_pending(timer));
 	timer->cpu = get_cpu();
 }
 /*
  * add_virt_timer - add an oneshot virtual CPU timer
  */
 void add_virt_timer(void *new)
 {
 	struct vtimer_list *timer;
 	timer = (struct vtimer_list *)new;
 	prepare_vtimer(timer);
 	timer->interval = 0;
 	internal_add_vtimer(timer);
 }
 EXPORT_SYMBOL(add_virt_timer);
 /*
  * add_virt_timer_int - add an interval virtual CPU timer
  */
 void add_virt_timer_periodic(void *new)
 {
 	struct vtimer_list *timer;
 	timer = (struct vtimer_list *)new;
 	prepare_vtimer(timer);
 	timer->interval = timer->expires;
 	internal_add_vtimer(timer);
 }
 EXPORT_SYMBOL(add_virt_timer_periodic);
 int __mod_vtimer(struct vtimer_list *timer, __u64 expires, int periodic)
 {
 	struct vtimer_queue *vq;
 	unsigned long flags;
 	int cpu;
 	BUG_ON(!timer->function);
 	BUG_ON(!expires || expires > VTIMER_MAX_SLICE);
 	if (timer->expires == expires && vtimer_pending(timer))
 		return 1;
 	cpu = get_cpu();
 	vq = &per_cpu(virt_cpu_timer, cpu);
 	/* disable interrupts before test if timer is pending */
 	spin_lock_irqsave(&vq->lock, flags);
 	/* if timer isn't pending add it on the current CPU */
 	if (!vtimer_pending(timer)) {
 		spin_unlock_irqrestore(&vq->lock, flags);
 		if (periodic)
 			timer->interval = expires;
 		else
 			timer->interval = 0;
 		timer->expires = expires;
 		timer->cpu = cpu;
 		internal_add_vtimer(timer);
 		return 0;
 	}
 	/* check if we run on the right CPU */
 	BUG_ON(timer->cpu != cpu);
 	list_del_init(&timer->entry);
 	timer->expires = expires;
 	if (periodic)
 		timer->interval = expires;
 	/* the timer can't expire anymore so we can release the lock */
 	spin_unlock_irqrestore(&vq->lock, flags);
 	internal_add_vtimer(timer);
 	return 1;
 }
 /*
  * If we change a pending timer the function must be called on the CPU
  * where the timer is running on.
  *
  * returns whether it has modified a pending timer (1) or not (0)
  */
 int mod_virt_timer(struct vtimer_list *timer, __u64 expires)
 {
 	return __mod_vtimer(timer, expires, 0);
 }
 EXPORT_SYMBOL(mod_virt_timer);
 /*
  * If we change a pending timer the function must be called on the CPU
  * where the timer is running on.
  *
  * returns whether it has modified a pending timer (1) or not (0)
  */
 int mod_virt_timer_periodic(struct vtimer_list *timer, __u64 expires)
 {
 	return __mod_vtimer(timer, expires, 1);
 }
 EXPORT_SYMBOL(mod_virt_timer_periodic);
 /*
  * delete a virtual timer
  *
  * returns whether the deleted timer was pending (1) or not (0)
  */
 int del_virt_timer(struct vtimer_list *timer)
 {
 	unsigned long flags;
 	struct vtimer_queue *vq;
 	/* check if timer is pending */
 	if (!vtimer_pending(timer))
 		return 0;
 	vq = &per_cpu(virt_cpu_timer, timer->cpu);
 	spin_lock_irqsave(&vq->lock, flags);
 	/* we don't interrupt a running timer, just let it expire! */
 	list_del_init(&timer->entry);
 	spin_unlock_irqrestore(&vq->lock, flags);
 	return 1;
 }
 EXPORT_SYMBOL(del_virt_timer);
 /*
  * Start the virtual CPU timer on the current CPU.
  */
 void init_cpu_vtimer(void)
 {
 	struct vtimer_queue *vq;
 	/* initialize per cpu vtimer structure */
 	vq = &__get_cpu_var(virt_cpu_timer);
 	INIT_LIST_HEAD(&vq->list);
 	spin_lock_init(&vq->lock);
 	/* enable cpu timer interrupts */
 	__ctl_set_bit(0,10);
 }
 static int __cpuinit s390_nohz_notify(struct notifier_block *self,
 				      unsigned long action, void *hcpu)
 {
 	struct s390_idle_data *idle;
 	long cpu = (long) hcpu;
 	idle = &per_cpu(s390_idle, cpu);
 	switch (action) {
 	case CPU_DYING:
 	case CPU_DYING_FROZEN:
 		idle->nohz_delay = 0;
 	default:
 		break;
 	}
 	return NOTIFY_OK;
 }
 void __init vtime_init(void)
 {
 	/* request the cpu timer external interrupt */
 	if (register_external_interrupt(0x1005, do_cpu_timer_interrupt))
 		panic("Couldn't request external interrupt 0x1005");
 	/* Enable cpu timer interrupts on the boot cpu. */
 	init_cpu_vtimer();
 	cpu_notifier(s390_nohz_notify, 0);
 }

arch/s390/mm/fault.c

Diff comments View file @ d7b250e

1	/*	1	/*
2	* arch/s390/mm/fault.c	2	* arch/s390/mm/fault.c
3	*	3	*
4	* S390 version	4	* S390 version
5	* Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation	5	* Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
6	* Author(s): Hartmut Penner (hp@de.ibm.com)	6	* Author(s): Hartmut Penner (hp@de.ibm.com)
7	* Ulrich Weigand (uweigand@de.ibm.com)	7	* Ulrich Weigand (uweigand@de.ibm.com)
8	*	8	*
9	* Derived from "arch/i386/mm/fault.c"	9	* Derived from "arch/i386/mm/fault.c"
10	* Copyright (C) 1995 Linus Torvalds	10	* Copyright (C) 1995 Linus Torvalds
11	*/	11	*/
12		12
13	#include <linux/kernel_stat.h>	13	#include <linux/kernel_stat.h>
14	#include <linux/perf_event.h>	14	#include <linux/perf_event.h>
15	#include <linux/signal.h>	15	#include <linux/signal.h>
16	#include <linux/sched.h>	16	#include <linux/sched.h>
17	#include <linux/kernel.h>	17	#include <linux/kernel.h>
18	#include <linux/errno.h>	18	#include <linux/errno.h>
19	#include <linux/string.h>	19	#include <linux/string.h>
20	#include <linux/types.h>	20	#include <linux/types.h>
21	#include <linux/ptrace.h>	21	#include <linux/ptrace.h>
22	#include <linux/mman.h>	22	#include <linux/mman.h>
23	#include <linux/mm.h>	23	#include <linux/mm.h>
24	#include <linux/compat.h>	24	#include <linux/compat.h>
25	#include <linux/smp.h>	25	#include <linux/smp.h>
26	#include <linux/kdebug.h>	26	#include <linux/kdebug.h>
27	#include <linux/init.h>	27	#include <linux/init.h>
28	#include <linux/console.h>	28	#include <linux/console.h>
29	#include <linux/module.h>	29	#include <linux/module.h>
30	#include <linux/hardirq.h>	30	#include <linux/hardirq.h>
31	#include <linux/kprobes.h>	31	#include <linux/kprobes.h>
32	#include <linux/uaccess.h>	32	#include <linux/uaccess.h>
33	#include <linux/hugetlb.h>	33	#include <linux/hugetlb.h>
34	#include <asm/asm-offsets.h>	34	#include <asm/asm-offsets.h>
35	#include <asm/system.h>	35	#include <asm/system.h>
36	#include <asm/pgtable.h>	36	#include <asm/pgtable.h>
37	#include <asm/s390_ext.h>	37	#include <asm/irq.h>
38	#include <asm/mmu_context.h>	38	#include <asm/mmu_context.h>
39	#include <asm/compat.h>	39	#include <asm/compat.h>
40	#include "../kernel/entry.h"	40	#include "../kernel/entry.h"
41		41
42	#ifndef CONFIG_64BIT	42	#ifndef CONFIG_64BIT
43	#define __FAIL_ADDR_MASK 0x7ffff000	43	#define __FAIL_ADDR_MASK 0x7ffff000
44	#define __SUBCODE_MASK 0x0200	44	#define __SUBCODE_MASK 0x0200
45	#define __PF_RES_FIELD 0ULL	45	#define __PF_RES_FIELD 0ULL
46	#else /* CONFIG_64BIT */	46	#else /* CONFIG_64BIT */
47	#define __FAIL_ADDR_MASK -4096L	47	#define __FAIL_ADDR_MASK -4096L
48	#define __SUBCODE_MASK 0x0600	48	#define __SUBCODE_MASK 0x0600
49	#define __PF_RES_FIELD 0x8000000000000000ULL	49	#define __PF_RES_FIELD 0x8000000000000000ULL
50	#endif /* CONFIG_64BIT */	50	#endif /* CONFIG_64BIT */
51		51
52	#define VM_FAULT_BADCONTEXT 0x010000	52	#define VM_FAULT_BADCONTEXT 0x010000
53	#define VM_FAULT_BADMAP 0x020000	53	#define VM_FAULT_BADMAP 0x020000
54	#define VM_FAULT_BADACCESS 0x040000	54	#define VM_FAULT_BADACCESS 0x040000
55		55
56	static unsigned long store_indication;	56	static unsigned long store_indication;
57		57
58	void fault_init(void)	58	void fault_init(void)
59	{	59	{
60	if (test_facility(2) && test_facility(75))	60	if (test_facility(2) && test_facility(75))
61	store_indication = 0xc00;	61	store_indication = 0xc00;
62	}	62	}
63		63
64	static inline int notify_page_fault(struct pt_regs *regs)	64	static inline int notify_page_fault(struct pt_regs *regs)
65	{	65	{
66	int ret = 0;	66	int ret = 0;
67		67
68	/* kprobe_running() needs smp_processor_id() */	68	/* kprobe_running() needs smp_processor_id() */
69	if (kprobes_built_in() && !user_mode(regs)) {	69	if (kprobes_built_in() && !user_mode(regs)) {
70	preempt_disable();	70	preempt_disable();
71	if (kprobe_running() && kprobe_fault_handler(regs, 14))	71	if (kprobe_running() && kprobe_fault_handler(regs, 14))
72	ret = 1;	72	ret = 1;
73	preempt_enable();	73	preempt_enable();
74	}	74	}
75	return ret;	75	return ret;
76	}	76	}
77		77
78		78
79	/*	79	/*
80	* Unlock any spinlocks which will prevent us from getting the	80	* Unlock any spinlocks which will prevent us from getting the
81	* message out.	81	* message out.
82	*/	82	*/
83	void bust_spinlocks(int yes)	83	void bust_spinlocks(int yes)
84	{	84	{
85	if (yes) {	85	if (yes) {
86	oops_in_progress = 1;	86	oops_in_progress = 1;
87	} else {	87	} else {
88	int loglevel_save = console_loglevel;	88	int loglevel_save = console_loglevel;
89	console_unblank();	89	console_unblank();
90	oops_in_progress = 0;	90	oops_in_progress = 0;
91	/*	91	/*
92	* OK, the message is on the console. Now we call printk()	92	* OK, the message is on the console. Now we call printk()
93	* without oops_in_progress set so that printk will give klogd	93	* without oops_in_progress set so that printk will give klogd
94	* a poke. Hold onto your hats...	94	* a poke. Hold onto your hats...
95	*/	95	*/
96	console_loglevel = 15;	96	console_loglevel = 15;
97	printk(" ");	97	printk(" ");
98	console_loglevel = loglevel_save;	98	console_loglevel = loglevel_save;
99	}	99	}
100	}	100	}
101		101
102	/*	102	/*
103	* Returns the address space associated with the fault.	103	* Returns the address space associated with the fault.
104	* Returns 0 for kernel space and 1 for user space.	104	* Returns 0 for kernel space and 1 for user space.
105	*/	105	*/
106	static inline int user_space_fault(unsigned long trans_exc_code)	106	static inline int user_space_fault(unsigned long trans_exc_code)
107	{	107	{
108	/*	108	/*
109	* The lowest two bits of the translation exception	109	* The lowest two bits of the translation exception
110	* identification indicate which paging table was used.	110	* identification indicate which paging table was used.
111	*/	111	*/
112	trans_exc_code &= 3;	112	trans_exc_code &= 3;
113	if (trans_exc_code == 2)	113	if (trans_exc_code == 2)
114	/* Access via secondary space, set_fs setting decides */	114	/* Access via secondary space, set_fs setting decides */
115	return current->thread.mm_segment.ar4;	115	return current->thread.mm_segment.ar4;
116	if (user_mode == HOME_SPACE_MODE)	116	if (user_mode == HOME_SPACE_MODE)
117	/* User space if the access has been done via home space. */	117	/* User space if the access has been done via home space. */
118	return trans_exc_code == 3;	118	return trans_exc_code == 3;
119	/*	119	/*
120	* If the user space is not the home space the kernel runs in home	120	* If the user space is not the home space the kernel runs in home
121	* space. Access via secondary space has already been covered,	121	* space. Access via secondary space has already been covered,
122	* access via primary space or access register is from user space	122	* access via primary space or access register is from user space
123	* and access via home space is from the kernel.	123	* and access via home space is from the kernel.
124	*/	124	*/
125	return trans_exc_code != 3;	125	return trans_exc_code != 3;
126	}	126	}
127		127
128	static inline void report_user_fault(struct pt_regs *regs, long int_code,	128	static inline void report_user_fault(struct pt_regs *regs, long int_code,
129	int signr, unsigned long address)	129	int signr, unsigned long address)
130	{	130	{
131	if ((task_pid_nr(current) > 1) && !show_unhandled_signals)	131	if ((task_pid_nr(current) > 1) && !show_unhandled_signals)
132	return;	132	return;
133	if (!unhandled_signal(current, signr))	133	if (!unhandled_signal(current, signr))
134	return;	134	return;
135	if (!printk_ratelimit())	135	if (!printk_ratelimit())
136	return;	136	return;
137	printk("User process fault: interruption code 0x%lX ", int_code);	137	printk("User process fault: interruption code 0x%lX ", int_code);
138	print_vma_addr(KERN_CONT "in ", regs->psw.addr & PSW_ADDR_INSN);	138	print_vma_addr(KERN_CONT "in ", regs->psw.addr & PSW_ADDR_INSN);
139	printk("\n");	139	printk("\n");
140	printk("failing address: %lX\n", address);	140	printk("failing address: %lX\n", address);
141	show_regs(regs);	141	show_regs(regs);
142	}	142	}
143		143
144	/*	144	/*
145	* Send SIGSEGV to task. This is an external routine	145	* Send SIGSEGV to task. This is an external routine
146	* to keep the stack usage of do_page_fault small.	146	* to keep the stack usage of do_page_fault small.
147	*/	147	*/
148	static noinline void do_sigsegv(struct pt_regs *regs, long int_code,	148	static noinline void do_sigsegv(struct pt_regs *regs, long int_code,
149	int si_code, unsigned long trans_exc_code)	149	int si_code, unsigned long trans_exc_code)
150	{	150	{
151	struct siginfo si;	151	struct siginfo si;
152	unsigned long address;	152	unsigned long address;
153		153
154	address = trans_exc_code & __FAIL_ADDR_MASK;	154	address = trans_exc_code & __FAIL_ADDR_MASK;
155	current->thread.prot_addr = address;	155	current->thread.prot_addr = address;
156	current->thread.trap_no = int_code;	156	current->thread.trap_no = int_code;
157	report_user_fault(regs, int_code, SIGSEGV, address);	157	report_user_fault(regs, int_code, SIGSEGV, address);
158	si.si_signo = SIGSEGV;	158	si.si_signo = SIGSEGV;
159	si.si_code = si_code;	159	si.si_code = si_code;
160	si.si_addr = (void __user *) address;	160	si.si_addr = (void __user *) address;
161	force_sig_info(SIGSEGV, &si, current);	161	force_sig_info(SIGSEGV, &si, current);
162	}	162	}
163		163
164	static noinline void do_no_context(struct pt_regs *regs, long int_code,	164	static noinline void do_no_context(struct pt_regs *regs, long int_code,
165	unsigned long trans_exc_code)	165	unsigned long trans_exc_code)
166	{	166	{
167	const struct exception_table_entry *fixup;	167	const struct exception_table_entry *fixup;
168	unsigned long address;	168	unsigned long address;
169		169
170	/* Are we prepared to handle this kernel fault? */	170	/* Are we prepared to handle this kernel fault? */
171	fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);	171	fixup = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
172	if (fixup) {	172	if (fixup) {
173	regs->psw.addr = fixup->fixup \| PSW_ADDR_AMODE;	173	regs->psw.addr = fixup->fixup \| PSW_ADDR_AMODE;
174	return;	174	return;
175	}	175	}
176		176
177	/*	177	/*
178	* Oops. The kernel tried to access some bad page. We'll have to	178	* Oops. The kernel tried to access some bad page. We'll have to
179	* terminate things with extreme prejudice.	179	* terminate things with extreme prejudice.
180	*/	180	*/
181	address = trans_exc_code & __FAIL_ADDR_MASK;	181	address = trans_exc_code & __FAIL_ADDR_MASK;
182	if (!user_space_fault(trans_exc_code))	182	if (!user_space_fault(trans_exc_code))
183	printk(KERN_ALERT "Unable to handle kernel pointer dereference"	183	printk(KERN_ALERT "Unable to handle kernel pointer dereference"
184	" at virtual kernel address %p\n", (void *)address);	184	" at virtual kernel address %p\n", (void *)address);
185	else	185	else
186	printk(KERN_ALERT "Unable to handle kernel paging request"	186	printk(KERN_ALERT "Unable to handle kernel paging request"
187	" at virtual user address %p\n", (void *)address);	187	" at virtual user address %p\n", (void *)address);
188		188
189	die("Oops", regs, int_code);	189	die("Oops", regs, int_code);
190	do_exit(SIGKILL);	190	do_exit(SIGKILL);
191	}	191	}
192		192
193	static noinline void do_low_address(struct pt_regs *regs, long int_code,	193	static noinline void do_low_address(struct pt_regs *regs, long int_code,
194	unsigned long trans_exc_code)	194	unsigned long trans_exc_code)
195	{	195	{
196	/* Low-address protection hit in kernel mode means	196	/* Low-address protection hit in kernel mode means
197	NULL pointer write access in kernel mode. */	197	NULL pointer write access in kernel mode. */
198	if (regs->psw.mask & PSW_MASK_PSTATE) {	198	if (regs->psw.mask & PSW_MASK_PSTATE) {
199	/* Low-address protection hit in user mode 'cannot happen'. */	199	/* Low-address protection hit in user mode 'cannot happen'. */
200	die ("Low-address protection", regs, int_code);	200	die ("Low-address protection", regs, int_code);
201	do_exit(SIGKILL);	201	do_exit(SIGKILL);
202	}	202	}
203		203
204	do_no_context(regs, int_code, trans_exc_code);	204	do_no_context(regs, int_code, trans_exc_code);
205	}	205	}
206		206
207	static noinline void do_sigbus(struct pt_regs *regs, long int_code,	207	static noinline void do_sigbus(struct pt_regs *regs, long int_code,
208	unsigned long trans_exc_code)	208	unsigned long trans_exc_code)
209	{	209	{
210	struct task_struct *tsk = current;	210	struct task_struct *tsk = current;
211	unsigned long address;	211	unsigned long address;
212	struct siginfo si;	212	struct siginfo si;
213		213
214	/*	214	/*
215	* Send a sigbus, regardless of whether we were in kernel	215	* Send a sigbus, regardless of whether we were in kernel
216	* or user mode.	216	* or user mode.
217	*/	217	*/
218	address = trans_exc_code & __FAIL_ADDR_MASK;	218	address = trans_exc_code & __FAIL_ADDR_MASK;
219	tsk->thread.prot_addr = address;	219	tsk->thread.prot_addr = address;
220	tsk->thread.trap_no = int_code;	220	tsk->thread.trap_no = int_code;
221	si.si_signo = SIGBUS;	221	si.si_signo = SIGBUS;
222	si.si_errno = 0;	222	si.si_errno = 0;
223	si.si_code = BUS_ADRERR;	223	si.si_code = BUS_ADRERR;
224	si.si_addr = (void __user *) address;	224	si.si_addr = (void __user *) address;
225	force_sig_info(SIGBUS, &si, tsk);	225	force_sig_info(SIGBUS, &si, tsk);
226	}	226	}
227		227
228	static noinline void do_fault_error(struct pt_regs *regs, long int_code,	228	static noinline void do_fault_error(struct pt_regs *regs, long int_code,
229	unsigned long trans_exc_code, int fault)	229	unsigned long trans_exc_code, int fault)
230	{	230	{
231	int si_code;	231	int si_code;
232		232
233	switch (fault) {	233	switch (fault) {
234	case VM_FAULT_BADACCESS:	234	case VM_FAULT_BADACCESS:
235	case VM_FAULT_BADMAP:	235	case VM_FAULT_BADMAP:
236	/* Bad memory access. Check if it is kernel or user space. */	236	/* Bad memory access. Check if it is kernel or user space. */
237	if (regs->psw.mask & PSW_MASK_PSTATE) {	237	if (regs->psw.mask & PSW_MASK_PSTATE) {
238	/* User mode accesses just cause a SIGSEGV */	238	/* User mode accesses just cause a SIGSEGV */
239	si_code = (fault == VM_FAULT_BADMAP) ?	239	si_code = (fault == VM_FAULT_BADMAP) ?
240	SEGV_MAPERR : SEGV_ACCERR;	240	SEGV_MAPERR : SEGV_ACCERR;
241	do_sigsegv(regs, int_code, si_code, trans_exc_code);	241	do_sigsegv(regs, int_code, si_code, trans_exc_code);
242	return;	242	return;
243	}	243	}
244	case VM_FAULT_BADCONTEXT:	244	case VM_FAULT_BADCONTEXT:
245	do_no_context(regs, int_code, trans_exc_code);	245	do_no_context(regs, int_code, trans_exc_code);
246	break;	246	break;
247	default: /* fault & VM_FAULT_ERROR */	247	default: /* fault & VM_FAULT_ERROR */
248	if (fault & VM_FAULT_OOM)	248	if (fault & VM_FAULT_OOM)
249	pagefault_out_of_memory();	249	pagefault_out_of_memory();
250	else if (fault & VM_FAULT_SIGBUS) {	250	else if (fault & VM_FAULT_SIGBUS) {
251	/* Kernel mode? Handle exceptions or die */	251	/* Kernel mode? Handle exceptions or die */
252	if (!(regs->psw.mask & PSW_MASK_PSTATE))	252	if (!(regs->psw.mask & PSW_MASK_PSTATE))
253	do_no_context(regs, int_code, trans_exc_code);	253	do_no_context(regs, int_code, trans_exc_code);
254	else	254	else
255	do_sigbus(regs, int_code, trans_exc_code);	255	do_sigbus(regs, int_code, trans_exc_code);
256	} else	256	} else
257	BUG();	257	BUG();
258	break;	258	break;
259	}	259	}
260	}	260	}
261		261
262	/*	262	/*
263	* This routine handles page faults. It determines the address,	263	* This routine handles page faults. It determines the address,
264	* and the problem, and then passes it off to one of the appropriate	264	* and the problem, and then passes it off to one of the appropriate
265	* routines.	265	* routines.
266	*	266	*
267	* interruption code (int_code):	267	* interruption code (int_code):
268	* 04 Protection -> Write-Protection (suprression)	268	* 04 Protection -> Write-Protection (suprression)
269	* 10 Segment translation -> Not present (nullification)	269	* 10 Segment translation -> Not present (nullification)
270	* 11 Page translation -> Not present (nullification)	270	* 11 Page translation -> Not present (nullification)
271	* 3b Region third trans. -> Not present (nullification)	271	* 3b Region third trans. -> Not present (nullification)
272	*/	272	*/
273	static inline int do_exception(struct pt_regs *regs, int access,	273	static inline int do_exception(struct pt_regs *regs, int access,
274	unsigned long trans_exc_code)	274	unsigned long trans_exc_code)
275	{	275	{
276	struct task_struct *tsk;	276	struct task_struct *tsk;
277	struct mm_struct *mm;	277	struct mm_struct *mm;
278	struct vm_area_struct *vma;	278	struct vm_area_struct *vma;
279	unsigned long address;	279	unsigned long address;
280	int fault, write;	280	int fault, write;
281		281
282	if (notify_page_fault(regs))	282	if (notify_page_fault(regs))
283	return 0;	283	return 0;
284		284
285	tsk = current;	285	tsk = current;
286	mm = tsk->mm;	286	mm = tsk->mm;
287		287
288	/*	288	/*
289	* Verify that the fault happened in user space, that	289	* Verify that the fault happened in user space, that
290	* we are not in an interrupt and that there is a	290	* we are not in an interrupt and that there is a
291	* user context.	291	* user context.
292	*/	292	*/
293	fault = VM_FAULT_BADCONTEXT;	293	fault = VM_FAULT_BADCONTEXT;
294	if (unlikely(!user_space_fault(trans_exc_code) \|\| in_atomic() \|\| !mm))	294	if (unlikely(!user_space_fault(trans_exc_code) \|\| in_atomic() \|\| !mm))
295	goto out;	295	goto out;
296		296
297	address = trans_exc_code & __FAIL_ADDR_MASK;	297	address = trans_exc_code & __FAIL_ADDR_MASK;
298	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, 0, regs, address);	298	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, 0, regs, address);
299	down_read(&mm->mmap_sem);	299	down_read(&mm->mmap_sem);
300		300
301	fault = VM_FAULT_BADMAP;	301	fault = VM_FAULT_BADMAP;
302	vma = find_vma(mm, address);	302	vma = find_vma(mm, address);
303	if (!vma)	303	if (!vma)
304	goto out_up;	304	goto out_up;
305		305
306	if (unlikely(vma->vm_start > address)) {	306	if (unlikely(vma->vm_start > address)) {
307	if (!(vma->vm_flags & VM_GROWSDOWN))	307	if (!(vma->vm_flags & VM_GROWSDOWN))
308	goto out_up;	308	goto out_up;
309	if (expand_stack(vma, address))	309	if (expand_stack(vma, address))
310	goto out_up;	310	goto out_up;
311	}	311	}
312		312
313	/*	313	/*
314	* Ok, we have a good vm_area for this memory access, so	314	* Ok, we have a good vm_area for this memory access, so
315	* we can handle it..	315	* we can handle it..
316	*/	316	*/
317	fault = VM_FAULT_BADACCESS;	317	fault = VM_FAULT_BADACCESS;
318	if (unlikely(!(vma->vm_flags & access)))	318	if (unlikely(!(vma->vm_flags & access)))
319	goto out_up;	319	goto out_up;
320		320
321	if (is_vm_hugetlb_page(vma))	321	if (is_vm_hugetlb_page(vma))
322	address &= HPAGE_MASK;	322	address &= HPAGE_MASK;
323	/*	323	/*
324	* If for any reason at all we couldn't handle the fault,	324	* If for any reason at all we couldn't handle the fault,
325	* make sure we exit gracefully rather than endlessly redo	325	* make sure we exit gracefully rather than endlessly redo
326	* the fault.	326	* the fault.
327	*/	327	*/
328	write = (access == VM_WRITE \|\|	328	write = (access == VM_WRITE \|\|
329	(trans_exc_code & store_indication) == 0x400) ?	329	(trans_exc_code & store_indication) == 0x400) ?
330	FAULT_FLAG_WRITE : 0;	330	FAULT_FLAG_WRITE : 0;
331	fault = handle_mm_fault(mm, vma, address, write);	331	fault = handle_mm_fault(mm, vma, address, write);
332	if (unlikely(fault & VM_FAULT_ERROR))	332	if (unlikely(fault & VM_FAULT_ERROR))
333	goto out_up;	333	goto out_up;
334		334
335	if (fault & VM_FAULT_MAJOR) {	335	if (fault & VM_FAULT_MAJOR) {
336	tsk->maj_flt++;	336	tsk->maj_flt++;
337	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, 0,	337	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, 0,
338	regs, address);	338	regs, address);
339	} else {	339	} else {
340	tsk->min_flt++;	340	tsk->min_flt++;
341	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, 0,	341	perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, 0,
342	regs, address);	342	regs, address);
343	}	343	}
344	/*	344	/*
345	* The instruction that caused the program check will	345	* The instruction that caused the program check will
346	* be repeated. Don't signal single step via SIGTRAP.	346	* be repeated. Don't signal single step via SIGTRAP.
347	*/	347	*/
348	clear_tsk_thread_flag(tsk, TIF_PER_TRAP);	348	clear_tsk_thread_flag(tsk, TIF_PER_TRAP);
349	fault = 0;	349	fault = 0;
350	out_up:	350	out_up:
351	up_read(&mm->mmap_sem);	351	up_read(&mm->mmap_sem);
352	out:	352	out:
353	return fault;	353	return fault;
354	}	354	}
355		355
356	void __kprobes do_protection_exception(struct pt_regs *regs, long pgm_int_code,	356	void __kprobes do_protection_exception(struct pt_regs *regs, long pgm_int_code,
357	unsigned long trans_exc_code)	357	unsigned long trans_exc_code)
358	{	358	{
359	int fault;	359	int fault;
360		360
361	/* Protection exception is suppressing, decrement psw address. */	361	/* Protection exception is suppressing, decrement psw address. */
362	regs->psw.addr -= (pgm_int_code >> 16);	362	regs->psw.addr -= (pgm_int_code >> 16);
363	/*	363	/*
364	* Check for low-address protection. This needs to be treated	364	* Check for low-address protection. This needs to be treated
365	* as a special case because the translation exception code	365	* as a special case because the translation exception code
366	* field is not guaranteed to contain valid data in this case.	366	* field is not guaranteed to contain valid data in this case.
367	*/	367	*/
368	if (unlikely(!(trans_exc_code & 4))) {	368	if (unlikely(!(trans_exc_code & 4))) {
369	do_low_address(regs, pgm_int_code, trans_exc_code);	369	do_low_address(regs, pgm_int_code, trans_exc_code);
370	return;	370	return;
371	}	371	}
372	fault = do_exception(regs, VM_WRITE, trans_exc_code);	372	fault = do_exception(regs, VM_WRITE, trans_exc_code);
373	if (unlikely(fault))	373	if (unlikely(fault))
374	do_fault_error(regs, 4, trans_exc_code, fault);	374	do_fault_error(regs, 4, trans_exc_code, fault);
375	}	375	}
376		376
377	void __kprobes do_dat_exception(struct pt_regs *regs, long pgm_int_code,	377	void __kprobes do_dat_exception(struct pt_regs *regs, long pgm_int_code,
378	unsigned long trans_exc_code)	378	unsigned long trans_exc_code)
379	{	379	{
380	int access, fault;	380	int access, fault;
381		381
382	access = VM_READ \| VM_EXEC \| VM_WRITE;	382	access = VM_READ \| VM_EXEC \| VM_WRITE;
383	fault = do_exception(regs, access, trans_exc_code);	383	fault = do_exception(regs, access, trans_exc_code);
384	if (unlikely(fault))	384	if (unlikely(fault))
385	do_fault_error(regs, pgm_int_code & 255, trans_exc_code, fault);	385	do_fault_error(regs, pgm_int_code & 255, trans_exc_code, fault);
386	}	386	}
387		387
388	#ifdef CONFIG_64BIT	388	#ifdef CONFIG_64BIT
389	void __kprobes do_asce_exception(struct pt_regs *regs, long pgm_int_code,	389	void __kprobes do_asce_exception(struct pt_regs *regs, long pgm_int_code,
390	unsigned long trans_exc_code)	390	unsigned long trans_exc_code)
391	{	391	{
392	struct mm_struct *mm = current->mm;	392	struct mm_struct *mm = current->mm;
393	struct vm_area_struct *vma;	393	struct vm_area_struct *vma;
394		394
395	if (unlikely(!user_space_fault(trans_exc_code) \|\| in_atomic() \|\| !mm))	395	if (unlikely(!user_space_fault(trans_exc_code) \|\| in_atomic() \|\| !mm))
396	goto no_context;	396	goto no_context;
397		397
398	down_read(&mm->mmap_sem);	398	down_read(&mm->mmap_sem);
399	vma = find_vma(mm, trans_exc_code & __FAIL_ADDR_MASK);	399	vma = find_vma(mm, trans_exc_code & __FAIL_ADDR_MASK);
400	up_read(&mm->mmap_sem);	400	up_read(&mm->mmap_sem);
401		401
402	if (vma) {	402	if (vma) {
403	update_mm(mm, current);	403	update_mm(mm, current);
404	return;	404	return;
405	}	405	}
406		406
407	/* User mode accesses just cause a SIGSEGV */	407	/* User mode accesses just cause a SIGSEGV */
408	if (regs->psw.mask & PSW_MASK_PSTATE) {	408	if (regs->psw.mask & PSW_MASK_PSTATE) {
409	do_sigsegv(regs, pgm_int_code, SEGV_MAPERR, trans_exc_code);	409	do_sigsegv(regs, pgm_int_code, SEGV_MAPERR, trans_exc_code);
410	return;	410	return;
411	}	411	}
412		412
413	no_context:	413	no_context:
414	do_no_context(regs, pgm_int_code, trans_exc_code);	414	do_no_context(regs, pgm_int_code, trans_exc_code);
415	}	415	}
416	#endif	416	#endif
417		417
418	int __handle_fault(unsigned long uaddr, unsigned long pgm_int_code, int write)	418	int __handle_fault(unsigned long uaddr, unsigned long pgm_int_code, int write)
419	{	419	{
420	struct pt_regs regs;	420	struct pt_regs regs;
421	int access, fault;	421	int access, fault;
422		422
423	regs.psw.mask = psw_kernel_bits;	423	regs.psw.mask = psw_kernel_bits;
424	if (!irqs_disabled())	424	if (!irqs_disabled())
425	regs.psw.mask \|= PSW_MASK_IO \| PSW_MASK_EXT;	425	regs.psw.mask \|= PSW_MASK_IO \| PSW_MASK_EXT;
426	regs.psw.addr = (unsigned long) __builtin_return_address(0);	426	regs.psw.addr = (unsigned long) __builtin_return_address(0);
427	regs.psw.addr \|= PSW_ADDR_AMODE;	427	regs.psw.addr \|= PSW_ADDR_AMODE;
428	uaddr &= PAGE_MASK;	428	uaddr &= PAGE_MASK;
429	access = write ? VM_WRITE : VM_READ;	429	access = write ? VM_WRITE : VM_READ;
430	fault = do_exception(&regs, access, uaddr \| 2);	430	fault = do_exception(&regs, access, uaddr \| 2);
431	if (unlikely(fault)) {	431	if (unlikely(fault)) {
432	if (fault & VM_FAULT_OOM) {	432	if (fault & VM_FAULT_OOM) {
433	pagefault_out_of_memory();	433	pagefault_out_of_memory();
434	fault = 0;	434	fault = 0;
435	} else if (fault & VM_FAULT_SIGBUS)	435	} else if (fault & VM_FAULT_SIGBUS)
436	do_sigbus(&regs, pgm_int_code, uaddr);	436	do_sigbus(&regs, pgm_int_code, uaddr);
437	}	437	}
438	return fault ? -EFAULT : 0;	438	return fault ? -EFAULT : 0;
439	}	439	}
440		440
441	#ifdef CONFIG_PFAULT	441	#ifdef CONFIG_PFAULT
442	/*	442	/*
443	* 'pfault' pseudo page faults routines.	443	* 'pfault' pseudo page faults routines.
444	*/	444	*/
445	static int pfault_disable;	445	static int pfault_disable;
446		446
447	static int __init nopfault(char *str)	447	static int __init nopfault(char *str)
448	{	448	{
449	pfault_disable = 1;	449	pfault_disable = 1;
450	return 1;	450	return 1;
451	}	451	}
452		452
453	__setup("nopfault", nopfault);	453	__setup("nopfault", nopfault);
454		454
455	struct pfault_refbk {	455	struct pfault_refbk {
456	u16 refdiagc;	456	u16 refdiagc;
457	u16 reffcode;	457	u16 reffcode;
458	u16 refdwlen;	458	u16 refdwlen;
459	u16 refversn;	459	u16 refversn;
460	u64 refgaddr;	460	u64 refgaddr;
461	u64 refselmk;	461	u64 refselmk;
462	u64 refcmpmk;	462	u64 refcmpmk;
463	u64 reserved;	463	u64 reserved;
464	} __attribute__ ((packed, aligned(8)));	464	} __attribute__ ((packed, aligned(8)));
465		465
466	int pfault_init(void)	466	int pfault_init(void)
467	{	467	{
468	struct pfault_refbk refbk = {	468	struct pfault_refbk refbk = {
469	.refdiagc = 0x258,	469	.refdiagc = 0x258,
470	.reffcode = 0,	470	.reffcode = 0,
471	.refdwlen = 5,	471	.refdwlen = 5,
472	.refversn = 2,	472	.refversn = 2,
473	.refgaddr = __LC_CURRENT_PID,	473	.refgaddr = __LC_CURRENT_PID,
474	.refselmk = 1ULL << 48,	474	.refselmk = 1ULL << 48,
475	.refcmpmk = 1ULL << 48,	475	.refcmpmk = 1ULL << 48,
476	.reserved = __PF_RES_FIELD };	476	.reserved = __PF_RES_FIELD };
477	int rc;	477	int rc;
478		478
479	if (!MACHINE_IS_VM \|\| pfault_disable)	479	if (!MACHINE_IS_VM \|\| pfault_disable)
480	return -1;	480	return -1;
481	asm volatile(	481	asm volatile(
482	" diag %1,%0,0x258\n"	482	" diag %1,%0,0x258\n"
483	"0: j 2f\n"	483	"0: j 2f\n"
484	"1: la %0,8\n"	484	"1: la %0,8\n"
485	"2:\n"	485	"2:\n"
486	EX_TABLE(0b,1b)	486	EX_TABLE(0b,1b)
487	: "=d" (rc) : "a" (&refbk), "m" (refbk) : "cc");	487	: "=d" (rc) : "a" (&refbk), "m" (refbk) : "cc");
488	return rc;	488	return rc;
489	}	489	}
490		490
491	void pfault_fini(void)	491	void pfault_fini(void)
492	{	492	{
493	struct pfault_refbk refbk = {	493	struct pfault_refbk refbk = {
494	.refdiagc = 0x258,	494	.refdiagc = 0x258,
495	.reffcode = 1,	495	.reffcode = 1,
496	.refdwlen = 5,	496	.refdwlen = 5,
497	.refversn = 2,	497	.refversn = 2,
498	};	498	};
499		499
500	if (!MACHINE_IS_VM \|\| pfault_disable)	500	if (!MACHINE_IS_VM \|\| pfault_disable)
501	return;	501	return;
502	asm volatile(	502	asm volatile(
503	" diag %0,0,0x258\n"	503	" diag %0,0,0x258\n"
504	"0:\n"	504	"0:\n"
505	EX_TABLE(0b,0b)	505	EX_TABLE(0b,0b)
506	: : "a" (&refbk), "m" (refbk) : "cc");	506	: : "a" (&refbk), "m" (refbk) : "cc");
507	}	507	}
508		508
509	static DEFINE_SPINLOCK(pfault_lock);	509	static DEFINE_SPINLOCK(pfault_lock);
510	static LIST_HEAD(pfault_list);	510	static LIST_HEAD(pfault_list);
511		511
512	static void pfault_interrupt(unsigned int ext_int_code,	512	static void pfault_interrupt(unsigned int ext_int_code,
513	unsigned int param32, unsigned long param64)	513	unsigned int param32, unsigned long param64)
514	{	514	{
515	struct task_struct *tsk;	515	struct task_struct *tsk;
516	__u16 subcode;	516	__u16 subcode;
517	pid_t pid;	517	pid_t pid;
518		518
519	/*	519	/*
520	* Get the external interruption subcode & pfault	520	* Get the external interruption subcode & pfault
521	* initial/completion signal bit. VM stores this	521	* initial/completion signal bit. VM stores this
522	* in the 'cpu address' field associated with the	522	* in the 'cpu address' field associated with the
523	* external interrupt.	523	* external interrupt.
524	*/	524	*/
525	subcode = ext_int_code >> 16;	525	subcode = ext_int_code >> 16;
526	if ((subcode & 0xff00) != __SUBCODE_MASK)	526	if ((subcode & 0xff00) != __SUBCODE_MASK)
527	return;	527	return;
528	kstat_cpu(smp_processor_id()).irqs[EXTINT_PFL]++;	528	kstat_cpu(smp_processor_id()).irqs[EXTINT_PFL]++;
529	if (subcode & 0x0080) {	529	if (subcode & 0x0080) {
530	/* Get the token (= pid of the affected task). */	530	/* Get the token (= pid of the affected task). */
531	pid = sizeof(void *) == 4 ? param32 : param64;	531	pid = sizeof(void *) == 4 ? param32 : param64;
532	rcu_read_lock();	532	rcu_read_lock();
533	tsk = find_task_by_pid_ns(pid, &init_pid_ns);	533	tsk = find_task_by_pid_ns(pid, &init_pid_ns);
534	if (tsk)	534	if (tsk)
535	get_task_struct(tsk);	535	get_task_struct(tsk);
536	rcu_read_unlock();	536	rcu_read_unlock();
537	if (!tsk)	537	if (!tsk)
538	return;	538	return;
539	} else {	539	} else {
540	tsk = current;	540	tsk = current;
541	}	541	}
542	spin_lock(&pfault_lock);	542	spin_lock(&pfault_lock);
543	if (subcode & 0x0080) {	543	if (subcode & 0x0080) {
544	/* signal bit is set -> a page has been swapped in by VM */	544	/* signal bit is set -> a page has been swapped in by VM */
545	if (tsk->thread.pfault_wait == 1) {	545	if (tsk->thread.pfault_wait == 1) {
546	/* Initial interrupt was faster than the completion	546	/* Initial interrupt was faster than the completion
547	* interrupt. pfault_wait is valid. Set pfault_wait	547	* interrupt. pfault_wait is valid. Set pfault_wait
548	* back to zero and wake up the process. This can	548	* back to zero and wake up the process. This can
549	* safely be done because the task is still sleeping	549	* safely be done because the task is still sleeping
550	* and can't produce new pfaults. */	550	* and can't produce new pfaults. */
551	tsk->thread.pfault_wait = 0;	551	tsk->thread.pfault_wait = 0;
552	list_del(&tsk->thread.list);	552	list_del(&tsk->thread.list);
553	wake_up_process(tsk);	553	wake_up_process(tsk);
554	} else {	554	} else {
555	/* Completion interrupt was faster than initial	555	/* Completion interrupt was faster than initial
556	* interrupt. Set pfault_wait to -1 so the initial	556	* interrupt. Set pfault_wait to -1 so the initial
557	* interrupt doesn't put the task to sleep. */	557	* interrupt doesn't put the task to sleep. */
558	tsk->thread.pfault_wait = -1;	558	tsk->thread.pfault_wait = -1;
559	}	559	}
560	put_task_struct(tsk);	560	put_task_struct(tsk);
561	} else {	561	} else {
562	/* signal bit not set -> a real page is missing. */	562	/* signal bit not set -> a real page is missing. */
563	if (tsk->thread.pfault_wait == -1) {	563	if (tsk->thread.pfault_wait == -1) {
564	/* Completion interrupt was faster than the initial	564	/* Completion interrupt was faster than the initial
565	* interrupt (pfault_wait == -1). Set pfault_wait	565	* interrupt (pfault_wait == -1). Set pfault_wait
566	* back to zero and exit. */	566	* back to zero and exit. */
567	tsk->thread.pfault_wait = 0;	567	tsk->thread.pfault_wait = 0;
568	} else {	568	} else {
569	/* Initial interrupt arrived before completion	569	/* Initial interrupt arrived before completion
570	* interrupt. Let the task sleep. */	570	* interrupt. Let the task sleep. */
571	tsk->thread.pfault_wait = 1;	571	tsk->thread.pfault_wait = 1;
572	list_add(&tsk->thread.list, &pfault_list);	572	list_add(&tsk->thread.list, &pfault_list);
573	set_task_state(tsk, TASK_UNINTERRUPTIBLE);	573	set_task_state(tsk, TASK_UNINTERRUPTIBLE);
574	set_tsk_need_resched(tsk);	574	set_tsk_need_resched(tsk);
575	}	575	}
576	}	576	}
577	spin_unlock(&pfault_lock);	577	spin_unlock(&pfault_lock);
578	}	578	}
579		579
580	static int __cpuinit pfault_cpu_notify(struct notifier_block *self,	580	static int __cpuinit pfault_cpu_notify(struct notifier_block *self,
581	unsigned long action, void *hcpu)	581	unsigned long action, void *hcpu)
582	{	582	{
583	struct thread_struct thread, next;	583	struct thread_struct thread, next;
584	struct task_struct *tsk;	584	struct task_struct *tsk;
585		585
586	switch (action) {	586	switch (action) {
587	case CPU_DEAD:	587	case CPU_DEAD:
588	case CPU_DEAD_FROZEN:	588	case CPU_DEAD_FROZEN:
589	spin_lock_irq(&pfault_lock);	589	spin_lock_irq(&pfault_lock);
590	list_for_each_entry_safe(thread, next, &pfault_list, list) {	590	list_for_each_entry_safe(thread, next, &pfault_list, list) {
591	thread->pfault_wait = 0;	591	thread->pfault_wait = 0;
592	list_del(&thread->list);	592	list_del(&thread->list);
593	tsk = container_of(thread, struct task_struct, thread);	593	tsk = container_of(thread, struct task_struct, thread);
594	wake_up_process(tsk);	594	wake_up_process(tsk);
595	}	595	}
596	spin_unlock_irq(&pfault_lock);	596	spin_unlock_irq(&pfault_lock);
597	break;	597	break;
598	default:	598	default:
599	break;	599	break;
600	}	600	}
601	return NOTIFY_OK;	601	return NOTIFY_OK;
602	}	602	}
603		603
604	static int __init pfault_irq_init(void)	604	static int __init pfault_irq_init(void)
605	{	605	{
606	int rc;	606	int rc;
607		607
608	if (!MACHINE_IS_VM)	608	if (!MACHINE_IS_VM)
609	return 0;	609	return 0;
610	rc = register_external_interrupt(0x2603, pfault_interrupt);	610	rc = register_external_interrupt(0x2603, pfault_interrupt);
611	if (rc)	611	if (rc)
612	goto out_extint;	612	goto out_extint;
613	rc = pfault_init() == 0 ? 0 : -EOPNOTSUPP;	613	rc = pfault_init() == 0 ? 0 : -EOPNOTSUPP;
614	if (rc)	614	if (rc)
615	goto out_pfault;	615	goto out_pfault;
616	service_subclass_irq_register();	616	service_subclass_irq_register();
617	hotcpu_notifier(pfault_cpu_notify, 0);	617	hotcpu_notifier(pfault_cpu_notify, 0);
618	return 0;	618	return 0;
619		619
620	out_pfault:	620	out_pfault:
621	unregister_external_interrupt(0x2603, pfault_interrupt);	621	unregister_external_interrupt(0x2603, pfault_interrupt);
622	out_extint:	622	out_extint:
623	pfault_disable = 1;	623	pfault_disable = 1;
624	return rc;	624	return rc;
625	}	625	}
626	early_initcall(pfault_irq_init);	626	early_initcall(pfault_irq_init);
627		627
628	#endif /* CONFIG_PFAULT */	628	#endif /* CONFIG_PFAULT */
629		629

arch/s390/oprofile/hwsampler.c

Diff comments View file @ d7b250e

1	/**	1	/**
2	* arch/s390/oprofile/hwsampler.c	2	* arch/s390/oprofile/hwsampler.c
3	*	3	*
4	* Copyright IBM Corp. 2010	4	* Copyright IBM Corp. 2010
5	* Author: Heinz Graalfs <graalfs@de.ibm.com>	5	* Author: Heinz Graalfs <graalfs@de.ibm.com>
6	*/	6	*/
7		7
8	#include <linux/kernel_stat.h>	8	#include <linux/kernel_stat.h>
9	#include <linux/kernel.h>	9	#include <linux/kernel.h>
10	#include <linux/module.h>	10	#include <linux/module.h>
11	#include <linux/smp.h>	11	#include <linux/smp.h>
12	#include <linux/errno.h>	12	#include <linux/errno.h>
13	#include <linux/workqueue.h>	13	#include <linux/workqueue.h>
14	#include <linux/interrupt.h>	14	#include <linux/interrupt.h>
15	#include <linux/notifier.h>	15	#include <linux/notifier.h>
16	#include <linux/cpu.h>	16	#include <linux/cpu.h>
17	#include <linux/semaphore.h>	17	#include <linux/semaphore.h>
18	#include <linux/oom.h>	18	#include <linux/oom.h>
19	#include <linux/oprofile.h>	19	#include <linux/oprofile.h>
20		20
21	#include <asm/lowcore.h>	21	#include <asm/lowcore.h>
22	#include <asm/s390_ext.h>	22	#include <asm/irq.h>
23		23
24	#include "hwsampler.h"	24	#include "hwsampler.h"
25		25
26	#define MAX_NUM_SDB 511	26	#define MAX_NUM_SDB 511
27	#define MIN_NUM_SDB 1	27	#define MIN_NUM_SDB 1
28		28
29	#define ALERT_REQ_MASK 0x4000000000000000ul	29	#define ALERT_REQ_MASK 0x4000000000000000ul
30	#define BUFFER_FULL_MASK 0x8000000000000000ul	30	#define BUFFER_FULL_MASK 0x8000000000000000ul
31		31
32	#define EI_IEA (1 << 31) /* invalid entry address */	32	#define EI_IEA (1 << 31) /* invalid entry address */
33	#define EI_ISE (1 << 30) /* incorrect SDBT entry */	33	#define EI_ISE (1 << 30) /* incorrect SDBT entry */
34	#define EI_PRA (1 << 29) /* program request alert */	34	#define EI_PRA (1 << 29) /* program request alert */
35	#define EI_SACA (1 << 23) /* sampler authorization change alert */	35	#define EI_SACA (1 << 23) /* sampler authorization change alert */
36	#define EI_LSDA (1 << 22) /* loss of sample data alert */	36	#define EI_LSDA (1 << 22) /* loss of sample data alert */
37		37
38	DECLARE_PER_CPU(struct hws_cpu_buffer, sampler_cpu_buffer);	38	DECLARE_PER_CPU(struct hws_cpu_buffer, sampler_cpu_buffer);
39		39
40	struct hws_execute_parms {	40	struct hws_execute_parms {
41	void *buffer;	41	void *buffer;
42	signed int rc;	42	signed int rc;
43	};	43	};
44		44
45	DEFINE_PER_CPU(struct hws_cpu_buffer, sampler_cpu_buffer);	45	DEFINE_PER_CPU(struct hws_cpu_buffer, sampler_cpu_buffer);
46	EXPORT_PER_CPU_SYMBOL(sampler_cpu_buffer);	46	EXPORT_PER_CPU_SYMBOL(sampler_cpu_buffer);
47		47
48	static DEFINE_MUTEX(hws_sem);	48	static DEFINE_MUTEX(hws_sem);
49	static DEFINE_MUTEX(hws_sem_oom);	49	static DEFINE_MUTEX(hws_sem_oom);
50		50
51	static unsigned char hws_flush_all;	51	static unsigned char hws_flush_all;
52	static unsigned int hws_oom;	52	static unsigned int hws_oom;
53	static struct workqueue_struct *hws_wq;	53	static struct workqueue_struct *hws_wq;
54		54
55	static unsigned int hws_state;	55	static unsigned int hws_state;
56	enum {	56	enum {
57	HWS_INIT = 1,	57	HWS_INIT = 1,
58	HWS_DEALLOCATED,	58	HWS_DEALLOCATED,
59	HWS_STOPPED,	59	HWS_STOPPED,
60	HWS_STARTED,	60	HWS_STARTED,
61	HWS_STOPPING };	61	HWS_STOPPING };
62		62
63	/* set to 1 if called by kernel during memory allocation */	63	/* set to 1 if called by kernel during memory allocation */
64	static unsigned char oom_killer_was_active;	64	static unsigned char oom_killer_was_active;
65	/* size of SDBT and SDB as of allocate API */	65	/* size of SDBT and SDB as of allocate API */
66	static unsigned long num_sdbt = 100;	66	static unsigned long num_sdbt = 100;
67	static unsigned long num_sdb = 511;	67	static unsigned long num_sdb = 511;
68	/* sampling interval (machine cycles) */	68	/* sampling interval (machine cycles) */
69	static unsigned long interval;	69	static unsigned long interval;
70		70
71	static unsigned long min_sampler_rate;	71	static unsigned long min_sampler_rate;
72	static unsigned long max_sampler_rate;	72	static unsigned long max_sampler_rate;
73		73
74	static int ssctl(void *buffer)	74	static int ssctl(void *buffer)
75	{	75	{
76	int cc;	76	int cc;
77		77
78	/* set in order to detect a program check */	78	/* set in order to detect a program check */
79	cc = 1;	79	cc = 1;
80		80
81	asm volatile(	81	asm volatile(
82	"0: .insn s,0xB2870000,0(%1)\n"	82	"0: .insn s,0xB2870000,0(%1)\n"
83	"1: ipm %0\n"	83	"1: ipm %0\n"
84	" srl %0,28\n"	84	" srl %0,28\n"
85	"2:\n"	85	"2:\n"
86	EX_TABLE(0b, 2b) EX_TABLE(1b, 2b)	86	EX_TABLE(0b, 2b) EX_TABLE(1b, 2b)
87	: "+d" (cc), "+a" (buffer)	87	: "+d" (cc), "+a" (buffer)
88	: "m" (((struct hws_ssctl_request_block )buffer))	88	: "m" (((struct hws_ssctl_request_block )buffer))
89	: "cc", "memory");	89	: "cc", "memory");
90		90
91	return cc ? -EINVAL : 0 ;	91	return cc ? -EINVAL : 0 ;
92	}	92	}
93		93
94	static int qsi(void *buffer)	94	static int qsi(void *buffer)
95	{	95	{
96	int cc;	96	int cc;
97	cc = 1;	97	cc = 1;
98		98
99	asm volatile(	99	asm volatile(
100	"0: .insn s,0xB2860000,0(%1)\n"	100	"0: .insn s,0xB2860000,0(%1)\n"
101	"1: lhi %0,0\n"	101	"1: lhi %0,0\n"
102	"2:\n"	102	"2:\n"
103	EX_TABLE(0b, 2b) EX_TABLE(1b, 2b)	103	EX_TABLE(0b, 2b) EX_TABLE(1b, 2b)
104	: "=d" (cc), "+a" (buffer)	104	: "=d" (cc), "+a" (buffer)
105	: "m" (((struct hws_qsi_info_block )buffer))	105	: "m" (((struct hws_qsi_info_block )buffer))
106	: "cc", "memory");	106	: "cc", "memory");
107		107
108	return cc ? -EINVAL : 0;	108	return cc ? -EINVAL : 0;
109	}	109	}
110		110
111	static void execute_qsi(void *parms)	111	static void execute_qsi(void *parms)
112	{	112	{
113	struct hws_execute_parms *ep = parms;	113	struct hws_execute_parms *ep = parms;
114		114
115	ep->rc = qsi(ep->buffer);	115	ep->rc = qsi(ep->buffer);
116	}	116	}
117		117
118	static void execute_ssctl(void *parms)	118	static void execute_ssctl(void *parms)
119	{	119	{
120	struct hws_execute_parms *ep = parms;	120	struct hws_execute_parms *ep = parms;
121		121
122	ep->rc = ssctl(ep->buffer);	122	ep->rc = ssctl(ep->buffer);
123	}	123	}
124		124
125	static int smp_ctl_ssctl_stop(int cpu)	125	static int smp_ctl_ssctl_stop(int cpu)
126	{	126	{
127	int rc;	127	int rc;
128	struct hws_execute_parms ep;	128	struct hws_execute_parms ep;
129	struct hws_cpu_buffer *cb;	129	struct hws_cpu_buffer *cb;
130		130
131	cb = &per_cpu(sampler_cpu_buffer, cpu);	131	cb = &per_cpu(sampler_cpu_buffer, cpu);
132		132
133	cb->ssctl.es = 0;	133	cb->ssctl.es = 0;
134	cb->ssctl.cs = 0;	134	cb->ssctl.cs = 0;
135		135
136	ep.buffer = &cb->ssctl;	136	ep.buffer = &cb->ssctl;
137	smp_call_function_single(cpu, execute_ssctl, &ep, 1);	137	smp_call_function_single(cpu, execute_ssctl, &ep, 1);
138	rc = ep.rc;	138	rc = ep.rc;
139	if (rc) {	139	if (rc) {
140	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);	140	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);
141	dump_stack();	141	dump_stack();
142	}	142	}
143		143
144	ep.buffer = &cb->qsi;	144	ep.buffer = &cb->qsi;
145	smp_call_function_single(cpu, execute_qsi, &ep, 1);	145	smp_call_function_single(cpu, execute_qsi, &ep, 1);
146		146
147	if (cb->qsi.es \|\| cb->qsi.cs) {	147	if (cb->qsi.es \|\| cb->qsi.cs) {
148	printk(KERN_EMERG "CPUMF sampling did not stop properly.\n");	148	printk(KERN_EMERG "CPUMF sampling did not stop properly.\n");
149	dump_stack();	149	dump_stack();
150	}	150	}
151		151
152	return rc;	152	return rc;
153	}	153	}
154		154
155	static int smp_ctl_ssctl_deactivate(int cpu)	155	static int smp_ctl_ssctl_deactivate(int cpu)
156	{	156	{
157	int rc;	157	int rc;
158	struct hws_execute_parms ep;	158	struct hws_execute_parms ep;
159	struct hws_cpu_buffer *cb;	159	struct hws_cpu_buffer *cb;
160		160
161	cb = &per_cpu(sampler_cpu_buffer, cpu);	161	cb = &per_cpu(sampler_cpu_buffer, cpu);
162		162
163	cb->ssctl.es = 1;	163	cb->ssctl.es = 1;
164	cb->ssctl.cs = 0;	164	cb->ssctl.cs = 0;
165		165
166	ep.buffer = &cb->ssctl;	166	ep.buffer = &cb->ssctl;
167	smp_call_function_single(cpu, execute_ssctl, &ep, 1);	167	smp_call_function_single(cpu, execute_ssctl, &ep, 1);
168	rc = ep.rc;	168	rc = ep.rc;
169	if (rc)	169	if (rc)
170	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);	170	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);
171		171
172	ep.buffer = &cb->qsi;	172	ep.buffer = &cb->qsi;
173	smp_call_function_single(cpu, execute_qsi, &ep, 1);	173	smp_call_function_single(cpu, execute_qsi, &ep, 1);
174		174
175	if (cb->qsi.cs)	175	if (cb->qsi.cs)
176	printk(KERN_EMERG "CPUMF sampling was not set inactive.\n");	176	printk(KERN_EMERG "CPUMF sampling was not set inactive.\n");
177		177
178	return rc;	178	return rc;
179	}	179	}
180		180
181	static int smp_ctl_ssctl_enable_activate(int cpu, unsigned long interval)	181	static int smp_ctl_ssctl_enable_activate(int cpu, unsigned long interval)
182	{	182	{
183	int rc;	183	int rc;
184	struct hws_execute_parms ep;	184	struct hws_execute_parms ep;
185	struct hws_cpu_buffer *cb;	185	struct hws_cpu_buffer *cb;
186		186
187	cb = &per_cpu(sampler_cpu_buffer, cpu);	187	cb = &per_cpu(sampler_cpu_buffer, cpu);
188		188
189	cb->ssctl.h = 1;	189	cb->ssctl.h = 1;
190	cb->ssctl.tear = cb->first_sdbt;	190	cb->ssctl.tear = cb->first_sdbt;
191	cb->ssctl.dear = (unsigned long ) cb->first_sdbt;	191	cb->ssctl.dear = (unsigned long ) cb->first_sdbt;
192	cb->ssctl.interval = interval;	192	cb->ssctl.interval = interval;
193	cb->ssctl.es = 1;	193	cb->ssctl.es = 1;
194	cb->ssctl.cs = 1;	194	cb->ssctl.cs = 1;
195		195
196	ep.buffer = &cb->ssctl;	196	ep.buffer = &cb->ssctl;
197	smp_call_function_single(cpu, execute_ssctl, &ep, 1);	197	smp_call_function_single(cpu, execute_ssctl, &ep, 1);
198	rc = ep.rc;	198	rc = ep.rc;
199	if (rc)	199	if (rc)
200	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);	200	printk(KERN_ERR "hwsampler: CPU %d CPUMF SSCTL failed.\n", cpu);
201		201
202	ep.buffer = &cb->qsi;	202	ep.buffer = &cb->qsi;
203	smp_call_function_single(cpu, execute_qsi, &ep, 1);	203	smp_call_function_single(cpu, execute_qsi, &ep, 1);
204	if (ep.rc)	204	if (ep.rc)
205	printk(KERN_ERR "hwsampler: CPU %d CPUMF QSI failed.\n", cpu);	205	printk(KERN_ERR "hwsampler: CPU %d CPUMF QSI failed.\n", cpu);
206		206
207	return rc;	207	return rc;
208	}	208	}
209		209
210	static int smp_ctl_qsi(int cpu)	210	static int smp_ctl_qsi(int cpu)
211	{	211	{
212	struct hws_execute_parms ep;	212	struct hws_execute_parms ep;
213	struct hws_cpu_buffer *cb;	213	struct hws_cpu_buffer *cb;
214		214
215	cb = &per_cpu(sampler_cpu_buffer, cpu);	215	cb = &per_cpu(sampler_cpu_buffer, cpu);
216		216
217	ep.buffer = &cb->qsi;	217	ep.buffer = &cb->qsi;
218	smp_call_function_single(cpu, execute_qsi, &ep, 1);	218	smp_call_function_single(cpu, execute_qsi, &ep, 1);
219		219
220	return ep.rc;	220	return ep.rc;
221	}	221	}
222		222
223	static inline unsigned long *trailer_entry_ptr(unsigned long v)	223	static inline unsigned long *trailer_entry_ptr(unsigned long v)
224	{	224	{
225	void *ret;	225	void *ret;
226		226
227	ret = (void *)v;	227	ret = (void *)v;
228	ret += PAGE_SIZE;	228	ret += PAGE_SIZE;
229	ret -= sizeof(struct hws_trailer_entry);	229	ret -= sizeof(struct hws_trailer_entry);
230		230
231	return (unsigned long *) ret;	231	return (unsigned long *) ret;
232	}	232	}
233		233
234	/* prototypes for external interrupt handler and worker */	234	/* prototypes for external interrupt handler and worker */
235	static void hws_ext_handler(unsigned int ext_int_code,	235	static void hws_ext_handler(unsigned int ext_int_code,
236	unsigned int param32, unsigned long param64);	236	unsigned int param32, unsigned long param64);
237		237
238	static void worker(struct work_struct *work);	238	static void worker(struct work_struct *work);
239		239
240	static void add_samples_to_oprofile(unsigned cpu, unsigned long *,	240	static void add_samples_to_oprofile(unsigned cpu, unsigned long *,
241	unsigned long *dear);	241	unsigned long *dear);
242		242
243	static void init_all_cpu_buffers(void)	243	static void init_all_cpu_buffers(void)
244	{	244	{
245	int cpu;	245	int cpu;
246	struct hws_cpu_buffer *cb;	246	struct hws_cpu_buffer *cb;
247		247
248	for_each_online_cpu(cpu) {	248	for_each_online_cpu(cpu) {
249	cb = &per_cpu(sampler_cpu_buffer, cpu);	249	cb = &per_cpu(sampler_cpu_buffer, cpu);
250	memset(cb, 0, sizeof(struct hws_cpu_buffer));	250	memset(cb, 0, sizeof(struct hws_cpu_buffer));
251	}	251	}
252	}	252	}
253		253
254	static int is_link_entry(unsigned long *s)	254	static int is_link_entry(unsigned long *s)
255	{	255	{
256	return *s & 0x1ul ? 1 : 0;	256	return *s & 0x1ul ? 1 : 0;
257	}	257	}
258		258
259	static unsigned long get_next_sdbt(unsigned long s)	259	static unsigned long get_next_sdbt(unsigned long s)
260	{	260	{
261	return (unsigned long ) (s & ~0x1ul);	261	return (unsigned long ) (s & ~0x1ul);
262	}	262	}
263		263
264	static int prepare_cpu_buffers(void)	264	static int prepare_cpu_buffers(void)
265	{	265	{
266	int cpu;	266	int cpu;
267	int rc;	267	int rc;
268	struct hws_cpu_buffer *cb;	268	struct hws_cpu_buffer *cb;
269		269
270	rc = 0;	270	rc = 0;
271	for_each_online_cpu(cpu) {	271	for_each_online_cpu(cpu) {
272	cb = &per_cpu(sampler_cpu_buffer, cpu);	272	cb = &per_cpu(sampler_cpu_buffer, cpu);
273	atomic_set(&cb->ext_params, 0);	273	atomic_set(&cb->ext_params, 0);
274	cb->worker_entry = 0;	274	cb->worker_entry = 0;
275	cb->sample_overflow = 0;	275	cb->sample_overflow = 0;
276	cb->req_alert = 0;	276	cb->req_alert = 0;
277	cb->incorrect_sdbt_entry = 0;	277	cb->incorrect_sdbt_entry = 0;
278	cb->invalid_entry_address = 0;	278	cb->invalid_entry_address = 0;
279	cb->loss_of_sample_data = 0;	279	cb->loss_of_sample_data = 0;
280	cb->sample_auth_change_alert = 0;	280	cb->sample_auth_change_alert = 0;
281	cb->finish = 0;	281	cb->finish = 0;
282	cb->oom = 0;	282	cb->oom = 0;
283	cb->stop_mode = 0;	283	cb->stop_mode = 0;
284	}	284	}
285		285
286	return rc;	286	return rc;
287	}	287	}
288		288
289	/*	289	/*
290	* allocate_sdbt() - allocate sampler memory	290	* allocate_sdbt() - allocate sampler memory
291	* @cpu: the cpu for which sampler memory is allocated	291	* @cpu: the cpu for which sampler memory is allocated
292	*	292	*
293	* A 4K page is allocated for each requested SDBT.	293	* A 4K page is allocated for each requested SDBT.
294	* A maximum of 511 4K pages are allocated for the SDBs in each of the SDBTs.	294	* A maximum of 511 4K pages are allocated for the SDBs in each of the SDBTs.
295	* Set ALERT_REQ mask in each SDBs trailer.	295	* Set ALERT_REQ mask in each SDBs trailer.
296	* Returns zero if successful, <0 otherwise.	296	* Returns zero if successful, <0 otherwise.
297	*/	297	*/
298	static int allocate_sdbt(int cpu)	298	static int allocate_sdbt(int cpu)
299	{	299	{
300	int j, k, rc;	300	int j, k, rc;
301	unsigned long *sdbt;	301	unsigned long *sdbt;
302	unsigned long sdb;	302	unsigned long sdb;
303	unsigned long *tail;	303	unsigned long *tail;
304	unsigned long *trailer;	304	unsigned long *trailer;
305	struct hws_cpu_buffer *cb;	305	struct hws_cpu_buffer *cb;
306		306
307	cb = &per_cpu(sampler_cpu_buffer, cpu);	307	cb = &per_cpu(sampler_cpu_buffer, cpu);
308		308
309	if (cb->first_sdbt)	309	if (cb->first_sdbt)
310	return -EINVAL;	310	return -EINVAL;
311		311
312	sdbt = NULL;	312	sdbt = NULL;
313	tail = sdbt;	313	tail = sdbt;
314		314
315	for (j = 0; j < num_sdbt; j++) {	315	for (j = 0; j < num_sdbt; j++) {
316	sdbt = (unsigned long *)get_zeroed_page(GFP_KERNEL);	316	sdbt = (unsigned long *)get_zeroed_page(GFP_KERNEL);
317		317
318	mutex_lock(&hws_sem_oom);	318	mutex_lock(&hws_sem_oom);
319	/* OOM killer might have been activated */	319	/* OOM killer might have been activated */
320	barrier();	320	barrier();
321	if (oom_killer_was_active \|\| !sdbt) {	321	if (oom_killer_was_active \|\| !sdbt) {
322	if (sdbt)	322	if (sdbt)
323	free_page((unsigned long)sdbt);	323	free_page((unsigned long)sdbt);
324		324
325	goto allocate_sdbt_error;	325	goto allocate_sdbt_error;
326	}	326	}
327	if (cb->first_sdbt == 0)	327	if (cb->first_sdbt == 0)
328	cb->first_sdbt = (unsigned long)sdbt;	328	cb->first_sdbt = (unsigned long)sdbt;
329		329
330	/* link current page to tail of chain */	330	/* link current page to tail of chain */
331	if (tail)	331	if (tail)
332	tail = (unsigned long)(void )sdbt + 1;	332	tail = (unsigned long)(void )sdbt + 1;
333		333
334	mutex_unlock(&hws_sem_oom);	334	mutex_unlock(&hws_sem_oom);
335		335
336	for (k = 0; k < num_sdb; k++) {	336	for (k = 0; k < num_sdb; k++) {
337	/* get and set SDB page */	337	/* get and set SDB page */
338	sdb = get_zeroed_page(GFP_KERNEL);	338	sdb = get_zeroed_page(GFP_KERNEL);
339		339
340	mutex_lock(&hws_sem_oom);	340	mutex_lock(&hws_sem_oom);
341	/* OOM killer might have been activated */	341	/* OOM killer might have been activated */
342	barrier();	342	barrier();
343	if (oom_killer_was_active \|\| !sdb) {	343	if (oom_killer_was_active \|\| !sdb) {
344	if (sdb)	344	if (sdb)
345	free_page(sdb);	345	free_page(sdb);
346		346
347	goto allocate_sdbt_error;	347	goto allocate_sdbt_error;
348	}	348	}
349	*sdbt = sdb;	349	*sdbt = sdb;
350	trailer = trailer_entry_ptr(*sdbt);	350	trailer = trailer_entry_ptr(*sdbt);
351	*trailer = ALERT_REQ_MASK;	351	*trailer = ALERT_REQ_MASK;
352	sdbt++;	352	sdbt++;
353	mutex_unlock(&hws_sem_oom);	353	mutex_unlock(&hws_sem_oom);
354	}	354	}
355	tail = sdbt;	355	tail = sdbt;
356	}	356	}
357	mutex_lock(&hws_sem_oom);	357	mutex_lock(&hws_sem_oom);
358	if (oom_killer_was_active)	358	if (oom_killer_was_active)
359	goto allocate_sdbt_error;	359	goto allocate_sdbt_error;
360		360
361	rc = 0;	361	rc = 0;
362	if (tail)	362	if (tail)
363	*tail = (unsigned long)	363	*tail = (unsigned long)
364	((void *)cb->first_sdbt) + 1;	364	((void *)cb->first_sdbt) + 1;
365		365
366	allocate_sdbt_exit:	366	allocate_sdbt_exit:
367	mutex_unlock(&hws_sem_oom);	367	mutex_unlock(&hws_sem_oom);
368	return rc;	368	return rc;
369		369
370	allocate_sdbt_error:	370	allocate_sdbt_error:
371	rc = -ENOMEM;	371	rc = -ENOMEM;
372	goto allocate_sdbt_exit;	372	goto allocate_sdbt_exit;
373	}	373	}
374		374
375	/*	375	/*
376	* deallocate_sdbt() - deallocate all sampler memory	376	* deallocate_sdbt() - deallocate all sampler memory
377	*	377	*
378	* For each online CPU all SDBT trees are deallocated.	378	* For each online CPU all SDBT trees are deallocated.
379	* Returns the number of freed pages.	379	* Returns the number of freed pages.
380	*/	380	*/
381	static int deallocate_sdbt(void)	381	static int deallocate_sdbt(void)
382	{	382	{
383	int cpu;	383	int cpu;
384	int counter;	384	int counter;
385		385
386	counter = 0;	386	counter = 0;
387		387
388	for_each_online_cpu(cpu) {	388	for_each_online_cpu(cpu) {
389	unsigned long start;	389	unsigned long start;
390	unsigned long sdbt;	390	unsigned long sdbt;
391	unsigned long *curr;	391	unsigned long *curr;
392	struct hws_cpu_buffer *cb;	392	struct hws_cpu_buffer *cb;
393		393
394	cb = &per_cpu(sampler_cpu_buffer, cpu);	394	cb = &per_cpu(sampler_cpu_buffer, cpu);
395		395
396	if (!cb->first_sdbt)	396	if (!cb->first_sdbt)
397	continue;	397	continue;
398		398
399	sdbt = cb->first_sdbt;	399	sdbt = cb->first_sdbt;
400	curr = (unsigned long *) sdbt;	400	curr = (unsigned long *) sdbt;
401	start = sdbt;	401	start = sdbt;
402		402
403	/* we'll free the SDBT after all SDBs are processed... */	403	/* we'll free the SDBT after all SDBs are processed... */
404	while (1) {	404	while (1) {
405	if (!*curr \|\| !sdbt)	405	if (!*curr \|\| !sdbt)
406	break;	406	break;
407		407
408	/* watch for link entry reset if found */	408	/* watch for link entry reset if found */
409	if (is_link_entry(curr)) {	409	if (is_link_entry(curr)) {
410	curr = get_next_sdbt(curr);	410	curr = get_next_sdbt(curr);
411	if (sdbt)	411	if (sdbt)
412	free_page(sdbt);	412	free_page(sdbt);
413		413
414	/* we are done if we reach the start */	414	/* we are done if we reach the start */
415	if ((unsigned long) curr == start)	415	if ((unsigned long) curr == start)
416	break;	416	break;
417	else	417	else
418	sdbt = (unsigned long) curr;	418	sdbt = (unsigned long) curr;
419	} else {	419	} else {
420	/* process SDB pointer */	420	/* process SDB pointer */
421	if (*curr) {	421	if (*curr) {
422	free_page(*curr);	422	free_page(*curr);
423	curr++;	423	curr++;
424	}	424	}
425	}	425	}
426	counter++;	426	counter++;
427	}	427	}
428	cb->first_sdbt = 0;	428	cb->first_sdbt = 0;
429	}	429	}
430	return counter;	430	return counter;
431	}	431	}
432		432
433	static int start_sampling(int cpu)	433	static int start_sampling(int cpu)
434	{	434	{
435	int rc;	435	int rc;
436	struct hws_cpu_buffer *cb;	436	struct hws_cpu_buffer *cb;
437		437
438	cb = &per_cpu(sampler_cpu_buffer, cpu);	438	cb = &per_cpu(sampler_cpu_buffer, cpu);
439	rc = smp_ctl_ssctl_enable_activate(cpu, interval);	439	rc = smp_ctl_ssctl_enable_activate(cpu, interval);
440	if (rc) {	440	if (rc) {
441	printk(KERN_INFO "hwsampler: CPU %d ssctl failed.\n", cpu);	441	printk(KERN_INFO "hwsampler: CPU %d ssctl failed.\n", cpu);
442	goto start_exit;	442	goto start_exit;
443	}	443	}
444		444
445	rc = -EINVAL;	445	rc = -EINVAL;
446	if (!cb->qsi.es) {	446	if (!cb->qsi.es) {
447	printk(KERN_INFO "hwsampler: CPU %d ssctl not enabled.\n", cpu);	447	printk(KERN_INFO "hwsampler: CPU %d ssctl not enabled.\n", cpu);
448	goto start_exit;	448	goto start_exit;
449	}	449	}
450		450
451	if (!cb->qsi.cs) {	451	if (!cb->qsi.cs) {
452	printk(KERN_INFO "hwsampler: CPU %d ssctl not active.\n", cpu);	452	printk(KERN_INFO "hwsampler: CPU %d ssctl not active.\n", cpu);
453	goto start_exit;	453	goto start_exit;
454	}	454	}
455		455
456	printk(KERN_INFO	456	printk(KERN_INFO
457	"hwsampler: CPU %d, CPUMF Sampling started, interval %lu.\n",	457	"hwsampler: CPU %d, CPUMF Sampling started, interval %lu.\n",
458	cpu, interval);	458	cpu, interval);
459		459
460	rc = 0;	460	rc = 0;
461		461
462	start_exit:	462	start_exit:
463	return rc;	463	return rc;
464	}	464	}
465		465
466	static int stop_sampling(int cpu)	466	static int stop_sampling(int cpu)
467	{	467	{
468	unsigned long v;	468	unsigned long v;
469	int rc;	469	int rc;
470	struct hws_cpu_buffer *cb;	470	struct hws_cpu_buffer *cb;
471		471
472	rc = smp_ctl_qsi(cpu);	472	rc = smp_ctl_qsi(cpu);
473	WARN_ON(rc);	473	WARN_ON(rc);
474		474
475	cb = &per_cpu(sampler_cpu_buffer, cpu);	475	cb = &per_cpu(sampler_cpu_buffer, cpu);
476	if (!rc && !cb->qsi.es)	476	if (!rc && !cb->qsi.es)
477	printk(KERN_INFO "hwsampler: CPU %d, already stopped.\n", cpu);	477	printk(KERN_INFO "hwsampler: CPU %d, already stopped.\n", cpu);
478		478
479	rc = smp_ctl_ssctl_stop(cpu);	479	rc = smp_ctl_ssctl_stop(cpu);
480	if (rc) {	480	if (rc) {
481	printk(KERN_INFO "hwsampler: CPU %d, ssctl stop error %d.\n",	481	printk(KERN_INFO "hwsampler: CPU %d, ssctl stop error %d.\n",
482	cpu, rc);	482	cpu, rc);
483	goto stop_exit;	483	goto stop_exit;
484	}	484	}
485		485
486	printk(KERN_INFO "hwsampler: CPU %d, CPUMF Sampling stopped.\n", cpu);	486	printk(KERN_INFO "hwsampler: CPU %d, CPUMF Sampling stopped.\n", cpu);
487		487
488	stop_exit:	488	stop_exit:
489	v = cb->req_alert;	489	v = cb->req_alert;
490	if (v)	490	if (v)
491	printk(KERN_ERR "hwsampler: CPU %d CPUMF Request alert,"	491	printk(KERN_ERR "hwsampler: CPU %d CPUMF Request alert,"
492	" count=%lu.\n", cpu, v);	492	" count=%lu.\n", cpu, v);
493		493
494	v = cb->loss_of_sample_data;	494	v = cb->loss_of_sample_data;
495	if (v)	495	if (v)
496	printk(KERN_ERR "hwsampler: CPU %d CPUMF Loss of sample data,"	496	printk(KERN_ERR "hwsampler: CPU %d CPUMF Loss of sample data,"
497	" count=%lu.\n", cpu, v);	497	" count=%lu.\n", cpu, v);
498		498
499	v = cb->invalid_entry_address;	499	v = cb->invalid_entry_address;
500	if (v)	500	if (v)
501	printk(KERN_ERR "hwsampler: CPU %d CPUMF Invalid entry address,"	501	printk(KERN_ERR "hwsampler: CPU %d CPUMF Invalid entry address,"
502	" count=%lu.\n", cpu, v);	502	" count=%lu.\n", cpu, v);
503		503
504	v = cb->incorrect_sdbt_entry;	504	v = cb->incorrect_sdbt_entry;
505	if (v)	505	if (v)
506	printk(KERN_ERR	506	printk(KERN_ERR
507	"hwsampler: CPU %d CPUMF Incorrect SDBT address,"	507	"hwsampler: CPU %d CPUMF Incorrect SDBT address,"
508	" count=%lu.\n", cpu, v);	508	" count=%lu.\n", cpu, v);
509		509
510	v = cb->sample_auth_change_alert;	510	v = cb->sample_auth_change_alert;
511	if (v)	511	if (v)
512	printk(KERN_ERR	512	printk(KERN_ERR
513	"hwsampler: CPU %d CPUMF Sample authorization change,"	513	"hwsampler: CPU %d CPUMF Sample authorization change,"
514	" count=%lu.\n", cpu, v);	514	" count=%lu.\n", cpu, v);
515		515
516	return rc;	516	return rc;
517	}	517	}
518		518
519	static int check_hardware_prerequisites(void)	519	static int check_hardware_prerequisites(void)
520	{	520	{
521	if (!test_facility(68))	521	if (!test_facility(68))
522	return -EOPNOTSUPP;	522	return -EOPNOTSUPP;
523	return 0;	523	return 0;
524	}	524	}
525	/*	525	/*
526	* hws_oom_callback() - the OOM callback function	526	* hws_oom_callback() - the OOM callback function
527	*	527	*
528	* In case the callback is invoked during memory allocation for the	528	* In case the callback is invoked during memory allocation for the
529	* hw sampler, all obtained memory is deallocated and a flag is set	529	* hw sampler, all obtained memory is deallocated and a flag is set
530	* so main sampler memory allocation can exit with a failure code.	530	* so main sampler memory allocation can exit with a failure code.
531	* In case the callback is invoked during sampling the hw sampler	531	* In case the callback is invoked during sampling the hw sampler
532	* is deactivated for all CPUs.	532	* is deactivated for all CPUs.
533	*/	533	*/
534	static int hws_oom_callback(struct notifier_block *nfb,	534	static int hws_oom_callback(struct notifier_block *nfb,
535	unsigned long dummy, void *parm)	535	unsigned long dummy, void *parm)
536	{	536	{
537	unsigned long *freed;	537	unsigned long *freed;
538	int cpu;	538	int cpu;
539	struct hws_cpu_buffer *cb;	539	struct hws_cpu_buffer *cb;
540		540
541	freed = parm;	541	freed = parm;
542		542
543	mutex_lock(&hws_sem_oom);	543	mutex_lock(&hws_sem_oom);
544		544
545	if (hws_state == HWS_DEALLOCATED) {	545	if (hws_state == HWS_DEALLOCATED) {
546	/* during memory allocation */	546	/* during memory allocation */
547	if (oom_killer_was_active == 0) {	547	if (oom_killer_was_active == 0) {
548	oom_killer_was_active = 1;	548	oom_killer_was_active = 1;
549	*freed += deallocate_sdbt();	549	*freed += deallocate_sdbt();
550	}	550	}
551	} else {	551	} else {
552	int i;	552	int i;
553	cpu = get_cpu();	553	cpu = get_cpu();
554	cb = &per_cpu(sampler_cpu_buffer, cpu);	554	cb = &per_cpu(sampler_cpu_buffer, cpu);
555		555
556	if (!cb->oom) {	556	if (!cb->oom) {
557	for_each_online_cpu(i) {	557	for_each_online_cpu(i) {
558	smp_ctl_ssctl_deactivate(i);	558	smp_ctl_ssctl_deactivate(i);
559	cb->oom = 1;	559	cb->oom = 1;
560	}	560	}
561	cb->finish = 1;	561	cb->finish = 1;
562		562
563	printk(KERN_INFO	563	printk(KERN_INFO
564	"hwsampler: CPU %d, OOM notify during CPUMF Sampling.\n",	564	"hwsampler: CPU %d, OOM notify during CPUMF Sampling.\n",
565	cpu);	565	cpu);
566	}	566	}
567	}	567	}
568		568
569	mutex_unlock(&hws_sem_oom);	569	mutex_unlock(&hws_sem_oom);
570		570
571	return NOTIFY_OK;	571	return NOTIFY_OK;
572	}	572	}
573		573
574	static struct notifier_block hws_oom_notifier = {	574	static struct notifier_block hws_oom_notifier = {
575	.notifier_call = hws_oom_callback	575	.notifier_call = hws_oom_callback
576	};	576	};
577		577
578	static int hws_cpu_callback(struct notifier_block *nfb,	578	static int hws_cpu_callback(struct notifier_block *nfb,
579	unsigned long action, void *hcpu)	579	unsigned long action, void *hcpu)
580	{	580	{
581	/* We do not have sampler space available for all possible CPUs.	581	/* We do not have sampler space available for all possible CPUs.
582	All CPUs should be online when hw sampling is activated. */	582	All CPUs should be online when hw sampling is activated. */
583	return NOTIFY_BAD;	583	return NOTIFY_BAD;
584	}	584	}
585		585
586	static struct notifier_block hws_cpu_notifier = {	586	static struct notifier_block hws_cpu_notifier = {
587	.notifier_call = hws_cpu_callback	587	.notifier_call = hws_cpu_callback
588	};	588	};
589		589
590	/**	590	/**
591	* hwsampler_deactivate() - set hardware sampling temporarily inactive	591	* hwsampler_deactivate() - set hardware sampling temporarily inactive
592	* @cpu: specifies the CPU to be set inactive.	592	* @cpu: specifies the CPU to be set inactive.
593	*	593	*
594	* Returns 0 on success, !0 on failure.	594	* Returns 0 on success, !0 on failure.
595	*/	595	*/
596	int hwsampler_deactivate(unsigned int cpu)	596	int hwsampler_deactivate(unsigned int cpu)
597	{	597	{
598	/*	598	/*
599	* Deactivate hw sampling temporarily and flush the buffer	599	* Deactivate hw sampling temporarily and flush the buffer
600	* by pushing all the pending samples to oprofile buffer.	600	* by pushing all the pending samples to oprofile buffer.
601	*	601	*
602	* This function can be called under one of the following conditions:	602	* This function can be called under one of the following conditions:
603	* Memory unmap, task is exiting.	603	* Memory unmap, task is exiting.
604	*/	604	*/
605	int rc;	605	int rc;
606	struct hws_cpu_buffer *cb;	606	struct hws_cpu_buffer *cb;
607		607
608	rc = 0;	608	rc = 0;
609	mutex_lock(&hws_sem);	609	mutex_lock(&hws_sem);
610		610
611	cb = &per_cpu(sampler_cpu_buffer, cpu);	611	cb = &per_cpu(sampler_cpu_buffer, cpu);
612	if (hws_state == HWS_STARTED) {	612	if (hws_state == HWS_STARTED) {
613	rc = smp_ctl_qsi(cpu);	613	rc = smp_ctl_qsi(cpu);
614	WARN_ON(rc);	614	WARN_ON(rc);
615	if (cb->qsi.cs) {	615	if (cb->qsi.cs) {
616	rc = smp_ctl_ssctl_deactivate(cpu);	616	rc = smp_ctl_ssctl_deactivate(cpu);
617	if (rc) {	617	if (rc) {
618	printk(KERN_INFO	618	printk(KERN_INFO
619	"hwsampler: CPU %d, CPUMF Deactivation failed.\n", cpu);	619	"hwsampler: CPU %d, CPUMF Deactivation failed.\n", cpu);
620	cb->finish = 1;	620	cb->finish = 1;
621	hws_state = HWS_STOPPING;	621	hws_state = HWS_STOPPING;
622	} else {	622	} else {
623	hws_flush_all = 1;	623	hws_flush_all = 1;
624	/* Add work to queue to read pending samples.*/	624	/* Add work to queue to read pending samples.*/
625	queue_work_on(cpu, hws_wq, &cb->worker);	625	queue_work_on(cpu, hws_wq, &cb->worker);
626	}	626	}
627	}	627	}
628	}	628	}
629	mutex_unlock(&hws_sem);	629	mutex_unlock(&hws_sem);
630		630
631	if (hws_wq)	631	if (hws_wq)
632	flush_workqueue(hws_wq);	632	flush_workqueue(hws_wq);
633		633
634	return rc;	634	return rc;
635	}	635	}
636		636
637	/**	637	/**
638	* hwsampler_activate() - activate/resume hardware sampling which was deactivated	638	* hwsampler_activate() - activate/resume hardware sampling which was deactivated
639	* @cpu: specifies the CPU to be set active.	639	* @cpu: specifies the CPU to be set active.
640	*	640	*
641	* Returns 0 on success, !0 on failure.	641	* Returns 0 on success, !0 on failure.
642	*/	642	*/
643	int hwsampler_activate(unsigned int cpu)	643	int hwsampler_activate(unsigned int cpu)
644	{	644	{
645	/*	645	/*
646	* Re-activate hw sampling. This should be called in pair with	646	* Re-activate hw sampling. This should be called in pair with
647	* hwsampler_deactivate().	647	* hwsampler_deactivate().
648	*/	648	*/
649	int rc;	649	int rc;
650	struct hws_cpu_buffer *cb;	650	struct hws_cpu_buffer *cb;
651		651
652	rc = 0;	652	rc = 0;
653	mutex_lock(&hws_sem);	653	mutex_lock(&hws_sem);
654		654
655	cb = &per_cpu(sampler_cpu_buffer, cpu);	655	cb = &per_cpu(sampler_cpu_buffer, cpu);
656	if (hws_state == HWS_STARTED) {	656	if (hws_state == HWS_STARTED) {
657	rc = smp_ctl_qsi(cpu);	657	rc = smp_ctl_qsi(cpu);
658	WARN_ON(rc);	658	WARN_ON(rc);
659	if (!cb->qsi.cs) {	659	if (!cb->qsi.cs) {
660	hws_flush_all = 0;	660	hws_flush_all = 0;
661	rc = smp_ctl_ssctl_enable_activate(cpu, interval);	661	rc = smp_ctl_ssctl_enable_activate(cpu, interval);
662	if (rc) {	662	if (rc) {
663	printk(KERN_ERR	663	printk(KERN_ERR
664	"CPU %d, CPUMF activate sampling failed.\n",	664	"CPU %d, CPUMF activate sampling failed.\n",
665	cpu);	665	cpu);
666	}	666	}
667	}	667	}
668	}	668	}
669		669
670	mutex_unlock(&hws_sem);	670	mutex_unlock(&hws_sem);
671		671
672	return rc;	672	return rc;
673	}	673	}
674		674
675	static void hws_ext_handler(unsigned int ext_int_code,	675	static void hws_ext_handler(unsigned int ext_int_code,
676	unsigned int param32, unsigned long param64)	676	unsigned int param32, unsigned long param64)
677	{	677	{
678	struct hws_cpu_buffer *cb;	678	struct hws_cpu_buffer *cb;
679		679
680	kstat_cpu(smp_processor_id()).irqs[EXTINT_CPM]++;	680	kstat_cpu(smp_processor_id()).irqs[EXTINT_CPM]++;
681	cb = &__get_cpu_var(sampler_cpu_buffer);	681	cb = &__get_cpu_var(sampler_cpu_buffer);
682	atomic_xchg(&cb->ext_params, atomic_read(&cb->ext_params) \| param32);	682	atomic_xchg(&cb->ext_params, atomic_read(&cb->ext_params) \| param32);
683	if (hws_wq)	683	if (hws_wq)
684	queue_work(hws_wq, &cb->worker);	684	queue_work(hws_wq, &cb->worker);
685	}	685	}
686		686
687	static int check_qsi_on_setup(void)	687	static int check_qsi_on_setup(void)
688	{	688	{
689	int rc;	689	int rc;
690	unsigned int cpu;	690	unsigned int cpu;
691	struct hws_cpu_buffer *cb;	691	struct hws_cpu_buffer *cb;
692		692
693	for_each_online_cpu(cpu) {	693	for_each_online_cpu(cpu) {
694	cb = &per_cpu(sampler_cpu_buffer, cpu);	694	cb = &per_cpu(sampler_cpu_buffer, cpu);
695	rc = smp_ctl_qsi(cpu);	695	rc = smp_ctl_qsi(cpu);
696	WARN_ON(rc);	696	WARN_ON(rc);
697	if (rc)	697	if (rc)
698	return -EOPNOTSUPP;	698	return -EOPNOTSUPP;
699		699
700	if (!cb->qsi.as) {	700	if (!cb->qsi.as) {
701	printk(KERN_INFO "hwsampler: CPUMF sampling is not authorized.\n");	701	printk(KERN_INFO "hwsampler: CPUMF sampling is not authorized.\n");
702	return -EINVAL;	702	return -EINVAL;
703	}	703	}
704		704
705	if (cb->qsi.es) {	705	if (cb->qsi.es) {
706	printk(KERN_WARNING "hwsampler: CPUMF is still enabled.\n");	706	printk(KERN_WARNING "hwsampler: CPUMF is still enabled.\n");
707	rc = smp_ctl_ssctl_stop(cpu);	707	rc = smp_ctl_ssctl_stop(cpu);
708	if (rc)	708	if (rc)
709	return -EINVAL;	709	return -EINVAL;
710		710
711	printk(KERN_INFO	711	printk(KERN_INFO
712	"CPU %d, CPUMF Sampling stopped now.\n", cpu);	712	"CPU %d, CPUMF Sampling stopped now.\n", cpu);
713	}	713	}
714	}	714	}
715	return 0;	715	return 0;
716	}	716	}
717		717
718	static int check_qsi_on_start(void)	718	static int check_qsi_on_start(void)
719	{	719	{
720	unsigned int cpu;	720	unsigned int cpu;
721	int rc;	721	int rc;
722	struct hws_cpu_buffer *cb;	722	struct hws_cpu_buffer *cb;
723		723
724	for_each_online_cpu(cpu) {	724	for_each_online_cpu(cpu) {
725	cb = &per_cpu(sampler_cpu_buffer, cpu);	725	cb = &per_cpu(sampler_cpu_buffer, cpu);
726	rc = smp_ctl_qsi(cpu);	726	rc = smp_ctl_qsi(cpu);
727	WARN_ON(rc);	727	WARN_ON(rc);
728		728
729	if (!cb->qsi.as)	729	if (!cb->qsi.as)
730	return -EINVAL;	730	return -EINVAL;
731		731
732	if (cb->qsi.es)	732	if (cb->qsi.es)
733	return -EINVAL;	733	return -EINVAL;
734		734
735	if (cb->qsi.cs)	735	if (cb->qsi.cs)
736	return -EINVAL;	736	return -EINVAL;
737	}	737	}
738	return 0;	738	return 0;
739	}	739	}
740		740
741	static void worker_on_start(unsigned int cpu)	741	static void worker_on_start(unsigned int cpu)
742	{	742	{
743	struct hws_cpu_buffer *cb;	743	struct hws_cpu_buffer *cb;
744		744
745	cb = &per_cpu(sampler_cpu_buffer, cpu);	745	cb = &per_cpu(sampler_cpu_buffer, cpu);
746	cb->worker_entry = cb->first_sdbt;	746	cb->worker_entry = cb->first_sdbt;
747	}	747	}
748		748
749	static int worker_check_error(unsigned int cpu, int ext_params)	749	static int worker_check_error(unsigned int cpu, int ext_params)
750	{	750	{
751	int rc;	751	int rc;
752	unsigned long *sdbt;	752	unsigned long *sdbt;
753	struct hws_cpu_buffer *cb;	753	struct hws_cpu_buffer *cb;
754		754
755	rc = 0;	755	rc = 0;
756	cb = &per_cpu(sampler_cpu_buffer, cpu);	756	cb = &per_cpu(sampler_cpu_buffer, cpu);
757	sdbt = (unsigned long *) cb->worker_entry;	757	sdbt = (unsigned long *) cb->worker_entry;
758		758
759	if (!sdbt \|\| !*sdbt)	759	if (!sdbt \|\| !*sdbt)
760	return -EINVAL;	760	return -EINVAL;
761		761
762	if (ext_params & EI_PRA)	762	if (ext_params & EI_PRA)
763	cb->req_alert++;	763	cb->req_alert++;
764		764
765	if (ext_params & EI_LSDA)	765	if (ext_params & EI_LSDA)
766	cb->loss_of_sample_data++;	766	cb->loss_of_sample_data++;
767		767
768	if (ext_params & EI_IEA) {	768	if (ext_params & EI_IEA) {
769	cb->invalid_entry_address++;	769	cb->invalid_entry_address++;
770	rc = -EINVAL;	770	rc = -EINVAL;
771	}	771	}
772		772
773	if (ext_params & EI_ISE) {	773	if (ext_params & EI_ISE) {
774	cb->incorrect_sdbt_entry++;	774	cb->incorrect_sdbt_entry++;
775	rc = -EINVAL;	775	rc = -EINVAL;
776	}	776	}
777		777
778	if (ext_params & EI_SACA) {	778	if (ext_params & EI_SACA) {
779	cb->sample_auth_change_alert++;	779	cb->sample_auth_change_alert++;
780	rc = -EINVAL;	780	rc = -EINVAL;
781	}	781	}
782		782
783	return rc;	783	return rc;
784	}	784	}
785		785
786	static void worker_on_finish(unsigned int cpu)	786	static void worker_on_finish(unsigned int cpu)
787	{	787	{
788	int rc, i;	788	int rc, i;
789	struct hws_cpu_buffer *cb;	789	struct hws_cpu_buffer *cb;
790		790
791	cb = &per_cpu(sampler_cpu_buffer, cpu);	791	cb = &per_cpu(sampler_cpu_buffer, cpu);
792		792
793	if (cb->finish) {	793	if (cb->finish) {
794	rc = smp_ctl_qsi(cpu);	794	rc = smp_ctl_qsi(cpu);
795	WARN_ON(rc);	795	WARN_ON(rc);
796	if (cb->qsi.es) {	796	if (cb->qsi.es) {
797	printk(KERN_INFO	797	printk(KERN_INFO
798	"hwsampler: CPU %d, CPUMF Stop/Deactivate sampling.\n",	798	"hwsampler: CPU %d, CPUMF Stop/Deactivate sampling.\n",
799	cpu);	799	cpu);
800	rc = smp_ctl_ssctl_stop(cpu);	800	rc = smp_ctl_ssctl_stop(cpu);
801	if (rc)	801	if (rc)
802	printk(KERN_INFO	802	printk(KERN_INFO
803	"hwsampler: CPU %d, CPUMF Deactivation failed.\n",	803	"hwsampler: CPU %d, CPUMF Deactivation failed.\n",
804	cpu);	804	cpu);
805		805
806	for_each_online_cpu(i) {	806	for_each_online_cpu(i) {
807	if (i == cpu)	807	if (i == cpu)
808	continue;	808	continue;
809	if (!cb->finish) {	809	if (!cb->finish) {
810	cb->finish = 1;	810	cb->finish = 1;
811	queue_work_on(i, hws_wq,	811	queue_work_on(i, hws_wq,
812	&cb->worker);	812	&cb->worker);
813	}	813	}
814	}	814	}
815	}	815	}
816	}	816	}
817	}	817	}
818		818
819	static void worker_on_interrupt(unsigned int cpu)	819	static void worker_on_interrupt(unsigned int cpu)
820	{	820	{
821	unsigned long *sdbt;	821	unsigned long *sdbt;
822	unsigned char done;	822	unsigned char done;
823	struct hws_cpu_buffer *cb;	823	struct hws_cpu_buffer *cb;
824		824
825	cb = &per_cpu(sampler_cpu_buffer, cpu);	825	cb = &per_cpu(sampler_cpu_buffer, cpu);
826		826
827	sdbt = (unsigned long *) cb->worker_entry;	827	sdbt = (unsigned long *) cb->worker_entry;
828		828
829	done = 0;	829	done = 0;
830	/* do not proceed if stop was entered,	830	/* do not proceed if stop was entered,
831	* forget the buffers not yet processed */	831	* forget the buffers not yet processed */
832	while (!done && !cb->stop_mode) {	832	while (!done && !cb->stop_mode) {
833	unsigned long *trailer;	833	unsigned long *trailer;
834	struct hws_trailer_entry *te;	834	struct hws_trailer_entry *te;
835	unsigned long *dear = 0;	835	unsigned long *dear = 0;
836		836
837	trailer = trailer_entry_ptr(*sdbt);	837	trailer = trailer_entry_ptr(*sdbt);
838	/* leave loop if no more work to do */	838	/* leave loop if no more work to do */
839	if (!(*trailer & BUFFER_FULL_MASK)) {	839	if (!(*trailer & BUFFER_FULL_MASK)) {
840	done = 1;	840	done = 1;
841	if (!hws_flush_all)	841	if (!hws_flush_all)
842	continue;	842	continue;
843	}	843	}
844		844
845	te = (struct hws_trailer_entry *)trailer;	845	te = (struct hws_trailer_entry *)trailer;
846	cb->sample_overflow += te->overflow;	846	cb->sample_overflow += te->overflow;
847		847
848	add_samples_to_oprofile(cpu, sdbt, dear);	848	add_samples_to_oprofile(cpu, sdbt, dear);
849		849
850	/* reset trailer */	850	/* reset trailer */
851	xchg((unsigned char *) te, 0x40);	851	xchg((unsigned char *) te, 0x40);
852		852
853	/* advance to next sdb slot in current sdbt */	853	/* advance to next sdb slot in current sdbt */
854	sdbt++;	854	sdbt++;
855	/* in case link bit is set use address w/o link bit */	855	/* in case link bit is set use address w/o link bit */
856	if (is_link_entry(sdbt))	856	if (is_link_entry(sdbt))
857	sdbt = get_next_sdbt(sdbt);	857	sdbt = get_next_sdbt(sdbt);
858		858
859	cb->worker_entry = (unsigned long)sdbt;	859	cb->worker_entry = (unsigned long)sdbt;
860	}	860	}
861	}	861	}
862		862
863	static void add_samples_to_oprofile(unsigned int cpu, unsigned long *sdbt,	863	static void add_samples_to_oprofile(unsigned int cpu, unsigned long *sdbt,
864	unsigned long *dear)	864	unsigned long *dear)
865	{	865	{
866	struct hws_data_entry *sample_data_ptr;	866	struct hws_data_entry *sample_data_ptr;
867	unsigned long *trailer;	867	unsigned long *trailer;
868		868
869	trailer = trailer_entry_ptr(*sdbt);	869	trailer = trailer_entry_ptr(*sdbt);
870	if (dear) {	870	if (dear) {
871	if (dear > trailer)	871	if (dear > trailer)
872	return;	872	return;
873	trailer = dear;	873	trailer = dear;
874	}	874	}
875		875
876	sample_data_ptr = (struct hws_data_entry )(sdbt);	876	sample_data_ptr = (struct hws_data_entry )(sdbt);
877		877
878	while ((unsigned long *)sample_data_ptr < trailer) {	878	while ((unsigned long *)sample_data_ptr < trailer) {
879	struct pt_regs *regs = NULL;	879	struct pt_regs *regs = NULL;
880	struct task_struct *tsk = NULL;	880	struct task_struct *tsk = NULL;
881		881
882	/*	882	/*
883	* Check sampling mode, 1 indicates basic (=customer) sampling	883	* Check sampling mode, 1 indicates basic (=customer) sampling
884	* mode.	884	* mode.
885	*/	885	*/
886	if (sample_data_ptr->def != 1) {	886	if (sample_data_ptr->def != 1) {
887	/* sample slot is not yet written */	887	/* sample slot is not yet written */
888	break;	888	break;
889	} else {	889	} else {
890	/* make sure we don't use it twice,	890	/* make sure we don't use it twice,
891	* the next time the sampler will set it again */	891	* the next time the sampler will set it again */
892	sample_data_ptr->def = 0;	892	sample_data_ptr->def = 0;
893	}	893	}
894		894
895	/* Get pt_regs. */	895	/* Get pt_regs. */
896	if (sample_data_ptr->P == 1) {	896	if (sample_data_ptr->P == 1) {
897	/* userspace sample */	897	/* userspace sample */
898	unsigned int pid = sample_data_ptr->prim_asn;	898	unsigned int pid = sample_data_ptr->prim_asn;
899	rcu_read_lock();	899	rcu_read_lock();
900	tsk = pid_task(find_vpid(pid), PIDTYPE_PID);	900	tsk = pid_task(find_vpid(pid), PIDTYPE_PID);
901	if (tsk)	901	if (tsk)
902	regs = task_pt_regs(tsk);	902	regs = task_pt_regs(tsk);
903	rcu_read_unlock();	903	rcu_read_unlock();
904	} else {	904	} else {
905	/* kernelspace sample */	905	/* kernelspace sample */
906	regs = task_pt_regs(current);	906	regs = task_pt_regs(current);
907	}	907	}
908		908
909	mutex_lock(&hws_sem);	909	mutex_lock(&hws_sem);
910	oprofile_add_ext_hw_sample(sample_data_ptr->ia, regs, 0,	910	oprofile_add_ext_hw_sample(sample_data_ptr->ia, regs, 0,
911	!sample_data_ptr->P, tsk);	911	!sample_data_ptr->P, tsk);
912	mutex_unlock(&hws_sem);	912	mutex_unlock(&hws_sem);
913		913
914	sample_data_ptr++;	914	sample_data_ptr++;
915	}	915	}
916	}	916	}
917		917
918	static void worker(struct work_struct *work)	918	static void worker(struct work_struct *work)
919	{	919	{
920	unsigned int cpu;	920	unsigned int cpu;
921	int ext_params;	921	int ext_params;
922	struct hws_cpu_buffer *cb;	922	struct hws_cpu_buffer *cb;
923		923
924	cb = container_of(work, struct hws_cpu_buffer, worker);	924	cb = container_of(work, struct hws_cpu_buffer, worker);
925	cpu = smp_processor_id();	925	cpu = smp_processor_id();
926	ext_params = atomic_xchg(&cb->ext_params, 0);	926	ext_params = atomic_xchg(&cb->ext_params, 0);
927		927
928	if (!cb->worker_entry)	928	if (!cb->worker_entry)
929	worker_on_start(cpu);	929	worker_on_start(cpu);
930		930
931	if (worker_check_error(cpu, ext_params))	931	if (worker_check_error(cpu, ext_params))
932	return;	932	return;
933		933
934	if (!cb->finish)	934	if (!cb->finish)
935	worker_on_interrupt(cpu);	935	worker_on_interrupt(cpu);
936		936
937	if (cb->finish)	937	if (cb->finish)
938	worker_on_finish(cpu);	938	worker_on_finish(cpu);
939	}	939	}
940		940
941	/**	941	/**
942	* hwsampler_allocate() - allocate memory for the hardware sampler	942	* hwsampler_allocate() - allocate memory for the hardware sampler
943	* @sdbt: number of SDBTs per online CPU (must be > 0)	943	* @sdbt: number of SDBTs per online CPU (must be > 0)
944	* @sdb: number of SDBs per SDBT (minimum 1, maximum 511)	944	* @sdb: number of SDBs per SDBT (minimum 1, maximum 511)
945	*	945	*
946	* Returns 0 on success, !0 on failure.	946	* Returns 0 on success, !0 on failure.
947	*/	947	*/
948	int hwsampler_allocate(unsigned long sdbt, unsigned long sdb)	948	int hwsampler_allocate(unsigned long sdbt, unsigned long sdb)
949	{	949	{
950	int cpu, rc;	950	int cpu, rc;
951	mutex_lock(&hws_sem);	951	mutex_lock(&hws_sem);
952		952
953	rc = -EINVAL;	953	rc = -EINVAL;
954	if (hws_state != HWS_DEALLOCATED)	954	if (hws_state != HWS_DEALLOCATED)
955	goto allocate_exit;	955	goto allocate_exit;
956		956
957	if (sdbt < 1)	957	if (sdbt < 1)
958	goto allocate_exit;	958	goto allocate_exit;
959		959
960	if (sdb > MAX_NUM_SDB \|\| sdb < MIN_NUM_SDB)	960	if (sdb > MAX_NUM_SDB \|\| sdb < MIN_NUM_SDB)
961	goto allocate_exit;	961	goto allocate_exit;
962		962
963	num_sdbt = sdbt;	963	num_sdbt = sdbt;
964	num_sdb = sdb;	964	num_sdb = sdb;
965		965
966	oom_killer_was_active = 0;	966	oom_killer_was_active = 0;
967	register_oom_notifier(&hws_oom_notifier);	967	register_oom_notifier(&hws_oom_notifier);
968		968
969	for_each_online_cpu(cpu) {	969	for_each_online_cpu(cpu) {
970	if (allocate_sdbt(cpu)) {	970	if (allocate_sdbt(cpu)) {
971	unregister_oom_notifier(&hws_oom_notifier);	971	unregister_oom_notifier(&hws_oom_notifier);
972	goto allocate_error;	972	goto allocate_error;
973	}	973	}
974	}	974	}
975	unregister_oom_notifier(&hws_oom_notifier);	975	unregister_oom_notifier(&hws_oom_notifier);
976	if (oom_killer_was_active)	976	if (oom_killer_was_active)
977	goto allocate_error;	977	goto allocate_error;
978		978
979	hws_state = HWS_STOPPED;	979	hws_state = HWS_STOPPED;
980	rc = 0;	980	rc = 0;
981		981
982	allocate_exit:	982	allocate_exit:
983	mutex_unlock(&hws_sem);	983	mutex_unlock(&hws_sem);
984	return rc;	984	return rc;
985		985
986	allocate_error:	986	allocate_error:
987	rc = -ENOMEM;	987	rc = -ENOMEM;
988	printk(KERN_ERR "hwsampler: CPUMF Memory allocation failed.\n");	988	printk(KERN_ERR "hwsampler: CPUMF Memory allocation failed.\n");
989	goto allocate_exit;	989	goto allocate_exit;
990	}	990	}
991		991
992	/**	992	/**
993	* hwsampler_deallocate() - deallocate hardware sampler memory	993	* hwsampler_deallocate() - deallocate hardware sampler memory
994	*	994	*
995	* Returns 0 on success, !0 on failure.	995	* Returns 0 on success, !0 on failure.
996	*/	996	*/
997	int hwsampler_deallocate()	997	int hwsampler_deallocate()
998	{	998	{
999	int rc;	999	int rc;
1000		1000
1001	mutex_lock(&hws_sem);	1001	mutex_lock(&hws_sem);
1002		1002
1003	rc = -EINVAL;	1003	rc = -EINVAL;
1004	if (hws_state != HWS_STOPPED)	1004	if (hws_state != HWS_STOPPED)
1005	goto deallocate_exit;	1005	goto deallocate_exit;
1006		1006
1007	ctl_clear_bit(0, 5); /* set bit 58 CR0 off */	1007	ctl_clear_bit(0, 5); /* set bit 58 CR0 off */
1008	deallocate_sdbt();	1008	deallocate_sdbt();
1009		1009
1010	hws_state = HWS_DEALLOCATED;	1010	hws_state = HWS_DEALLOCATED;
1011	rc = 0;	1011	rc = 0;
1012		1012
1013	deallocate_exit:	1013	deallocate_exit:
1014	mutex_unlock(&hws_sem);	1014	mutex_unlock(&hws_sem);
1015		1015
1016	return rc;	1016	return rc;
1017	}	1017	}
1018		1018
1019	unsigned long hwsampler_query_min_interval(void)	1019	unsigned long hwsampler_query_min_interval(void)
1020	{	1020	{
1021	return min_sampler_rate;	1021	return min_sampler_rate;
1022	}	1022	}
1023		1023
1024	unsigned long hwsampler_query_max_interval(void)	1024	unsigned long hwsampler_query_max_interval(void)
1025	{	1025	{
1026	return max_sampler_rate;	1026	return max_sampler_rate;
1027	}	1027	}
1028		1028
1029	unsigned long hwsampler_get_sample_overflow_count(unsigned int cpu)	1029	unsigned long hwsampler_get_sample_overflow_count(unsigned int cpu)
1030	{	1030	{
1031	struct hws_cpu_buffer *cb;	1031	struct hws_cpu_buffer *cb;
1032		1032
1033	cb = &per_cpu(sampler_cpu_buffer, cpu);	1033	cb = &per_cpu(sampler_cpu_buffer, cpu);
1034		1034
1035	return cb->sample_overflow;	1035	return cb->sample_overflow;
1036	}	1036	}
1037		1037
1038	int hwsampler_setup()	1038	int hwsampler_setup()
1039	{	1039	{
1040	int rc;	1040	int rc;
1041	int cpu;	1041	int cpu;
1042	struct hws_cpu_buffer *cb;	1042	struct hws_cpu_buffer *cb;
1043		1043
1044	mutex_lock(&hws_sem);	1044	mutex_lock(&hws_sem);
1045		1045
1046	rc = -EINVAL;	1046	rc = -EINVAL;
1047	if (hws_state)	1047	if (hws_state)
1048	goto setup_exit;	1048	goto setup_exit;
1049		1049
1050	hws_state = HWS_INIT;	1050	hws_state = HWS_INIT;
1051		1051
1052	init_all_cpu_buffers();	1052	init_all_cpu_buffers();
1053		1053
1054	rc = check_hardware_prerequisites();	1054	rc = check_hardware_prerequisites();
1055	if (rc)	1055	if (rc)
1056	goto setup_exit;	1056	goto setup_exit;
1057		1057
1058	rc = check_qsi_on_setup();	1058	rc = check_qsi_on_setup();
1059	if (rc)	1059	if (rc)
1060	goto setup_exit;	1060	goto setup_exit;
1061		1061
1062	rc = -EINVAL;	1062	rc = -EINVAL;
1063	hws_wq = create_workqueue("hwsampler");	1063	hws_wq = create_workqueue("hwsampler");
1064	if (!hws_wq)	1064	if (!hws_wq)
1065	goto setup_exit;	1065	goto setup_exit;
1066		1066
1067	register_cpu_notifier(&hws_cpu_notifier);	1067	register_cpu_notifier(&hws_cpu_notifier);
1068		1068
1069	for_each_online_cpu(cpu) {	1069	for_each_online_cpu(cpu) {
1070	cb = &per_cpu(sampler_cpu_buffer, cpu);	1070	cb = &per_cpu(sampler_cpu_buffer, cpu);
1071	INIT_WORK(&cb->worker, worker);	1071	INIT_WORK(&cb->worker, worker);
1072	rc = smp_ctl_qsi(cpu);	1072	rc = smp_ctl_qsi(cpu);
1073	WARN_ON(rc);	1073	WARN_ON(rc);
1074	if (min_sampler_rate != cb->qsi.min_sampl_rate) {	1074	if (min_sampler_rate != cb->qsi.min_sampl_rate) {
1075	if (min_sampler_rate) {	1075	if (min_sampler_rate) {
1076	printk(KERN_WARNING	1076	printk(KERN_WARNING
1077	"hwsampler: different min sampler rate values.\n");	1077	"hwsampler: different min sampler rate values.\n");
1078	if (min_sampler_rate < cb->qsi.min_sampl_rate)	1078	if (min_sampler_rate < cb->qsi.min_sampl_rate)
1079	min_sampler_rate =	1079	min_sampler_rate =
1080	cb->qsi.min_sampl_rate;	1080	cb->qsi.min_sampl_rate;
1081	} else	1081	} else
1082	min_sampler_rate = cb->qsi.min_sampl_rate;	1082	min_sampler_rate = cb->qsi.min_sampl_rate;
1083	}	1083	}
1084	if (max_sampler_rate != cb->qsi.max_sampl_rate) {	1084	if (max_sampler_rate != cb->qsi.max_sampl_rate) {
1085	if (max_sampler_rate) {	1085	if (max_sampler_rate) {
1086	printk(KERN_WARNING	1086	printk(KERN_WARNING
1087	"hwsampler: different max sampler rate values.\n");	1087	"hwsampler: different max sampler rate values.\n");
1088	if (max_sampler_rate > cb->qsi.max_sampl_rate)	1088	if (max_sampler_rate > cb->qsi.max_sampl_rate)
1089	max_sampler_rate =	1089	max_sampler_rate =
1090	cb->qsi.max_sampl_rate;	1090	cb->qsi.max_sampl_rate;
1091	} else	1091	} else
1092	max_sampler_rate = cb->qsi.max_sampl_rate;	1092	max_sampler_rate = cb->qsi.max_sampl_rate;
1093	}	1093	}
1094	}	1094	}
1095	register_external_interrupt(0x1407, hws_ext_handler);	1095	register_external_interrupt(0x1407, hws_ext_handler);
1096		1096
1097	hws_state = HWS_DEALLOCATED;	1097	hws_state = HWS_DEALLOCATED;
1098	rc = 0;	1098	rc = 0;
1099		1099
1100	setup_exit:	1100	setup_exit:
1101	mutex_unlock(&hws_sem);	1101	mutex_unlock(&hws_sem);
1102	return rc;	1102	return rc;
1103	}	1103	}
1104		1104
1105	int hwsampler_shutdown()	1105	int hwsampler_shutdown()
1106	{	1106	{
1107	int rc;	1107	int rc;
1108		1108
1109	mutex_lock(&hws_sem);	1109	mutex_lock(&hws_sem);
1110		1110
1111	rc = -EINVAL;	1111	rc = -EINVAL;
1112	if (hws_state == HWS_DEALLOCATED \|\| hws_state == HWS_STOPPED) {	1112	if (hws_state == HWS_DEALLOCATED \|\| hws_state == HWS_STOPPED) {
1113	mutex_unlock(&hws_sem);	1113	mutex_unlock(&hws_sem);
1114		1114
1115	if (hws_wq)	1115	if (hws_wq)
1116	flush_workqueue(hws_wq);	1116	flush_workqueue(hws_wq);
1117		1117
1118	mutex_lock(&hws_sem);	1118	mutex_lock(&hws_sem);
1119		1119
1120	if (hws_state == HWS_STOPPED) {	1120	if (hws_state == HWS_STOPPED) {
1121	ctl_clear_bit(0, 5); /* set bit 58 CR0 off */	1121	ctl_clear_bit(0, 5); /* set bit 58 CR0 off */
1122	deallocate_sdbt();	1122	deallocate_sdbt();
1123	}	1123	}
1124	if (hws_wq) {	1124	if (hws_wq) {
1125	destroy_workqueue(hws_wq);	1125	destroy_workqueue(hws_wq);
1126	hws_wq = NULL;	1126	hws_wq = NULL;
1127	}	1127	}
1128		1128
1129	unregister_external_interrupt(0x1407, hws_ext_handler);	1129	unregister_external_interrupt(0x1407, hws_ext_handler);
1130	hws_state = HWS_INIT;	1130	hws_state = HWS_INIT;
1131	rc = 0;	1131	rc = 0;
1132	}	1132	}
1133	mutex_unlock(&hws_sem);	1133	mutex_unlock(&hws_sem);
1134		1134
1135	unregister_cpu_notifier(&hws_cpu_notifier);	1135	unregister_cpu_notifier(&hws_cpu_notifier);
1136		1136
1137	return rc;	1137	return rc;
1138	}	1138	}
1139		1139
1140	/**	1140	/**
1141	* hwsampler_start_all() - start hardware sampling on all online CPUs	1141	* hwsampler_start_all() - start hardware sampling on all online CPUs
1142	* @rate: specifies the used interval when samples are taken	1142	* @rate: specifies the used interval when samples are taken
1143	*	1143	*
1144	* Returns 0 on success, !0 on failure.	1144	* Returns 0 on success, !0 on failure.
1145	*/	1145	*/
1146	int hwsampler_start_all(unsigned long rate)	1146	int hwsampler_start_all(unsigned long rate)
1147	{	1147	{
1148	int rc, cpu;	1148	int rc, cpu;
1149		1149
1150	mutex_lock(&hws_sem);	1150	mutex_lock(&hws_sem);
1151		1151
1152	hws_oom = 0;	1152	hws_oom = 0;
1153		1153
1154	rc = -EINVAL;	1154	rc = -EINVAL;
1155	if (hws_state != HWS_STOPPED)	1155	if (hws_state != HWS_STOPPED)
1156	goto start_all_exit;	1156	goto start_all_exit;
1157		1157
1158	interval = rate;	1158	interval = rate;
1159		1159
1160	/* fail if rate is not valid */	1160	/* fail if rate is not valid */
1161	if (interval < min_sampler_rate \|\| interval > max_sampler_rate)	1161	if (interval < min_sampler_rate \|\| interval > max_sampler_rate)
1162	goto start_all_exit;	1162	goto start_all_exit;
1163		1163
1164	rc = check_qsi_on_start();	1164	rc = check_qsi_on_start();
1165	if (rc)	1165	if (rc)
1166	goto start_all_exit;	1166	goto start_all_exit;
1167		1167
1168	rc = prepare_cpu_buffers();	1168	rc = prepare_cpu_buffers();
1169	if (rc)	1169	if (rc)
1170	goto start_all_exit;	1170	goto start_all_exit;
1171		1171
1172	for_each_online_cpu(cpu) {	1172	for_each_online_cpu(cpu) {
1173	rc = start_sampling(cpu);	1173	rc = start_sampling(cpu);
1174	if (rc)	1174	if (rc)
1175	break;	1175	break;
1176	}	1176	}
1177	if (rc) {	1177	if (rc) {
1178	for_each_online_cpu(cpu) {	1178	for_each_online_cpu(cpu) {
1179	stop_sampling(cpu);	1179	stop_sampling(cpu);
1180	}	1180	}
1181	goto start_all_exit;	1181	goto start_all_exit;
1182	}	1182	}
1183	hws_state = HWS_STARTED;	1183	hws_state = HWS_STARTED;
1184	rc = 0;	1184	rc = 0;
1185		1185
1186	start_all_exit:	1186	start_all_exit:
1187	mutex_unlock(&hws_sem);	1187	mutex_unlock(&hws_sem);
1188		1188
1189	if (rc)	1189	if (rc)
1190	return rc;	1190	return rc;
1191		1191
1192	register_oom_notifier(&hws_oom_notifier);	1192	register_oom_notifier(&hws_oom_notifier);
1193	hws_oom = 1;	1193	hws_oom = 1;
1194	hws_flush_all = 0;	1194	hws_flush_all = 0;
1195	/* now let them in, 1407 CPUMF external interrupts */	1195	/* now let them in, 1407 CPUMF external interrupts */
1196	ctl_set_bit(0, 5); /* set CR0 bit 58 */	1196	ctl_set_bit(0, 5); /* set CR0 bit 58 */
1197		1197
1198	return 0;	1198	return 0;
1199	}	1199	}
1200		1200
1201	/**	1201	/**
1202	* hwsampler_stop_all() - stop hardware sampling on all online CPUs	1202	* hwsampler_stop_all() - stop hardware sampling on all online CPUs
1203	*	1203	*
1204	* Returns 0 on success, !0 on failure.	1204	* Returns 0 on success, !0 on failure.
1205	*/	1205	*/
1206	int hwsampler_stop_all()	1206	int hwsampler_stop_all()
1207	{	1207	{
1208	int tmp_rc, rc, cpu;	1208	int tmp_rc, rc, cpu;
1209	struct hws_cpu_buffer *cb;	1209	struct hws_cpu_buffer *cb;
1210		1210
1211	mutex_lock(&hws_sem);	1211	mutex_lock(&hws_sem);
1212		1212
1213	rc = 0;	1213	rc = 0;
1214	if (hws_state == HWS_INIT) {	1214	if (hws_state == HWS_INIT) {
1215	mutex_unlock(&hws_sem);	1215	mutex_unlock(&hws_sem);
1216	return rc;	1216	return rc;
1217	}	1217	}
1218	hws_state = HWS_STOPPING;	1218	hws_state = HWS_STOPPING;
1219	mutex_unlock(&hws_sem);	1219	mutex_unlock(&hws_sem);
1220		1220
1221	for_each_online_cpu(cpu) {	1221	for_each_online_cpu(cpu) {
1222	cb = &per_cpu(sampler_cpu_buffer, cpu);	1222	cb = &per_cpu(sampler_cpu_buffer, cpu);
1223	cb->stop_mode = 1;	1223	cb->stop_mode = 1;
1224	tmp_rc = stop_sampling(cpu);	1224	tmp_rc = stop_sampling(cpu);
1225	if (tmp_rc)	1225	if (tmp_rc)
1226	rc = tmp_rc;	1226	rc = tmp_rc;
1227	}	1227	}
1228		1228
1229	if (hws_wq)	1229	if (hws_wq)
1230	flush_workqueue(hws_wq);	1230	flush_workqueue(hws_wq);
1231		1231
1232	mutex_lock(&hws_sem);	1232	mutex_lock(&hws_sem);
1233	if (hws_oom) {	1233	if (hws_oom) {
1234	unregister_oom_notifier(&hws_oom_notifier);	1234	unregister_oom_notifier(&hws_oom_notifier);
1235	hws_oom = 0;	1235	hws_oom = 0;
1236	}	1236	}
1237	hws_state = HWS_STOPPED;	1237	hws_state = HWS_STOPPED;
1238	mutex_unlock(&hws_sem);	1238	mutex_unlock(&hws_sem);
1239		1239
1240	return rc;	1240	return rc;
1241	}	1241	}
1242		1242

drivers/s390/block/dasd_diag.c

Diff comments View file @ d7b250e

1	/*	1	/*
2	* File...........: linux/drivers/s390/block/dasd_diag.c	2	* File...........: linux/drivers/s390/block/dasd_diag.c
3	* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>	3	* Author(s)......: Holger Smolinski <Holger.Smolinski@de.ibm.com>
4	* Based on.......: linux/drivers/s390/block/mdisk.c	4	* Based on.......: linux/drivers/s390/block/mdisk.c
5	* ...............: by Hartmunt Penner <hpenner@de.ibm.com>	5	* ...............: by Hartmunt Penner <hpenner@de.ibm.com>
6	* Bugreports.to..: <Linux390@de.ibm.com>	6	* Bugreports.to..: <Linux390@de.ibm.com>
7	* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000	7	* (C) IBM Corporation, IBM Deutschland Entwicklung GmbH, 1999,2000
8	*	8	*
9	*/	9	*/
10		10
11	#define KMSG_COMPONENT "dasd"	11	#define KMSG_COMPONENT "dasd"
12		12
13	#include <linux/kernel_stat.h>	13	#include <linux/kernel_stat.h>
14	#include <linux/stddef.h>	14	#include <linux/stddef.h>
15	#include <linux/kernel.h>	15	#include <linux/kernel.h>
16	#include <linux/slab.h>	16	#include <linux/slab.h>
17	#include <linux/hdreg.h>	17	#include <linux/hdreg.h>
18	#include <linux/bio.h>	18	#include <linux/bio.h>
19	#include <linux/module.h>	19	#include <linux/module.h>
20	#include <linux/init.h>	20	#include <linux/init.h>
21	#include <linux/jiffies.h>	21	#include <linux/jiffies.h>
22		22
23	#include <asm/dasd.h>	23	#include <asm/dasd.h>
24	#include <asm/debug.h>	24	#include <asm/debug.h>
25	#include <asm/ebcdic.h>	25	#include <asm/ebcdic.h>
26	#include <asm/io.h>	26	#include <asm/io.h>
27	#include <asm/s390_ext.h>	27	#include <asm/irq.h>
28	#include <asm/vtoc.h>	28	#include <asm/vtoc.h>
29	#include <asm/diag.h>	29	#include <asm/diag.h>
30		30
31	#include "dasd_int.h"	31	#include "dasd_int.h"
32	#include "dasd_diag.h"	32	#include "dasd_diag.h"
33		33
34	#define PRINTK_HEADER "dasd(diag):"	34	#define PRINTK_HEADER "dasd(diag):"
35		35
36	MODULE_LICENSE("GPL");	36	MODULE_LICENSE("GPL");
37		37
38	/* The maximum number of blocks per request (max_blocks) is dependent on the	38	/* The maximum number of blocks per request (max_blocks) is dependent on the
39	* amount of storage that is available in the static I/O buffer for each	39	* amount of storage that is available in the static I/O buffer for each
40	* device. Currently each device gets 2 pages. We want to fit two requests	40	* device. Currently each device gets 2 pages. We want to fit two requests
41	* into the available memory so that we can immediately start the next if one	41	* into the available memory so that we can immediately start the next if one
42	* finishes. */	42	* finishes. */
43	#define DIAG_MAX_BLOCKS (((2 * PAGE_SIZE - sizeof(struct dasd_ccw_req) - \	43	#define DIAG_MAX_BLOCKS (((2 * PAGE_SIZE - sizeof(struct dasd_ccw_req) - \
44	sizeof(struct dasd_diag_req)) / \	44	sizeof(struct dasd_diag_req)) / \
45	sizeof(struct dasd_diag_bio)) / 2)	45	sizeof(struct dasd_diag_bio)) / 2)
46	#define DIAG_MAX_RETRIES 32	46	#define DIAG_MAX_RETRIES 32
47	#define DIAG_TIMEOUT 50	47	#define DIAG_TIMEOUT 50
48		48
49	static struct dasd_discipline dasd_diag_discipline;	49	static struct dasd_discipline dasd_diag_discipline;
50		50
51	struct dasd_diag_private {	51	struct dasd_diag_private {
52	struct dasd_diag_characteristics rdc_data;	52	struct dasd_diag_characteristics rdc_data;
53	struct dasd_diag_rw_io iob;	53	struct dasd_diag_rw_io iob;
54	struct dasd_diag_init_io iib;	54	struct dasd_diag_init_io iib;
55	blocknum_t pt_block;	55	blocknum_t pt_block;
56	struct ccw_dev_id dev_id;	56	struct ccw_dev_id dev_id;
57	};	57	};
58		58
59	struct dasd_diag_req {	59	struct dasd_diag_req {
60	unsigned int block_count;	60	unsigned int block_count;
61	struct dasd_diag_bio bio[0];	61	struct dasd_diag_bio bio[0];
62	};	62	};
63		63
64	static const u8 DASD_DIAG_CMS1[] = { 0xc3, 0xd4, 0xe2, 0xf1 };/* EBCDIC CMS1 */	64	static const u8 DASD_DIAG_CMS1[] = { 0xc3, 0xd4, 0xe2, 0xf1 };/* EBCDIC CMS1 */
65		65
66	/* Perform DIAG250 call with block I/O parameter list iob (input and output)	66	/* Perform DIAG250 call with block I/O parameter list iob (input and output)
67	* and function code cmd.	67	* and function code cmd.
68	* In case of an exception return 3. Otherwise return result of bitwise OR of	68	* In case of an exception return 3. Otherwise return result of bitwise OR of
69	* resulting condition code and DIAG return code. */	69	* resulting condition code and DIAG return code. */
70	static inline int dia250(void *iob, int cmd)	70	static inline int dia250(void *iob, int cmd)
71	{	71	{
72	register unsigned long reg2 asm ("2") = (unsigned long) iob;	72	register unsigned long reg2 asm ("2") = (unsigned long) iob;
73	typedef union {	73	typedef union {
74	struct dasd_diag_init_io init_io;	74	struct dasd_diag_init_io init_io;
75	struct dasd_diag_rw_io rw_io;	75	struct dasd_diag_rw_io rw_io;
76	} addr_type;	76	} addr_type;
77	int rc;	77	int rc;
78		78
79	rc = 3;	79	rc = 3;
80	asm volatile(	80	asm volatile(
81	" diag 2,%2,0x250\n"	81	" diag 2,%2,0x250\n"
82	"0: ipm %0\n"	82	"0: ipm %0\n"
83	" srl %0,28\n"	83	" srl %0,28\n"
84	" or %0,3\n"	84	" or %0,3\n"
85	"1:\n"	85	"1:\n"
86	EX_TABLE(0b,1b)	86	EX_TABLE(0b,1b)
87	: "+d" (rc), "=m" ((addr_type ) iob)	87	: "+d" (rc), "=m" ((addr_type ) iob)
88	: "d" (cmd), "d" (reg2), "m" ((addr_type ) iob)	88	: "d" (cmd), "d" (reg2), "m" ((addr_type ) iob)
89	: "3", "cc");	89	: "3", "cc");
90	return rc;	90	return rc;
91	}	91	}
92		92
93	/* Initialize block I/O to DIAG device using the specified blocksize and	93	/* Initialize block I/O to DIAG device using the specified blocksize and
94	* block offset. On success, return zero and set end_block to contain the	94	* block offset. On success, return zero and set end_block to contain the
95	* number of blocks on the device minus the specified offset. Return non-zero	95	* number of blocks on the device minus the specified offset. Return non-zero
96	* otherwise. */	96	* otherwise. */
97	static inline int	97	static inline int
98	mdsk_init_io(struct dasd_device *device, unsigned int blocksize,	98	mdsk_init_io(struct dasd_device *device, unsigned int blocksize,
99	blocknum_t offset, blocknum_t *end_block)	99	blocknum_t offset, blocknum_t *end_block)
100	{	100	{
101	struct dasd_diag_private *private;	101	struct dasd_diag_private *private;
102	struct dasd_diag_init_io *iib;	102	struct dasd_diag_init_io *iib;
103	int rc;	103	int rc;
104		104
105	private = (struct dasd_diag_private *) device->private;	105	private = (struct dasd_diag_private *) device->private;
106	iib = &private->iib;	106	iib = &private->iib;
107	memset(iib, 0, sizeof (struct dasd_diag_init_io));	107	memset(iib, 0, sizeof (struct dasd_diag_init_io));
108		108
109	iib->dev_nr = private->dev_id.devno;	109	iib->dev_nr = private->dev_id.devno;
110	iib->block_size = blocksize;	110	iib->block_size = blocksize;
111	iib->offset = offset;	111	iib->offset = offset;
112	iib->flaga = DASD_DIAG_FLAGA_DEFAULT;	112	iib->flaga = DASD_DIAG_FLAGA_DEFAULT;
113		113
114	rc = dia250(iib, INIT_BIO);	114	rc = dia250(iib, INIT_BIO);
115		115
116	if ((rc & 3) == 0 && end_block)	116	if ((rc & 3) == 0 && end_block)
117	*end_block = iib->end_block;	117	*end_block = iib->end_block;
118		118
119	return rc;	119	return rc;
120	}	120	}
121		121
122	/* Remove block I/O environment for device. Return zero on success, non-zero	122	/* Remove block I/O environment for device. Return zero on success, non-zero
123	* otherwise. */	123	* otherwise. */
124	static inline int	124	static inline int
125	mdsk_term_io(struct dasd_device * device)	125	mdsk_term_io(struct dasd_device * device)
126	{	126	{
127	struct dasd_diag_private *private;	127	struct dasd_diag_private *private;
128	struct dasd_diag_init_io *iib;	128	struct dasd_diag_init_io *iib;
129	int rc;	129	int rc;
130		130
131	private = (struct dasd_diag_private *) device->private;	131	private = (struct dasd_diag_private *) device->private;
132	iib = &private->iib;	132	iib = &private->iib;
133	memset(iib, 0, sizeof (struct dasd_diag_init_io));	133	memset(iib, 0, sizeof (struct dasd_diag_init_io));
134	iib->dev_nr = private->dev_id.devno;	134	iib->dev_nr = private->dev_id.devno;
135	rc = dia250(iib, TERM_BIO);	135	rc = dia250(iib, TERM_BIO);
136	return rc;	136	return rc;
137	}	137	}
138		138
139	/* Error recovery for failed DIAG requests - try to reestablish the DIAG	139	/* Error recovery for failed DIAG requests - try to reestablish the DIAG
140	* environment. */	140	* environment. */
141	static void	141	static void
142	dasd_diag_erp(struct dasd_device *device)	142	dasd_diag_erp(struct dasd_device *device)
143	{	143	{
144	int rc;	144	int rc;
145		145
146	mdsk_term_io(device);	146	mdsk_term_io(device);
147	rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);	147	rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
148	if (rc == 4) {	148	if (rc == 4) {
149	if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))	149	if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))
150	pr_warning("%s: The access mode of a DIAG device "	150	pr_warning("%s: The access mode of a DIAG device "
151	"changed to read-only\n",	151	"changed to read-only\n",
152	dev_name(&device->cdev->dev));	152	dev_name(&device->cdev->dev));
153	rc = 0;	153	rc = 0;
154	}	154	}
155	if (rc)	155	if (rc)
156	pr_warning("%s: DIAG ERP failed with "	156	pr_warning("%s: DIAG ERP failed with "
157	"rc=%d\n", dev_name(&device->cdev->dev), rc);	157	"rc=%d\n", dev_name(&device->cdev->dev), rc);
158	}	158	}
159		159
160	/* Start a given request at the device. Return zero on success, non-zero	160	/* Start a given request at the device. Return zero on success, non-zero
161	* otherwise. */	161	* otherwise. */
162	static int	162	static int
163	dasd_start_diag(struct dasd_ccw_req * cqr)	163	dasd_start_diag(struct dasd_ccw_req * cqr)
164	{	164	{
165	struct dasd_device *device;	165	struct dasd_device *device;
166	struct dasd_diag_private *private;	166	struct dasd_diag_private *private;
167	struct dasd_diag_req *dreq;	167	struct dasd_diag_req *dreq;
168	int rc;	168	int rc;
169		169
170	device = cqr->startdev;	170	device = cqr->startdev;
171	if (cqr->retries < 0) {	171	if (cqr->retries < 0) {
172	DBF_DEV_EVENT(DBF_ERR, device, "DIAG start_IO: request %p "	172	DBF_DEV_EVENT(DBF_ERR, device, "DIAG start_IO: request %p "
173	"- no retry left)", cqr);	173	"- no retry left)", cqr);
174	cqr->status = DASD_CQR_ERROR;	174	cqr->status = DASD_CQR_ERROR;
175	return -EIO;	175	return -EIO;
176	}	176	}
177	private = (struct dasd_diag_private *) device->private;	177	private = (struct dasd_diag_private *) device->private;
178	dreq = (struct dasd_diag_req *) cqr->data;	178	dreq = (struct dasd_diag_req *) cqr->data;
179		179
180	private->iob.dev_nr = private->dev_id.devno;	180	private->iob.dev_nr = private->dev_id.devno;
181	private->iob.key = 0;	181	private->iob.key = 0;
182	private->iob.flags = DASD_DIAG_RWFLAG_ASYNC;	182	private->iob.flags = DASD_DIAG_RWFLAG_ASYNC;
183	private->iob.block_count = dreq->block_count;	183	private->iob.block_count = dreq->block_count;
184	private->iob.interrupt_params = (addr_t) cqr;	184	private->iob.interrupt_params = (addr_t) cqr;
185	private->iob.bio_list = dreq->bio;	185	private->iob.bio_list = dreq->bio;
186	private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;	186	private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
187		187
188	cqr->startclk = get_clock();	188	cqr->startclk = get_clock();
189	cqr->starttime = jiffies;	189	cqr->starttime = jiffies;
190	cqr->retries--;	190	cqr->retries--;
191		191
192	rc = dia250(&private->iob, RW_BIO);	192	rc = dia250(&private->iob, RW_BIO);
193	switch (rc) {	193	switch (rc) {
194	case 0: /* Synchronous I/O finished successfully */	194	case 0: /* Synchronous I/O finished successfully */
195	cqr->stopclk = get_clock();	195	cqr->stopclk = get_clock();
196	cqr->status = DASD_CQR_SUCCESS;	196	cqr->status = DASD_CQR_SUCCESS;
197	/* Indicate to calling function that only a dasd_schedule_bh()	197	/* Indicate to calling function that only a dasd_schedule_bh()
198	and no timer is needed */	198	and no timer is needed */
199	rc = -EACCES;	199	rc = -EACCES;
200	break;	200	break;
201	case 8: /* Asynchronous I/O was started */	201	case 8: /* Asynchronous I/O was started */
202	cqr->status = DASD_CQR_IN_IO;	202	cqr->status = DASD_CQR_IN_IO;
203	rc = 0;	203	rc = 0;
204	break;	204	break;
205	default: /* Error condition */	205	default: /* Error condition */
206	cqr->status = DASD_CQR_QUEUED;	206	cqr->status = DASD_CQR_QUEUED;
207	DBF_DEV_EVENT(DBF_WARNING, device, "dia250 returned rc=%d", rc);	207	DBF_DEV_EVENT(DBF_WARNING, device, "dia250 returned rc=%d", rc);
208	dasd_diag_erp(device);	208	dasd_diag_erp(device);
209	rc = -EIO;	209	rc = -EIO;
210	break;	210	break;
211	}	211	}
212	cqr->intrc = rc;	212	cqr->intrc = rc;
213	return rc;	213	return rc;
214	}	214	}
215		215
216	/* Terminate given request at the device. */	216	/* Terminate given request at the device. */
217	static int	217	static int
218	dasd_diag_term_IO(struct dasd_ccw_req * cqr)	218	dasd_diag_term_IO(struct dasd_ccw_req * cqr)
219	{	219	{
220	struct dasd_device *device;	220	struct dasd_device *device;
221		221
222	device = cqr->startdev;	222	device = cqr->startdev;
223	mdsk_term_io(device);	223	mdsk_term_io(device);
224	mdsk_init_io(device, device->block->bp_block, 0, NULL);	224	mdsk_init_io(device, device->block->bp_block, 0, NULL);
225	cqr->status = DASD_CQR_CLEAR_PENDING;	225	cqr->status = DASD_CQR_CLEAR_PENDING;
226	cqr->stopclk = get_clock();	226	cqr->stopclk = get_clock();
227	dasd_schedule_device_bh(device);	227	dasd_schedule_device_bh(device);
228	return 0;	228	return 0;
229	}	229	}
230		230
231	/* Handle external interruption. */	231	/* Handle external interruption. */
232	static void dasd_ext_handler(unsigned int ext_int_code,	232	static void dasd_ext_handler(unsigned int ext_int_code,
233	unsigned int param32, unsigned long param64)	233	unsigned int param32, unsigned long param64)
234	{	234	{
235	struct dasd_ccw_req cqr, next;	235	struct dasd_ccw_req cqr, next;
236	struct dasd_device *device;	236	struct dasd_device *device;
237	unsigned long long expires;	237	unsigned long long expires;
238	unsigned long flags;	238	unsigned long flags;
239	addr_t ip;	239	addr_t ip;
240	int rc;	240	int rc;
241		241
242	switch (ext_int_code >> 24) {	242	switch (ext_int_code >> 24) {
243	case DASD_DIAG_CODE_31BIT:	243	case DASD_DIAG_CODE_31BIT:
244	ip = (addr_t) param32;	244	ip = (addr_t) param32;
245	break;	245	break;
246	case DASD_DIAG_CODE_64BIT:	246	case DASD_DIAG_CODE_64BIT:
247	ip = (addr_t) param64;	247	ip = (addr_t) param64;
248	break;	248	break;
249	default:	249	default:
250	return;	250	return;
251	}	251	}
252	kstat_cpu(smp_processor_id()).irqs[EXTINT_DSD]++;	252	kstat_cpu(smp_processor_id()).irqs[EXTINT_DSD]++;
253	if (!ip) { /* no intparm: unsolicited interrupt */	253	if (!ip) { /* no intparm: unsolicited interrupt */
254	DBF_EVENT(DBF_NOTICE, "%s", "caught unsolicited "	254	DBF_EVENT(DBF_NOTICE, "%s", "caught unsolicited "
255	"interrupt");	255	"interrupt");
256	return;	256	return;
257	}	257	}
258	cqr = (struct dasd_ccw_req *) ip;	258	cqr = (struct dasd_ccw_req *) ip;
259	device = (struct dasd_device *) cqr->startdev;	259	device = (struct dasd_device *) cqr->startdev;
260	if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {	260	if (strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
261	DBF_DEV_EVENT(DBF_WARNING, device,	261	DBF_DEV_EVENT(DBF_WARNING, device,
262	" magic number of dasd_ccw_req 0x%08X doesn't"	262	" magic number of dasd_ccw_req 0x%08X doesn't"
263	" match discipline 0x%08X",	263	" match discipline 0x%08X",
264	cqr->magic, (int ) (&device->discipline->name));	264	cqr->magic, (int ) (&device->discipline->name));
265	return;	265	return;
266	}	266	}
267		267
268	/* get irq lock to modify request queue */	268	/* get irq lock to modify request queue */
269	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);	269	spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
270		270
271	/* Check for a pending clear operation */	271	/* Check for a pending clear operation */
272	if (cqr->status == DASD_CQR_CLEAR_PENDING) {	272	if (cqr->status == DASD_CQR_CLEAR_PENDING) {
273	cqr->status = DASD_CQR_CLEARED;	273	cqr->status = DASD_CQR_CLEARED;
274	dasd_device_clear_timer(device);	274	dasd_device_clear_timer(device);
275	dasd_schedule_device_bh(device);	275	dasd_schedule_device_bh(device);
276	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);	276	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
277	return;	277	return;
278	}	278	}
279		279
280	cqr->stopclk = get_clock();	280	cqr->stopclk = get_clock();
281		281
282	expires = 0;	282	expires = 0;
283	if ((ext_int_code & 0xff0000) == 0) {	283	if ((ext_int_code & 0xff0000) == 0) {
284	cqr->status = DASD_CQR_SUCCESS;	284	cqr->status = DASD_CQR_SUCCESS;
285	/* Start first request on queue if possible -> fast_io. */	285	/* Start first request on queue if possible -> fast_io. */
286	if (!list_empty(&device->ccw_queue)) {	286	if (!list_empty(&device->ccw_queue)) {
287	next = list_entry(device->ccw_queue.next,	287	next = list_entry(device->ccw_queue.next,
288	struct dasd_ccw_req, devlist);	288	struct dasd_ccw_req, devlist);
289	if (next->status == DASD_CQR_QUEUED) {	289	if (next->status == DASD_CQR_QUEUED) {
290	rc = dasd_start_diag(next);	290	rc = dasd_start_diag(next);
291	if (rc == 0)	291	if (rc == 0)
292	expires = next->expires;	292	expires = next->expires;
293	}	293	}
294	}	294	}
295	} else {	295	} else {
296	cqr->status = DASD_CQR_QUEUED;	296	cqr->status = DASD_CQR_QUEUED;
297	DBF_DEV_EVENT(DBF_DEBUG, device, "interrupt status for "	297	DBF_DEV_EVENT(DBF_DEBUG, device, "interrupt status for "
298	"request %p was %d (%d retries left)", cqr,	298	"request %p was %d (%d retries left)", cqr,
299	(ext_int_code >> 16) & 0xff, cqr->retries);	299	(ext_int_code >> 16) & 0xff, cqr->retries);
300	dasd_diag_erp(device);	300	dasd_diag_erp(device);
301	}	301	}
302		302
303	if (expires != 0)	303	if (expires != 0)
304	dasd_device_set_timer(device, expires);	304	dasd_device_set_timer(device, expires);
305	else	305	else
306	dasd_device_clear_timer(device);	306	dasd_device_clear_timer(device);
307	dasd_schedule_device_bh(device);	307	dasd_schedule_device_bh(device);
308		308
309	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);	309	spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
310	}	310	}
311		311
312	/* Check whether device can be controlled by DIAG discipline. Return zero on	312	/* Check whether device can be controlled by DIAG discipline. Return zero on
313	* success, non-zero otherwise. */	313	* success, non-zero otherwise. */
314	static int	314	static int
315	dasd_diag_check_device(struct dasd_device *device)	315	dasd_diag_check_device(struct dasd_device *device)
316	{	316	{
317	struct dasd_block *block;	317	struct dasd_block *block;
318	struct dasd_diag_private *private;	318	struct dasd_diag_private *private;
319	struct dasd_diag_characteristics *rdc_data;	319	struct dasd_diag_characteristics *rdc_data;
320	struct dasd_diag_bio bio;	320	struct dasd_diag_bio bio;
321	struct vtoc_cms_label *label;	321	struct vtoc_cms_label *label;
322	blocknum_t end_block;	322	blocknum_t end_block;
323	unsigned int sb, bsize;	323	unsigned int sb, bsize;
324	int rc;	324	int rc;
325		325
326	private = (struct dasd_diag_private *) device->private;	326	private = (struct dasd_diag_private *) device->private;
327	if (private == NULL) {	327	if (private == NULL) {
328	private = kzalloc(sizeof(struct dasd_diag_private),GFP_KERNEL);	328	private = kzalloc(sizeof(struct dasd_diag_private),GFP_KERNEL);
329	if (private == NULL) {	329	if (private == NULL) {
330	DBF_DEV_EVENT(DBF_WARNING, device, "%s",	330	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
331	"Allocating memory for private DASD data "	331	"Allocating memory for private DASD data "
332	"failed\n");	332	"failed\n");
333	return -ENOMEM;	333	return -ENOMEM;
334	}	334	}
335	ccw_device_get_id(device->cdev, &private->dev_id);	335	ccw_device_get_id(device->cdev, &private->dev_id);
336	device->private = (void *) private;	336	device->private = (void *) private;
337	}	337	}
338	block = dasd_alloc_block();	338	block = dasd_alloc_block();
339	if (IS_ERR(block)) {	339	if (IS_ERR(block)) {
340	DBF_DEV_EVENT(DBF_WARNING, device, "%s",	340	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
341	"could not allocate dasd block structure");	341	"could not allocate dasd block structure");
342	device->private = NULL;	342	device->private = NULL;
343	kfree(private);	343	kfree(private);
344	return PTR_ERR(block);	344	return PTR_ERR(block);
345	}	345	}
346	device->block = block;	346	device->block = block;
347	block->base = device;	347	block->base = device;
348		348
349	/* Read Device Characteristics */	349	/* Read Device Characteristics */
350	rdc_data = (void *) &(private->rdc_data);	350	rdc_data = (void *) &(private->rdc_data);
351	rdc_data->dev_nr = private->dev_id.devno;	351	rdc_data->dev_nr = private->dev_id.devno;
352	rdc_data->rdc_len = sizeof (struct dasd_diag_characteristics);	352	rdc_data->rdc_len = sizeof (struct dasd_diag_characteristics);
353		353
354	rc = diag210((struct diag210 *) rdc_data);	354	rc = diag210((struct diag210 *) rdc_data);
355	if (rc) {	355	if (rc) {
356	DBF_DEV_EVENT(DBF_WARNING, device, "failed to retrieve device "	356	DBF_DEV_EVENT(DBF_WARNING, device, "failed to retrieve device "
357	"information (rc=%d)", rc);	357	"information (rc=%d)", rc);
358	rc = -EOPNOTSUPP;	358	rc = -EOPNOTSUPP;
359	goto out;	359	goto out;
360	}	360	}
361		361
362	device->default_expires = DIAG_TIMEOUT;	362	device->default_expires = DIAG_TIMEOUT;
363		363
364	/* Figure out position of label block */	364	/* Figure out position of label block */
365	switch (private->rdc_data.vdev_class) {	365	switch (private->rdc_data.vdev_class) {
366	case DEV_CLASS_FBA:	366	case DEV_CLASS_FBA:
367	private->pt_block = 1;	367	private->pt_block = 1;
368	break;	368	break;
369	case DEV_CLASS_ECKD:	369	case DEV_CLASS_ECKD:
370	private->pt_block = 2;	370	private->pt_block = 2;
371	break;	371	break;
372	default:	372	default:
373	pr_warning("%s: Device type %d is not supported "	373	pr_warning("%s: Device type %d is not supported "
374	"in DIAG mode\n", dev_name(&device->cdev->dev),	374	"in DIAG mode\n", dev_name(&device->cdev->dev),
375	private->rdc_data.vdev_class);	375	private->rdc_data.vdev_class);
376	rc = -EOPNOTSUPP;	376	rc = -EOPNOTSUPP;
377	goto out;	377	goto out;
378	}	378	}
379		379
380	DBF_DEV_EVENT(DBF_INFO, device,	380	DBF_DEV_EVENT(DBF_INFO, device,
381	"%04X: %04X on real %04X/%02X",	381	"%04X: %04X on real %04X/%02X",
382	rdc_data->dev_nr,	382	rdc_data->dev_nr,
383	rdc_data->vdev_type,	383	rdc_data->vdev_type,
384	rdc_data->rdev_type, rdc_data->rdev_model);	384	rdc_data->rdev_type, rdc_data->rdev_model);
385		385
386	/* terminate all outstanding operations */	386	/* terminate all outstanding operations */
387	mdsk_term_io(device);	387	mdsk_term_io(device);
388		388
389	/* figure out blocksize of device */	389	/* figure out blocksize of device */
390	label = (struct vtoc_cms_label *) get_zeroed_page(GFP_KERNEL);	390	label = (struct vtoc_cms_label *) get_zeroed_page(GFP_KERNEL);
391	if (label == NULL) {	391	if (label == NULL) {
392	DBF_DEV_EVENT(DBF_WARNING, device, "%s",	392	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
393	"No memory to allocate initialization request");	393	"No memory to allocate initialization request");
394	rc = -ENOMEM;	394	rc = -ENOMEM;
395	goto out;	395	goto out;
396	}	396	}
397	rc = 0;	397	rc = 0;
398	end_block = 0;	398	end_block = 0;
399	/* try all sizes - needed for ECKD devices */	399	/* try all sizes - needed for ECKD devices */
400	for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {	400	for (bsize = 512; bsize <= PAGE_SIZE; bsize <<= 1) {
401	mdsk_init_io(device, bsize, 0, &end_block);	401	mdsk_init_io(device, bsize, 0, &end_block);
402	memset(&bio, 0, sizeof (struct dasd_diag_bio));	402	memset(&bio, 0, sizeof (struct dasd_diag_bio));
403	bio.type = MDSK_READ_REQ;	403	bio.type = MDSK_READ_REQ;
404	bio.block_number = private->pt_block + 1;	404	bio.block_number = private->pt_block + 1;
405	bio.buffer = label;	405	bio.buffer = label;
406	memset(&private->iob, 0, sizeof (struct dasd_diag_rw_io));	406	memset(&private->iob, 0, sizeof (struct dasd_diag_rw_io));
407	private->iob.dev_nr = rdc_data->dev_nr;	407	private->iob.dev_nr = rdc_data->dev_nr;
408	private->iob.key = 0;	408	private->iob.key = 0;
409	private->iob.flags = 0; /* do synchronous io */	409	private->iob.flags = 0; /* do synchronous io */
410	private->iob.block_count = 1;	410	private->iob.block_count = 1;
411	private->iob.interrupt_params = 0;	411	private->iob.interrupt_params = 0;
412	private->iob.bio_list = &bio;	412	private->iob.bio_list = &bio;
413	private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;	413	private->iob.flaga = DASD_DIAG_FLAGA_DEFAULT;
414	rc = dia250(&private->iob, RW_BIO);	414	rc = dia250(&private->iob, RW_BIO);
415	if (rc == 3) {	415	if (rc == 3) {
416	pr_warning("%s: A 64-bit DIAG call failed\n",	416	pr_warning("%s: A 64-bit DIAG call failed\n",
417	dev_name(&device->cdev->dev));	417	dev_name(&device->cdev->dev));
418	rc = -EOPNOTSUPP;	418	rc = -EOPNOTSUPP;
419	goto out_label;	419	goto out_label;
420	}	420	}
421	mdsk_term_io(device);	421	mdsk_term_io(device);
422	if (rc == 0)	422	if (rc == 0)
423	break;	423	break;
424	}	424	}
425	if (bsize > PAGE_SIZE) {	425	if (bsize > PAGE_SIZE) {
426	pr_warning("%s: Accessing the DASD failed because of an "	426	pr_warning("%s: Accessing the DASD failed because of an "
427	"incorrect format (rc=%d)\n",	427	"incorrect format (rc=%d)\n",
428	dev_name(&device->cdev->dev), rc);	428	dev_name(&device->cdev->dev), rc);
429	rc = -EIO;	429	rc = -EIO;
430	goto out_label;	430	goto out_label;
431	}	431	}
432	/* check for label block */	432	/* check for label block */
433	if (memcmp(label->label_id, DASD_DIAG_CMS1,	433	if (memcmp(label->label_id, DASD_DIAG_CMS1,
434	sizeof(DASD_DIAG_CMS1)) == 0) {	434	sizeof(DASD_DIAG_CMS1)) == 0) {
435	/* get formatted blocksize from label block */	435	/* get formatted blocksize from label block */
436	bsize = (unsigned int) label->block_size;	436	bsize = (unsigned int) label->block_size;
437	block->blocks = (unsigned long) label->block_count;	437	block->blocks = (unsigned long) label->block_count;
438	} else	438	} else
439	block->blocks = end_block;	439	block->blocks = end_block;
440	block->bp_block = bsize;	440	block->bp_block = bsize;
441	block->s2b_shift = 0; /* bits to shift 512 to get a block */	441	block->s2b_shift = 0; /* bits to shift 512 to get a block */
442	for (sb = 512; sb < bsize; sb = sb << 1)	442	for (sb = 512; sb < bsize; sb = sb << 1)
443	block->s2b_shift++;	443	block->s2b_shift++;
444	rc = mdsk_init_io(device, block->bp_block, 0, NULL);	444	rc = mdsk_init_io(device, block->bp_block, 0, NULL);
445	if (rc && (rc != 4)) {	445	if (rc && (rc != 4)) {
446	pr_warning("%s: DIAG initialization failed with rc=%d\n",	446	pr_warning("%s: DIAG initialization failed with rc=%d\n",
447	dev_name(&device->cdev->dev), rc);	447	dev_name(&device->cdev->dev), rc);
448	rc = -EIO;	448	rc = -EIO;
449	} else {	449	} else {
450	if (rc == 4)	450	if (rc == 4)
451	set_bit(DASD_FLAG_DEVICE_RO, &device->flags);	451	set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
452	pr_info("%s: New DASD with %ld byte/block, total size %ld "	452	pr_info("%s: New DASD with %ld byte/block, total size %ld "
453	"KB%s\n", dev_name(&device->cdev->dev),	453	"KB%s\n", dev_name(&device->cdev->dev),
454	(unsigned long) block->bp_block,	454	(unsigned long) block->bp_block,
455	(unsigned long) (block->blocks <<	455	(unsigned long) (block->blocks <<
456	block->s2b_shift) >> 1,	456	block->s2b_shift) >> 1,
457	(rc == 4) ? ", read-only device" : "");	457	(rc == 4) ? ", read-only device" : "");
458	rc = 0;	458	rc = 0;
459	}	459	}
460	out_label:	460	out_label:
461	free_page((long) label);	461	free_page((long) label);
462	out:	462	out:
463	if (rc) {	463	if (rc) {
464	device->block = NULL;	464	device->block = NULL;
465	dasd_free_block(block);	465	dasd_free_block(block);
466	device->private = NULL;	466	device->private = NULL;
467	kfree(private);	467	kfree(private);
468	}	468	}
469	return rc;	469	return rc;
470	}	470	}
471		471
472	/* Fill in virtual disk geometry for device. Return zero on success, non-zero	472	/* Fill in virtual disk geometry for device. Return zero on success, non-zero
473	* otherwise. */	473	* otherwise. */
474	static int	474	static int
475	dasd_diag_fill_geometry(struct dasd_block block, struct hd_geometry geo)	475	dasd_diag_fill_geometry(struct dasd_block block, struct hd_geometry geo)
476	{	476	{
477	if (dasd_check_blocksize(block->bp_block) != 0)	477	if (dasd_check_blocksize(block->bp_block) != 0)
478	return -EINVAL;	478	return -EINVAL;
479	geo->cylinders = (block->blocks << block->s2b_shift) >> 10;	479	geo->cylinders = (block->blocks << block->s2b_shift) >> 10;
480	geo->heads = 16;	480	geo->heads = 16;
481	geo->sectors = 128 >> block->s2b_shift;	481	geo->sectors = 128 >> block->s2b_shift;
482	return 0;	482	return 0;
483	}	483	}
484		484
485	static dasd_erp_fn_t	485	static dasd_erp_fn_t
486	dasd_diag_erp_action(struct dasd_ccw_req * cqr)	486	dasd_diag_erp_action(struct dasd_ccw_req * cqr)
487	{	487	{
488	return dasd_default_erp_action;	488	return dasd_default_erp_action;
489	}	489	}
490		490
491	static dasd_erp_fn_t	491	static dasd_erp_fn_t
492	dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)	492	dasd_diag_erp_postaction(struct dasd_ccw_req * cqr)
493	{	493	{
494	return dasd_default_erp_postaction;	494	return dasd_default_erp_postaction;
495	}	495	}
496		496
497	/* Create DASD request from block device request. Return pointer to new	497	/* Create DASD request from block device request. Return pointer to new
498	* request on success, ERR_PTR otherwise. */	498	* request on success, ERR_PTR otherwise. */
499	static struct dasd_ccw_req dasd_diag_build_cp(struct dasd_device memdev,	499	static struct dasd_ccw_req dasd_diag_build_cp(struct dasd_device memdev,
500	struct dasd_block *block,	500	struct dasd_block *block,
501	struct request *req)	501	struct request *req)
502	{	502	{
503	struct dasd_ccw_req *cqr;	503	struct dasd_ccw_req *cqr;
504	struct dasd_diag_req *dreq;	504	struct dasd_diag_req *dreq;
505	struct dasd_diag_bio *dbio;	505	struct dasd_diag_bio *dbio;
506	struct req_iterator iter;	506	struct req_iterator iter;
507	struct bio_vec *bv;	507	struct bio_vec *bv;
508	char *dst;	508	char *dst;
509	unsigned int count, datasize;	509	unsigned int count, datasize;
510	sector_t recid, first_rec, last_rec;	510	sector_t recid, first_rec, last_rec;
511	unsigned int blksize, off;	511	unsigned int blksize, off;
512	unsigned char rw_cmd;	512	unsigned char rw_cmd;
513		513
514	if (rq_data_dir(req) == READ)	514	if (rq_data_dir(req) == READ)
515	rw_cmd = MDSK_READ_REQ;	515	rw_cmd = MDSK_READ_REQ;
516	else if (rq_data_dir(req) == WRITE)	516	else if (rq_data_dir(req) == WRITE)
517	rw_cmd = MDSK_WRITE_REQ;	517	rw_cmd = MDSK_WRITE_REQ;
518	else	518	else
519	return ERR_PTR(-EINVAL);	519	return ERR_PTR(-EINVAL);
520	blksize = block->bp_block;	520	blksize = block->bp_block;
521	/* Calculate record id of first and last block. */	521	/* Calculate record id of first and last block. */
522	first_rec = blk_rq_pos(req) >> block->s2b_shift;	522	first_rec = blk_rq_pos(req) >> block->s2b_shift;
523	last_rec =	523	last_rec =
524	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;	524	(blk_rq_pos(req) + blk_rq_sectors(req) - 1) >> block->s2b_shift;
525	/* Check struct bio and count the number of blocks for the request. */	525	/* Check struct bio and count the number of blocks for the request. */
526	count = 0;	526	count = 0;
527	rq_for_each_segment(bv, req, iter) {	527	rq_for_each_segment(bv, req, iter) {
528	if (bv->bv_len & (blksize - 1))	528	if (bv->bv_len & (blksize - 1))
529	/* Fba can only do full blocks. */	529	/* Fba can only do full blocks. */
530	return ERR_PTR(-EINVAL);	530	return ERR_PTR(-EINVAL);
531	count += bv->bv_len >> (block->s2b_shift + 9);	531	count += bv->bv_len >> (block->s2b_shift + 9);
532	}	532	}
533	/* Paranoia. */	533	/* Paranoia. */
534	if (count != last_rec - first_rec + 1)	534	if (count != last_rec - first_rec + 1)
535	return ERR_PTR(-EINVAL);	535	return ERR_PTR(-EINVAL);
536	/* Build the request */	536	/* Build the request */
537	datasize = sizeof(struct dasd_diag_req) +	537	datasize = sizeof(struct dasd_diag_req) +
538	count*sizeof(struct dasd_diag_bio);	538	count*sizeof(struct dasd_diag_bio);
539	cqr = dasd_smalloc_request(DASD_DIAG_MAGIC, 0, datasize, memdev);	539	cqr = dasd_smalloc_request(DASD_DIAG_MAGIC, 0, datasize, memdev);
540	if (IS_ERR(cqr))	540	if (IS_ERR(cqr))
541	return cqr;	541	return cqr;
542		542
543	dreq = (struct dasd_diag_req *) cqr->data;	543	dreq = (struct dasd_diag_req *) cqr->data;
544	dreq->block_count = count;	544	dreq->block_count = count;
545	dbio = dreq->bio;	545	dbio = dreq->bio;
546	recid = first_rec;	546	recid = first_rec;
547	rq_for_each_segment(bv, req, iter) {	547	rq_for_each_segment(bv, req, iter) {
548	dst = page_address(bv->bv_page) + bv->bv_offset;	548	dst = page_address(bv->bv_page) + bv->bv_offset;
549	for (off = 0; off < bv->bv_len; off += blksize) {	549	for (off = 0; off < bv->bv_len; off += blksize) {
550	memset(dbio, 0, sizeof (struct dasd_diag_bio));	550	memset(dbio, 0, sizeof (struct dasd_diag_bio));
551	dbio->type = rw_cmd;	551	dbio->type = rw_cmd;
552	dbio->block_number = recid + 1;	552	dbio->block_number = recid + 1;
553	dbio->buffer = dst;	553	dbio->buffer = dst;
554	dbio++;	554	dbio++;
555	dst += blksize;	555	dst += blksize;
556	recid++;	556	recid++;
557	}	557	}
558	}	558	}
559	cqr->retries = DIAG_MAX_RETRIES;	559	cqr->retries = DIAG_MAX_RETRIES;
560	cqr->buildclk = get_clock();	560	cqr->buildclk = get_clock();
561	if (blk_noretry_request(req) \|\|	561	if (blk_noretry_request(req) \|\|
562	block->base->features & DASD_FEATURE_FAILFAST)	562	block->base->features & DASD_FEATURE_FAILFAST)
563	set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);	563	set_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags);
564	cqr->startdev = memdev;	564	cqr->startdev = memdev;
565	cqr->memdev = memdev;	565	cqr->memdev = memdev;
566	cqr->block = block;	566	cqr->block = block;
567	cqr->expires = memdev->default_expires * HZ;	567	cqr->expires = memdev->default_expires * HZ;
568	cqr->status = DASD_CQR_FILLED;	568	cqr->status = DASD_CQR_FILLED;
569	return cqr;	569	return cqr;
570	}	570	}
571		571
572	/* Release DASD request. Return non-zero if request was successful, zero	572	/* Release DASD request. Return non-zero if request was successful, zero
573	* otherwise. */	573	* otherwise. */
574	static int	574	static int
575	dasd_diag_free_cp(struct dasd_ccw_req cqr, struct request req)	575	dasd_diag_free_cp(struct dasd_ccw_req cqr, struct request req)
576	{	576	{
577	int status;	577	int status;
578		578
579	status = cqr->status == DASD_CQR_DONE;	579	status = cqr->status == DASD_CQR_DONE;
580	dasd_sfree_request(cqr, cqr->memdev);	580	dasd_sfree_request(cqr, cqr->memdev);
581	return status;	581	return status;
582	}	582	}
583		583
584	static void dasd_diag_handle_terminated_request(struct dasd_ccw_req *cqr)	584	static void dasd_diag_handle_terminated_request(struct dasd_ccw_req *cqr)
585	{	585	{
586	cqr->status = DASD_CQR_FILLED;	586	cqr->status = DASD_CQR_FILLED;
587	};	587	};
588		588
589	/* Fill in IOCTL data for device. */	589	/* Fill in IOCTL data for device. */
590	static int	590	static int
591	dasd_diag_fill_info(struct dasd_device * device,	591	dasd_diag_fill_info(struct dasd_device * device,
592	struct dasd_information2_t * info)	592	struct dasd_information2_t * info)
593	{	593	{
594	struct dasd_diag_private *private;	594	struct dasd_diag_private *private;
595		595
596	private = (struct dasd_diag_private *) device->private;	596	private = (struct dasd_diag_private *) device->private;
597	info->label_block = (unsigned int) private->pt_block;	597	info->label_block = (unsigned int) private->pt_block;
598	info->FBA_layout = 1;	598	info->FBA_layout = 1;
599	info->format = DASD_FORMAT_LDL;	599	info->format = DASD_FORMAT_LDL;
600	info->characteristics_size = sizeof (struct dasd_diag_characteristics);	600	info->characteristics_size = sizeof (struct dasd_diag_characteristics);
601	memcpy(info->characteristics,	601	memcpy(info->characteristics,
602	&((struct dasd_diag_private *) device->private)->rdc_data,	602	&((struct dasd_diag_private *) device->private)->rdc_data,
603	sizeof (struct dasd_diag_characteristics));	603	sizeof (struct dasd_diag_characteristics));
604	info->confdata_size = 0;	604	info->confdata_size = 0;
605	return 0;	605	return 0;
606	}	606	}
607		607
608	static void	608	static void
609	dasd_diag_dump_sense(struct dasd_device device, struct dasd_ccw_req req,	609	dasd_diag_dump_sense(struct dasd_device device, struct dasd_ccw_req req,
610	struct irb *stat)	610	struct irb *stat)
611	{	611	{
612	DBF_DEV_EVENT(DBF_WARNING, device, "%s",	612	DBF_DEV_EVENT(DBF_WARNING, device, "%s",
613	"dump sense not available for DIAG data");	613	"dump sense not available for DIAG data");
614	}	614	}
615		615
616	static struct dasd_discipline dasd_diag_discipline = {	616	static struct dasd_discipline dasd_diag_discipline = {
617	.owner = THIS_MODULE,	617	.owner = THIS_MODULE,
618	.name = "DIAG",	618	.name = "DIAG",
619	.ebcname = "DIAG",	619	.ebcname = "DIAG",
620	.max_blocks = DIAG_MAX_BLOCKS,	620	.max_blocks = DIAG_MAX_BLOCKS,
621	.check_device = dasd_diag_check_device,	621	.check_device = dasd_diag_check_device,
622	.verify_path = dasd_generic_verify_path,	622	.verify_path = dasd_generic_verify_path,
623	.fill_geometry = dasd_diag_fill_geometry,	623	.fill_geometry = dasd_diag_fill_geometry,
624	.start_IO = dasd_start_diag,	624	.start_IO = dasd_start_diag,
625	.term_IO = dasd_diag_term_IO,	625	.term_IO = dasd_diag_term_IO,
626	.handle_terminated_request = dasd_diag_handle_terminated_request,	626	.handle_terminated_request = dasd_diag_handle_terminated_request,
627	.erp_action = dasd_diag_erp_action,	627	.erp_action = dasd_diag_erp_action,
628	.erp_postaction = dasd_diag_erp_postaction,	628	.erp_postaction = dasd_diag_erp_postaction,
629	.build_cp = dasd_diag_build_cp,	629	.build_cp = dasd_diag_build_cp,
630	.free_cp = dasd_diag_free_cp,	630	.free_cp = dasd_diag_free_cp,
631	.dump_sense = dasd_diag_dump_sense,	631	.dump_sense = dasd_diag_dump_sense,
632	.fill_info = dasd_diag_fill_info,	632	.fill_info = dasd_diag_fill_info,
633	};	633	};
634		634
635	static int __init	635	static int __init
636	dasd_diag_init(void)	636	dasd_diag_init(void)
637	{	637	{
638	if (!MACHINE_IS_VM) {	638	if (!MACHINE_IS_VM) {
639	pr_info("Discipline %s cannot be used without z/VM\n",	639	pr_info("Discipline %s cannot be used without z/VM\n",
640	dasd_diag_discipline.name);	640	dasd_diag_discipline.name);
641	return -ENODEV;	641	return -ENODEV;
642	}	642	}
643	ASCEBC(dasd_diag_discipline.ebcname, 4);	643	ASCEBC(dasd_diag_discipline.ebcname, 4);
644		644
645	service_subclass_irq_register();	645	service_subclass_irq_register();
646	register_external_interrupt(0x2603, dasd_ext_handler);	646	register_external_interrupt(0x2603, dasd_ext_handler);
647	dasd_diag_discipline_pointer = &dasd_diag_discipline;	647	dasd_diag_discipline_pointer = &dasd_diag_discipline;
648	return 0;	648	return 0;
649	}	649	}
650		650
651	static void __exit	651	static void __exit
652	dasd_diag_cleanup(void)	652	dasd_diag_cleanup(void)
653	{	653	{
654	unregister_external_interrupt(0x2603, dasd_ext_handler);	654	unregister_external_interrupt(0x2603, dasd_ext_handler);
655	service_subclass_irq_unregister();	655	service_subclass_irq_unregister();
656	dasd_diag_discipline_pointer = NULL;	656	dasd_diag_discipline_pointer = NULL;
657	}	657	}
658		658
659	module_init(dasd_diag_init);	659	module_init(dasd_diag_init);
660	module_exit(dasd_diag_cleanup);	660	module_exit(dasd_diag_cleanup);
661		661

drivers/s390/char/sclp.c

Diff comments View file @ d7b250e

 /*
  * core function to access sclp interface
  *
  * Copyright IBM Corp. 1999, 2009
  *
  * Author(s): Martin Peschke <mpeschke@de.ibm.com>
  *	      Martin Schwidefsky <schwidefsky@de.ibm.com>
  */
 #include <linux/kernel_stat.h>
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 #include <linux/timer.h>
 #include <linux/reboot.h>
 #include <linux/jiffies.h>
 #include <linux/init.h>
 #include <linux/suspend.h>
 #include <linux/completion.h>
 #include <linux/platform_device.h>
-#include <asm/s390_ext.h>
 #include <asm/types.h>
 #include <asm/irq.h>
 #include "sclp.h"
 #define SCLP_HEADER		"sclp: "
 /* Lock to protect internal data consistency. */
 static DEFINE_SPINLOCK(sclp_lock);
 /* Mask of events that we can send to the sclp interface. */
 static sccb_mask_t sclp_receive_mask;
 /* Mask of events that we can receive from the sclp interface. */
 static sccb_mask_t sclp_send_mask;
 /* List of registered event listeners and senders. */
 static struct list_head sclp_reg_list;
 /* List of queued requests. */
 static struct list_head sclp_req_queue;
 /* Data for read and and init requests. */
 static struct sclp_req sclp_read_req;
 static struct sclp_req sclp_init_req;
 static char sclp_read_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
 static char sclp_init_sccb[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE)));
 /* Suspend request */
 static DECLARE_COMPLETION(sclp_request_queue_flushed);
 static void sclp_suspend_req_cb(struct sclp_req *req, void *data)
 {
 	complete(&sclp_request_queue_flushed);
 }
 static struct sclp_req sclp_suspend_req;
 /* Timer for request retries. */
 static struct timer_list sclp_request_timer;
 /* Internal state: is the driver initialized? */
 static volatile enum sclp_init_state_t {
 	sclp_init_state_uninitialized,
 	sclp_init_state_initializing,
 	sclp_init_state_initialized
 } sclp_init_state = sclp_init_state_uninitialized;
 /* Internal state: is a request active at the sclp? */
 static volatile enum sclp_running_state_t {
 	sclp_running_state_idle,
 	sclp_running_state_running,
 	sclp_running_state_reset_pending
 } sclp_running_state = sclp_running_state_idle;
 /* Internal state: is a read request pending? */
 static volatile enum sclp_reading_state_t {
 	sclp_reading_state_idle,
 	sclp_reading_state_reading
 } sclp_reading_state = sclp_reading_state_idle;
 /* Internal state: is the driver currently serving requests? */
 static volatile enum sclp_activation_state_t {
 	sclp_activation_state_active,
 	sclp_activation_state_deactivating,
 	sclp_activation_state_inactive,
 	sclp_activation_state_activating
 } sclp_activation_state = sclp_activation_state_active;
 /* Internal state: is an init mask request pending? */
 static volatile enum sclp_mask_state_t {
 	sclp_mask_state_idle,
 	sclp_mask_state_initializing
 } sclp_mask_state = sclp_mask_state_idle;
 /* Internal state: is the driver suspended? */
 static enum sclp_suspend_state_t {
 	sclp_suspend_state_running,
 	sclp_suspend_state_suspended,
 } sclp_suspend_state = sclp_suspend_state_running;
 /* Maximum retry counts */
 #define SCLP_INIT_RETRY		3
 #define SCLP_MASK_RETRY		3
 /* Timeout intervals in seconds.*/
 #define SCLP_BUSY_INTERVAL	10
 #define SCLP_RETRY_INTERVAL	30
 static void sclp_process_queue(void);
 static void __sclp_make_read_req(void);
 static int sclp_init_mask(int calculate);
 static int sclp_init(void);
 /* Perform service call. Return 0 on success, non-zero otherwise. */
 int
 sclp_service_call(sclp_cmdw_t command, void *sccb)
 {
 	int cc;
 	asm volatile(
 		"	.insn	rre,0xb2200000,%1,%2\n"  /* servc %1,%2 */
 		"	ipm	%0\n"
 		"	srl	%0,28"
 		: "=&d" (cc) : "d" (command), "a" (__pa(sccb))
 		: "cc", "memory");
 	if (cc == 3)
 		return -EIO;
 	if (cc == 2)
 		return -EBUSY;
 	return 0;
 }
 static void
 __sclp_queue_read_req(void)
 {
 	if (sclp_reading_state == sclp_reading_state_idle) {
 		sclp_reading_state = sclp_reading_state_reading;
 		__sclp_make_read_req();
 		/* Add request to head of queue */
 		list_add(&sclp_read_req.list, &sclp_req_queue);
 	}
 }
 /* Set up request retry timer. Called while sclp_lock is locked. */
 static inline void
 __sclp_set_request_timer(unsigned long time, void (*function)(unsigned long),
 			 unsigned long data)
 {
 	del_timer(&sclp_request_timer);
 	sclp_request_timer.function = function;
 	sclp_request_timer.data = data;
 	sclp_request_timer.expires = jiffies + time;
 	add_timer(&sclp_request_timer);
 }
 /* Request timeout handler. Restart the request queue. If DATA is non-zero,
  * force restart of running request. */
 static void
 sclp_request_timeout(unsigned long data)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (data) {
 		if (sclp_running_state == sclp_running_state_running) {
 			/* Break running state and queue NOP read event request
 			 * to get a defined interface state. */
 			__sclp_queue_read_req();
 			sclp_running_state = sclp_running_state_idle;
 		}
 	} else {
 		__sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 					 sclp_request_timeout, 0);
 	}
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	sclp_process_queue();
 }
 /* Try to start a request. Return zero if the request was successfully
  * started or if it will be started at a later time. Return non-zero otherwise.
  * Called while sclp_lock is locked. */
 static int
 __sclp_start_request(struct sclp_req *req)
 {
 	int rc;
 	if (sclp_running_state != sclp_running_state_idle)
 		return 0;
 	del_timer(&sclp_request_timer);
 	rc = sclp_service_call(req->command, req->sccb);
 	req->start_count++;
 	if (rc == 0) {
 		/* Successfully started request */
 		req->status = SCLP_REQ_RUNNING;
 		sclp_running_state = sclp_running_state_running;
 		__sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
 					 sclp_request_timeout, 1);
 		return 0;
 	} else if (rc == -EBUSY) {
 		/* Try again later */
 		__sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 					 sclp_request_timeout, 0);
 		return 0;
 	}
 	/* Request failed */
 	req->status = SCLP_REQ_FAILED;
 	return rc;
 }
 /* Try to start queued requests. */
 static void
 sclp_process_queue(void)
 {
 	struct sclp_req *req;
 	int rc;
 	unsigned long flags;
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (sclp_running_state != sclp_running_state_idle) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return;
 	}
 	del_timer(&sclp_request_timer);
 	while (!list_empty(&sclp_req_queue)) {
 		req = list_entry(sclp_req_queue.next, struct sclp_req, list);
 		if (!req->sccb)
 			goto do_post;
 		rc = __sclp_start_request(req);
 		if (rc == 0)
 			break;
 		/* Request failed */
 		if (req->start_count > 1) {
 			/* Cannot abort already submitted request - could still
 			 * be active at the SCLP */
 			__sclp_set_request_timer(SCLP_BUSY_INTERVAL * HZ,
 						 sclp_request_timeout, 0);
 			break;
 		}
 do_post:
 		/* Post-processing for aborted request */
 		list_del(&req->list);
 		if (req->callback) {
 			spin_unlock_irqrestore(&sclp_lock, flags);
 			req->callback(req, req->callback_data);
 			spin_lock_irqsave(&sclp_lock, flags);
 		}
 	}
 	spin_unlock_irqrestore(&sclp_lock, flags);
 }
 static int __sclp_can_add_request(struct sclp_req *req)
 {
 	if (req == &sclp_suspend_req || req == &sclp_init_req)
 		return 1;
 	if (sclp_suspend_state != sclp_suspend_state_running)
 		return 0;
 	if (sclp_init_state != sclp_init_state_initialized)
 		return 0;
 	if (sclp_activation_state != sclp_activation_state_active)
 		return 0;
 	return 1;
 }
 /* Queue a new request. Return zero on success, non-zero otherwise. */
 int
 sclp_add_request(struct sclp_req *req)
 {
 	unsigned long flags;
 	int rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (!__sclp_can_add_request(req)) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EIO;
 	}
 	req->status = SCLP_REQ_QUEUED;
 	req->start_count = 0;
 	list_add_tail(&req->list, &sclp_req_queue);
 	rc = 0;
 	/* Start if request is first in list */
 	if (sclp_running_state == sclp_running_state_idle &&
 	    req->list.prev == &sclp_req_queue) {
 		if (!req->sccb) {
 			list_del(&req->list);
 			rc = -ENODATA;
 			goto out;
 		}
 		rc = __sclp_start_request(req);
 		if (rc)
 			list_del(&req->list);
 	}
 out:
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 EXPORT_SYMBOL(sclp_add_request);
 /* Dispatch events found in request buffer to registered listeners. Return 0
  * if all events were dispatched, non-zero otherwise. */
 static int
 sclp_dispatch_evbufs(struct sccb_header *sccb)
 {
 	unsigned long flags;
 	struct evbuf_header *evbuf;
 	struct list_head *l;
 	struct sclp_register *reg;
 	int offset;
 	int rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	rc = 0;
 	for (offset = sizeof(struct sccb_header); offset < sccb->length;
 	     offset += evbuf->length) {
 		evbuf = (struct evbuf_header *) ((addr_t) sccb + offset);
 		/* Check for malformed hardware response */
 		if (evbuf->length == 0)
 			break;
 		/* Search for event handler */
 		reg = NULL;
 		list_for_each(l, &sclp_reg_list) {
 			reg = list_entry(l, struct sclp_register, list);
 			if (reg->receive_mask & (1 << (32 - evbuf->type)))
 				break;
 			else
 				reg = NULL;
 		}
 		if (reg && reg->receiver_fn) {
 			spin_unlock_irqrestore(&sclp_lock, flags);
 			reg->receiver_fn(evbuf);
 			spin_lock_irqsave(&sclp_lock, flags);
 		} else if (reg == NULL)
 			rc = -ENOSYS;
 	}
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 /* Read event data request callback. */
 static void
 sclp_read_cb(struct sclp_req *req, void *data)
 {
 	unsigned long flags;
 	struct sccb_header *sccb;
 	sccb = (struct sccb_header *) req->sccb;
 	if (req->status == SCLP_REQ_DONE && (sccb->response_code == 0x20 ||
 	    sccb->response_code == 0x220))
 		sclp_dispatch_evbufs(sccb);
 	spin_lock_irqsave(&sclp_lock, flags);
 	sclp_reading_state = sclp_reading_state_idle;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 }
 /* Prepare read event data request. Called while sclp_lock is locked. */
 static void __sclp_make_read_req(void)
 {
 	struct sccb_header *sccb;
 	sccb = (struct sccb_header *) sclp_read_sccb;
 	clear_page(sccb);
 	memset(&sclp_read_req, 0, sizeof(struct sclp_req));
 	sclp_read_req.command = SCLP_CMDW_READ_EVENT_DATA;
 	sclp_read_req.status = SCLP_REQ_QUEUED;
 	sclp_read_req.start_count = 0;
 	sclp_read_req.callback = sclp_read_cb;
 	sclp_read_req.sccb = sccb;
 	sccb->length = PAGE_SIZE;
 	sccb->function_code = 0;
 	sccb->control_mask[2] = 0x80;
 }
 /* Search request list for request with matching sccb. Return request if found,
  * NULL otherwise. Called while sclp_lock is locked. */
 static inline struct sclp_req *
 __sclp_find_req(u32 sccb)
 {
 	struct list_head *l;
 	struct sclp_req *req;
 	list_for_each(l, &sclp_req_queue) {
 		req = list_entry(l, struct sclp_req, list);
 		if (sccb == (u32) (addr_t) req->sccb)
 				return req;
 	}
 	return NULL;
 }
 /* Handler for external interruption. Perform request post-processing.
  * Prepare read event data request if necessary. Start processing of next
  * request on queue. */
 static void sclp_interrupt_handler(unsigned int ext_int_code,
 				   unsigned int param32, unsigned long param64)
 {
 	struct sclp_req *req;
 	u32 finished_sccb;
 	u32 evbuf_pending;
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
 	spin_lock(&sclp_lock);
 	finished_sccb = param32 & 0xfffffff8;
 	evbuf_pending = param32 & 0x3;
 	if (finished_sccb) {
 		del_timer(&sclp_request_timer);
 		sclp_running_state = sclp_running_state_reset_pending;
 		req = __sclp_find_req(finished_sccb);
 		if (req) {
 			/* Request post-processing */
 			list_del(&req->list);
 			req->status = SCLP_REQ_DONE;
 			if (req->callback) {
 				spin_unlock(&sclp_lock);
 				req->callback(req, req->callback_data);
 				spin_lock(&sclp_lock);
 			}
 		}
 		sclp_running_state = sclp_running_state_idle;
 	}
 	if (evbuf_pending &&
 	    sclp_activation_state == sclp_activation_state_active)
 		__sclp_queue_read_req();
 	spin_unlock(&sclp_lock);
 	sclp_process_queue();
 }
 /* Convert interval in jiffies to TOD ticks. */
 static inline u64
 sclp_tod_from_jiffies(unsigned long jiffies)
 {
 	return (u64) (jiffies / HZ) << 32;
 }
 /* Wait until a currently running request finished. Note: while this function
  * is running, no timers are served on the calling CPU. */
 void
 sclp_sync_wait(void)
 {
 	unsigned long long old_tick;
 	unsigned long flags;
 	unsigned long cr0, cr0_sync;
 	u64 timeout;
 	int irq_context;
 	/* We'll be disabling timer interrupts, so we need a custom timeout
 	 * mechanism */
 	timeout = 0;
 	if (timer_pending(&sclp_request_timer)) {
 		/* Get timeout TOD value */
 		timeout = get_clock() +
 			  sclp_tod_from_jiffies(sclp_request_timer.expires -
 						jiffies);
 	}
 	local_irq_save(flags);
 	/* Prevent bottom half from executing once we force interrupts open */
 	irq_context = in_interrupt();
 	if (!irq_context)
 		local_bh_disable();
 	/* Enable service-signal interruption, disable timer interrupts */
 	old_tick = local_tick_disable();
 	trace_hardirqs_on();
 	__ctl_store(cr0, 0, 0);
 	cr0_sync = cr0;
 	cr0_sync &= 0xffff00a0;
 	cr0_sync |= 0x00000200;
 	__ctl_load(cr0_sync, 0, 0);
 	__arch_local_irq_stosm(0x01);
 	/* Loop until driver state indicates finished request */
 	while (sclp_running_state != sclp_running_state_idle) {
 		/* Check for expired request timer */
 		if (timer_pending(&sclp_request_timer) &&
 		    get_clock() > timeout &&
 		    del_timer(&sclp_request_timer))
 			sclp_request_timer.function(sclp_request_timer.data);
 		cpu_relax();
 	}
 	local_irq_disable();
 	__ctl_load(cr0, 0, 0);
 	if (!irq_context)
 		_local_bh_enable();
 	local_tick_enable(old_tick);
 	local_irq_restore(flags);
 }
 EXPORT_SYMBOL(sclp_sync_wait);
 /* Dispatch changes in send and receive mask to registered listeners. */
 static void
 sclp_dispatch_state_change(void)
 {
 	struct list_head *l;
 	struct sclp_register *reg;
 	unsigned long flags;
 	sccb_mask_t receive_mask;
 	sccb_mask_t send_mask;
 	do {
 		spin_lock_irqsave(&sclp_lock, flags);
 		reg = NULL;
 		list_for_each(l, &sclp_reg_list) {
 			reg = list_entry(l, struct sclp_register, list);
 			receive_mask = reg->send_mask & sclp_receive_mask;
 			send_mask = reg->receive_mask & sclp_send_mask;
 			if (reg->sclp_receive_mask != receive_mask ||
 			    reg->sclp_send_mask != send_mask) {
 				reg->sclp_receive_mask = receive_mask;
 				reg->sclp_send_mask = send_mask;
 				break;
 			} else
 				reg = NULL;
 		}
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		if (reg && reg->state_change_fn)
 			reg->state_change_fn(reg);
 	} while (reg);
 }
 struct sclp_statechangebuf {
 	struct evbuf_header	header;
 	u8		validity_sclp_active_facility_mask : 1;
 	u8		validity_sclp_receive_mask : 1;
 	u8		validity_sclp_send_mask : 1;
 	u8		validity_read_data_function_mask : 1;
 	u16		_zeros : 12;
 	u16		mask_length;
 	u64		sclp_active_facility_mask;
 	sccb_mask_t	sclp_receive_mask;
 	sccb_mask_t	sclp_send_mask;
 	u32		read_data_function_mask;
 } __attribute__((packed));
 /* State change event callback. Inform listeners of changes. */
 static void
 sclp_state_change_cb(struct evbuf_header *evbuf)
 {
 	unsigned long flags;
 	struct sclp_statechangebuf *scbuf;
 	scbuf = (struct sclp_statechangebuf *) evbuf;
 	if (scbuf->mask_length != sizeof(sccb_mask_t))
 		return;
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (scbuf->validity_sclp_receive_mask)
 		sclp_receive_mask = scbuf->sclp_receive_mask;
 	if (scbuf->validity_sclp_send_mask)
 		sclp_send_mask = scbuf->sclp_send_mask;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	if (scbuf->validity_sclp_active_facility_mask)
 		sclp_facilities = scbuf->sclp_active_facility_mask;
 	sclp_dispatch_state_change();
 }
 static struct sclp_register sclp_state_change_event = {
 	.receive_mask = EVTYP_STATECHANGE_MASK,
 	.receiver_fn = sclp_state_change_cb
 };
 /* Calculate receive and send mask of currently registered listeners.
  * Called while sclp_lock is locked. */
 static inline void
 __sclp_get_mask(sccb_mask_t *receive_mask, sccb_mask_t *send_mask)
 {
 	struct list_head *l;
 	struct sclp_register *t;
 	*receive_mask = 0;
 	*send_mask = 0;
 	list_for_each(l, &sclp_reg_list) {
 		t = list_entry(l, struct sclp_register, list);
 		*receive_mask |= t->receive_mask;
 		*send_mask |= t->send_mask;
 	}
 }
 /* Register event listener. Return 0 on success, non-zero otherwise. */
 int
 sclp_register(struct sclp_register *reg)
 {
 	unsigned long flags;
 	sccb_mask_t receive_mask;
 	sccb_mask_t send_mask;
 	int rc;
 	rc = sclp_init();
 	if (rc)
 		return rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Check event mask for collisions */
 	__sclp_get_mask(&receive_mask, &send_mask);
 	if (reg->receive_mask & receive_mask || reg->send_mask & send_mask) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EBUSY;
 	}
 	/* Trigger initial state change callback */
 	reg->sclp_receive_mask = 0;
 	reg->sclp_send_mask = 0;
 	reg->pm_event_posted = 0;
 	list_add(&reg->list, &sclp_reg_list);
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	rc = sclp_init_mask(1);
 	if (rc) {
 		spin_lock_irqsave(&sclp_lock, flags);
 		list_del(&reg->list);
 		spin_unlock_irqrestore(&sclp_lock, flags);
 	}
 	return rc;
 }
 EXPORT_SYMBOL(sclp_register);
 /* Unregister event listener. */
 void
 sclp_unregister(struct sclp_register *reg)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&sclp_lock, flags);
 	list_del(&reg->list);
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	sclp_init_mask(1);
 }
 EXPORT_SYMBOL(sclp_unregister);
 /* Remove event buffers which are marked processed. Return the number of
  * remaining event buffers. */
 int
 sclp_remove_processed(struct sccb_header *sccb)
 {
 	struct evbuf_header *evbuf;
 	int unprocessed;
 	u16 remaining;
 	evbuf = (struct evbuf_header *) (sccb + 1);
 	unprocessed = 0;
 	remaining = sccb->length - sizeof(struct sccb_header);
 	while (remaining > 0) {
 		remaining -= evbuf->length;
 		if (evbuf->flags & 0x80) {
 			sccb->length -= evbuf->length;
 			memcpy(evbuf, (void *) ((addr_t) evbuf + evbuf->length),
 			       remaining);
 		} else {
 			unprocessed++;
 			evbuf = (struct evbuf_header *)
 					((addr_t) evbuf + evbuf->length);
 		}
 	}
 	return unprocessed;
 }
 EXPORT_SYMBOL(sclp_remove_processed);
 struct init_sccb {
 	struct sccb_header header;
 	u16 _reserved;
 	u16 mask_length;
 	sccb_mask_t receive_mask;
 	sccb_mask_t send_mask;
 	sccb_mask_t sclp_receive_mask;
 	sccb_mask_t sclp_send_mask;
 } __attribute__((packed));
 /* Prepare init mask request. Called while sclp_lock is locked. */
 static inline void
 __sclp_make_init_req(u32 receive_mask, u32 send_mask)
 {
 	struct init_sccb *sccb;
 	sccb = (struct init_sccb *) sclp_init_sccb;
 	clear_page(sccb);
 	memset(&sclp_init_req, 0, sizeof(struct sclp_req));
 	sclp_init_req.command = SCLP_CMDW_WRITE_EVENT_MASK;
 	sclp_init_req.status = SCLP_REQ_FILLED;
 	sclp_init_req.start_count = 0;
 	sclp_init_req.callback = NULL;
 	sclp_init_req.callback_data = NULL;
 	sclp_init_req.sccb = sccb;
 	sccb->header.length = sizeof(struct init_sccb);
 	sccb->mask_length = sizeof(sccb_mask_t);
 	sccb->receive_mask = receive_mask;
 	sccb->send_mask = send_mask;
 	sccb->sclp_receive_mask = 0;
 	sccb->sclp_send_mask = 0;
 }
 /* Start init mask request. If calculate is non-zero, calculate the mask as
  * requested by registered listeners. Use zero mask otherwise. Return 0 on
  * success, non-zero otherwise. */
 static int
 sclp_init_mask(int calculate)
 {
 	unsigned long flags;
 	struct init_sccb *sccb = (struct init_sccb *) sclp_init_sccb;
 	sccb_mask_t receive_mask;
 	sccb_mask_t send_mask;
 	int retry;
 	int rc;
 	unsigned long wait;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Check if interface is in appropriate state */
 	if (sclp_mask_state != sclp_mask_state_idle) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EBUSY;
 	}
 	if (sclp_activation_state == sclp_activation_state_inactive) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EINVAL;
 	}
 	sclp_mask_state = sclp_mask_state_initializing;
 	/* Determine mask */
 	if (calculate)
 		__sclp_get_mask(&receive_mask, &send_mask);
 	else {
 		receive_mask = 0;
 		send_mask = 0;
 	}
 	rc = -EIO;
 	for (retry = 0; retry <= SCLP_MASK_RETRY; retry++) {
 		/* Prepare request */
 		__sclp_make_init_req(receive_mask, send_mask);
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		if (sclp_add_request(&sclp_init_req)) {
 			/* Try again later */
 			wait = jiffies + SCLP_BUSY_INTERVAL * HZ;
 			while (time_before(jiffies, wait))
 				sclp_sync_wait();
 			spin_lock_irqsave(&sclp_lock, flags);
 			continue;
 		}
 		while (sclp_init_req.status != SCLP_REQ_DONE &&
 		       sclp_init_req.status != SCLP_REQ_FAILED)
 			sclp_sync_wait();
 		spin_lock_irqsave(&sclp_lock, flags);
 		if (sclp_init_req.status == SCLP_REQ_DONE &&
 		    sccb->header.response_code == 0x20) {
 			/* Successful request */
 			if (calculate) {
 				sclp_receive_mask = sccb->sclp_receive_mask;
 				sclp_send_mask = sccb->sclp_send_mask;
 			} else {
 				sclp_receive_mask = 0;
 				sclp_send_mask = 0;
 			}
 			spin_unlock_irqrestore(&sclp_lock, flags);
 			sclp_dispatch_state_change();
 			spin_lock_irqsave(&sclp_lock, flags);
 			rc = 0;
 			break;
 		}
 	}
 	sclp_mask_state = sclp_mask_state_idle;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 /* Deactivate SCLP interface. On success, new requests will be rejected,
  * events will no longer be dispatched. Return 0 on success, non-zero
  * otherwise. */
 int
 sclp_deactivate(void)
 {
 	unsigned long flags;
 	int rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Deactivate can only be called when active */
 	if (sclp_activation_state != sclp_activation_state_active) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EINVAL;
 	}
 	sclp_activation_state = sclp_activation_state_deactivating;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	rc = sclp_init_mask(0);
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (rc == 0)
 		sclp_activation_state = sclp_activation_state_inactive;
 	else
 		sclp_activation_state = sclp_activation_state_active;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 EXPORT_SYMBOL(sclp_deactivate);
 /* Reactivate SCLP interface after sclp_deactivate. On success, new
  * requests will be accepted, events will be dispatched again. Return 0 on
  * success, non-zero otherwise. */
 int
 sclp_reactivate(void)
 {
 	unsigned long flags;
 	int rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Reactivate can only be called when inactive */
 	if (sclp_activation_state != sclp_activation_state_inactive) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return -EINVAL;
 	}
 	sclp_activation_state = sclp_activation_state_activating;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	rc = sclp_init_mask(1);
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (rc == 0)
 		sclp_activation_state = sclp_activation_state_active;
 	else
 		sclp_activation_state = sclp_activation_state_inactive;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 EXPORT_SYMBOL(sclp_reactivate);
 /* Handler for external interruption used during initialization. Modify
  * request state to done. */
 static void sclp_check_handler(unsigned int ext_int_code,
 			       unsigned int param32, unsigned long param64)
 {
 	u32 finished_sccb;
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_SCP]++;
 	finished_sccb = param32 & 0xfffffff8;
 	/* Is this the interrupt we are waiting for? */
 	if (finished_sccb == 0)
 		return;
 	if (finished_sccb != (u32) (addr_t) sclp_init_sccb)
 		panic("sclp: unsolicited interrupt for buffer at 0x%x\n",
 		      finished_sccb);
 	spin_lock(&sclp_lock);
 	if (sclp_running_state == sclp_running_state_running) {
 		sclp_init_req.status = SCLP_REQ_DONE;
 		sclp_running_state = sclp_running_state_idle;
 	}
 	spin_unlock(&sclp_lock);
 }
 /* Initial init mask request timed out. Modify request state to failed. */
 static void
 sclp_check_timeout(unsigned long data)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (sclp_running_state == sclp_running_state_running) {
 		sclp_init_req.status = SCLP_REQ_FAILED;
 		sclp_running_state = sclp_running_state_idle;
 	}
 	spin_unlock_irqrestore(&sclp_lock, flags);
 }
 /* Perform a check of the SCLP interface. Return zero if the interface is
  * available and there are no pending requests from a previous instance.
  * Return non-zero otherwise. */
 static int
 sclp_check_interface(void)
 {
 	struct init_sccb *sccb;
 	unsigned long flags;
 	int retry;
 	int rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Prepare init mask command */
 	rc = register_external_interrupt(0x2401, sclp_check_handler);
 	if (rc) {
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return rc;
 	}
 	for (retry = 0; retry <= SCLP_INIT_RETRY; retry++) {
 		__sclp_make_init_req(0, 0);
 		sccb = (struct init_sccb *) sclp_init_req.sccb;
 		rc = sclp_service_call(sclp_init_req.command, sccb);
 		if (rc == -EIO)
 			break;
 		sclp_init_req.status = SCLP_REQ_RUNNING;
 		sclp_running_state = sclp_running_state_running;
 		__sclp_set_request_timer(SCLP_RETRY_INTERVAL * HZ,
 					 sclp_check_timeout, 0);
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		/* Enable service-signal interruption - needs to happen
 		 * with IRQs enabled. */
 		service_subclass_irq_register();
 		/* Wait for signal from interrupt or timeout */
 		sclp_sync_wait();
 		/* Disable service-signal interruption - needs to happen
 		 * with IRQs enabled. */
 		service_subclass_irq_unregister();
 		spin_lock_irqsave(&sclp_lock, flags);
 		del_timer(&sclp_request_timer);
 		if (sclp_init_req.status == SCLP_REQ_DONE &&
 		    sccb->header.response_code == 0x20) {
 			rc = 0;
 			break;
 		} else
 			rc = -EBUSY;
 	}
 	unregister_external_interrupt(0x2401, sclp_check_handler);
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 /* Reboot event handler. Reset send and receive mask to prevent pending SCLP
  * events from interfering with rebooted system. */
 static int
 sclp_reboot_event(struct notifier_block *this, unsigned long event, void *ptr)
 {
 	sclp_deactivate();
 	return NOTIFY_DONE;
 }
 static struct notifier_block sclp_reboot_notifier = {
 	.notifier_call = sclp_reboot_event
 };
 /*
  * Suspend/resume SCLP notifier implementation
  */
 static void sclp_pm_event(enum sclp_pm_event sclp_pm_event, int rollback)
 {
 	struct sclp_register *reg;
 	unsigned long flags;
 	if (!rollback) {
 		spin_lock_irqsave(&sclp_lock, flags);
 		list_for_each_entry(reg, &sclp_reg_list, list)
 			reg->pm_event_posted = 0;
 		spin_unlock_irqrestore(&sclp_lock, flags);
 	}
 	do {
 		spin_lock_irqsave(&sclp_lock, flags);
 		list_for_each_entry(reg, &sclp_reg_list, list) {
 			if (rollback && reg->pm_event_posted)
 				goto found;
 			if (!rollback && !reg->pm_event_posted)
 				goto found;
 		}
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		return;
 found:
 		spin_unlock_irqrestore(&sclp_lock, flags);
 		if (reg->pm_event_fn)
 			reg->pm_event_fn(reg, sclp_pm_event);
 		reg->pm_event_posted = rollback ? 0 : 1;
 	} while (1);
 }
 /*
  * Susend/resume callbacks for platform device
  */
 static int sclp_freeze(struct device *dev)
 {
 	unsigned long flags;
 	int rc;
 	sclp_pm_event(SCLP_PM_EVENT_FREEZE, 0);
 	spin_lock_irqsave(&sclp_lock, flags);
 	sclp_suspend_state = sclp_suspend_state_suspended;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	/* Init supend data */
 	memset(&sclp_suspend_req, 0, sizeof(sclp_suspend_req));
 	sclp_suspend_req.callback = sclp_suspend_req_cb;
 	sclp_suspend_req.status = SCLP_REQ_FILLED;
 	init_completion(&sclp_request_queue_flushed);
 	rc = sclp_add_request(&sclp_suspend_req);
 	if (rc == 0)
 		wait_for_completion(&sclp_request_queue_flushed);
 	else if (rc != -ENODATA)
 		goto fail_thaw;
 	rc = sclp_deactivate();
 	if (rc)
 		goto fail_thaw;
 	return 0;
 fail_thaw:
 	spin_lock_irqsave(&sclp_lock, flags);
 	sclp_suspend_state = sclp_suspend_state_running;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	sclp_pm_event(SCLP_PM_EVENT_THAW, 1);
 	return rc;
 }
 static int sclp_undo_suspend(enum sclp_pm_event event)
 {
 	unsigned long flags;
 	int rc;
 	rc = sclp_reactivate();
 	if (rc)
 		return rc;
 	spin_lock_irqsave(&sclp_lock, flags);
 	sclp_suspend_state = sclp_suspend_state_running;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	sclp_pm_event(event, 0);
 	return 0;
 }
 static int sclp_thaw(struct device *dev)
 {
 	return sclp_undo_suspend(SCLP_PM_EVENT_THAW);
 }
 static int sclp_restore(struct device *dev)
 {
 	return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);
 }
 static const struct dev_pm_ops sclp_pm_ops = {
 	.freeze		= sclp_freeze,
 	.thaw		= sclp_thaw,
 	.restore	= sclp_restore,
 };
 static struct platform_driver sclp_pdrv = {
 	.driver = {
 		.name	= "sclp",
 		.owner	= THIS_MODULE,
 		.pm	= &sclp_pm_ops,
 	},
 };
 static struct platform_device *sclp_pdev;
 /* Initialize SCLP driver. Return zero if driver is operational, non-zero
  * otherwise. */
 static int
 sclp_init(void)
 {
 	unsigned long flags;
 	int rc = 0;
 	spin_lock_irqsave(&sclp_lock, flags);
 	/* Check for previous or running initialization */
 	if (sclp_init_state != sclp_init_state_uninitialized)
 		goto fail_unlock;
 	sclp_init_state = sclp_init_state_initializing;
 	/* Set up variables */
 	INIT_LIST_HEAD(&sclp_req_queue);
 	INIT_LIST_HEAD(&sclp_reg_list);
 	list_add(&sclp_state_change_event.list, &sclp_reg_list);
 	init_timer(&sclp_request_timer);
 	/* Check interface */
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	rc = sclp_check_interface();
 	spin_lock_irqsave(&sclp_lock, flags);
 	if (rc)
 		goto fail_init_state_uninitialized;
 	/* Register reboot handler */
 	rc = register_reboot_notifier(&sclp_reboot_notifier);
 	if (rc)
 		goto fail_init_state_uninitialized;
 	/* Register interrupt handler */
 	rc = register_external_interrupt(0x2401, sclp_interrupt_handler);
 	if (rc)
 		goto fail_unregister_reboot_notifier;
 	sclp_init_state = sclp_init_state_initialized;
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	/* Enable service-signal external interruption - needs to happen with
 	 * IRQs enabled. */
 	service_subclass_irq_register();
 	sclp_init_mask(1);
 	return 0;
 fail_unregister_reboot_notifier:
 	unregister_reboot_notifier(&sclp_reboot_notifier);
 fail_init_state_uninitialized:
 	sclp_init_state = sclp_init_state_uninitialized;
 fail_unlock:
 	spin_unlock_irqrestore(&sclp_lock, flags);
 	return rc;
 }
 /*
  * SCLP panic notifier: If we are suspended, we thaw SCLP in order to be able
  * to print the panic message.
  */
 static int sclp_panic_notify(struct notifier_block *self,
 			     unsigned long event, void *data)
 {
 	if (sclp_suspend_state == sclp_suspend_state_suspended)
 		sclp_undo_suspend(SCLP_PM_EVENT_THAW);
 	return NOTIFY_OK;
 }
 static struct notifier_block sclp_on_panic_nb = {
 	.notifier_call = sclp_panic_notify,
 	.priority = SCLP_PANIC_PRIO,
 };
 static __init int sclp_initcall(void)
 {
 	int rc;
 	rc = platform_driver_register(&sclp_pdrv);
 	if (rc)
 		return rc;
 	sclp_pdev = platform_device_register_simple("sclp", -1, NULL, 0);
 	rc = IS_ERR(sclp_pdev) ? PTR_ERR(sclp_pdev) : 0;
 	if (rc)
 		goto fail_platform_driver_unregister;
 	rc = atomic_notifier_chain_register(&panic_notifier_list,
 					    &sclp_on_panic_nb);
 	if (rc)
 		goto fail_platform_device_unregister;
 	return sclp_init();
 fail_platform_device_unregister:
 	platform_device_unregister(sclp_pdev);
 fail_platform_driver_unregister:
 	platform_driver_unregister(&sclp_pdrv);
 	return rc;
 }
 arch_initcall(sclp_initcall);

drivers/s390/kvm/kvm_virtio.c

Diff comments View file @ d7b250e

 /*
  * kvm_virtio.c - virtio for kvm on s390
  *
  * Copyright IBM Corp. 2008
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License (version 2 only)
  * as published by the Free Software Foundation.
  *
  *    Author(s): Christian Borntraeger <borntraeger@de.ibm.com>
  */
 #include <linux/kernel_stat.h>
 #include <linux/init.h>
 #include <linux/bootmem.h>
 #include <linux/err.h>
 #include <linux/virtio.h>
 #include <linux/virtio_config.h>
 #include <linux/slab.h>
 #include <linux/virtio_console.h>
 #include <linux/interrupt.h>
 #include <linux/virtio_ring.h>
 #include <linux/pfn.h>
 #include <asm/io.h>
 #include <asm/kvm_para.h>
 #include <asm/kvm_virtio.h>
 #include <asm/setup.h>
-#include <asm/s390_ext.h>
 #include <asm/irq.h>
 #define VIRTIO_SUBCODE_64 0x0D00
 /*
  * The pointer to our (page) of device descriptions.
  */
 static void *kvm_devices;
 struct work_struct hotplug_work;
 struct kvm_device {
 	struct virtio_device vdev;
 	struct kvm_device_desc *desc;
 };
 #define to_kvmdev(vd) container_of(vd, struct kvm_device, vdev)
 /*
  * memory layout:
  * - kvm_device_descriptor
  *        struct kvm_device_desc
  * - configuration
  *        struct kvm_vqconfig
  * - feature bits
  * - config space
  */
 static struct kvm_vqconfig *kvm_vq_config(const struct kvm_device_desc *desc)
 {
 	return (struct kvm_vqconfig *)(desc + 1);
 }
 static u8 *kvm_vq_features(const struct kvm_device_desc *desc)
 {
 	return (u8 *)(kvm_vq_config(desc) + desc->num_vq);
 }
 static u8 *kvm_vq_configspace(const struct kvm_device_desc *desc)
 {
 	return kvm_vq_features(desc) + desc->feature_len * 2;
 }
 /*
  * The total size of the config page used by this device (incl. desc)
  */
 static unsigned desc_size(const struct kvm_device_desc *desc)
 {
 	return sizeof(*desc)
 		+ desc->num_vq * sizeof(struct kvm_vqconfig)
 		+ desc->feature_len * 2
 		+ desc->config_len;
 }
 /* This gets the device's feature bits. */
 static u32 kvm_get_features(struct virtio_device *vdev)
 {
 	unsigned int i;
 	u32 features = 0;
 	struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
 	u8 *in_features = kvm_vq_features(desc);
 	for (i = 0; i < min(desc->feature_len * 8, 32); i++)
 		if (in_features[i / 8] & (1 << (i % 8)))
 			features |= (1 << i);
 	return features;
 }
 static void kvm_finalize_features(struct virtio_device *vdev)
 {
 	unsigned int i, bits;
 	struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
 	/* Second half of bitmap is features we accept. */
 	u8 *out_features = kvm_vq_features(desc) + desc->feature_len;
 	/* Give virtio_ring a chance to accept features. */
 	vring_transport_features(vdev);
 	memset(out_features, 0, desc->feature_len);
 	bits = min_t(unsigned, desc->feature_len, sizeof(vdev->features)) * 8;
 	for (i = 0; i < bits; i++) {
 		if (test_bit(i, vdev->features))
 			out_features[i / 8] |= (1 << (i % 8));
 	}
 }
 /*
  * Reading and writing elements in config space
  */
 static void kvm_get(struct virtio_device *vdev, unsigned int offset,
 		   void *buf, unsigned len)
 {
 	struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
 	BUG_ON(offset + len > desc->config_len);
 	memcpy(buf, kvm_vq_configspace(desc) + offset, len);
 }
 static void kvm_set(struct virtio_device *vdev, unsigned int offset,
 		   const void *buf, unsigned len)
 {
 	struct kvm_device_desc *desc = to_kvmdev(vdev)->desc;
 	BUG_ON(offset + len > desc->config_len);
 	memcpy(kvm_vq_configspace(desc) + offset, buf, len);
 }
 /*
  * The operations to get and set the status word just access
  * the status field of the device descriptor. set_status will also
  * make a hypercall to the host, to tell about status changes
  */
 static u8 kvm_get_status(struct virtio_device *vdev)
 {
 	return to_kvmdev(vdev)->desc->status;
 }
 static void kvm_set_status(struct virtio_device *vdev, u8 status)
 {
 	BUG_ON(!status);
 	to_kvmdev(vdev)->desc->status = status;
 	kvm_hypercall1(KVM_S390_VIRTIO_SET_STATUS,
 		       (unsigned long) to_kvmdev(vdev)->desc);
 }
 /*
  * To reset the device, we use the KVM_VIRTIO_RESET hypercall, using the
  * descriptor address. The Host will zero the status and all the
  * features.
  */
 static void kvm_reset(struct virtio_device *vdev)
 {
 	kvm_hypercall1(KVM_S390_VIRTIO_RESET,
 		       (unsigned long) to_kvmdev(vdev)->desc);
 }
 /*
  * When the virtio_ring code wants to notify the Host, it calls us here and we
  * make a hypercall.  We hand the address  of the virtqueue so the Host
  * knows which virtqueue we're talking about.
  */
 static void kvm_notify(struct virtqueue *vq)
 {
 	struct kvm_vqconfig *config = vq->priv;
 	kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, config->address);
 }
 /*
  * This routine finds the first virtqueue described in the configuration of
  * this device and sets it up.
  */
 static struct virtqueue *kvm_find_vq(struct virtio_device *vdev,
 				     unsigned index,
 				     void (*callback)(struct virtqueue *vq),
 				     const char *name)
 {
 	struct kvm_device *kdev = to_kvmdev(vdev);
 	struct kvm_vqconfig *config;
 	struct virtqueue *vq;
 	int err;
 	if (index >= kdev->desc->num_vq)
 		return ERR_PTR(-ENOENT);
 	config = kvm_vq_config(kdev->desc)+index;
 	err = vmem_add_mapping(config->address,
 			       vring_size(config->num,
 					  KVM_S390_VIRTIO_RING_ALIGN));
 	if (err)
 		goto out;
 	vq = vring_new_virtqueue(config->num, KVM_S390_VIRTIO_RING_ALIGN,
 				 vdev, (void *) config->address,
 				 kvm_notify, callback, name);
 	if (!vq) {
 		err = -ENOMEM;
 		goto unmap;
 	}
 	/*
 	 * register a callback token
 	 * The host will sent this via the external interrupt parameter
 	 */
 	config->token = (u64) vq;
 	vq->priv = config;
 	return vq;
 unmap:
 	vmem_remove_mapping(config->address,
 			    vring_size(config->num,
 				       KVM_S390_VIRTIO_RING_ALIGN));
 out:
 	return ERR_PTR(err);
 }
 static void kvm_del_vq(struct virtqueue *vq)
 {
 	struct kvm_vqconfig *config = vq->priv;
 	vring_del_virtqueue(vq);
 	vmem_remove_mapping(config->address,
 			    vring_size(config->num,
 				       KVM_S390_VIRTIO_RING_ALIGN));
 }
 static void kvm_del_vqs(struct virtio_device *vdev)
 {
 	struct virtqueue *vq, *n;
 	list_for_each_entry_safe(vq, n, &vdev->vqs, list)
 		kvm_del_vq(vq);
 }
 static int kvm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 			struct virtqueue *vqs[],
 			vq_callback_t *callbacks[],
 			const char *names[])
 {
 	struct kvm_device *kdev = to_kvmdev(vdev);
 	int i;
 	/* We must have this many virtqueues. */
 	if (nvqs > kdev->desc->num_vq)
 		return -ENOENT;
 	for (i = 0; i < nvqs; ++i) {
 		vqs[i] = kvm_find_vq(vdev, i, callbacks[i], names[i]);
 		if (IS_ERR(vqs[i]))
 			goto error;
 	}
 	return 0;
 error:
 	kvm_del_vqs(vdev);
 	return PTR_ERR(vqs[i]);
 }
 /*
  * The config ops structure as defined by virtio config
  */
 static struct virtio_config_ops kvm_vq_configspace_ops = {
 	.get_features = kvm_get_features,
 	.finalize_features = kvm_finalize_features,
 	.get = kvm_get,
 	.set = kvm_set,
 	.get_status = kvm_get_status,
 	.set_status = kvm_set_status,
 	.reset = kvm_reset,
 	.find_vqs = kvm_find_vqs,
 	.del_vqs = kvm_del_vqs,
 };
 /*
  * The root device for the kvm virtio devices.
  * This makes them appear as /sys/devices/kvm_s390/0,1,2 not /sys/devices/0,1,2.
  */
 static struct device *kvm_root;
 /*
  * adds a new device and register it with virtio
  * appropriate drivers are loaded by the device model
  */
 static void add_kvm_device(struct kvm_device_desc *d, unsigned int offset)
 {
 	struct kvm_device *kdev;
 	kdev = kzalloc(sizeof(*kdev), GFP_KERNEL);
 	if (!kdev) {
 		printk(KERN_EMERG "Cannot allocate kvm dev %u type %u\n",
 		       offset, d->type);
 		return;
 	}
 	kdev->vdev.dev.parent = kvm_root;
 	kdev->vdev.id.device = d->type;
 	kdev->vdev.config = &kvm_vq_configspace_ops;
 	kdev->desc = d;
 	if (register_virtio_device(&kdev->vdev) != 0) {
 		printk(KERN_ERR "Failed to register kvm device %u type %u\n",
 		       offset, d->type);
 		kfree(kdev);
 	}
 }
 /*
  * scan_devices() simply iterates through the device page.
  * The type 0 is reserved to mean "end of devices".
  */
 static void scan_devices(void)
 {
 	unsigned int i;
 	struct kvm_device_desc *d;
 	for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
 		d = kvm_devices + i;
 		if (d->type == 0)
 			break;
 		add_kvm_device(d, i);
 	}
 }
 /*
  * match for a kvm device with a specific desc pointer
  */
 static int match_desc(struct device *dev, void *data)
 {
 	if ((ulong)to_kvmdev(dev_to_virtio(dev))->desc == (ulong)data)
 		return 1;
 	return 0;
 }
 /*
  * hotplug_device tries to find changes in the device page.
  */
 static void hotplug_devices(struct work_struct *dummy)
 {
 	unsigned int i;
 	struct kvm_device_desc *d;
 	struct device *dev;
 	for (i = 0; i < PAGE_SIZE; i += desc_size(d)) {
 		d = kvm_devices + i;
 		/* end of list */
 		if (d->type == 0)
 			break;
 		/* device already exists */
 		dev = device_find_child(kvm_root, d, match_desc);
 		if (dev) {
 			/* XXX check for hotplug remove */
 			put_device(dev);
 			continue;
 		}
 		/* new device */
 		printk(KERN_INFO "Adding new virtio device %p\n", d);
 		add_kvm_device(d, i);
 	}
 }
 /*
  * we emulate the request_irq behaviour on top of s390 extints
  */
 static void kvm_extint_handler(unsigned int ext_int_code,
 			       unsigned int param32, unsigned long param64)
 {
 	struct virtqueue *vq;
 	u16 subcode;
 	u32 param;
 	subcode = ext_int_code >> 16;
 	if ((subcode & 0xff00) != VIRTIO_SUBCODE_64)
 		return;
 	kstat_cpu(smp_processor_id()).irqs[EXTINT_VRT]++;
 	/* The LSB might be overloaded, we have to mask it */
 	vq = (struct virtqueue *)(param64 & ~1UL);
 	/* We use ext_params to decide what this interrupt means */
 	param = param32 & VIRTIO_PARAM_MASK;
 	switch (param) {
 	case VIRTIO_PARAM_CONFIG_CHANGED:
 	{
 		struct virtio_driver *drv;
 		drv = container_of(vq->vdev->dev.driver,
 				   struct virtio_driver, driver);
 		if (drv->config_changed)
 			drv->config_changed(vq->vdev);
 		break;
 	}
 	case VIRTIO_PARAM_DEV_ADD:
 		schedule_work(&hotplug_work);
 		break;
 	case VIRTIO_PARAM_VRING_INTERRUPT:
 	default:
 		vring_interrupt(0, vq);
 		break;
 	}
 }
 /*
  * Init function for virtio
  * devices are in a single page above top of "normal" mem
  */
 static int __init kvm_devices_init(void)
 {
 	int rc;
 	if (!MACHINE_IS_KVM)
 		return -ENODEV;
 	kvm_root = root_device_register("kvm_s390");
 	if (IS_ERR(kvm_root)) {
 		rc = PTR_ERR(kvm_root);
 		printk(KERN_ERR "Could not register kvm_s390 root device");
 		return rc;
 	}
 	rc = vmem_add_mapping(real_memory_size, PAGE_SIZE);
 	if (rc) {
 		root_device_unregister(kvm_root);
 		return rc;
 	}
 	kvm_devices = (void *) real_memory_size;
 	INIT_WORK(&hotplug_work, hotplug_devices);
 	service_subclass_irq_register();
 	register_external_interrupt(0x2603, kvm_extint_handler);
 	scan_devices();
 	return 0;
 }
 /* code for early console output with virtio_console */
 static __init int early_put_chars(u32 vtermno, const char *buf, int count)
 {
 	char scratch[17];
 	unsigned int len = count;
 	if (len > sizeof(scratch) - 1)
 		len = sizeof(scratch) - 1;
 	scratch[len] = '\0';
 	memcpy(scratch, buf, len);
 	kvm_hypercall1(KVM_S390_VIRTIO_NOTIFY, __pa(scratch));
 	return len;
 }
 static int __init s390_virtio_console_init(void)
 {
 	if (!MACHINE_IS_KVM)
 		return -ENODEV;
 	return virtio_cons_early_init(early_put_chars);
 }
 console_initcall(s390_virtio_console_init);
 /*
  * We do this after core stuff, but before the drivers.
  */
 postcore_initcall(kvm_devices_init);

net/iucv/iucv.c

Diff comments View file @ d7b250e

1	/*	1	/*
2	* IUCV base infrastructure.	2	* IUCV base infrastructure.
3	*	3	*
4	* Copyright IBM Corp. 2001, 2009	4	* Copyright IBM Corp. 2001, 2009
5	*	5	*
6	* Author(s):	6	* Author(s):
7	* Original source:	7	* Original source:
8	* Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000	8	* Alan Altmark (Alan_Altmark@us.ibm.com) Sept. 2000
9	* Xenia Tkatschow (xenia@us.ibm.com)	9	* Xenia Tkatschow (xenia@us.ibm.com)
10	* 2Gb awareness and general cleanup:	10	* 2Gb awareness and general cleanup:
11	* Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)	11	* Fritz Elfert (elfert@de.ibm.com, felfert@millenux.com)
12	* Rewritten for af_iucv:	12	* Rewritten for af_iucv:
13	* Martin Schwidefsky <schwidefsky@de.ibm.com>	13	* Martin Schwidefsky <schwidefsky@de.ibm.com>
14	* PM functions:	14	* PM functions:
15	* Ursula Braun (ursula.braun@de.ibm.com)	15	* Ursula Braun (ursula.braun@de.ibm.com)
16	*	16	*
17	* Documentation used:	17	* Documentation used:
18	* The original source	18	* The original source
19	* CP Programming Service, IBM document # SC24-5760	19	* CP Programming Service, IBM document # SC24-5760
20	*	20	*
21	* This program is free software; you can redistribute it and/or modify	21	* This program is free software; you can redistribute it and/or modify
22	* it under the terms of the GNU General Public License as published by	22	* it under the terms of the GNU General Public License as published by
23	* the Free Software Foundation; either version 2, or (at your option)	23	* the Free Software Foundation; either version 2, or (at your option)
24	* any later version.	24	* any later version.
25	*	25	*
26	* This program is distributed in the hope that it will be useful,	26	* This program is distributed in the hope that it will be useful,
27	* but WITHOUT ANY WARRANTY; without even the implied warranty of	27	* but WITHOUT ANY WARRANTY; without even the implied warranty of
28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29	* GNU General Public License for more details.	29	* GNU General Public License for more details.
30	*	30	*
31	* You should have received a copy of the GNU General Public License	31	* You should have received a copy of the GNU General Public License
32	* along with this program; if not, write to the Free Software	32	* along with this program; if not, write to the Free Software
33	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	33	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
34	*/	34	*/
35		35
36	#define KMSG_COMPONENT "iucv"	36	#define KMSG_COMPONENT "iucv"
37	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt	37	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
38		38
39	#include <linux/kernel_stat.h>	39	#include <linux/kernel_stat.h>
40	#include <linux/module.h>	40	#include <linux/module.h>
41	#include <linux/moduleparam.h>	41	#include <linux/moduleparam.h>
42	#include <linux/spinlock.h>	42	#include <linux/spinlock.h>
43	#include <linux/kernel.h>	43	#include <linux/kernel.h>
44	#include <linux/slab.h>	44	#include <linux/slab.h>
45	#include <linux/init.h>	45	#include <linux/init.h>
46	#include <linux/interrupt.h>	46	#include <linux/interrupt.h>
47	#include <linux/list.h>	47	#include <linux/list.h>
48	#include <linux/errno.h>	48	#include <linux/errno.h>
49	#include <linux/err.h>	49	#include <linux/err.h>
50	#include <linux/device.h>	50	#include <linux/device.h>
51	#include <linux/cpu.h>	51	#include <linux/cpu.h>
52	#include <linux/reboot.h>	52	#include <linux/reboot.h>
53	#include <net/iucv/iucv.h>	53	#include <net/iucv/iucv.h>
54	#include <asm/atomic.h>	54	#include <asm/atomic.h>
55	#include <asm/ebcdic.h>	55	#include <asm/ebcdic.h>
56	#include <asm/io.h>	56	#include <asm/io.h>
57	#include <asm/s390_ext.h>	57	#include <asm/irq.h>
58	#include <asm/smp.h>	58	#include <asm/smp.h>
59		59
60	/*	60	/*
61	* FLAGS:	61	* FLAGS:
62	* All flags are defined in the field IPFLAGS1 of each function	62	* All flags are defined in the field IPFLAGS1 of each function
63	* and can be found in CP Programming Services.	63	* and can be found in CP Programming Services.
64	* IPSRCCLS - Indicates you have specified a source class.	64	* IPSRCCLS - Indicates you have specified a source class.
65	* IPTRGCLS - Indicates you have specified a target class.	65	* IPTRGCLS - Indicates you have specified a target class.
66	* IPFGPID - Indicates you have specified a pathid.	66	* IPFGPID - Indicates you have specified a pathid.
67	* IPFGMID - Indicates you have specified a message ID.	67	* IPFGMID - Indicates you have specified a message ID.
68	* IPNORPY - Indicates a one-way message. No reply expected.	68	* IPNORPY - Indicates a one-way message. No reply expected.
69	* IPALL - Indicates that all paths are affected.	69	* IPALL - Indicates that all paths are affected.
70	*/	70	*/
71	#define IUCV_IPSRCCLS 0x01	71	#define IUCV_IPSRCCLS 0x01
72	#define IUCV_IPTRGCLS 0x01	72	#define IUCV_IPTRGCLS 0x01
73	#define IUCV_IPFGPID 0x02	73	#define IUCV_IPFGPID 0x02
74	#define IUCV_IPFGMID 0x04	74	#define IUCV_IPFGMID 0x04
75	#define IUCV_IPNORPY 0x10	75	#define IUCV_IPNORPY 0x10
76	#define IUCV_IPALL 0x80	76	#define IUCV_IPALL 0x80
77		77
78	static int iucv_bus_match(struct device dev, struct device_driver drv)	78	static int iucv_bus_match(struct device dev, struct device_driver drv)
79	{	79	{
80	return 0;	80	return 0;
81	}	81	}
82		82
83	enum iucv_pm_states {	83	enum iucv_pm_states {
84	IUCV_PM_INITIAL = 0,	84	IUCV_PM_INITIAL = 0,
85	IUCV_PM_FREEZING = 1,	85	IUCV_PM_FREEZING = 1,
86	IUCV_PM_THAWING = 2,	86	IUCV_PM_THAWING = 2,
87	IUCV_PM_RESTORING = 3,	87	IUCV_PM_RESTORING = 3,
88	};	88	};
89	static enum iucv_pm_states iucv_pm_state;	89	static enum iucv_pm_states iucv_pm_state;
90		90
91	static int iucv_pm_prepare(struct device *);	91	static int iucv_pm_prepare(struct device *);
92	static void iucv_pm_complete(struct device *);	92	static void iucv_pm_complete(struct device *);
93	static int iucv_pm_freeze(struct device *);	93	static int iucv_pm_freeze(struct device *);
94	static int iucv_pm_thaw(struct device *);	94	static int iucv_pm_thaw(struct device *);
95	static int iucv_pm_restore(struct device *);	95	static int iucv_pm_restore(struct device *);
96		96
97	static const struct dev_pm_ops iucv_pm_ops = {	97	static const struct dev_pm_ops iucv_pm_ops = {
98	.prepare = iucv_pm_prepare,	98	.prepare = iucv_pm_prepare,
99	.complete = iucv_pm_complete,	99	.complete = iucv_pm_complete,
100	.freeze = iucv_pm_freeze,	100	.freeze = iucv_pm_freeze,
101	.thaw = iucv_pm_thaw,	101	.thaw = iucv_pm_thaw,
102	.restore = iucv_pm_restore,	102	.restore = iucv_pm_restore,
103	};	103	};
104		104
105	struct bus_type iucv_bus = {	105	struct bus_type iucv_bus = {
106	.name = "iucv",	106	.name = "iucv",
107	.match = iucv_bus_match,	107	.match = iucv_bus_match,
108	.pm = &iucv_pm_ops,	108	.pm = &iucv_pm_ops,
109	};	109	};
110	EXPORT_SYMBOL(iucv_bus);	110	EXPORT_SYMBOL(iucv_bus);
111		111
112	struct device *iucv_root;	112	struct device *iucv_root;
113	EXPORT_SYMBOL(iucv_root);	113	EXPORT_SYMBOL(iucv_root);
114		114
115	static int iucv_available;	115	static int iucv_available;
116		116
117	/* General IUCV interrupt structure */	117	/* General IUCV interrupt structure */
118	struct iucv_irq_data {	118	struct iucv_irq_data {
119	u16 ippathid;	119	u16 ippathid;
120	u8 ipflags1;	120	u8 ipflags1;
121	u8 iptype;	121	u8 iptype;
122	u32 res2[8];	122	u32 res2[8];
123	};	123	};
124		124
125	struct iucv_irq_list {	125	struct iucv_irq_list {
126	struct list_head list;	126	struct list_head list;
127	struct iucv_irq_data data;	127	struct iucv_irq_data data;
128	};	128	};
129		129
130	static struct iucv_irq_data *iucv_irq_data[NR_CPUS];	130	static struct iucv_irq_data *iucv_irq_data[NR_CPUS];
131	static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE };	131	static cpumask_t iucv_buffer_cpumask = { CPU_BITS_NONE };
132	static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE };	132	static cpumask_t iucv_irq_cpumask = { CPU_BITS_NONE };
133		133
134	/*	134	/*
135	* Queue of interrupt buffers lock for delivery via the tasklet	135	* Queue of interrupt buffers lock for delivery via the tasklet
136	* (fast but can't call smp_call_function).	136	* (fast but can't call smp_call_function).
137	*/	137	*/
138	static LIST_HEAD(iucv_task_queue);	138	static LIST_HEAD(iucv_task_queue);
139		139
140	/*	140	/*
141	* The tasklet for fast delivery of iucv interrupts.	141	* The tasklet for fast delivery of iucv interrupts.
142	*/	142	*/
143	static void iucv_tasklet_fn(unsigned long);	143	static void iucv_tasklet_fn(unsigned long);
144	static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0);	144	static DECLARE_TASKLET(iucv_tasklet, iucv_tasklet_fn,0);
145		145
146	/*	146	/*
147	* Queue of interrupt buffers for delivery via a work queue	147	* Queue of interrupt buffers for delivery via a work queue
148	* (slower but can call smp_call_function).	148	* (slower but can call smp_call_function).
149	*/	149	*/
150	static LIST_HEAD(iucv_work_queue);	150	static LIST_HEAD(iucv_work_queue);
151		151
152	/*	152	/*
153	* The work element to deliver path pending interrupts.	153	* The work element to deliver path pending interrupts.
154	*/	154	*/
155	static void iucv_work_fn(struct work_struct *work);	155	static void iucv_work_fn(struct work_struct *work);
156	static DECLARE_WORK(iucv_work, iucv_work_fn);	156	static DECLARE_WORK(iucv_work, iucv_work_fn);
157		157
158	/*	158	/*
159	* Spinlock protecting task and work queue.	159	* Spinlock protecting task and work queue.
160	*/	160	*/
161	static DEFINE_SPINLOCK(iucv_queue_lock);	161	static DEFINE_SPINLOCK(iucv_queue_lock);
162		162
163	enum iucv_command_codes {	163	enum iucv_command_codes {
164	IUCV_QUERY = 0,	164	IUCV_QUERY = 0,
165	IUCV_RETRIEVE_BUFFER = 2,	165	IUCV_RETRIEVE_BUFFER = 2,
166	IUCV_SEND = 4,	166	IUCV_SEND = 4,
167	IUCV_RECEIVE = 5,	167	IUCV_RECEIVE = 5,
168	IUCV_REPLY = 6,	168	IUCV_REPLY = 6,
169	IUCV_REJECT = 8,	169	IUCV_REJECT = 8,
170	IUCV_PURGE = 9,	170	IUCV_PURGE = 9,
171	IUCV_ACCEPT = 10,	171	IUCV_ACCEPT = 10,
172	IUCV_CONNECT = 11,	172	IUCV_CONNECT = 11,
173	IUCV_DECLARE_BUFFER = 12,	173	IUCV_DECLARE_BUFFER = 12,
174	IUCV_QUIESCE = 13,	174	IUCV_QUIESCE = 13,
175	IUCV_RESUME = 14,	175	IUCV_RESUME = 14,
176	IUCV_SEVER = 15,	176	IUCV_SEVER = 15,
177	IUCV_SETMASK = 16,	177	IUCV_SETMASK = 16,
178	IUCV_SETCONTROLMASK = 17,	178	IUCV_SETCONTROLMASK = 17,
179	};	179	};
180		180
181	/*	181	/*
182	* Error messages that are used with the iucv_sever function. They get	182	* Error messages that are used with the iucv_sever function. They get
183	* converted to EBCDIC.	183	* converted to EBCDIC.
184	*/	184	*/
185	static char iucv_error_no_listener[16] = "NO LISTENER";	185	static char iucv_error_no_listener[16] = "NO LISTENER";
186	static char iucv_error_no_memory[16] = "NO MEMORY";	186	static char iucv_error_no_memory[16] = "NO MEMORY";
187	static char iucv_error_pathid[16] = "INVALID PATHID";	187	static char iucv_error_pathid[16] = "INVALID PATHID";
188		188
189	/*	189	/*
190	* iucv_handler_list: List of registered handlers.	190	* iucv_handler_list: List of registered handlers.
191	*/	191	*/
192	static LIST_HEAD(iucv_handler_list);	192	static LIST_HEAD(iucv_handler_list);
193		193
194	/*	194	/*
195	* iucv_path_table: an array of iucv_path structures.	195	* iucv_path_table: an array of iucv_path structures.
196	*/	196	*/
197	static struct iucv_path **iucv_path_table;	197	static struct iucv_path **iucv_path_table;
198	static unsigned long iucv_max_pathid;	198	static unsigned long iucv_max_pathid;
199		199
200	/*	200	/*
201	* iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table	201	* iucv_lock: spinlock protecting iucv_handler_list and iucv_pathid_table
202	*/	202	*/
203	static DEFINE_SPINLOCK(iucv_table_lock);	203	static DEFINE_SPINLOCK(iucv_table_lock);
204		204
205	/*	205	/*
206	* iucv_active_cpu: contains the number of the cpu executing the tasklet	206	* iucv_active_cpu: contains the number of the cpu executing the tasklet
207	* or the work handler. Needed for iucv_path_sever called from tasklet.	207	* or the work handler. Needed for iucv_path_sever called from tasklet.
208	*/	208	*/
209	static int iucv_active_cpu = -1;	209	static int iucv_active_cpu = -1;
210		210
211	/*	211	/*
212	* Mutex and wait queue for iucv_register/iucv_unregister.	212	* Mutex and wait queue for iucv_register/iucv_unregister.
213	*/	213	*/
214	static DEFINE_MUTEX(iucv_register_mutex);	214	static DEFINE_MUTEX(iucv_register_mutex);
215		215
216	/*	216	/*
217	* Counter for number of non-smp capable handlers.	217	* Counter for number of non-smp capable handlers.
218	*/	218	*/
219	static int iucv_nonsmp_handler;	219	static int iucv_nonsmp_handler;
220		220
221	/*	221	/*
222	* IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,	222	* IUCV control data structure. Used by iucv_path_accept, iucv_path_connect,
223	* iucv_path_quiesce and iucv_path_sever.	223	* iucv_path_quiesce and iucv_path_sever.
224	*/	224	*/
225	struct iucv_cmd_control {	225	struct iucv_cmd_control {
226	u16 ippathid;	226	u16 ippathid;
227	u8 ipflags1;	227	u8 ipflags1;
228	u8 iprcode;	228	u8 iprcode;
229	u16 ipmsglim;	229	u16 ipmsglim;
230	u16 res1;	230	u16 res1;
231	u8 ipvmid[8];	231	u8 ipvmid[8];
232	u8 ipuser[16];	232	u8 ipuser[16];
233	u8 iptarget[8];	233	u8 iptarget[8];
234	} __attribute__ ((packed,aligned(8)));	234	} __attribute__ ((packed,aligned(8)));
235		235
236	/*	236	/*
237	* Data in parameter list iucv structure. Used by iucv_message_send,	237	* Data in parameter list iucv structure. Used by iucv_message_send,
238	* iucv_message_send2way and iucv_message_reply.	238	* iucv_message_send2way and iucv_message_reply.
239	*/	239	*/
240	struct iucv_cmd_dpl {	240	struct iucv_cmd_dpl {
241	u16 ippathid;	241	u16 ippathid;
242	u8 ipflags1;	242	u8 ipflags1;
243	u8 iprcode;	243	u8 iprcode;
244	u32 ipmsgid;	244	u32 ipmsgid;
245	u32 iptrgcls;	245	u32 iptrgcls;
246	u8 iprmmsg[8];	246	u8 iprmmsg[8];
247	u32 ipsrccls;	247	u32 ipsrccls;
248	u32 ipmsgtag;	248	u32 ipmsgtag;
249	u32 ipbfadr2;	249	u32 ipbfadr2;
250	u32 ipbfln2f;	250	u32 ipbfln2f;
251	u32 res;	251	u32 res;
252	} __attribute__ ((packed,aligned(8)));	252	} __attribute__ ((packed,aligned(8)));
253		253
254	/*	254	/*
255	* Data in buffer iucv structure. Used by iucv_message_receive,	255	* Data in buffer iucv structure. Used by iucv_message_receive,
256	* iucv_message_reject, iucv_message_send, iucv_message_send2way	256	* iucv_message_reject, iucv_message_send, iucv_message_send2way
257	* and iucv_declare_cpu.	257	* and iucv_declare_cpu.
258	*/	258	*/
259	struct iucv_cmd_db {	259	struct iucv_cmd_db {
260	u16 ippathid;	260	u16 ippathid;
261	u8 ipflags1;	261	u8 ipflags1;
262	u8 iprcode;	262	u8 iprcode;
263	u32 ipmsgid;	263	u32 ipmsgid;
264	u32 iptrgcls;	264	u32 iptrgcls;
265	u32 ipbfadr1;	265	u32 ipbfadr1;
266	u32 ipbfln1f;	266	u32 ipbfln1f;
267	u32 ipsrccls;	267	u32 ipsrccls;
268	u32 ipmsgtag;	268	u32 ipmsgtag;
269	u32 ipbfadr2;	269	u32 ipbfadr2;
270	u32 ipbfln2f;	270	u32 ipbfln2f;
271	u32 res;	271	u32 res;
272	} __attribute__ ((packed,aligned(8)));	272	} __attribute__ ((packed,aligned(8)));
273		273
274	/*	274	/*
275	* Purge message iucv structure. Used by iucv_message_purge.	275	* Purge message iucv structure. Used by iucv_message_purge.
276	*/	276	*/
277	struct iucv_cmd_purge {	277	struct iucv_cmd_purge {
278	u16 ippathid;	278	u16 ippathid;
279	u8 ipflags1;	279	u8 ipflags1;
280	u8 iprcode;	280	u8 iprcode;
281	u32 ipmsgid;	281	u32 ipmsgid;
282	u8 ipaudit[3];	282	u8 ipaudit[3];
283	u8 res1[5];	283	u8 res1[5];
284	u32 res2;	284	u32 res2;
285	u32 ipsrccls;	285	u32 ipsrccls;
286	u32 ipmsgtag;	286	u32 ipmsgtag;
287	u32 res3[3];	287	u32 res3[3];
288	} __attribute__ ((packed,aligned(8)));	288	} __attribute__ ((packed,aligned(8)));
289		289
290	/*	290	/*
291	* Set mask iucv structure. Used by iucv_enable_cpu.	291	* Set mask iucv structure. Used by iucv_enable_cpu.
292	*/	292	*/
293	struct iucv_cmd_set_mask {	293	struct iucv_cmd_set_mask {
294	u8 ipmask;	294	u8 ipmask;
295	u8 res1[2];	295	u8 res1[2];
296	u8 iprcode;	296	u8 iprcode;
297	u32 res2[9];	297	u32 res2[9];
298	} __attribute__ ((packed,aligned(8)));	298	} __attribute__ ((packed,aligned(8)));
299		299
300	union iucv_param {	300	union iucv_param {
301	struct iucv_cmd_control ctrl;	301	struct iucv_cmd_control ctrl;
302	struct iucv_cmd_dpl dpl;	302	struct iucv_cmd_dpl dpl;
303	struct iucv_cmd_db db;	303	struct iucv_cmd_db db;
304	struct iucv_cmd_purge purge;	304	struct iucv_cmd_purge purge;
305	struct iucv_cmd_set_mask set_mask;	305	struct iucv_cmd_set_mask set_mask;
306	};	306	};
307		307
308	/*	308	/*
309	* Anchor for per-cpu IUCV command parameter block.	309	* Anchor for per-cpu IUCV command parameter block.
310	*/	310	*/
311	static union iucv_param *iucv_param[NR_CPUS];	311	static union iucv_param *iucv_param[NR_CPUS];
312	static union iucv_param *iucv_param_irq[NR_CPUS];	312	static union iucv_param *iucv_param_irq[NR_CPUS];
313		313
314	/**	314	/**
315	* iucv_call_b2f0	315	* iucv_call_b2f0
316	* @code: identifier of IUCV call to CP.	316	* @code: identifier of IUCV call to CP.
317	* @parm: pointer to a struct iucv_parm block	317	* @parm: pointer to a struct iucv_parm block
318	*	318	*
319	* Calls CP to execute IUCV commands.	319	* Calls CP to execute IUCV commands.
320	*	320	*
321	* Returns the result of the CP IUCV call.	321	* Returns the result of the CP IUCV call.
322	*/	322	*/
323	static inline int iucv_call_b2f0(int command, union iucv_param *parm)	323	static inline int iucv_call_b2f0(int command, union iucv_param *parm)
324	{	324	{
325	register unsigned long reg0 asm ("0");	325	register unsigned long reg0 asm ("0");
326	register unsigned long reg1 asm ("1");	326	register unsigned long reg1 asm ("1");
327	int ccode;	327	int ccode;
328		328
329	reg0 = command;	329	reg0 = command;
330	reg1 = virt_to_phys(parm);	330	reg1 = virt_to_phys(parm);
331	asm volatile(	331	asm volatile(
332	" .long 0xb2f01000\n"	332	" .long 0xb2f01000\n"
333	" ipm %0\n"	333	" ipm %0\n"
334	" srl %0,28\n"	334	" srl %0,28\n"
335	: "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)	335	: "=d" (ccode), "=m" (*parm), "+d" (reg0), "+a" (reg1)
336	: "m" (*parm) : "cc");	336	: "m" (*parm) : "cc");
337	return (ccode == 1) ? parm->ctrl.iprcode : ccode;	337	return (ccode == 1) ? parm->ctrl.iprcode : ccode;
338	}	338	}
339		339
340	/**	340	/**
341	* iucv_query_maxconn	341	* iucv_query_maxconn
342	*	342	*
343	* Determines the maximum number of connections that may be established.	343	* Determines the maximum number of connections that may be established.
344	*	344	*
345	* Returns the maximum number of connections or -EPERM is IUCV is not	345	* Returns the maximum number of connections or -EPERM is IUCV is not
346	* available.	346	* available.
347	*/	347	*/
348	static int iucv_query_maxconn(void)	348	static int iucv_query_maxconn(void)
349	{	349	{
350	register unsigned long reg0 asm ("0");	350	register unsigned long reg0 asm ("0");
351	register unsigned long reg1 asm ("1");	351	register unsigned long reg1 asm ("1");
352	void *param;	352	void *param;
353	int ccode;	353	int ccode;
354		354
355	param = kzalloc(sizeof(union iucv_param), GFP_KERNEL\|GFP_DMA);	355	param = kzalloc(sizeof(union iucv_param), GFP_KERNEL\|GFP_DMA);
356	if (!param)	356	if (!param)
357	return -ENOMEM;	357	return -ENOMEM;
358	reg0 = IUCV_QUERY;	358	reg0 = IUCV_QUERY;
359	reg1 = (unsigned long) param;	359	reg1 = (unsigned long) param;
360	asm volatile (	360	asm volatile (
361	" .long 0xb2f01000\n"	361	" .long 0xb2f01000\n"
362	" ipm %0\n"	362	" ipm %0\n"
363	" srl %0,28\n"	363	" srl %0,28\n"
364	: "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");	364	: "=d" (ccode), "+d" (reg0), "+d" (reg1) : : "cc");
365	if (ccode == 0)	365	if (ccode == 0)
366	iucv_max_pathid = reg1;	366	iucv_max_pathid = reg1;
367	kfree(param);	367	kfree(param);
368	return ccode ? -EPERM : 0;	368	return ccode ? -EPERM : 0;
369	}	369	}
370		370
371	/**	371	/**
372	* iucv_allow_cpu	372	* iucv_allow_cpu
373	* @data: unused	373	* @data: unused
374	*	374	*
375	* Allow iucv interrupts on this cpu.	375	* Allow iucv interrupts on this cpu.
376	*/	376	*/
377	static void iucv_allow_cpu(void *data)	377	static void iucv_allow_cpu(void *data)
378	{	378	{
379	int cpu = smp_processor_id();	379	int cpu = smp_processor_id();
380	union iucv_param *parm;	380	union iucv_param *parm;
381		381
382	/*	382	/*
383	* Enable all iucv interrupts.	383	* Enable all iucv interrupts.
384	* ipmask contains bits for the different interrupts	384	* ipmask contains bits for the different interrupts
385	* 0x80 - Flag to allow nonpriority message pending interrupts	385	* 0x80 - Flag to allow nonpriority message pending interrupts
386	* 0x40 - Flag to allow priority message pending interrupts	386	* 0x40 - Flag to allow priority message pending interrupts
387	* 0x20 - Flag to allow nonpriority message completion interrupts	387	* 0x20 - Flag to allow nonpriority message completion interrupts
388	* 0x10 - Flag to allow priority message completion interrupts	388	* 0x10 - Flag to allow priority message completion interrupts
389	* 0x08 - Flag to allow IUCV control interrupts	389	* 0x08 - Flag to allow IUCV control interrupts
390	*/	390	*/
391	parm = iucv_param_irq[cpu];	391	parm = iucv_param_irq[cpu];
392	memset(parm, 0, sizeof(union iucv_param));	392	memset(parm, 0, sizeof(union iucv_param));
393	parm->set_mask.ipmask = 0xf8;	393	parm->set_mask.ipmask = 0xf8;
394	iucv_call_b2f0(IUCV_SETMASK, parm);	394	iucv_call_b2f0(IUCV_SETMASK, parm);
395		395
396	/*	396	/*
397	* Enable all iucv control interrupts.	397	* Enable all iucv control interrupts.
398	* ipmask contains bits for the different interrupts	398	* ipmask contains bits for the different interrupts
399	* 0x80 - Flag to allow pending connections interrupts	399	* 0x80 - Flag to allow pending connections interrupts
400	* 0x40 - Flag to allow connection complete interrupts	400	* 0x40 - Flag to allow connection complete interrupts
401	* 0x20 - Flag to allow connection severed interrupts	401	* 0x20 - Flag to allow connection severed interrupts
402	* 0x10 - Flag to allow connection quiesced interrupts	402	* 0x10 - Flag to allow connection quiesced interrupts
403	* 0x08 - Flag to allow connection resumed interrupts	403	* 0x08 - Flag to allow connection resumed interrupts
404	*/	404	*/
405	memset(parm, 0, sizeof(union iucv_param));	405	memset(parm, 0, sizeof(union iucv_param));
406	parm->set_mask.ipmask = 0xf8;	406	parm->set_mask.ipmask = 0xf8;
407	iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);	407	iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
408	/* Set indication that iucv interrupts are allowed for this cpu. */	408	/* Set indication that iucv interrupts are allowed for this cpu. */
409	cpumask_set_cpu(cpu, &iucv_irq_cpumask);	409	cpumask_set_cpu(cpu, &iucv_irq_cpumask);
410	}	410	}
411		411
412	/**	412	/**
413	* iucv_block_cpu	413	* iucv_block_cpu
414	* @data: unused	414	* @data: unused
415	*	415	*
416	* Block iucv interrupts on this cpu.	416	* Block iucv interrupts on this cpu.
417	*/	417	*/
418	static void iucv_block_cpu(void *data)	418	static void iucv_block_cpu(void *data)
419	{	419	{
420	int cpu = smp_processor_id();	420	int cpu = smp_processor_id();
421	union iucv_param *parm;	421	union iucv_param *parm;
422		422
423	/* Disable all iucv interrupts. */	423	/* Disable all iucv interrupts. */
424	parm = iucv_param_irq[cpu];	424	parm = iucv_param_irq[cpu];
425	memset(parm, 0, sizeof(union iucv_param));	425	memset(parm, 0, sizeof(union iucv_param));
426	iucv_call_b2f0(IUCV_SETMASK, parm);	426	iucv_call_b2f0(IUCV_SETMASK, parm);
427		427
428	/* Clear indication that iucv interrupts are allowed for this cpu. */	428	/* Clear indication that iucv interrupts are allowed for this cpu. */
429	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);	429	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);
430	}	430	}
431		431
432	/**	432	/**
433	* iucv_block_cpu_almost	433	* iucv_block_cpu_almost
434	* @data: unused	434	* @data: unused
435	*	435	*
436	* Allow connection-severed interrupts only on this cpu.	436	* Allow connection-severed interrupts only on this cpu.
437	*/	437	*/
438	static void iucv_block_cpu_almost(void *data)	438	static void iucv_block_cpu_almost(void *data)
439	{	439	{
440	int cpu = smp_processor_id();	440	int cpu = smp_processor_id();
441	union iucv_param *parm;	441	union iucv_param *parm;
442		442
443	/* Allow iucv control interrupts only */	443	/* Allow iucv control interrupts only */
444	parm = iucv_param_irq[cpu];	444	parm = iucv_param_irq[cpu];
445	memset(parm, 0, sizeof(union iucv_param));	445	memset(parm, 0, sizeof(union iucv_param));
446	parm->set_mask.ipmask = 0x08;	446	parm->set_mask.ipmask = 0x08;
447	iucv_call_b2f0(IUCV_SETMASK, parm);	447	iucv_call_b2f0(IUCV_SETMASK, parm);
448	/* Allow iucv-severed interrupt only */	448	/* Allow iucv-severed interrupt only */
449	memset(parm, 0, sizeof(union iucv_param));	449	memset(parm, 0, sizeof(union iucv_param));
450	parm->set_mask.ipmask = 0x20;	450	parm->set_mask.ipmask = 0x20;
451	iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);	451	iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);
452		452
453	/* Clear indication that iucv interrupts are allowed for this cpu. */	453	/* Clear indication that iucv interrupts are allowed for this cpu. */
454	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);	454	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);
455	}	455	}
456		456
457	/**	457	/**
458	* iucv_declare_cpu	458	* iucv_declare_cpu
459	* @data: unused	459	* @data: unused
460	*	460	*
461	* Declare a interrupt buffer on this cpu.	461	* Declare a interrupt buffer on this cpu.
462	*/	462	*/
463	static void iucv_declare_cpu(void *data)	463	static void iucv_declare_cpu(void *data)
464	{	464	{
465	int cpu = smp_processor_id();	465	int cpu = smp_processor_id();
466	union iucv_param *parm;	466	union iucv_param *parm;
467	int rc;	467	int rc;
468		468
469	if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask))	469	if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
470	return;	470	return;
471		471
472	/* Declare interrupt buffer. */	472	/* Declare interrupt buffer. */
473	parm = iucv_param_irq[cpu];	473	parm = iucv_param_irq[cpu];
474	memset(parm, 0, sizeof(union iucv_param));	474	memset(parm, 0, sizeof(union iucv_param));
475	parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);	475	parm->db.ipbfadr1 = virt_to_phys(iucv_irq_data[cpu]);
476	rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);	476	rc = iucv_call_b2f0(IUCV_DECLARE_BUFFER, parm);
477	if (rc) {	477	if (rc) {
478	char *err = "Unknown";	478	char *err = "Unknown";
479	switch (rc) {	479	switch (rc) {
480	case 0x03:	480	case 0x03:
481	err = "Directory error";	481	err = "Directory error";
482	break;	482	break;
483	case 0x0a:	483	case 0x0a:
484	err = "Invalid length";	484	err = "Invalid length";
485	break;	485	break;
486	case 0x13:	486	case 0x13:
487	err = "Buffer already exists";	487	err = "Buffer already exists";
488	break;	488	break;
489	case 0x3e:	489	case 0x3e:
490	err = "Buffer overlap";	490	err = "Buffer overlap";
491	break;	491	break;
492	case 0x5c:	492	case 0x5c:
493	err = "Paging or storage error";	493	err = "Paging or storage error";
494	break;	494	break;
495	}	495	}
496	pr_warning("Defining an interrupt buffer on CPU %i"	496	pr_warning("Defining an interrupt buffer on CPU %i"
497	" failed with 0x%02x (%s)\n", cpu, rc, err);	497	" failed with 0x%02x (%s)\n", cpu, rc, err);
498	return;	498	return;
499	}	499	}
500		500
501	/* Set indication that an iucv buffer exists for this cpu. */	501	/* Set indication that an iucv buffer exists for this cpu. */
502	cpumask_set_cpu(cpu, &iucv_buffer_cpumask);	502	cpumask_set_cpu(cpu, &iucv_buffer_cpumask);
503		503
504	if (iucv_nonsmp_handler == 0 \|\| cpumask_empty(&iucv_irq_cpumask))	504	if (iucv_nonsmp_handler == 0 \|\| cpumask_empty(&iucv_irq_cpumask))
505	/* Enable iucv interrupts on this cpu. */	505	/* Enable iucv interrupts on this cpu. */
506	iucv_allow_cpu(NULL);	506	iucv_allow_cpu(NULL);
507	else	507	else
508	/* Disable iucv interrupts on this cpu. */	508	/* Disable iucv interrupts on this cpu. */
509	iucv_block_cpu(NULL);	509	iucv_block_cpu(NULL);
510	}	510	}
511		511
512	/**	512	/**
513	* iucv_retrieve_cpu	513	* iucv_retrieve_cpu
514	* @data: unused	514	* @data: unused
515	*	515	*
516	* Retrieve interrupt buffer on this cpu.	516	* Retrieve interrupt buffer on this cpu.
517	*/	517	*/
518	static void iucv_retrieve_cpu(void *data)	518	static void iucv_retrieve_cpu(void *data)
519	{	519	{
520	int cpu = smp_processor_id();	520	int cpu = smp_processor_id();
521	union iucv_param *parm;	521	union iucv_param *parm;
522		522
523	if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask))	523	if (!cpumask_test_cpu(cpu, &iucv_buffer_cpumask))
524	return;	524	return;
525		525
526	/* Block iucv interrupts. */	526	/* Block iucv interrupts. */
527	iucv_block_cpu(NULL);	527	iucv_block_cpu(NULL);
528		528
529	/* Retrieve interrupt buffer. */	529	/* Retrieve interrupt buffer. */
530	parm = iucv_param_irq[cpu];	530	parm = iucv_param_irq[cpu];
531	iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);	531	iucv_call_b2f0(IUCV_RETRIEVE_BUFFER, parm);
532		532
533	/* Clear indication that an iucv buffer exists for this cpu. */	533	/* Clear indication that an iucv buffer exists for this cpu. */
534	cpumask_clear_cpu(cpu, &iucv_buffer_cpumask);	534	cpumask_clear_cpu(cpu, &iucv_buffer_cpumask);
535	}	535	}
536		536
537	/**	537	/**
538	* iucv_setmask_smp	538	* iucv_setmask_smp
539	*	539	*
540	* Allow iucv interrupts on all cpus.	540	* Allow iucv interrupts on all cpus.
541	*/	541	*/
542	static void iucv_setmask_mp(void)	542	static void iucv_setmask_mp(void)
543	{	543	{
544	int cpu;	544	int cpu;
545		545
546	get_online_cpus();	546	get_online_cpus();
547	for_each_online_cpu(cpu)	547	for_each_online_cpu(cpu)
548	/* Enable all cpus with a declared buffer. */	548	/* Enable all cpus with a declared buffer. */
549	if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) &&	549	if (cpumask_test_cpu(cpu, &iucv_buffer_cpumask) &&
550	!cpumask_test_cpu(cpu, &iucv_irq_cpumask))	550	!cpumask_test_cpu(cpu, &iucv_irq_cpumask))
551	smp_call_function_single(cpu, iucv_allow_cpu,	551	smp_call_function_single(cpu, iucv_allow_cpu,
552	NULL, 1);	552	NULL, 1);
553	put_online_cpus();	553	put_online_cpus();
554	}	554	}
555		555
556	/**	556	/**
557	* iucv_setmask_up	557	* iucv_setmask_up
558	*	558	*
559	* Allow iucv interrupts on a single cpu.	559	* Allow iucv interrupts on a single cpu.
560	*/	560	*/
561	static void iucv_setmask_up(void)	561	static void iucv_setmask_up(void)
562	{	562	{
563	cpumask_t cpumask;	563	cpumask_t cpumask;
564	int cpu;	564	int cpu;
565		565
566	/* Disable all cpu but the first in cpu_irq_cpumask. */	566	/* Disable all cpu but the first in cpu_irq_cpumask. */
567	cpumask_copy(&cpumask, &iucv_irq_cpumask);	567	cpumask_copy(&cpumask, &iucv_irq_cpumask);
568	cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask);	568	cpumask_clear_cpu(cpumask_first(&iucv_irq_cpumask), &cpumask);
569	for_each_cpu(cpu, &cpumask)	569	for_each_cpu(cpu, &cpumask)
570	smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);	570	smp_call_function_single(cpu, iucv_block_cpu, NULL, 1);
571	}	571	}
572		572
573	/**	573	/**
574	* iucv_enable	574	* iucv_enable
575	*	575	*
576	* This function makes iucv ready for use. It allocates the pathid	576	* This function makes iucv ready for use. It allocates the pathid
577	* table, declares an iucv interrupt buffer and enables the iucv	577	* table, declares an iucv interrupt buffer and enables the iucv
578	* interrupts. Called when the first user has registered an iucv	578	* interrupts. Called when the first user has registered an iucv
579	* handler.	579	* handler.
580	*/	580	*/
581	static int iucv_enable(void)	581	static int iucv_enable(void)
582	{	582	{
583	size_t alloc_size;	583	size_t alloc_size;
584	int cpu, rc;	584	int cpu, rc;
585		585
586	get_online_cpus();	586	get_online_cpus();
587	rc = -ENOMEM;	587	rc = -ENOMEM;
588	alloc_size = iucv_max_pathid * sizeof(struct iucv_path);	588	alloc_size = iucv_max_pathid * sizeof(struct iucv_path);
589	iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);	589	iucv_path_table = kzalloc(alloc_size, GFP_KERNEL);
590	if (!iucv_path_table)	590	if (!iucv_path_table)
591	goto out;	591	goto out;
592	/* Declare per cpu buffers. */	592	/* Declare per cpu buffers. */
593	rc = -EIO;	593	rc = -EIO;
594	for_each_online_cpu(cpu)	594	for_each_online_cpu(cpu)
595	smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);	595	smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
596	if (cpumask_empty(&iucv_buffer_cpumask))	596	if (cpumask_empty(&iucv_buffer_cpumask))
597	/* No cpu could declare an iucv buffer. */	597	/* No cpu could declare an iucv buffer. */
598	goto out;	598	goto out;
599	put_online_cpus();	599	put_online_cpus();
600	return 0;	600	return 0;
601	out:	601	out:
602	kfree(iucv_path_table);	602	kfree(iucv_path_table);
603	iucv_path_table = NULL;	603	iucv_path_table = NULL;
604	put_online_cpus();	604	put_online_cpus();
605	return rc;	605	return rc;
606	}	606	}
607		607
608	/**	608	/**
609	* iucv_disable	609	* iucv_disable
610	*	610	*
611	* This function shuts down iucv. It disables iucv interrupts, retrieves	611	* This function shuts down iucv. It disables iucv interrupts, retrieves
612	* the iucv interrupt buffer and frees the pathid table. Called after the	612	* the iucv interrupt buffer and frees the pathid table. Called after the
613	* last user unregister its iucv handler.	613	* last user unregister its iucv handler.
614	*/	614	*/
615	static void iucv_disable(void)	615	static void iucv_disable(void)
616	{	616	{
617	get_online_cpus();	617	get_online_cpus();
618	on_each_cpu(iucv_retrieve_cpu, NULL, 1);	618	on_each_cpu(iucv_retrieve_cpu, NULL, 1);
619	kfree(iucv_path_table);	619	kfree(iucv_path_table);
620	iucv_path_table = NULL;	620	iucv_path_table = NULL;
621	put_online_cpus();	621	put_online_cpus();
622	}	622	}
623		623
624	static int __cpuinit iucv_cpu_notify(struct notifier_block *self,	624	static int __cpuinit iucv_cpu_notify(struct notifier_block *self,
625	unsigned long action, void *hcpu)	625	unsigned long action, void *hcpu)
626	{	626	{
627	cpumask_t cpumask;	627	cpumask_t cpumask;
628	long cpu = (long) hcpu;	628	long cpu = (long) hcpu;
629		629
630	switch (action) {	630	switch (action) {
631	case CPU_UP_PREPARE:	631	case CPU_UP_PREPARE:
632	case CPU_UP_PREPARE_FROZEN:	632	case CPU_UP_PREPARE_FROZEN:
633	iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),	633	iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
634	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	634	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
635	if (!iucv_irq_data[cpu])	635	if (!iucv_irq_data[cpu])
636	return notifier_from_errno(-ENOMEM);	636	return notifier_from_errno(-ENOMEM);
637		637
638	iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),	638	iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
639	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	639	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
640	if (!iucv_param[cpu]) {	640	if (!iucv_param[cpu]) {
641	kfree(iucv_irq_data[cpu]);	641	kfree(iucv_irq_data[cpu]);
642	iucv_irq_data[cpu] = NULL;	642	iucv_irq_data[cpu] = NULL;
643	return notifier_from_errno(-ENOMEM);	643	return notifier_from_errno(-ENOMEM);
644	}	644	}
645	iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),	645	iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
646	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	646	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
647	if (!iucv_param_irq[cpu]) {	647	if (!iucv_param_irq[cpu]) {
648	kfree(iucv_param[cpu]);	648	kfree(iucv_param[cpu]);
649	iucv_param[cpu] = NULL;	649	iucv_param[cpu] = NULL;
650	kfree(iucv_irq_data[cpu]);	650	kfree(iucv_irq_data[cpu]);
651	iucv_irq_data[cpu] = NULL;	651	iucv_irq_data[cpu] = NULL;
652	return notifier_from_errno(-ENOMEM);	652	return notifier_from_errno(-ENOMEM);
653	}	653	}
654	break;	654	break;
655	case CPU_UP_CANCELED:	655	case CPU_UP_CANCELED:
656	case CPU_UP_CANCELED_FROZEN:	656	case CPU_UP_CANCELED_FROZEN:
657	case CPU_DEAD:	657	case CPU_DEAD:
658	case CPU_DEAD_FROZEN:	658	case CPU_DEAD_FROZEN:
659	kfree(iucv_param_irq[cpu]);	659	kfree(iucv_param_irq[cpu]);
660	iucv_param_irq[cpu] = NULL;	660	iucv_param_irq[cpu] = NULL;
661	kfree(iucv_param[cpu]);	661	kfree(iucv_param[cpu]);
662	iucv_param[cpu] = NULL;	662	iucv_param[cpu] = NULL;
663	kfree(iucv_irq_data[cpu]);	663	kfree(iucv_irq_data[cpu]);
664	iucv_irq_data[cpu] = NULL;	664	iucv_irq_data[cpu] = NULL;
665	break;	665	break;
666	case CPU_ONLINE:	666	case CPU_ONLINE:
667	case CPU_ONLINE_FROZEN:	667	case CPU_ONLINE_FROZEN:
668	case CPU_DOWN_FAILED:	668	case CPU_DOWN_FAILED:
669	case CPU_DOWN_FAILED_FROZEN:	669	case CPU_DOWN_FAILED_FROZEN:
670	if (!iucv_path_table)	670	if (!iucv_path_table)
671	break;	671	break;
672	smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);	672	smp_call_function_single(cpu, iucv_declare_cpu, NULL, 1);
673	break;	673	break;
674	case CPU_DOWN_PREPARE:	674	case CPU_DOWN_PREPARE:
675	case CPU_DOWN_PREPARE_FROZEN:	675	case CPU_DOWN_PREPARE_FROZEN:
676	if (!iucv_path_table)	676	if (!iucv_path_table)
677	break;	677	break;
678	cpumask_copy(&cpumask, &iucv_buffer_cpumask);	678	cpumask_copy(&cpumask, &iucv_buffer_cpumask);
679	cpumask_clear_cpu(cpu, &cpumask);	679	cpumask_clear_cpu(cpu, &cpumask);
680	if (cpumask_empty(&cpumask))	680	if (cpumask_empty(&cpumask))
681	/* Can't offline last IUCV enabled cpu. */	681	/* Can't offline last IUCV enabled cpu. */
682	return notifier_from_errno(-EINVAL);	682	return notifier_from_errno(-EINVAL);
683	smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1);	683	smp_call_function_single(cpu, iucv_retrieve_cpu, NULL, 1);
684	if (cpumask_empty(&iucv_irq_cpumask))	684	if (cpumask_empty(&iucv_irq_cpumask))
685	smp_call_function_single(	685	smp_call_function_single(
686	cpumask_first(&iucv_buffer_cpumask),	686	cpumask_first(&iucv_buffer_cpumask),
687	iucv_allow_cpu, NULL, 1);	687	iucv_allow_cpu, NULL, 1);
688	break;	688	break;
689	}	689	}
690	return NOTIFY_OK;	690	return NOTIFY_OK;
691	}	691	}
692		692
693	static struct notifier_block __refdata iucv_cpu_notifier = {	693	static struct notifier_block __refdata iucv_cpu_notifier = {
694	.notifier_call = iucv_cpu_notify,	694	.notifier_call = iucv_cpu_notify,
695	};	695	};
696		696
697	/**	697	/**
698	* iucv_sever_pathid	698	* iucv_sever_pathid
699	* @pathid: path identification number.	699	* @pathid: path identification number.
700	* @userdata: 16-bytes of user data.	700	* @userdata: 16-bytes of user data.
701	*	701	*
702	* Sever an iucv path to free up the pathid. Used internally.	702	* Sever an iucv path to free up the pathid. Used internally.
703	*/	703	*/
704	static int iucv_sever_pathid(u16 pathid, u8 userdata[16])	704	static int iucv_sever_pathid(u16 pathid, u8 userdata[16])
705	{	705	{
706	union iucv_param *parm;	706	union iucv_param *parm;
707		707
708	parm = iucv_param_irq[smp_processor_id()];	708	parm = iucv_param_irq[smp_processor_id()];
709	memset(parm, 0, sizeof(union iucv_param));	709	memset(parm, 0, sizeof(union iucv_param));
710	if (userdata)	710	if (userdata)
711	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));	711	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
712	parm->ctrl.ippathid = pathid;	712	parm->ctrl.ippathid = pathid;
713	return iucv_call_b2f0(IUCV_SEVER, parm);	713	return iucv_call_b2f0(IUCV_SEVER, parm);
714	}	714	}
715		715
716	/**	716	/**
717	* __iucv_cleanup_queue	717	* __iucv_cleanup_queue
718	* @dummy: unused dummy argument	718	* @dummy: unused dummy argument
719	*	719	*
720	* Nop function called via smp_call_function to force work items from	720	* Nop function called via smp_call_function to force work items from
721	* pending external iucv interrupts to the work queue.	721	* pending external iucv interrupts to the work queue.
722	*/	722	*/
723	static void __iucv_cleanup_queue(void *dummy)	723	static void __iucv_cleanup_queue(void *dummy)
724	{	724	{
725	}	725	}
726		726
727	/**	727	/**
728	* iucv_cleanup_queue	728	* iucv_cleanup_queue
729	*	729	*
730	* Function called after a path has been severed to find all remaining	730	* Function called after a path has been severed to find all remaining
731	* work items for the now stale pathid. The caller needs to hold the	731	* work items for the now stale pathid. The caller needs to hold the
732	* iucv_table_lock.	732	* iucv_table_lock.
733	*/	733	*/
734	static void iucv_cleanup_queue(void)	734	static void iucv_cleanup_queue(void)
735	{	735	{
736	struct iucv_irq_list p, n;	736	struct iucv_irq_list p, n;
737		737
738	/*	738	/*
739	* When a path is severed, the pathid can be reused immediately	739	* When a path is severed, the pathid can be reused immediately
740	* on a iucv connect or a connection pending interrupt. Remove	740	* on a iucv connect or a connection pending interrupt. Remove
741	* all entries from the task queue that refer to a stale pathid	741	* all entries from the task queue that refer to a stale pathid
742	* (iucv_path_table[ix] == NULL). Only then do the iucv connect	742	* (iucv_path_table[ix] == NULL). Only then do the iucv connect
743	* or deliver the connection pending interrupt. To get all the	743	* or deliver the connection pending interrupt. To get all the
744	* pending interrupts force them to the work queue by calling	744	* pending interrupts force them to the work queue by calling
745	* an empty function on all cpus.	745	* an empty function on all cpus.
746	*/	746	*/
747	smp_call_function(__iucv_cleanup_queue, NULL, 1);	747	smp_call_function(__iucv_cleanup_queue, NULL, 1);
748	spin_lock_irq(&iucv_queue_lock);	748	spin_lock_irq(&iucv_queue_lock);
749	list_for_each_entry_safe(p, n, &iucv_task_queue, list) {	749	list_for_each_entry_safe(p, n, &iucv_task_queue, list) {
750	/* Remove stale work items from the task queue. */	750	/* Remove stale work items from the task queue. */
751	if (iucv_path_table[p->data.ippathid] == NULL) {	751	if (iucv_path_table[p->data.ippathid] == NULL) {
752	list_del(&p->list);	752	list_del(&p->list);
753	kfree(p);	753	kfree(p);
754	}	754	}
755	}	755	}
756	spin_unlock_irq(&iucv_queue_lock);	756	spin_unlock_irq(&iucv_queue_lock);
757	}	757	}
758		758
759	/**	759	/**
760	* iucv_register:	760	* iucv_register:
761	* @handler: address of iucv handler structure	761	* @handler: address of iucv handler structure
762	* @smp: != 0 indicates that the handler can deal with out of order messages	762	* @smp: != 0 indicates that the handler can deal with out of order messages
763	*	763	*
764	* Registers a driver with IUCV.	764	* Registers a driver with IUCV.
765	*	765	*
766	* Returns 0 on success, -ENOMEM if the memory allocation for the pathid	766	* Returns 0 on success, -ENOMEM if the memory allocation for the pathid
767	* table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.	767	* table failed, or -EIO if IUCV_DECLARE_BUFFER failed on all cpus.
768	*/	768	*/
769	int iucv_register(struct iucv_handler *handler, int smp)	769	int iucv_register(struct iucv_handler *handler, int smp)
770	{	770	{
771	int rc;	771	int rc;
772		772
773	if (!iucv_available)	773	if (!iucv_available)
774	return -ENOSYS;	774	return -ENOSYS;
775	mutex_lock(&iucv_register_mutex);	775	mutex_lock(&iucv_register_mutex);
776	if (!smp)	776	if (!smp)
777	iucv_nonsmp_handler++;	777	iucv_nonsmp_handler++;
778	if (list_empty(&iucv_handler_list)) {	778	if (list_empty(&iucv_handler_list)) {
779	rc = iucv_enable();	779	rc = iucv_enable();
780	if (rc)	780	if (rc)
781	goto out_mutex;	781	goto out_mutex;
782	} else if (!smp && iucv_nonsmp_handler == 1)	782	} else if (!smp && iucv_nonsmp_handler == 1)
783	iucv_setmask_up();	783	iucv_setmask_up();
784	INIT_LIST_HEAD(&handler->paths);	784	INIT_LIST_HEAD(&handler->paths);
785		785
786	spin_lock_bh(&iucv_table_lock);	786	spin_lock_bh(&iucv_table_lock);
787	list_add_tail(&handler->list, &iucv_handler_list);	787	list_add_tail(&handler->list, &iucv_handler_list);
788	spin_unlock_bh(&iucv_table_lock);	788	spin_unlock_bh(&iucv_table_lock);
789	rc = 0;	789	rc = 0;
790	out_mutex:	790	out_mutex:
791	mutex_unlock(&iucv_register_mutex);	791	mutex_unlock(&iucv_register_mutex);
792	return rc;	792	return rc;
793	}	793	}
794	EXPORT_SYMBOL(iucv_register);	794	EXPORT_SYMBOL(iucv_register);
795		795
796	/**	796	/**
797	* iucv_unregister	797	* iucv_unregister
798	* @handler: address of iucv handler structure	798	* @handler: address of iucv handler structure
799	* @smp: != 0 indicates that the handler can deal with out of order messages	799	* @smp: != 0 indicates that the handler can deal with out of order messages
800	*	800	*
801	* Unregister driver from IUCV.	801	* Unregister driver from IUCV.
802	*/	802	*/
803	void iucv_unregister(struct iucv_handler *handler, int smp)	803	void iucv_unregister(struct iucv_handler *handler, int smp)
804	{	804	{
805	struct iucv_path p, n;	805	struct iucv_path p, n;
806		806
807	mutex_lock(&iucv_register_mutex);	807	mutex_lock(&iucv_register_mutex);
808	spin_lock_bh(&iucv_table_lock);	808	spin_lock_bh(&iucv_table_lock);
809	/* Remove handler from the iucv_handler_list. */	809	/* Remove handler from the iucv_handler_list. */
810	list_del_init(&handler->list);	810	list_del_init(&handler->list);
811	/* Sever all pathids still referring to the handler. */	811	/* Sever all pathids still referring to the handler. */
812	list_for_each_entry_safe(p, n, &handler->paths, list) {	812	list_for_each_entry_safe(p, n, &handler->paths, list) {
813	iucv_sever_pathid(p->pathid, NULL);	813	iucv_sever_pathid(p->pathid, NULL);
814	iucv_path_table[p->pathid] = NULL;	814	iucv_path_table[p->pathid] = NULL;
815	list_del(&p->list);	815	list_del(&p->list);
816	iucv_path_free(p);	816	iucv_path_free(p);
817	}	817	}
818	spin_unlock_bh(&iucv_table_lock);	818	spin_unlock_bh(&iucv_table_lock);
819	if (!smp)	819	if (!smp)
820	iucv_nonsmp_handler--;	820	iucv_nonsmp_handler--;
821	if (list_empty(&iucv_handler_list))	821	if (list_empty(&iucv_handler_list))
822	iucv_disable();	822	iucv_disable();
823	else if (!smp && iucv_nonsmp_handler == 0)	823	else if (!smp && iucv_nonsmp_handler == 0)
824	iucv_setmask_mp();	824	iucv_setmask_mp();
825	mutex_unlock(&iucv_register_mutex);	825	mutex_unlock(&iucv_register_mutex);
826	}	826	}
827	EXPORT_SYMBOL(iucv_unregister);	827	EXPORT_SYMBOL(iucv_unregister);
828		828
829	static int iucv_reboot_event(struct notifier_block *this,	829	static int iucv_reboot_event(struct notifier_block *this,
830	unsigned long event, void *ptr)	830	unsigned long event, void *ptr)
831	{	831	{
832	int i;	832	int i;
833		833
834	get_online_cpus();	834	get_online_cpus();
835	on_each_cpu(iucv_block_cpu, NULL, 1);	835	on_each_cpu(iucv_block_cpu, NULL, 1);
836	preempt_disable();	836	preempt_disable();
837	for (i = 0; i < iucv_max_pathid; i++) {	837	for (i = 0; i < iucv_max_pathid; i++) {
838	if (iucv_path_table[i])	838	if (iucv_path_table[i])
839	iucv_sever_pathid(i, NULL);	839	iucv_sever_pathid(i, NULL);
840	}	840	}
841	preempt_enable();	841	preempt_enable();
842	put_online_cpus();	842	put_online_cpus();
843	iucv_disable();	843	iucv_disable();
844	return NOTIFY_DONE;	844	return NOTIFY_DONE;
845	}	845	}
846		846
847	static struct notifier_block iucv_reboot_notifier = {	847	static struct notifier_block iucv_reboot_notifier = {
848	.notifier_call = iucv_reboot_event,	848	.notifier_call = iucv_reboot_event,
849	};	849	};
850		850
851	/**	851	/**
852	* iucv_path_accept	852	* iucv_path_accept
853	* @path: address of iucv path structure	853	* @path: address of iucv path structure
854	* @handler: address of iucv handler structure	854	* @handler: address of iucv handler structure
855	* @userdata: 16 bytes of data reflected to the communication partner	855	* @userdata: 16 bytes of data reflected to the communication partner
856	* @private: private data passed to interrupt handlers for this path	856	* @private: private data passed to interrupt handlers for this path
857	*	857	*
858	* This function is issued after the user received a connection pending	858	* This function is issued after the user received a connection pending
859	* external interrupt and now wishes to complete the IUCV communication path.	859	* external interrupt and now wishes to complete the IUCV communication path.
860	*	860	*
861	* Returns the result of the CP IUCV call.	861	* Returns the result of the CP IUCV call.
862	*/	862	*/
863	int iucv_path_accept(struct iucv_path path, struct iucv_handler handler,	863	int iucv_path_accept(struct iucv_path path, struct iucv_handler handler,
864	u8 userdata[16], void *private)	864	u8 userdata[16], void *private)
865	{	865	{
866	union iucv_param *parm;	866	union iucv_param *parm;
867	int rc;	867	int rc;
868		868
869	local_bh_disable();	869	local_bh_disable();
870	if (cpumask_empty(&iucv_buffer_cpumask)) {	870	if (cpumask_empty(&iucv_buffer_cpumask)) {
871	rc = -EIO;	871	rc = -EIO;
872	goto out;	872	goto out;
873	}	873	}
874	/* Prepare parameter block. */	874	/* Prepare parameter block. */
875	parm = iucv_param[smp_processor_id()];	875	parm = iucv_param[smp_processor_id()];
876	memset(parm, 0, sizeof(union iucv_param));	876	memset(parm, 0, sizeof(union iucv_param));
877	parm->ctrl.ippathid = path->pathid;	877	parm->ctrl.ippathid = path->pathid;
878	parm->ctrl.ipmsglim = path->msglim;	878	parm->ctrl.ipmsglim = path->msglim;
879	if (userdata)	879	if (userdata)
880	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));	880	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
881	parm->ctrl.ipflags1 = path->flags;	881	parm->ctrl.ipflags1 = path->flags;
882		882
883	rc = iucv_call_b2f0(IUCV_ACCEPT, parm);	883	rc = iucv_call_b2f0(IUCV_ACCEPT, parm);
884	if (!rc) {	884	if (!rc) {
885	path->private = private;	885	path->private = private;
886	path->msglim = parm->ctrl.ipmsglim;	886	path->msglim = parm->ctrl.ipmsglim;
887	path->flags = parm->ctrl.ipflags1;	887	path->flags = parm->ctrl.ipflags1;
888	}	888	}
889	out:	889	out:
890	local_bh_enable();	890	local_bh_enable();
891	return rc;	891	return rc;
892	}	892	}
893	EXPORT_SYMBOL(iucv_path_accept);	893	EXPORT_SYMBOL(iucv_path_accept);
894		894
895	/**	895	/**
896	* iucv_path_connect	896	* iucv_path_connect
897	* @path: address of iucv path structure	897	* @path: address of iucv path structure
898	* @handler: address of iucv handler structure	898	* @handler: address of iucv handler structure
899	* @userid: 8-byte user identification	899	* @userid: 8-byte user identification
900	* @system: 8-byte target system identification	900	* @system: 8-byte target system identification
901	* @userdata: 16 bytes of data reflected to the communication partner	901	* @userdata: 16 bytes of data reflected to the communication partner
902	* @private: private data passed to interrupt handlers for this path	902	* @private: private data passed to interrupt handlers for this path
903	*	903	*
904	* This function establishes an IUCV path. Although the connect may complete	904	* This function establishes an IUCV path. Although the connect may complete
905	* successfully, you are not able to use the path until you receive an IUCV	905	* successfully, you are not able to use the path until you receive an IUCV
906	* Connection Complete external interrupt.	906	* Connection Complete external interrupt.
907	*	907	*
908	* Returns the result of the CP IUCV call.	908	* Returns the result of the CP IUCV call.
909	*/	909	*/
910	int iucv_path_connect(struct iucv_path path, struct iucv_handler handler,	910	int iucv_path_connect(struct iucv_path path, struct iucv_handler handler,
911	u8 userid[8], u8 system[8], u8 userdata[16],	911	u8 userid[8], u8 system[8], u8 userdata[16],
912	void *private)	912	void *private)
913	{	913	{
914	union iucv_param *parm;	914	union iucv_param *parm;
915	int rc;	915	int rc;
916		916
917	spin_lock_bh(&iucv_table_lock);	917	spin_lock_bh(&iucv_table_lock);
918	iucv_cleanup_queue();	918	iucv_cleanup_queue();
919	if (cpumask_empty(&iucv_buffer_cpumask)) {	919	if (cpumask_empty(&iucv_buffer_cpumask)) {
920	rc = -EIO;	920	rc = -EIO;
921	goto out;	921	goto out;
922	}	922	}
923	parm = iucv_param[smp_processor_id()];	923	parm = iucv_param[smp_processor_id()];
924	memset(parm, 0, sizeof(union iucv_param));	924	memset(parm, 0, sizeof(union iucv_param));
925	parm->ctrl.ipmsglim = path->msglim;	925	parm->ctrl.ipmsglim = path->msglim;
926	parm->ctrl.ipflags1 = path->flags;	926	parm->ctrl.ipflags1 = path->flags;
927	if (userid) {	927	if (userid) {
928	memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));	928	memcpy(parm->ctrl.ipvmid, userid, sizeof(parm->ctrl.ipvmid));
929	ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));	929	ASCEBC(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
930	EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));	930	EBC_TOUPPER(parm->ctrl.ipvmid, sizeof(parm->ctrl.ipvmid));
931	}	931	}
932	if (system) {	932	if (system) {
933	memcpy(parm->ctrl.iptarget, system,	933	memcpy(parm->ctrl.iptarget, system,
934	sizeof(parm->ctrl.iptarget));	934	sizeof(parm->ctrl.iptarget));
935	ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));	935	ASCEBC(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
936	EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));	936	EBC_TOUPPER(parm->ctrl.iptarget, sizeof(parm->ctrl.iptarget));
937	}	937	}
938	if (userdata)	938	if (userdata)
939	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));	939	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
940		940
941	rc = iucv_call_b2f0(IUCV_CONNECT, parm);	941	rc = iucv_call_b2f0(IUCV_CONNECT, parm);
942	if (!rc) {	942	if (!rc) {
943	if (parm->ctrl.ippathid < iucv_max_pathid) {	943	if (parm->ctrl.ippathid < iucv_max_pathid) {
944	path->pathid = parm->ctrl.ippathid;	944	path->pathid = parm->ctrl.ippathid;
945	path->msglim = parm->ctrl.ipmsglim;	945	path->msglim = parm->ctrl.ipmsglim;
946	path->flags = parm->ctrl.ipflags1;	946	path->flags = parm->ctrl.ipflags1;
947	path->handler = handler;	947	path->handler = handler;
948	path->private = private;	948	path->private = private;
949	list_add_tail(&path->list, &handler->paths);	949	list_add_tail(&path->list, &handler->paths);
950	iucv_path_table[path->pathid] = path;	950	iucv_path_table[path->pathid] = path;
951	} else {	951	} else {
952	iucv_sever_pathid(parm->ctrl.ippathid,	952	iucv_sever_pathid(parm->ctrl.ippathid,
953	iucv_error_pathid);	953	iucv_error_pathid);
954	rc = -EIO;	954	rc = -EIO;
955	}	955	}
956	}	956	}
957	out:	957	out:
958	spin_unlock_bh(&iucv_table_lock);	958	spin_unlock_bh(&iucv_table_lock);
959	return rc;	959	return rc;
960	}	960	}
961	EXPORT_SYMBOL(iucv_path_connect);	961	EXPORT_SYMBOL(iucv_path_connect);
962		962
963	/**	963	/**
964	* iucv_path_quiesce:	964	* iucv_path_quiesce:
965	* @path: address of iucv path structure	965	* @path: address of iucv path structure
966	* @userdata: 16 bytes of data reflected to the communication partner	966	* @userdata: 16 bytes of data reflected to the communication partner
967	*	967	*
968	* This function temporarily suspends incoming messages on an IUCV path.	968	* This function temporarily suspends incoming messages on an IUCV path.
969	* You can later reactivate the path by invoking the iucv_resume function.	969	* You can later reactivate the path by invoking the iucv_resume function.
970	*	970	*
971	* Returns the result from the CP IUCV call.	971	* Returns the result from the CP IUCV call.
972	*/	972	*/
973	int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])	973	int iucv_path_quiesce(struct iucv_path *path, u8 userdata[16])
974	{	974	{
975	union iucv_param *parm;	975	union iucv_param *parm;
976	int rc;	976	int rc;
977		977
978	local_bh_disable();	978	local_bh_disable();
979	if (cpumask_empty(&iucv_buffer_cpumask)) {	979	if (cpumask_empty(&iucv_buffer_cpumask)) {
980	rc = -EIO;	980	rc = -EIO;
981	goto out;	981	goto out;
982	}	982	}
983	parm = iucv_param[smp_processor_id()];	983	parm = iucv_param[smp_processor_id()];
984	memset(parm, 0, sizeof(union iucv_param));	984	memset(parm, 0, sizeof(union iucv_param));
985	if (userdata)	985	if (userdata)
986	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));	986	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
987	parm->ctrl.ippathid = path->pathid;	987	parm->ctrl.ippathid = path->pathid;
988	rc = iucv_call_b2f0(IUCV_QUIESCE, parm);	988	rc = iucv_call_b2f0(IUCV_QUIESCE, parm);
989	out:	989	out:
990	local_bh_enable();	990	local_bh_enable();
991	return rc;	991	return rc;
992	}	992	}
993	EXPORT_SYMBOL(iucv_path_quiesce);	993	EXPORT_SYMBOL(iucv_path_quiesce);
994		994
995	/**	995	/**
996	* iucv_path_resume:	996	* iucv_path_resume:
997	* @path: address of iucv path structure	997	* @path: address of iucv path structure
998	* @userdata: 16 bytes of data reflected to the communication partner	998	* @userdata: 16 bytes of data reflected to the communication partner
999	*	999	*
1000	* This function resumes incoming messages on an IUCV path that has	1000	* This function resumes incoming messages on an IUCV path that has
1001	* been stopped with iucv_path_quiesce.	1001	* been stopped with iucv_path_quiesce.
1002	*	1002	*
1003	* Returns the result from the CP IUCV call.	1003	* Returns the result from the CP IUCV call.
1004	*/	1004	*/
1005	int iucv_path_resume(struct iucv_path *path, u8 userdata[16])	1005	int iucv_path_resume(struct iucv_path *path, u8 userdata[16])
1006	{	1006	{
1007	union iucv_param *parm;	1007	union iucv_param *parm;
1008	int rc;	1008	int rc;
1009		1009
1010	local_bh_disable();	1010	local_bh_disable();
1011	if (cpumask_empty(&iucv_buffer_cpumask)) {	1011	if (cpumask_empty(&iucv_buffer_cpumask)) {
1012	rc = -EIO;	1012	rc = -EIO;
1013	goto out;	1013	goto out;
1014	}	1014	}
1015	parm = iucv_param[smp_processor_id()];	1015	parm = iucv_param[smp_processor_id()];
1016	memset(parm, 0, sizeof(union iucv_param));	1016	memset(parm, 0, sizeof(union iucv_param));
1017	if (userdata)	1017	if (userdata)
1018	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));	1018	memcpy(parm->ctrl.ipuser, userdata, sizeof(parm->ctrl.ipuser));
1019	parm->ctrl.ippathid = path->pathid;	1019	parm->ctrl.ippathid = path->pathid;
1020	rc = iucv_call_b2f0(IUCV_RESUME, parm);	1020	rc = iucv_call_b2f0(IUCV_RESUME, parm);
1021	out:	1021	out:
1022	local_bh_enable();	1022	local_bh_enable();
1023	return rc;	1023	return rc;
1024	}	1024	}
1025		1025
1026	/**	1026	/**
1027	* iucv_path_sever	1027	* iucv_path_sever
1028	* @path: address of iucv path structure	1028	* @path: address of iucv path structure
1029	* @userdata: 16 bytes of data reflected to the communication partner	1029	* @userdata: 16 bytes of data reflected to the communication partner
1030	*	1030	*
1031	* This function terminates an IUCV path.	1031	* This function terminates an IUCV path.
1032	*	1032	*
1033	* Returns the result from the CP IUCV call.	1033	* Returns the result from the CP IUCV call.
1034	*/	1034	*/
1035	int iucv_path_sever(struct iucv_path *path, u8 userdata[16])	1035	int iucv_path_sever(struct iucv_path *path, u8 userdata[16])
1036	{	1036	{
1037	int rc;	1037	int rc;
1038		1038
1039	preempt_disable();	1039	preempt_disable();
1040	if (cpumask_empty(&iucv_buffer_cpumask)) {	1040	if (cpumask_empty(&iucv_buffer_cpumask)) {
1041	rc = -EIO;	1041	rc = -EIO;
1042	goto out;	1042	goto out;
1043	}	1043	}
1044	if (iucv_active_cpu != smp_processor_id())	1044	if (iucv_active_cpu != smp_processor_id())
1045	spin_lock_bh(&iucv_table_lock);	1045	spin_lock_bh(&iucv_table_lock);
1046	rc = iucv_sever_pathid(path->pathid, userdata);	1046	rc = iucv_sever_pathid(path->pathid, userdata);
1047	iucv_path_table[path->pathid] = NULL;	1047	iucv_path_table[path->pathid] = NULL;
1048	list_del_init(&path->list);	1048	list_del_init(&path->list);
1049	if (iucv_active_cpu != smp_processor_id())	1049	if (iucv_active_cpu != smp_processor_id())
1050	spin_unlock_bh(&iucv_table_lock);	1050	spin_unlock_bh(&iucv_table_lock);
1051	out:	1051	out:
1052	preempt_enable();	1052	preempt_enable();
1053	return rc;	1053	return rc;
1054	}	1054	}
1055	EXPORT_SYMBOL(iucv_path_sever);	1055	EXPORT_SYMBOL(iucv_path_sever);
1056		1056
1057	/**	1057	/**
1058	* iucv_message_purge	1058	* iucv_message_purge
1059	* @path: address of iucv path structure	1059	* @path: address of iucv path structure
1060	* @msg: address of iucv msg structure	1060	* @msg: address of iucv msg structure
1061	* @srccls: source class of message	1061	* @srccls: source class of message
1062	*	1062	*
1063	* Cancels a message you have sent.	1063	* Cancels a message you have sent.
1064	*	1064	*
1065	* Returns the result from the CP IUCV call.	1065	* Returns the result from the CP IUCV call.
1066	*/	1066	*/
1067	int iucv_message_purge(struct iucv_path path, struct iucv_message msg,	1067	int iucv_message_purge(struct iucv_path path, struct iucv_message msg,
1068	u32 srccls)	1068	u32 srccls)
1069	{	1069	{
1070	union iucv_param *parm;	1070	union iucv_param *parm;
1071	int rc;	1071	int rc;
1072		1072
1073	local_bh_disable();	1073	local_bh_disable();
1074	if (cpumask_empty(&iucv_buffer_cpumask)) {	1074	if (cpumask_empty(&iucv_buffer_cpumask)) {
1075	rc = -EIO;	1075	rc = -EIO;
1076	goto out;	1076	goto out;
1077	}	1077	}
1078	parm = iucv_param[smp_processor_id()];	1078	parm = iucv_param[smp_processor_id()];
1079	memset(parm, 0, sizeof(union iucv_param));	1079	memset(parm, 0, sizeof(union iucv_param));
1080	parm->purge.ippathid = path->pathid;	1080	parm->purge.ippathid = path->pathid;
1081	parm->purge.ipmsgid = msg->id;	1081	parm->purge.ipmsgid = msg->id;
1082	parm->purge.ipsrccls = srccls;	1082	parm->purge.ipsrccls = srccls;
1083	parm->purge.ipflags1 = IUCV_IPSRCCLS \| IUCV_IPFGMID \| IUCV_IPFGPID;	1083	parm->purge.ipflags1 = IUCV_IPSRCCLS \| IUCV_IPFGMID \| IUCV_IPFGPID;
1084	rc = iucv_call_b2f0(IUCV_PURGE, parm);	1084	rc = iucv_call_b2f0(IUCV_PURGE, parm);
1085	if (!rc) {	1085	if (!rc) {
1086	msg->audit = ((u32 ) &parm->purge.ipaudit) >> 8;	1086	msg->audit = ((u32 ) &parm->purge.ipaudit) >> 8;
1087	msg->tag = parm->purge.ipmsgtag;	1087	msg->tag = parm->purge.ipmsgtag;
1088	}	1088	}
1089	out:	1089	out:
1090	local_bh_enable();	1090	local_bh_enable();
1091	return rc;	1091	return rc;
1092	}	1092	}
1093	EXPORT_SYMBOL(iucv_message_purge);	1093	EXPORT_SYMBOL(iucv_message_purge);
1094		1094
1095	/**	1095	/**
1096	* iucv_message_receive_iprmdata	1096	* iucv_message_receive_iprmdata
1097	* @path: address of iucv path structure	1097	* @path: address of iucv path structure
1098	* @msg: address of iucv msg structure	1098	* @msg: address of iucv msg structure
1099	* @flags: how the message is received (IUCV_IPBUFLST)	1099	* @flags: how the message is received (IUCV_IPBUFLST)
1100	* @buffer: address of data buffer or address of struct iucv_array	1100	* @buffer: address of data buffer or address of struct iucv_array
1101	* @size: length of data buffer	1101	* @size: length of data buffer
1102	* @residual:	1102	* @residual:
1103	*	1103	*
1104	* Internal function used by iucv_message_receive and __iucv_message_receive	1104	* Internal function used by iucv_message_receive and __iucv_message_receive
1105	* to receive RMDATA data stored in struct iucv_message.	1105	* to receive RMDATA data stored in struct iucv_message.
1106	*/	1106	*/
1107	static int iucv_message_receive_iprmdata(struct iucv_path *path,	1107	static int iucv_message_receive_iprmdata(struct iucv_path *path,
1108	struct iucv_message *msg,	1108	struct iucv_message *msg,
1109	u8 flags, void *buffer,	1109	u8 flags, void *buffer,
1110	size_t size, size_t *residual)	1110	size_t size, size_t *residual)
1111	{	1111	{
1112	struct iucv_array *array;	1112	struct iucv_array *array;
1113	u8 *rmmsg;	1113	u8 *rmmsg;
1114	size_t copy;	1114	size_t copy;
1115		1115
1116	/*	1116	/*
1117	* Message is 8 bytes long and has been stored to the	1117	* Message is 8 bytes long and has been stored to the
1118	* message descriptor itself.	1118	* message descriptor itself.
1119	*/	1119	*/
1120	if (residual)	1120	if (residual)
1121	*residual = abs(size - 8);	1121	*residual = abs(size - 8);
1122	rmmsg = msg->rmmsg;	1122	rmmsg = msg->rmmsg;
1123	if (flags & IUCV_IPBUFLST) {	1123	if (flags & IUCV_IPBUFLST) {
1124	/* Copy to struct iucv_array. */	1124	/* Copy to struct iucv_array. */
1125	size = (size < 8) ? size : 8;	1125	size = (size < 8) ? size : 8;
1126	for (array = buffer; size > 0; array++) {	1126	for (array = buffer; size > 0; array++) {
1127	copy = min_t(size_t, size, array->length);	1127	copy = min_t(size_t, size, array->length);
1128	memcpy((u8 *)(addr_t) array->address,	1128	memcpy((u8 *)(addr_t) array->address,
1129	rmmsg, copy);	1129	rmmsg, copy);
1130	rmmsg += copy;	1130	rmmsg += copy;
1131	size -= copy;	1131	size -= copy;
1132	}	1132	}
1133	} else {	1133	} else {
1134	/* Copy to direct buffer. */	1134	/* Copy to direct buffer. */
1135	memcpy(buffer, rmmsg, min_t(size_t, size, 8));	1135	memcpy(buffer, rmmsg, min_t(size_t, size, 8));
1136	}	1136	}
1137	return 0;	1137	return 0;
1138	}	1138	}
1139		1139
1140	/**	1140	/**
1141	* __iucv_message_receive	1141	* __iucv_message_receive
1142	* @path: address of iucv path structure	1142	* @path: address of iucv path structure
1143	* @msg: address of iucv msg structure	1143	* @msg: address of iucv msg structure
1144	* @flags: how the message is received (IUCV_IPBUFLST)	1144	* @flags: how the message is received (IUCV_IPBUFLST)
1145	* @buffer: address of data buffer or address of struct iucv_array	1145	* @buffer: address of data buffer or address of struct iucv_array
1146	* @size: length of data buffer	1146	* @size: length of data buffer
1147	* @residual:	1147	* @residual:
1148	*	1148	*
1149	* This function receives messages that are being sent to you over	1149	* This function receives messages that are being sent to you over
1150	* established paths. This function will deal with RMDATA messages	1150	* established paths. This function will deal with RMDATA messages
1151	* embedded in struct iucv_message as well.	1151	* embedded in struct iucv_message as well.
1152	*	1152	*
1153	* Locking: no locking	1153	* Locking: no locking
1154	*	1154	*
1155	* Returns the result from the CP IUCV call.	1155	* Returns the result from the CP IUCV call.
1156	*/	1156	*/
1157	int __iucv_message_receive(struct iucv_path path, struct iucv_message msg,	1157	int __iucv_message_receive(struct iucv_path path, struct iucv_message msg,
1158	u8 flags, void buffer, size_t size, size_t residual)	1158	u8 flags, void buffer, size_t size, size_t residual)
1159	{	1159	{
1160	union iucv_param *parm;	1160	union iucv_param *parm;
1161	int rc;	1161	int rc;
1162		1162
1163	if (msg->flags & IUCV_IPRMDATA)	1163	if (msg->flags & IUCV_IPRMDATA)
1164	return iucv_message_receive_iprmdata(path, msg, flags,	1164	return iucv_message_receive_iprmdata(path, msg, flags,
1165	buffer, size, residual);	1165	buffer, size, residual);
1166	if (cpumask_empty(&iucv_buffer_cpumask)) {	1166	if (cpumask_empty(&iucv_buffer_cpumask)) {
1167	rc = -EIO;	1167	rc = -EIO;
1168	goto out;	1168	goto out;
1169	}	1169	}
1170	parm = iucv_param[smp_processor_id()];	1170	parm = iucv_param[smp_processor_id()];
1171	memset(parm, 0, sizeof(union iucv_param));	1171	memset(parm, 0, sizeof(union iucv_param));
1172	parm->db.ipbfadr1 = (u32)(addr_t) buffer;	1172	parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1173	parm->db.ipbfln1f = (u32) size;	1173	parm->db.ipbfln1f = (u32) size;
1174	parm->db.ipmsgid = msg->id;	1174	parm->db.ipmsgid = msg->id;
1175	parm->db.ippathid = path->pathid;	1175	parm->db.ippathid = path->pathid;
1176	parm->db.iptrgcls = msg->class;	1176	parm->db.iptrgcls = msg->class;
1177	parm->db.ipflags1 = (flags \| IUCV_IPFGPID \|	1177	parm->db.ipflags1 = (flags \| IUCV_IPFGPID \|
1178	IUCV_IPFGMID \| IUCV_IPTRGCLS);	1178	IUCV_IPFGMID \| IUCV_IPTRGCLS);
1179	rc = iucv_call_b2f0(IUCV_RECEIVE, parm);	1179	rc = iucv_call_b2f0(IUCV_RECEIVE, parm);
1180	if (!rc \|\| rc == 5) {	1180	if (!rc \|\| rc == 5) {
1181	msg->flags = parm->db.ipflags1;	1181	msg->flags = parm->db.ipflags1;
1182	if (residual)	1182	if (residual)
1183	*residual = parm->db.ipbfln1f;	1183	*residual = parm->db.ipbfln1f;
1184	}	1184	}
1185	out:	1185	out:
1186	return rc;	1186	return rc;
1187	}	1187	}
1188	EXPORT_SYMBOL(__iucv_message_receive);	1188	EXPORT_SYMBOL(__iucv_message_receive);
1189		1189
1190	/**	1190	/**
1191	* iucv_message_receive	1191	* iucv_message_receive
1192	* @path: address of iucv path structure	1192	* @path: address of iucv path structure
1193	* @msg: address of iucv msg structure	1193	* @msg: address of iucv msg structure
1194	* @flags: how the message is received (IUCV_IPBUFLST)	1194	* @flags: how the message is received (IUCV_IPBUFLST)
1195	* @buffer: address of data buffer or address of struct iucv_array	1195	* @buffer: address of data buffer or address of struct iucv_array
1196	* @size: length of data buffer	1196	* @size: length of data buffer
1197	* @residual:	1197	* @residual:
1198	*	1198	*
1199	* This function receives messages that are being sent to you over	1199	* This function receives messages that are being sent to you over
1200	* established paths. This function will deal with RMDATA messages	1200	* established paths. This function will deal with RMDATA messages
1201	* embedded in struct iucv_message as well.	1201	* embedded in struct iucv_message as well.
1202	*	1202	*
1203	* Locking: local_bh_enable/local_bh_disable	1203	* Locking: local_bh_enable/local_bh_disable
1204	*	1204	*
1205	* Returns the result from the CP IUCV call.	1205	* Returns the result from the CP IUCV call.
1206	*/	1206	*/
1207	int iucv_message_receive(struct iucv_path path, struct iucv_message msg,	1207	int iucv_message_receive(struct iucv_path path, struct iucv_message msg,
1208	u8 flags, void buffer, size_t size, size_t residual)	1208	u8 flags, void buffer, size_t size, size_t residual)
1209	{	1209	{
1210	int rc;	1210	int rc;
1211		1211
1212	if (msg->flags & IUCV_IPRMDATA)	1212	if (msg->flags & IUCV_IPRMDATA)
1213	return iucv_message_receive_iprmdata(path, msg, flags,	1213	return iucv_message_receive_iprmdata(path, msg, flags,
1214	buffer, size, residual);	1214	buffer, size, residual);
1215	local_bh_disable();	1215	local_bh_disable();
1216	rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);	1216	rc = __iucv_message_receive(path, msg, flags, buffer, size, residual);
1217	local_bh_enable();	1217	local_bh_enable();
1218	return rc;	1218	return rc;
1219	}	1219	}
1220	EXPORT_SYMBOL(iucv_message_receive);	1220	EXPORT_SYMBOL(iucv_message_receive);
1221		1221
1222	/**	1222	/**
1223	* iucv_message_reject	1223	* iucv_message_reject
1224	* @path: address of iucv path structure	1224	* @path: address of iucv path structure
1225	* @msg: address of iucv msg structure	1225	* @msg: address of iucv msg structure
1226	*	1226	*
1227	* The reject function refuses a specified message. Between the time you	1227	* The reject function refuses a specified message. Between the time you
1228	* are notified of a message and the time that you complete the message,	1228	* are notified of a message and the time that you complete the message,
1229	* the message may be rejected.	1229	* the message may be rejected.
1230	*	1230	*
1231	* Returns the result from the CP IUCV call.	1231	* Returns the result from the CP IUCV call.
1232	*/	1232	*/
1233	int iucv_message_reject(struct iucv_path path, struct iucv_message msg)	1233	int iucv_message_reject(struct iucv_path path, struct iucv_message msg)
1234	{	1234	{
1235	union iucv_param *parm;	1235	union iucv_param *parm;
1236	int rc;	1236	int rc;
1237		1237
1238	local_bh_disable();	1238	local_bh_disable();
1239	if (cpumask_empty(&iucv_buffer_cpumask)) {	1239	if (cpumask_empty(&iucv_buffer_cpumask)) {
1240	rc = -EIO;	1240	rc = -EIO;
1241	goto out;	1241	goto out;
1242	}	1242	}
1243	parm = iucv_param[smp_processor_id()];	1243	parm = iucv_param[smp_processor_id()];
1244	memset(parm, 0, sizeof(union iucv_param));	1244	memset(parm, 0, sizeof(union iucv_param));
1245	parm->db.ippathid = path->pathid;	1245	parm->db.ippathid = path->pathid;
1246	parm->db.ipmsgid = msg->id;	1246	parm->db.ipmsgid = msg->id;
1247	parm->db.iptrgcls = msg->class;	1247	parm->db.iptrgcls = msg->class;
1248	parm->db.ipflags1 = (IUCV_IPTRGCLS \| IUCV_IPFGMID \| IUCV_IPFGPID);	1248	parm->db.ipflags1 = (IUCV_IPTRGCLS \| IUCV_IPFGMID \| IUCV_IPFGPID);
1249	rc = iucv_call_b2f0(IUCV_REJECT, parm);	1249	rc = iucv_call_b2f0(IUCV_REJECT, parm);
1250	out:	1250	out:
1251	local_bh_enable();	1251	local_bh_enable();
1252	return rc;	1252	return rc;
1253	}	1253	}
1254	EXPORT_SYMBOL(iucv_message_reject);	1254	EXPORT_SYMBOL(iucv_message_reject);
1255		1255
1256	/**	1256	/**
1257	* iucv_message_reply	1257	* iucv_message_reply
1258	* @path: address of iucv path structure	1258	* @path: address of iucv path structure
1259	* @msg: address of iucv msg structure	1259	* @msg: address of iucv msg structure
1260	* @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)	1260	* @flags: how the reply is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1261	* @reply: address of reply data buffer or address of struct iucv_array	1261	* @reply: address of reply data buffer or address of struct iucv_array
1262	* @size: length of reply data buffer	1262	* @size: length of reply data buffer
1263	*	1263	*
1264	* This function responds to the two-way messages that you receive. You	1264	* This function responds to the two-way messages that you receive. You
1265	* must identify completely the message to which you wish to reply. ie,	1265	* must identify completely the message to which you wish to reply. ie,
1266	* pathid, msgid, and trgcls. Prmmsg signifies the data is moved into	1266	* pathid, msgid, and trgcls. Prmmsg signifies the data is moved into
1267	* the parameter list.	1267	* the parameter list.
1268	*	1268	*
1269	* Returns the result from the CP IUCV call.	1269	* Returns the result from the CP IUCV call.
1270	*/	1270	*/
1271	int iucv_message_reply(struct iucv_path path, struct iucv_message msg,	1271	int iucv_message_reply(struct iucv_path path, struct iucv_message msg,
1272	u8 flags, void *reply, size_t size)	1272	u8 flags, void *reply, size_t size)
1273	{	1273	{
1274	union iucv_param *parm;	1274	union iucv_param *parm;
1275	int rc;	1275	int rc;
1276		1276
1277	local_bh_disable();	1277	local_bh_disable();
1278	if (cpumask_empty(&iucv_buffer_cpumask)) {	1278	if (cpumask_empty(&iucv_buffer_cpumask)) {
1279	rc = -EIO;	1279	rc = -EIO;
1280	goto out;	1280	goto out;
1281	}	1281	}
1282	parm = iucv_param[smp_processor_id()];	1282	parm = iucv_param[smp_processor_id()];
1283	memset(parm, 0, sizeof(union iucv_param));	1283	memset(parm, 0, sizeof(union iucv_param));
1284	if (flags & IUCV_IPRMDATA) {	1284	if (flags & IUCV_IPRMDATA) {
1285	parm->dpl.ippathid = path->pathid;	1285	parm->dpl.ippathid = path->pathid;
1286	parm->dpl.ipflags1 = flags;	1286	parm->dpl.ipflags1 = flags;
1287	parm->dpl.ipmsgid = msg->id;	1287	parm->dpl.ipmsgid = msg->id;
1288	parm->dpl.iptrgcls = msg->class;	1288	parm->dpl.iptrgcls = msg->class;
1289	memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));	1289	memcpy(parm->dpl.iprmmsg, reply, min_t(size_t, size, 8));
1290	} else {	1290	} else {
1291	parm->db.ipbfadr1 = (u32)(addr_t) reply;	1291	parm->db.ipbfadr1 = (u32)(addr_t) reply;
1292	parm->db.ipbfln1f = (u32) size;	1292	parm->db.ipbfln1f = (u32) size;
1293	parm->db.ippathid = path->pathid;	1293	parm->db.ippathid = path->pathid;
1294	parm->db.ipflags1 = flags;	1294	parm->db.ipflags1 = flags;
1295	parm->db.ipmsgid = msg->id;	1295	parm->db.ipmsgid = msg->id;
1296	parm->db.iptrgcls = msg->class;	1296	parm->db.iptrgcls = msg->class;
1297	}	1297	}
1298	rc = iucv_call_b2f0(IUCV_REPLY, parm);	1298	rc = iucv_call_b2f0(IUCV_REPLY, parm);
1299	out:	1299	out:
1300	local_bh_enable();	1300	local_bh_enable();
1301	return rc;	1301	return rc;
1302	}	1302	}
1303	EXPORT_SYMBOL(iucv_message_reply);	1303	EXPORT_SYMBOL(iucv_message_reply);
1304		1304
1305	/**	1305	/**
1306	* __iucv_message_send	1306	* __iucv_message_send
1307	* @path: address of iucv path structure	1307	* @path: address of iucv path structure
1308	* @msg: address of iucv msg structure	1308	* @msg: address of iucv msg structure
1309	* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)	1309	* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1310	* @srccls: source class of message	1310	* @srccls: source class of message
1311	* @buffer: address of send buffer or address of struct iucv_array	1311	* @buffer: address of send buffer or address of struct iucv_array
1312	* @size: length of send buffer	1312	* @size: length of send buffer
1313	*	1313	*
1314	* This function transmits data to another application. Data to be	1314	* This function transmits data to another application. Data to be
1315	* transmitted is in a buffer and this is a one-way message and the	1315	* transmitted is in a buffer and this is a one-way message and the
1316	* receiver will not reply to the message.	1316	* receiver will not reply to the message.
1317	*	1317	*
1318	* Locking: no locking	1318	* Locking: no locking
1319	*	1319	*
1320	* Returns the result from the CP IUCV call.	1320	* Returns the result from the CP IUCV call.
1321	*/	1321	*/
1322	int __iucv_message_send(struct iucv_path path, struct iucv_message msg,	1322	int __iucv_message_send(struct iucv_path path, struct iucv_message msg,
1323	u8 flags, u32 srccls, void *buffer, size_t size)	1323	u8 flags, u32 srccls, void *buffer, size_t size)
1324	{	1324	{
1325	union iucv_param *parm;	1325	union iucv_param *parm;
1326	int rc;	1326	int rc;
1327		1327
1328	if (cpumask_empty(&iucv_buffer_cpumask)) {	1328	if (cpumask_empty(&iucv_buffer_cpumask)) {
1329	rc = -EIO;	1329	rc = -EIO;
1330	goto out;	1330	goto out;
1331	}	1331	}
1332	parm = iucv_param[smp_processor_id()];	1332	parm = iucv_param[smp_processor_id()];
1333	memset(parm, 0, sizeof(union iucv_param));	1333	memset(parm, 0, sizeof(union iucv_param));
1334	if (flags & IUCV_IPRMDATA) {	1334	if (flags & IUCV_IPRMDATA) {
1335	/* Message of 8 bytes can be placed into the parameter list. */	1335	/* Message of 8 bytes can be placed into the parameter list. */
1336	parm->dpl.ippathid = path->pathid;	1336	parm->dpl.ippathid = path->pathid;
1337	parm->dpl.ipflags1 = flags \| IUCV_IPNORPY;	1337	parm->dpl.ipflags1 = flags \| IUCV_IPNORPY;
1338	parm->dpl.iptrgcls = msg->class;	1338	parm->dpl.iptrgcls = msg->class;
1339	parm->dpl.ipsrccls = srccls;	1339	parm->dpl.ipsrccls = srccls;
1340	parm->dpl.ipmsgtag = msg->tag;	1340	parm->dpl.ipmsgtag = msg->tag;
1341	memcpy(parm->dpl.iprmmsg, buffer, 8);	1341	memcpy(parm->dpl.iprmmsg, buffer, 8);
1342	} else {	1342	} else {
1343	parm->db.ipbfadr1 = (u32)(addr_t) buffer;	1343	parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1344	parm->db.ipbfln1f = (u32) size;	1344	parm->db.ipbfln1f = (u32) size;
1345	parm->db.ippathid = path->pathid;	1345	parm->db.ippathid = path->pathid;
1346	parm->db.ipflags1 = flags \| IUCV_IPNORPY;	1346	parm->db.ipflags1 = flags \| IUCV_IPNORPY;
1347	parm->db.iptrgcls = msg->class;	1347	parm->db.iptrgcls = msg->class;
1348	parm->db.ipsrccls = srccls;	1348	parm->db.ipsrccls = srccls;
1349	parm->db.ipmsgtag = msg->tag;	1349	parm->db.ipmsgtag = msg->tag;
1350	}	1350	}
1351	rc = iucv_call_b2f0(IUCV_SEND, parm);	1351	rc = iucv_call_b2f0(IUCV_SEND, parm);
1352	if (!rc)	1352	if (!rc)
1353	msg->id = parm->db.ipmsgid;	1353	msg->id = parm->db.ipmsgid;
1354	out:	1354	out:
1355	return rc;	1355	return rc;
1356	}	1356	}
1357	EXPORT_SYMBOL(__iucv_message_send);	1357	EXPORT_SYMBOL(__iucv_message_send);
1358		1358
1359	/**	1359	/**
1360	* iucv_message_send	1360	* iucv_message_send
1361	* @path: address of iucv path structure	1361	* @path: address of iucv path structure
1362	* @msg: address of iucv msg structure	1362	* @msg: address of iucv msg structure
1363	* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)	1363	* @flags: how the message is sent (IUCV_IPRMDATA, IUCV_IPPRTY, IUCV_IPBUFLST)
1364	* @srccls: source class of message	1364	* @srccls: source class of message
1365	* @buffer: address of send buffer or address of struct iucv_array	1365	* @buffer: address of send buffer or address of struct iucv_array
1366	* @size: length of send buffer	1366	* @size: length of send buffer
1367	*	1367	*
1368	* This function transmits data to another application. Data to be	1368	* This function transmits data to another application. Data to be
1369	* transmitted is in a buffer and this is a one-way message and the	1369	* transmitted is in a buffer and this is a one-way message and the
1370	* receiver will not reply to the message.	1370	* receiver will not reply to the message.
1371	*	1371	*
1372	* Locking: local_bh_enable/local_bh_disable	1372	* Locking: local_bh_enable/local_bh_disable
1373	*	1373	*
1374	* Returns the result from the CP IUCV call.	1374	* Returns the result from the CP IUCV call.
1375	*/	1375	*/
1376	int iucv_message_send(struct iucv_path path, struct iucv_message msg,	1376	int iucv_message_send(struct iucv_path path, struct iucv_message msg,
1377	u8 flags, u32 srccls, void *buffer, size_t size)	1377	u8 flags, u32 srccls, void *buffer, size_t size)
1378	{	1378	{
1379	int rc;	1379	int rc;
1380		1380
1381	local_bh_disable();	1381	local_bh_disable();
1382	rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);	1382	rc = __iucv_message_send(path, msg, flags, srccls, buffer, size);
1383	local_bh_enable();	1383	local_bh_enable();
1384	return rc;	1384	return rc;
1385	}	1385	}
1386	EXPORT_SYMBOL(iucv_message_send);	1386	EXPORT_SYMBOL(iucv_message_send);
1387		1387
1388	/**	1388	/**
1389	* iucv_message_send2way	1389	* iucv_message_send2way
1390	* @path: address of iucv path structure	1390	* @path: address of iucv path structure
1391	* @msg: address of iucv msg structure	1391	* @msg: address of iucv msg structure
1392	* @flags: how the message is sent and the reply is received	1392	* @flags: how the message is sent and the reply is received
1393	* (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)	1393	* (IUCV_IPRMDATA, IUCV_IPBUFLST, IUCV_IPPRTY, IUCV_ANSLST)
1394	* @srccls: source class of message	1394	* @srccls: source class of message
1395	* @buffer: address of send buffer or address of struct iucv_array	1395	* @buffer: address of send buffer or address of struct iucv_array
1396	* @size: length of send buffer	1396	* @size: length of send buffer
1397	* @ansbuf: address of answer buffer or address of struct iucv_array	1397	* @ansbuf: address of answer buffer or address of struct iucv_array
1398	* @asize: size of reply buffer	1398	* @asize: size of reply buffer
1399	*	1399	*
1400	* This function transmits data to another application. Data to be	1400	* This function transmits data to another application. Data to be
1401	* transmitted is in a buffer. The receiver of the send is expected to	1401	* transmitted is in a buffer. The receiver of the send is expected to
1402	* reply to the message and a buffer is provided into which IUCV moves	1402	* reply to the message and a buffer is provided into which IUCV moves
1403	* the reply to this message.	1403	* the reply to this message.
1404	*	1404	*
1405	* Returns the result from the CP IUCV call.	1405	* Returns the result from the CP IUCV call.
1406	*/	1406	*/
1407	int iucv_message_send2way(struct iucv_path path, struct iucv_message msg,	1407	int iucv_message_send2way(struct iucv_path path, struct iucv_message msg,
1408	u8 flags, u32 srccls, void *buffer, size_t size,	1408	u8 flags, u32 srccls, void *buffer, size_t size,
1409	void answer, size_t asize, size_t residual)	1409	void answer, size_t asize, size_t residual)
1410	{	1410	{
1411	union iucv_param *parm;	1411	union iucv_param *parm;
1412	int rc;	1412	int rc;
1413		1413
1414	local_bh_disable();	1414	local_bh_disable();
1415	if (cpumask_empty(&iucv_buffer_cpumask)) {	1415	if (cpumask_empty(&iucv_buffer_cpumask)) {
1416	rc = -EIO;	1416	rc = -EIO;
1417	goto out;	1417	goto out;
1418	}	1418	}
1419	parm = iucv_param[smp_processor_id()];	1419	parm = iucv_param[smp_processor_id()];
1420	memset(parm, 0, sizeof(union iucv_param));	1420	memset(parm, 0, sizeof(union iucv_param));
1421	if (flags & IUCV_IPRMDATA) {	1421	if (flags & IUCV_IPRMDATA) {
1422	parm->dpl.ippathid = path->pathid;	1422	parm->dpl.ippathid = path->pathid;
1423	parm->dpl.ipflags1 = path->flags; /* priority message */	1423	parm->dpl.ipflags1 = path->flags; /* priority message */
1424	parm->dpl.iptrgcls = msg->class;	1424	parm->dpl.iptrgcls = msg->class;
1425	parm->dpl.ipsrccls = srccls;	1425	parm->dpl.ipsrccls = srccls;
1426	parm->dpl.ipmsgtag = msg->tag;	1426	parm->dpl.ipmsgtag = msg->tag;
1427	parm->dpl.ipbfadr2 = (u32)(addr_t) answer;	1427	parm->dpl.ipbfadr2 = (u32)(addr_t) answer;
1428	parm->dpl.ipbfln2f = (u32) asize;	1428	parm->dpl.ipbfln2f = (u32) asize;
1429	memcpy(parm->dpl.iprmmsg, buffer, 8);	1429	memcpy(parm->dpl.iprmmsg, buffer, 8);
1430	} else {	1430	} else {
1431	parm->db.ippathid = path->pathid;	1431	parm->db.ippathid = path->pathid;
1432	parm->db.ipflags1 = path->flags; /* priority message */	1432	parm->db.ipflags1 = path->flags; /* priority message */
1433	parm->db.iptrgcls = msg->class;	1433	parm->db.iptrgcls = msg->class;
1434	parm->db.ipsrccls = srccls;	1434	parm->db.ipsrccls = srccls;
1435	parm->db.ipmsgtag = msg->tag;	1435	parm->db.ipmsgtag = msg->tag;
1436	parm->db.ipbfadr1 = (u32)(addr_t) buffer;	1436	parm->db.ipbfadr1 = (u32)(addr_t) buffer;
1437	parm->db.ipbfln1f = (u32) size;	1437	parm->db.ipbfln1f = (u32) size;
1438	parm->db.ipbfadr2 = (u32)(addr_t) answer;	1438	parm->db.ipbfadr2 = (u32)(addr_t) answer;
1439	parm->db.ipbfln2f = (u32) asize;	1439	parm->db.ipbfln2f = (u32) asize;
1440	}	1440	}
1441	rc = iucv_call_b2f0(IUCV_SEND, parm);	1441	rc = iucv_call_b2f0(IUCV_SEND, parm);
1442	if (!rc)	1442	if (!rc)
1443	msg->id = parm->db.ipmsgid;	1443	msg->id = parm->db.ipmsgid;
1444	out:	1444	out:
1445	local_bh_enable();	1445	local_bh_enable();
1446	return rc;	1446	return rc;
1447	}	1447	}
1448	EXPORT_SYMBOL(iucv_message_send2way);	1448	EXPORT_SYMBOL(iucv_message_send2way);
1449		1449
1450	/**	1450	/**
1451	* iucv_path_pending	1451	* iucv_path_pending
1452	* @data: Pointer to external interrupt buffer	1452	* @data: Pointer to external interrupt buffer
1453	*	1453	*
1454	* Process connection pending work item. Called from tasklet while holding	1454	* Process connection pending work item. Called from tasklet while holding
1455	* iucv_table_lock.	1455	* iucv_table_lock.
1456	*/	1456	*/
1457	struct iucv_path_pending {	1457	struct iucv_path_pending {
1458	u16 ippathid;	1458	u16 ippathid;
1459	u8 ipflags1;	1459	u8 ipflags1;
1460	u8 iptype;	1460	u8 iptype;
1461	u16 ipmsglim;	1461	u16 ipmsglim;
1462	u16 res1;	1462	u16 res1;
1463	u8 ipvmid[8];	1463	u8 ipvmid[8];
1464	u8 ipuser[16];	1464	u8 ipuser[16];
1465	u32 res3;	1465	u32 res3;
1466	u8 ippollfg;	1466	u8 ippollfg;
1467	u8 res4[3];	1467	u8 res4[3];
1468	} __packed;	1468	} __packed;
1469		1469
1470	static void iucv_path_pending(struct iucv_irq_data *data)	1470	static void iucv_path_pending(struct iucv_irq_data *data)
1471	{	1471	{
1472	struct iucv_path_pending ipp = (void ) data;	1472	struct iucv_path_pending ipp = (void ) data;
1473	struct iucv_handler *handler;	1473	struct iucv_handler *handler;
1474	struct iucv_path *path;	1474	struct iucv_path *path;
1475	char *error;	1475	char *error;
1476		1476
1477	BUG_ON(iucv_path_table[ipp->ippathid]);	1477	BUG_ON(iucv_path_table[ipp->ippathid]);
1478	/* New pathid, handler found. Create a new path struct. */	1478	/* New pathid, handler found. Create a new path struct. */
1479	error = iucv_error_no_memory;	1479	error = iucv_error_no_memory;
1480	path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);	1480	path = iucv_path_alloc(ipp->ipmsglim, ipp->ipflags1, GFP_ATOMIC);
1481	if (!path)	1481	if (!path)
1482	goto out_sever;	1482	goto out_sever;
1483	path->pathid = ipp->ippathid;	1483	path->pathid = ipp->ippathid;
1484	iucv_path_table[path->pathid] = path;	1484	iucv_path_table[path->pathid] = path;
1485	EBCASC(ipp->ipvmid, 8);	1485	EBCASC(ipp->ipvmid, 8);
1486		1486
1487	/* Call registered handler until one is found that wants the path. */	1487	/* Call registered handler until one is found that wants the path. */
1488	list_for_each_entry(handler, &iucv_handler_list, list) {	1488	list_for_each_entry(handler, &iucv_handler_list, list) {
1489	if (!handler->path_pending)	1489	if (!handler->path_pending)
1490	continue;	1490	continue;
1491	/*	1491	/*
1492	* Add path to handler to allow a call to iucv_path_sever	1492	* Add path to handler to allow a call to iucv_path_sever
1493	* inside the path_pending function. If the handler returns	1493	* inside the path_pending function. If the handler returns
1494	* an error remove the path from the handler again.	1494	* an error remove the path from the handler again.
1495	*/	1495	*/
1496	list_add(&path->list, &handler->paths);	1496	list_add(&path->list, &handler->paths);
1497	path->handler = handler;	1497	path->handler = handler;
1498	if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))	1498	if (!handler->path_pending(path, ipp->ipvmid, ipp->ipuser))
1499	return;	1499	return;
1500	list_del(&path->list);	1500	list_del(&path->list);
1501	path->handler = NULL;	1501	path->handler = NULL;
1502	}	1502	}
1503	/* No handler wanted the path. */	1503	/* No handler wanted the path. */
1504	iucv_path_table[path->pathid] = NULL;	1504	iucv_path_table[path->pathid] = NULL;
1505	iucv_path_free(path);	1505	iucv_path_free(path);
1506	error = iucv_error_no_listener;	1506	error = iucv_error_no_listener;
1507	out_sever:	1507	out_sever:
1508	iucv_sever_pathid(ipp->ippathid, error);	1508	iucv_sever_pathid(ipp->ippathid, error);
1509	}	1509	}
1510		1510
1511	/**	1511	/**
1512	* iucv_path_complete	1512	* iucv_path_complete
1513	* @data: Pointer to external interrupt buffer	1513	* @data: Pointer to external interrupt buffer
1514	*	1514	*
1515	* Process connection complete work item. Called from tasklet while holding	1515	* Process connection complete work item. Called from tasklet while holding
1516	* iucv_table_lock.	1516	* iucv_table_lock.
1517	*/	1517	*/
1518	struct iucv_path_complete {	1518	struct iucv_path_complete {
1519	u16 ippathid;	1519	u16 ippathid;
1520	u8 ipflags1;	1520	u8 ipflags1;
1521	u8 iptype;	1521	u8 iptype;
1522	u16 ipmsglim;	1522	u16 ipmsglim;
1523	u16 res1;	1523	u16 res1;
1524	u8 res2[8];	1524	u8 res2[8];
1525	u8 ipuser[16];	1525	u8 ipuser[16];
1526	u32 res3;	1526	u32 res3;
1527	u8 ippollfg;	1527	u8 ippollfg;
1528	u8 res4[3];	1528	u8 res4[3];
1529	} __packed;	1529	} __packed;
1530		1530
1531	static void iucv_path_complete(struct iucv_irq_data *data)	1531	static void iucv_path_complete(struct iucv_irq_data *data)
1532	{	1532	{
1533	struct iucv_path_complete ipc = (void ) data;	1533	struct iucv_path_complete ipc = (void ) data;
1534	struct iucv_path *path = iucv_path_table[ipc->ippathid];	1534	struct iucv_path *path = iucv_path_table[ipc->ippathid];
1535		1535
1536	if (path)	1536	if (path)
1537	path->flags = ipc->ipflags1;	1537	path->flags = ipc->ipflags1;
1538	if (path && path->handler && path->handler->path_complete)	1538	if (path && path->handler && path->handler->path_complete)
1539	path->handler->path_complete(path, ipc->ipuser);	1539	path->handler->path_complete(path, ipc->ipuser);
1540	}	1540	}
1541		1541
1542	/**	1542	/**
1543	* iucv_path_severed	1543	* iucv_path_severed
1544	* @data: Pointer to external interrupt buffer	1544	* @data: Pointer to external interrupt buffer
1545	*	1545	*
1546	* Process connection severed work item. Called from tasklet while holding	1546	* Process connection severed work item. Called from tasklet while holding
1547	* iucv_table_lock.	1547	* iucv_table_lock.
1548	*/	1548	*/
1549	struct iucv_path_severed {	1549	struct iucv_path_severed {
1550	u16 ippathid;	1550	u16 ippathid;
1551	u8 res1;	1551	u8 res1;
1552	u8 iptype;	1552	u8 iptype;
1553	u32 res2;	1553	u32 res2;
1554	u8 res3[8];	1554	u8 res3[8];
1555	u8 ipuser[16];	1555	u8 ipuser[16];
1556	u32 res4;	1556	u32 res4;
1557	u8 ippollfg;	1557	u8 ippollfg;
1558	u8 res5[3];	1558	u8 res5[3];
1559	} __packed;	1559	} __packed;
1560		1560
1561	static void iucv_path_severed(struct iucv_irq_data *data)	1561	static void iucv_path_severed(struct iucv_irq_data *data)
1562	{	1562	{
1563	struct iucv_path_severed ips = (void ) data;	1563	struct iucv_path_severed ips = (void ) data;
1564	struct iucv_path *path = iucv_path_table[ips->ippathid];	1564	struct iucv_path *path = iucv_path_table[ips->ippathid];
1565		1565
1566	if (!path \|\| !path->handler) /* Already severed */	1566	if (!path \|\| !path->handler) /* Already severed */
1567	return;	1567	return;
1568	if (path->handler->path_severed)	1568	if (path->handler->path_severed)
1569	path->handler->path_severed(path, ips->ipuser);	1569	path->handler->path_severed(path, ips->ipuser);
1570	else {	1570	else {
1571	iucv_sever_pathid(path->pathid, NULL);	1571	iucv_sever_pathid(path->pathid, NULL);
1572	iucv_path_table[path->pathid] = NULL;	1572	iucv_path_table[path->pathid] = NULL;
1573	list_del(&path->list);	1573	list_del(&path->list);
1574	iucv_path_free(path);	1574	iucv_path_free(path);
1575	}	1575	}
1576	}	1576	}
1577		1577
1578	/**	1578	/**
1579	* iucv_path_quiesced	1579	* iucv_path_quiesced
1580	* @data: Pointer to external interrupt buffer	1580	* @data: Pointer to external interrupt buffer
1581	*	1581	*
1582	* Process connection quiesced work item. Called from tasklet while holding	1582	* Process connection quiesced work item. Called from tasklet while holding
1583	* iucv_table_lock.	1583	* iucv_table_lock.
1584	*/	1584	*/
1585	struct iucv_path_quiesced {	1585	struct iucv_path_quiesced {
1586	u16 ippathid;	1586	u16 ippathid;
1587	u8 res1;	1587	u8 res1;
1588	u8 iptype;	1588	u8 iptype;
1589	u32 res2;	1589	u32 res2;
1590	u8 res3[8];	1590	u8 res3[8];
1591	u8 ipuser[16];	1591	u8 ipuser[16];
1592	u32 res4;	1592	u32 res4;
1593	u8 ippollfg;	1593	u8 ippollfg;
1594	u8 res5[3];	1594	u8 res5[3];
1595	} __packed;	1595	} __packed;
1596		1596
1597	static void iucv_path_quiesced(struct iucv_irq_data *data)	1597	static void iucv_path_quiesced(struct iucv_irq_data *data)
1598	{	1598	{
1599	struct iucv_path_quiesced ipq = (void ) data;	1599	struct iucv_path_quiesced ipq = (void ) data;
1600	struct iucv_path *path = iucv_path_table[ipq->ippathid];	1600	struct iucv_path *path = iucv_path_table[ipq->ippathid];
1601		1601
1602	if (path && path->handler && path->handler->path_quiesced)	1602	if (path && path->handler && path->handler->path_quiesced)
1603	path->handler->path_quiesced(path, ipq->ipuser);	1603	path->handler->path_quiesced(path, ipq->ipuser);
1604	}	1604	}
1605		1605
1606	/**	1606	/**
1607	* iucv_path_resumed	1607	* iucv_path_resumed
1608	* @data: Pointer to external interrupt buffer	1608	* @data: Pointer to external interrupt buffer
1609	*	1609	*
1610	* Process connection resumed work item. Called from tasklet while holding	1610	* Process connection resumed work item. Called from tasklet while holding
1611	* iucv_table_lock.	1611	* iucv_table_lock.
1612	*/	1612	*/
1613	struct iucv_path_resumed {	1613	struct iucv_path_resumed {
1614	u16 ippathid;	1614	u16 ippathid;
1615	u8 res1;	1615	u8 res1;
1616	u8 iptype;	1616	u8 iptype;
1617	u32 res2;	1617	u32 res2;
1618	u8 res3[8];	1618	u8 res3[8];
1619	u8 ipuser[16];	1619	u8 ipuser[16];
1620	u32 res4;	1620	u32 res4;
1621	u8 ippollfg;	1621	u8 ippollfg;
1622	u8 res5[3];	1622	u8 res5[3];
1623	} __packed;	1623	} __packed;
1624		1624
1625	static void iucv_path_resumed(struct iucv_irq_data *data)	1625	static void iucv_path_resumed(struct iucv_irq_data *data)
1626	{	1626	{
1627	struct iucv_path_resumed ipr = (void ) data;	1627	struct iucv_path_resumed ipr = (void ) data;
1628	struct iucv_path *path = iucv_path_table[ipr->ippathid];	1628	struct iucv_path *path = iucv_path_table[ipr->ippathid];
1629		1629
1630	if (path && path->handler && path->handler->path_resumed)	1630	if (path && path->handler && path->handler->path_resumed)
1631	path->handler->path_resumed(path, ipr->ipuser);	1631	path->handler->path_resumed(path, ipr->ipuser);
1632	}	1632	}
1633		1633
1634	/**	1634	/**
1635	* iucv_message_complete	1635	* iucv_message_complete
1636	* @data: Pointer to external interrupt buffer	1636	* @data: Pointer to external interrupt buffer
1637	*	1637	*
1638	* Process message complete work item. Called from tasklet while holding	1638	* Process message complete work item. Called from tasklet while holding
1639	* iucv_table_lock.	1639	* iucv_table_lock.
1640	*/	1640	*/
1641	struct iucv_message_complete {	1641	struct iucv_message_complete {
1642	u16 ippathid;	1642	u16 ippathid;
1643	u8 ipflags1;	1643	u8 ipflags1;
1644	u8 iptype;	1644	u8 iptype;
1645	u32 ipmsgid;	1645	u32 ipmsgid;
1646	u32 ipaudit;	1646	u32 ipaudit;
1647	u8 iprmmsg[8];	1647	u8 iprmmsg[8];
1648	u32 ipsrccls;	1648	u32 ipsrccls;
1649	u32 ipmsgtag;	1649	u32 ipmsgtag;
1650	u32 res;	1650	u32 res;
1651	u32 ipbfln2f;	1651	u32 ipbfln2f;
1652	u8 ippollfg;	1652	u8 ippollfg;
1653	u8 res2[3];	1653	u8 res2[3];
1654	} __packed;	1654	} __packed;
1655		1655
1656	static void iucv_message_complete(struct iucv_irq_data *data)	1656	static void iucv_message_complete(struct iucv_irq_data *data)
1657	{	1657	{
1658	struct iucv_message_complete imc = (void ) data;	1658	struct iucv_message_complete imc = (void ) data;
1659	struct iucv_path *path = iucv_path_table[imc->ippathid];	1659	struct iucv_path *path = iucv_path_table[imc->ippathid];
1660	struct iucv_message msg;	1660	struct iucv_message msg;
1661		1661
1662	if (path && path->handler && path->handler->message_complete) {	1662	if (path && path->handler && path->handler->message_complete) {
1663	msg.flags = imc->ipflags1;	1663	msg.flags = imc->ipflags1;
1664	msg.id = imc->ipmsgid;	1664	msg.id = imc->ipmsgid;
1665	msg.audit = imc->ipaudit;	1665	msg.audit = imc->ipaudit;
1666	memcpy(msg.rmmsg, imc->iprmmsg, 8);	1666	memcpy(msg.rmmsg, imc->iprmmsg, 8);
1667	msg.class = imc->ipsrccls;	1667	msg.class = imc->ipsrccls;
1668	msg.tag = imc->ipmsgtag;	1668	msg.tag = imc->ipmsgtag;
1669	msg.length = imc->ipbfln2f;	1669	msg.length = imc->ipbfln2f;
1670	path->handler->message_complete(path, &msg);	1670	path->handler->message_complete(path, &msg);
1671	}	1671	}
1672	}	1672	}
1673		1673
1674	/**	1674	/**
1675	* iucv_message_pending	1675	* iucv_message_pending
1676	* @data: Pointer to external interrupt buffer	1676	* @data: Pointer to external interrupt buffer
1677	*	1677	*
1678	* Process message pending work item. Called from tasklet while holding	1678	* Process message pending work item. Called from tasklet while holding
1679	* iucv_table_lock.	1679	* iucv_table_lock.
1680	*/	1680	*/
1681	struct iucv_message_pending {	1681	struct iucv_message_pending {
1682	u16 ippathid;	1682	u16 ippathid;
1683	u8 ipflags1;	1683	u8 ipflags1;
1684	u8 iptype;	1684	u8 iptype;
1685	u32 ipmsgid;	1685	u32 ipmsgid;
1686	u32 iptrgcls;	1686	u32 iptrgcls;
1687	union {	1687	union {
1688	u32 iprmmsg1_u32;	1688	u32 iprmmsg1_u32;
1689	u8 iprmmsg1[4];	1689	u8 iprmmsg1[4];
1690	} ln1msg1;	1690	} ln1msg1;
1691	union {	1691	union {
1692	u32 ipbfln1f;	1692	u32 ipbfln1f;
1693	u8 iprmmsg2[4];	1693	u8 iprmmsg2[4];
1694	} ln1msg2;	1694	} ln1msg2;
1695	u32 res1[3];	1695	u32 res1[3];
1696	u32 ipbfln2f;	1696	u32 ipbfln2f;
1697	u8 ippollfg;	1697	u8 ippollfg;
1698	u8 res2[3];	1698	u8 res2[3];
1699	} __packed;	1699	} __packed;
1700		1700
1701	static void iucv_message_pending(struct iucv_irq_data *data)	1701	static void iucv_message_pending(struct iucv_irq_data *data)
1702	{	1702	{
1703	struct iucv_message_pending imp = (void ) data;	1703	struct iucv_message_pending imp = (void ) data;
1704	struct iucv_path *path = iucv_path_table[imp->ippathid];	1704	struct iucv_path *path = iucv_path_table[imp->ippathid];
1705	struct iucv_message msg;	1705	struct iucv_message msg;
1706		1706
1707	if (path && path->handler && path->handler->message_pending) {	1707	if (path && path->handler && path->handler->message_pending) {
1708	msg.flags = imp->ipflags1;	1708	msg.flags = imp->ipflags1;
1709	msg.id = imp->ipmsgid;	1709	msg.id = imp->ipmsgid;
1710	msg.class = imp->iptrgcls;	1710	msg.class = imp->iptrgcls;
1711	if (imp->ipflags1 & IUCV_IPRMDATA) {	1711	if (imp->ipflags1 & IUCV_IPRMDATA) {
1712	memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8);	1712	memcpy(msg.rmmsg, imp->ln1msg1.iprmmsg1, 8);
1713	msg.length = 8;	1713	msg.length = 8;
1714	} else	1714	} else
1715	msg.length = imp->ln1msg2.ipbfln1f;	1715	msg.length = imp->ln1msg2.ipbfln1f;
1716	msg.reply_size = imp->ipbfln2f;	1716	msg.reply_size = imp->ipbfln2f;
1717	path->handler->message_pending(path, &msg);	1717	path->handler->message_pending(path, &msg);
1718	}	1718	}
1719	}	1719	}
1720		1720
1721	/**	1721	/**
1722	* iucv_tasklet_fn:	1722	* iucv_tasklet_fn:
1723	*	1723	*
1724	* This tasklet loops over the queue of irq buffers created by	1724	* This tasklet loops over the queue of irq buffers created by
1725	* iucv_external_interrupt, calls the appropriate action handler	1725	* iucv_external_interrupt, calls the appropriate action handler
1726	* and then frees the buffer.	1726	* and then frees the buffer.
1727	*/	1727	*/
1728	static void iucv_tasklet_fn(unsigned long ignored)	1728	static void iucv_tasklet_fn(unsigned long ignored)
1729	{	1729	{
1730	typedef void iucv_irq_fn(struct iucv_irq_data *);	1730	typedef void iucv_irq_fn(struct iucv_irq_data *);
1731	static iucv_irq_fn *irq_fn[] = {	1731	static iucv_irq_fn *irq_fn[] = {
1732	[0x02] = iucv_path_complete,	1732	[0x02] = iucv_path_complete,
1733	[0x03] = iucv_path_severed,	1733	[0x03] = iucv_path_severed,
1734	[0x04] = iucv_path_quiesced,	1734	[0x04] = iucv_path_quiesced,
1735	[0x05] = iucv_path_resumed,	1735	[0x05] = iucv_path_resumed,
1736	[0x06] = iucv_message_complete,	1736	[0x06] = iucv_message_complete,
1737	[0x07] = iucv_message_complete,	1737	[0x07] = iucv_message_complete,
1738	[0x08] = iucv_message_pending,	1738	[0x08] = iucv_message_pending,
1739	[0x09] = iucv_message_pending,	1739	[0x09] = iucv_message_pending,
1740	};	1740	};
1741	LIST_HEAD(task_queue);	1741	LIST_HEAD(task_queue);
1742	struct iucv_irq_list p, n;	1742	struct iucv_irq_list p, n;
1743		1743
1744	/* Serialize tasklet, iucv_path_sever and iucv_path_connect. */	1744	/* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1745	if (!spin_trylock(&iucv_table_lock)) {	1745	if (!spin_trylock(&iucv_table_lock)) {
1746	tasklet_schedule(&iucv_tasklet);	1746	tasklet_schedule(&iucv_tasklet);
1747	return;	1747	return;
1748	}	1748	}
1749	iucv_active_cpu = smp_processor_id();	1749	iucv_active_cpu = smp_processor_id();
1750		1750
1751	spin_lock_irq(&iucv_queue_lock);	1751	spin_lock_irq(&iucv_queue_lock);
1752	list_splice_init(&iucv_task_queue, &task_queue);	1752	list_splice_init(&iucv_task_queue, &task_queue);
1753	spin_unlock_irq(&iucv_queue_lock);	1753	spin_unlock_irq(&iucv_queue_lock);
1754		1754
1755	list_for_each_entry_safe(p, n, &task_queue, list) {	1755	list_for_each_entry_safe(p, n, &task_queue, list) {
1756	list_del_init(&p->list);	1756	list_del_init(&p->list);
1757	irq_fn[p->data.iptype](&p->data);	1757	irq_fn[p->data.iptype](&p->data);
1758	kfree(p);	1758	kfree(p);
1759	}	1759	}
1760		1760
1761	iucv_active_cpu = -1;	1761	iucv_active_cpu = -1;
1762	spin_unlock(&iucv_table_lock);	1762	spin_unlock(&iucv_table_lock);
1763	}	1763	}
1764		1764
1765	/**	1765	/**
1766	* iucv_work_fn:	1766	* iucv_work_fn:
1767	*	1767	*
1768	* This work function loops over the queue of path pending irq blocks	1768	* This work function loops over the queue of path pending irq blocks
1769	* created by iucv_external_interrupt, calls the appropriate action	1769	* created by iucv_external_interrupt, calls the appropriate action
1770	* handler and then frees the buffer.	1770	* handler and then frees the buffer.
1771	*/	1771	*/
1772	static void iucv_work_fn(struct work_struct *work)	1772	static void iucv_work_fn(struct work_struct *work)
1773	{	1773	{
1774	LIST_HEAD(work_queue);	1774	LIST_HEAD(work_queue);
1775	struct iucv_irq_list p, n;	1775	struct iucv_irq_list p, n;
1776		1776
1777	/* Serialize tasklet, iucv_path_sever and iucv_path_connect. */	1777	/* Serialize tasklet, iucv_path_sever and iucv_path_connect. */
1778	spin_lock_bh(&iucv_table_lock);	1778	spin_lock_bh(&iucv_table_lock);
1779	iucv_active_cpu = smp_processor_id();	1779	iucv_active_cpu = smp_processor_id();
1780		1780
1781	spin_lock_irq(&iucv_queue_lock);	1781	spin_lock_irq(&iucv_queue_lock);
1782	list_splice_init(&iucv_work_queue, &work_queue);	1782	list_splice_init(&iucv_work_queue, &work_queue);
1783	spin_unlock_irq(&iucv_queue_lock);	1783	spin_unlock_irq(&iucv_queue_lock);
1784		1784
1785	iucv_cleanup_queue();	1785	iucv_cleanup_queue();
1786	list_for_each_entry_safe(p, n, &work_queue, list) {	1786	list_for_each_entry_safe(p, n, &work_queue, list) {
1787	list_del_init(&p->list);	1787	list_del_init(&p->list);
1788	iucv_path_pending(&p->data);	1788	iucv_path_pending(&p->data);
1789	kfree(p);	1789	kfree(p);
1790	}	1790	}
1791		1791
1792	iucv_active_cpu = -1;	1792	iucv_active_cpu = -1;
1793	spin_unlock_bh(&iucv_table_lock);	1793	spin_unlock_bh(&iucv_table_lock);
1794	}	1794	}
1795		1795
1796	/**	1796	/**
1797	* iucv_external_interrupt	1797	* iucv_external_interrupt
1798	* @code: irq code	1798	* @code: irq code
1799	*	1799	*
1800	* Handles external interrupts coming in from CP.	1800	* Handles external interrupts coming in from CP.
1801	* Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().	1801	* Places the interrupt buffer on a queue and schedules iucv_tasklet_fn().
1802	*/	1802	*/
1803	static void iucv_external_interrupt(unsigned int ext_int_code,	1803	static void iucv_external_interrupt(unsigned int ext_int_code,
1804	unsigned int param32, unsigned long param64)	1804	unsigned int param32, unsigned long param64)
1805	{	1805	{
1806	struct iucv_irq_data *p;	1806	struct iucv_irq_data *p;
1807	struct iucv_irq_list *work;	1807	struct iucv_irq_list *work;
1808		1808
1809	kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++;	1809	kstat_cpu(smp_processor_id()).irqs[EXTINT_IUC]++;
1810	p = iucv_irq_data[smp_processor_id()];	1810	p = iucv_irq_data[smp_processor_id()];
1811	if (p->ippathid >= iucv_max_pathid) {	1811	if (p->ippathid >= iucv_max_pathid) {
1812	WARN_ON(p->ippathid >= iucv_max_pathid);	1812	WARN_ON(p->ippathid >= iucv_max_pathid);
1813	iucv_sever_pathid(p->ippathid, iucv_error_no_listener);	1813	iucv_sever_pathid(p->ippathid, iucv_error_no_listener);
1814	return;	1814	return;
1815	}	1815	}
1816	BUG_ON(p->iptype < 0x01 \|\| p->iptype > 0x09);	1816	BUG_ON(p->iptype < 0x01 \|\| p->iptype > 0x09);
1817	work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);	1817	work = kmalloc(sizeof(struct iucv_irq_list), GFP_ATOMIC);
1818	if (!work) {	1818	if (!work) {
1819	pr_warning("iucv_external_interrupt: out of memory\n");	1819	pr_warning("iucv_external_interrupt: out of memory\n");
1820	return;	1820	return;
1821	}	1821	}
1822	memcpy(&work->data, p, sizeof(work->data));	1822	memcpy(&work->data, p, sizeof(work->data));
1823	spin_lock(&iucv_queue_lock);	1823	spin_lock(&iucv_queue_lock);
1824	if (p->iptype == 0x01) {	1824	if (p->iptype == 0x01) {
1825	/* Path pending interrupt. */	1825	/* Path pending interrupt. */
1826	list_add_tail(&work->list, &iucv_work_queue);	1826	list_add_tail(&work->list, &iucv_work_queue);
1827	schedule_work(&iucv_work);	1827	schedule_work(&iucv_work);
1828	} else {	1828	} else {
1829	/* The other interrupts. */	1829	/* The other interrupts. */
1830	list_add_tail(&work->list, &iucv_task_queue);	1830	list_add_tail(&work->list, &iucv_task_queue);
1831	tasklet_schedule(&iucv_tasklet);	1831	tasklet_schedule(&iucv_tasklet);
1832	}	1832	}
1833	spin_unlock(&iucv_queue_lock);	1833	spin_unlock(&iucv_queue_lock);
1834	}	1834	}
1835		1835
1836	static int iucv_pm_prepare(struct device *dev)	1836	static int iucv_pm_prepare(struct device *dev)
1837	{	1837	{
1838	int rc = 0;	1838	int rc = 0;
1839		1839
1840	#ifdef CONFIG_PM_DEBUG	1840	#ifdef CONFIG_PM_DEBUG
1841	printk(KERN_INFO "iucv_pm_prepare\n");	1841	printk(KERN_INFO "iucv_pm_prepare\n");
1842	#endif	1842	#endif
1843	if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)	1843	if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)
1844	rc = dev->driver->pm->prepare(dev);	1844	rc = dev->driver->pm->prepare(dev);
1845	return rc;	1845	return rc;
1846	}	1846	}
1847		1847
1848	static void iucv_pm_complete(struct device *dev)	1848	static void iucv_pm_complete(struct device *dev)
1849	{	1849	{
1850	#ifdef CONFIG_PM_DEBUG	1850	#ifdef CONFIG_PM_DEBUG
1851	printk(KERN_INFO "iucv_pm_complete\n");	1851	printk(KERN_INFO "iucv_pm_complete\n");
1852	#endif	1852	#endif
1853	if (dev->driver && dev->driver->pm && dev->driver->pm->complete)	1853	if (dev->driver && dev->driver->pm && dev->driver->pm->complete)
1854	dev->driver->pm->complete(dev);	1854	dev->driver->pm->complete(dev);
1855	}	1855	}
1856		1856
1857	/**	1857	/**
1858	* iucv_path_table_empty() - determine if iucv path table is empty	1858	* iucv_path_table_empty() - determine if iucv path table is empty
1859	*	1859	*
1860	* Returns 0 if there are still iucv pathes defined	1860	* Returns 0 if there are still iucv pathes defined
1861	* 1 if there are no iucv pathes defined	1861	* 1 if there are no iucv pathes defined
1862	*/	1862	*/
1863	int iucv_path_table_empty(void)	1863	int iucv_path_table_empty(void)
1864	{	1864	{
1865	int i;	1865	int i;
1866		1866
1867	for (i = 0; i < iucv_max_pathid; i++) {	1867	for (i = 0; i < iucv_max_pathid; i++) {
1868	if (iucv_path_table[i])	1868	if (iucv_path_table[i])
1869	return 0;	1869	return 0;
1870	}	1870	}
1871	return 1;	1871	return 1;
1872	}	1872	}
1873		1873
1874	/**	1874	/**
1875	* iucv_pm_freeze() - Freeze PM callback	1875	* iucv_pm_freeze() - Freeze PM callback
1876	* @dev: iucv-based device	1876	* @dev: iucv-based device
1877	*	1877	*
1878	* disable iucv interrupts	1878	* disable iucv interrupts
1879	* invoke callback function of the iucv-based driver	1879	* invoke callback function of the iucv-based driver
1880	* shut down iucv, if no iucv-pathes are established anymore	1880	* shut down iucv, if no iucv-pathes are established anymore
1881	*/	1881	*/
1882	static int iucv_pm_freeze(struct device *dev)	1882	static int iucv_pm_freeze(struct device *dev)
1883	{	1883	{
1884	int cpu;	1884	int cpu;
1885	struct iucv_irq_list p, n;	1885	struct iucv_irq_list p, n;
1886	int rc = 0;	1886	int rc = 0;
1887		1887
1888	#ifdef CONFIG_PM_DEBUG	1888	#ifdef CONFIG_PM_DEBUG
1889	printk(KERN_WARNING "iucv_pm_freeze\n");	1889	printk(KERN_WARNING "iucv_pm_freeze\n");
1890	#endif	1890	#endif
1891	if (iucv_pm_state != IUCV_PM_FREEZING) {	1891	if (iucv_pm_state != IUCV_PM_FREEZING) {
1892	for_each_cpu(cpu, &iucv_irq_cpumask)	1892	for_each_cpu(cpu, &iucv_irq_cpumask)
1893	smp_call_function_single(cpu, iucv_block_cpu_almost,	1893	smp_call_function_single(cpu, iucv_block_cpu_almost,
1894	NULL, 1);	1894	NULL, 1);
1895	cancel_work_sync(&iucv_work);	1895	cancel_work_sync(&iucv_work);
1896	list_for_each_entry_safe(p, n, &iucv_work_queue, list) {	1896	list_for_each_entry_safe(p, n, &iucv_work_queue, list) {
1897	list_del_init(&p->list);	1897	list_del_init(&p->list);
1898	iucv_sever_pathid(p->data.ippathid,	1898	iucv_sever_pathid(p->data.ippathid,
1899	iucv_error_no_listener);	1899	iucv_error_no_listener);
1900	kfree(p);	1900	kfree(p);
1901	}	1901	}
1902	}	1902	}
1903	iucv_pm_state = IUCV_PM_FREEZING;	1903	iucv_pm_state = IUCV_PM_FREEZING;
1904	if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)	1904	if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)
1905	rc = dev->driver->pm->freeze(dev);	1905	rc = dev->driver->pm->freeze(dev);
1906	if (iucv_path_table_empty())	1906	if (iucv_path_table_empty())
1907	iucv_disable();	1907	iucv_disable();
1908	return rc;	1908	return rc;
1909	}	1909	}
1910		1910
1911	/**	1911	/**
1912	* iucv_pm_thaw() - Thaw PM callback	1912	* iucv_pm_thaw() - Thaw PM callback
1913	* @dev: iucv-based device	1913	* @dev: iucv-based device
1914	*	1914	*
1915	* make iucv ready for use again: allocate path table, declare interrupt buffers	1915	* make iucv ready for use again: allocate path table, declare interrupt buffers
1916	* and enable iucv interrupts	1916	* and enable iucv interrupts
1917	* invoke callback function of the iucv-based driver	1917	* invoke callback function of the iucv-based driver
1918	*/	1918	*/
1919	static int iucv_pm_thaw(struct device *dev)	1919	static int iucv_pm_thaw(struct device *dev)
1920	{	1920	{
1921	int rc = 0;	1921	int rc = 0;
1922		1922
1923	#ifdef CONFIG_PM_DEBUG	1923	#ifdef CONFIG_PM_DEBUG
1924	printk(KERN_WARNING "iucv_pm_thaw\n");	1924	printk(KERN_WARNING "iucv_pm_thaw\n");
1925	#endif	1925	#endif
1926	iucv_pm_state = IUCV_PM_THAWING;	1926	iucv_pm_state = IUCV_PM_THAWING;
1927	if (!iucv_path_table) {	1927	if (!iucv_path_table) {
1928	rc = iucv_enable();	1928	rc = iucv_enable();
1929	if (rc)	1929	if (rc)
1930	goto out;	1930	goto out;
1931	}	1931	}
1932	if (cpumask_empty(&iucv_irq_cpumask)) {	1932	if (cpumask_empty(&iucv_irq_cpumask)) {
1933	if (iucv_nonsmp_handler)	1933	if (iucv_nonsmp_handler)
1934	/* enable interrupts on one cpu */	1934	/* enable interrupts on one cpu */
1935	iucv_allow_cpu(NULL);	1935	iucv_allow_cpu(NULL);
1936	else	1936	else
1937	/* enable interrupts on all cpus */	1937	/* enable interrupts on all cpus */
1938	iucv_setmask_mp();	1938	iucv_setmask_mp();
1939	}	1939	}
1940	if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)	1940	if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)
1941	rc = dev->driver->pm->thaw(dev);	1941	rc = dev->driver->pm->thaw(dev);
1942	out:	1942	out:
1943	return rc;	1943	return rc;
1944	}	1944	}
1945		1945
1946	/**	1946	/**
1947	* iucv_pm_restore() - Restore PM callback	1947	* iucv_pm_restore() - Restore PM callback
1948	* @dev: iucv-based device	1948	* @dev: iucv-based device
1949	*	1949	*
1950	* make iucv ready for use again: allocate path table, declare interrupt buffers	1950	* make iucv ready for use again: allocate path table, declare interrupt buffers
1951	* and enable iucv interrupts	1951	* and enable iucv interrupts
1952	* invoke callback function of the iucv-based driver	1952	* invoke callback function of the iucv-based driver
1953	*/	1953	*/
1954	static int iucv_pm_restore(struct device *dev)	1954	static int iucv_pm_restore(struct device *dev)
1955	{	1955	{
1956	int rc = 0;	1956	int rc = 0;
1957		1957
1958	#ifdef CONFIG_PM_DEBUG	1958	#ifdef CONFIG_PM_DEBUG
1959	printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);	1959	printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);
1960	#endif	1960	#endif
1961	if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)	1961	if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)
1962	pr_warning("Suspending Linux did not completely close all IUCV "	1962	pr_warning("Suspending Linux did not completely close all IUCV "
1963	"connections\n");	1963	"connections\n");
1964	iucv_pm_state = IUCV_PM_RESTORING;	1964	iucv_pm_state = IUCV_PM_RESTORING;
1965	if (cpumask_empty(&iucv_irq_cpumask)) {	1965	if (cpumask_empty(&iucv_irq_cpumask)) {
1966	rc = iucv_query_maxconn();	1966	rc = iucv_query_maxconn();
1967	rc = iucv_enable();	1967	rc = iucv_enable();
1968	if (rc)	1968	if (rc)
1969	goto out;	1969	goto out;
1970	}	1970	}
1971	if (dev->driver && dev->driver->pm && dev->driver->pm->restore)	1971	if (dev->driver && dev->driver->pm && dev->driver->pm->restore)
1972	rc = dev->driver->pm->restore(dev);	1972	rc = dev->driver->pm->restore(dev);
1973	out:	1973	out:
1974	return rc;	1974	return rc;
1975	}	1975	}
1976		1976
1977	/**	1977	/**
1978	* iucv_init	1978	* iucv_init
1979	*	1979	*
1980	* Allocates and initializes various data structures.	1980	* Allocates and initializes various data structures.
1981	*/	1981	*/
1982	static int __init iucv_init(void)	1982	static int __init iucv_init(void)
1983	{	1983	{
1984	int rc;	1984	int rc;
1985	int cpu;	1985	int cpu;
1986		1986
1987	if (!MACHINE_IS_VM) {	1987	if (!MACHINE_IS_VM) {
1988	rc = -EPROTONOSUPPORT;	1988	rc = -EPROTONOSUPPORT;
1989	goto out;	1989	goto out;
1990	}	1990	}
1991	rc = iucv_query_maxconn();	1991	rc = iucv_query_maxconn();
1992	if (rc)	1992	if (rc)
1993	goto out;	1993	goto out;
1994	rc = register_external_interrupt(0x4000, iucv_external_interrupt);	1994	rc = register_external_interrupt(0x4000, iucv_external_interrupt);
1995	if (rc)	1995	if (rc)
1996	goto out;	1996	goto out;
1997	iucv_root = root_device_register("iucv");	1997	iucv_root = root_device_register("iucv");
1998	if (IS_ERR(iucv_root)) {	1998	if (IS_ERR(iucv_root)) {
1999	rc = PTR_ERR(iucv_root);	1999	rc = PTR_ERR(iucv_root);
2000	goto out_int;	2000	goto out_int;
2001	}	2001	}
2002		2002
2003	for_each_online_cpu(cpu) {	2003	for_each_online_cpu(cpu) {
2004	/* Note: GFP_DMA used to get memory below 2G */	2004	/* Note: GFP_DMA used to get memory below 2G */
2005	iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),	2005	iucv_irq_data[cpu] = kmalloc_node(sizeof(struct iucv_irq_data),
2006	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	2006	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
2007	if (!iucv_irq_data[cpu]) {	2007	if (!iucv_irq_data[cpu]) {
2008	rc = -ENOMEM;	2008	rc = -ENOMEM;
2009	goto out_free;	2009	goto out_free;
2010	}	2010	}
2011		2011
2012	/* Allocate parameter blocks. */	2012	/* Allocate parameter blocks. */
2013	iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),	2013	iucv_param[cpu] = kmalloc_node(sizeof(union iucv_param),
2014	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	2014	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
2015	if (!iucv_param[cpu]) {	2015	if (!iucv_param[cpu]) {
2016	rc = -ENOMEM;	2016	rc = -ENOMEM;
2017	goto out_free;	2017	goto out_free;
2018	}	2018	}
2019	iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),	2019	iucv_param_irq[cpu] = kmalloc_node(sizeof(union iucv_param),
2020	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));	2020	GFP_KERNEL\|GFP_DMA, cpu_to_node(cpu));
2021	if (!iucv_param_irq[cpu]) {	2021	if (!iucv_param_irq[cpu]) {
2022	rc = -ENOMEM;	2022	rc = -ENOMEM;
2023	goto out_free;	2023	goto out_free;
2024	}	2024	}
2025		2025
2026	}	2026	}
2027	rc = register_hotcpu_notifier(&iucv_cpu_notifier);	2027	rc = register_hotcpu_notifier(&iucv_cpu_notifier);
2028	if (rc)	2028	if (rc)
2029	goto out_free;	2029	goto out_free;
2030	rc = register_reboot_notifier(&iucv_reboot_notifier);	2030	rc = register_reboot_notifier(&iucv_reboot_notifier);
2031	if (rc)	2031	if (rc)
2032	goto out_cpu;	2032	goto out_cpu;
2033	ASCEBC(iucv_error_no_listener, 16);	2033	ASCEBC(iucv_error_no_listener, 16);
2034	ASCEBC(iucv_error_no_memory, 16);	2034	ASCEBC(iucv_error_no_memory, 16);
2035	ASCEBC(iucv_error_pathid, 16);	2035	ASCEBC(iucv_error_pathid, 16);
2036	iucv_available = 1;	2036	iucv_available = 1;
2037	rc = bus_register(&iucv_bus);	2037	rc = bus_register(&iucv_bus);
2038	if (rc)	2038	if (rc)
2039	goto out_reboot;	2039	goto out_reboot;
2040	return 0;	2040	return 0;
2041		2041
2042	out_reboot:	2042	out_reboot:
2043	unregister_reboot_notifier(&iucv_reboot_notifier);	2043	unregister_reboot_notifier(&iucv_reboot_notifier);
2044	out_cpu:	2044	out_cpu:
2045	unregister_hotcpu_notifier(&iucv_cpu_notifier);	2045	unregister_hotcpu_notifier(&iucv_cpu_notifier);
2046	out_free:	2046	out_free:
2047	for_each_possible_cpu(cpu) {	2047	for_each_possible_cpu(cpu) {
2048	kfree(iucv_param_irq[cpu]);	2048	kfree(iucv_param_irq[cpu]);
2049	iucv_param_irq[cpu] = NULL;	2049	iucv_param_irq[cpu] = NULL;
2050	kfree(iucv_param[cpu]);	2050	kfree(iucv_param[cpu]);
2051	iucv_param[cpu] = NULL;	2051	iucv_param[cpu] = NULL;
2052	kfree(iucv_irq_data[cpu]);	2052	kfree(iucv_irq_data[cpu]);
2053	iucv_irq_data[cpu] = NULL;	2053	iucv_irq_data[cpu] = NULL;
2054	}	2054	}
2055	root_device_unregister(iucv_root);	2055	root_device_unregister(iucv_root);
2056	out_int:	2056	out_int:
2057	unregister_external_interrupt(0x4000, iucv_external_interrupt);	2057	unregister_external_interrupt(0x4000, iucv_external_interrupt);
2058	out:	2058	out:
2059	return rc;	2059	return rc;
2060	}	2060	}
2061		2061
2062	/**	2062	/**
2063	* iucv_exit	2063	* iucv_exit
2064	*	2064	*
2065	* Frees everything allocated from iucv_init.	2065	* Frees everything allocated from iucv_init.
2066	*/	2066	*/
2067	static void __exit iucv_exit(void)	2067	static void __exit iucv_exit(void)
2068	{	2068	{
2069	struct iucv_irq_list p, n;	2069	struct iucv_irq_list p, n;
2070	int cpu;	2070	int cpu;
2071		2071
2072	spin_lock_irq(&iucv_queue_lock);	2072	spin_lock_irq(&iucv_queue_lock);
2073	list_for_each_entry_safe(p, n, &iucv_task_queue, list)	2073	list_for_each_entry_safe(p, n, &iucv_task_queue, list)
2074	kfree(p);	2074	kfree(p);
2075	list_for_each_entry_safe(p, n, &iucv_work_queue, list)	2075	list_for_each_entry_safe(p, n, &iucv_work_queue, list)
2076	kfree(p);	2076	kfree(p);
2077	spin_unlock_irq(&iucv_queue_lock);	2077	spin_unlock_irq(&iucv_queue_lock);
2078	unregister_reboot_notifier(&iucv_reboot_notifier);	2078	unregister_reboot_notifier(&iucv_reboot_notifier);
2079	unregister_hotcpu_notifier(&iucv_cpu_notifier);	2079	unregister_hotcpu_notifier(&iucv_cpu_notifier);
2080	for_each_possible_cpu(cpu) {	2080	for_each_possible_cpu(cpu) {
2081	kfree(iucv_param_irq[cpu]);	2081	kfree(iucv_param_irq[cpu]);
2082	iucv_param_irq[cpu] = NULL;	2082	iucv_param_irq[cpu] = NULL;
2083	kfree(iucv_param[cpu]);	2083	kfree(iucv_param[cpu]);
2084	iucv_param[cpu] = NULL;	2084	iucv_param[cpu] = NULL;
2085	kfree(iucv_irq_data[cpu]);	2085	kfree(iucv_irq_data[cpu]);
2086	iucv_irq_data[cpu] = NULL;	2086	iucv_irq_data[cpu] = NULL;
2087	}	2087	}
2088	root_device_unregister(iucv_root);	2088	root_device_unregister(iucv_root);
2089	bus_unregister(&iucv_bus);	2089	bus_unregister(&iucv_bus);
2090	unregister_external_interrupt(0x4000, iucv_external_interrupt);	2090	unregister_external_interrupt(0x4000, iucv_external_interrupt);
2091	}	2091	}
2092		2092
2093	subsys_initcall(iucv_init);	2093	subsys_initcall(iucv_init);
2094	module_exit(iucv_exit);	2094	module_exit(iucv_exit);
2095		2095
2096	MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");	2096	MODULE_AUTHOR("(C) 2001 IBM Corp. by Fritz Elfert (felfert@millenux.com)");
2097	MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");	2097	MODULE_DESCRIPTION("Linux for S/390 IUCV lowlevel driver");
2098	MODULE_LICENSE("GPL");	2098	MODULE_LICENSE("GPL");
2099		2099

1	#	1	#
2	# Makefile for the linux kernel.	2	# Makefile for the linux kernel.
3	#	3	#
4		4
5	ifdef CONFIG_FUNCTION_TRACER	5	ifdef CONFIG_FUNCTION_TRACER
6	# Don't trace early setup code and tracing code	6	# Don't trace early setup code and tracing code
7	CFLAGS_REMOVE_early.o = -pg	7	CFLAGS_REMOVE_early.o = -pg
8	CFLAGS_REMOVE_ftrace.o = -pg	8	CFLAGS_REMOVE_ftrace.o = -pg
9	endif	9	endif
10		10
11	#	11	#
12	# Passing null pointers is ok for smp code, since we access the lowcore here.	12	# Passing null pointers is ok for smp code, since we access the lowcore here.
13	#	13	#
14	CFLAGS_smp.o := -Wno-nonnull	14	CFLAGS_smp.o := -Wno-nonnull
15		15
16	#	16	#
17	# Pass UTS_MACHINE for user_regset definition	17	# Pass UTS_MACHINE for user_regset definition
18	#	18	#
19	CFLAGS_ptrace.o += -DUTS_MACHINE='"$(UTS_MACHINE)"'	19	CFLAGS_ptrace.o += -DUTS_MACHINE='"$(UTS_MACHINE)"'
20		20
21	CFLAGS_sysinfo.o += -Iinclude/math-emu -Iarch/s390/math-emu -w	21	CFLAGS_sysinfo.o += -Iinclude/math-emu -Iarch/s390/math-emu -w
22		22
23	obj-y := bitmap.o traps.o time.o process.o base.o early.o setup.o \	23	obj-y := bitmap.o traps.o time.o process.o base.o early.o setup.o vtime.o \
24	processor.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \	24	processor.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o nmi.o \
25	s390_ext.o debug.o irq.o ipl.o dis.o diag.o mem_detect.o \	25	debug.o irq.o ipl.o dis.o diag.o mem_detect.o sclp.o vdso.o \
26	vdso.o vtime.o sysinfo.o nmi.o sclp.o jump_label.o	26	sysinfo.o jump_label.o
27		27
28	obj-y += $(if $(CONFIG_64BIT),entry64.o,entry.o)	28	obj-y += $(if $(CONFIG_64BIT),entry64.o,entry.o)
29	obj-y += $(if $(CONFIG_64BIT),reipl64.o,reipl.o)	29	obj-y += $(if $(CONFIG_64BIT),reipl64.o,reipl.o)
30		30
31	extra-y += head.o init_task.o vmlinux.lds	31	extra-y += head.o init_task.o vmlinux.lds
32	extra-y += $(if $(CONFIG_64BIT),head64.o,head31.o)	32	extra-y += $(if $(CONFIG_64BIT),head64.o,head31.o)
33		33
34	obj-$(CONFIG_MODULES) += s390_ksyms.o module.o	34	obj-$(CONFIG_MODULES) += s390_ksyms.o module.o
35	obj-$(CONFIG_SMP) += smp.o topology.o	35	obj-$(CONFIG_SMP) += smp.o topology.o
36	obj-$(CONFIG_SMP) += $(if $(CONFIG_64BIT),switch_cpu64.o, \	36	obj-$(CONFIG_SMP) += $(if $(CONFIG_64BIT),switch_cpu64.o, \
37	switch_cpu.o)	37	switch_cpu.o)
38	obj-$(CONFIG_HIBERNATION) += suspend.o swsusp_asm64.o	38	obj-$(CONFIG_HIBERNATION) += suspend.o swsusp_asm64.o
39	obj-$(CONFIG_AUDIT) += audit.o	39	obj-$(CONFIG_AUDIT) += audit.o
40	compat-obj-$(CONFIG_AUDIT) += compat_audit.o	40	compat-obj-$(CONFIG_AUDIT) += compat_audit.o
41	obj-$(CONFIG_COMPAT) += compat_linux.o compat_signal.o \	41	obj-$(CONFIG_COMPAT) += compat_linux.o compat_signal.o \
42	compat_wrapper.o compat_exec_domain.o \	42	compat_wrapper.o compat_exec_domain.o \
43	$(compat-obj-y)	43	$(compat-obj-y)
44		44
45	obj-$(CONFIG_STACKTRACE) += stacktrace.o	45	obj-$(CONFIG_STACKTRACE) += stacktrace.o
46	obj-$(CONFIG_KPROBES) += kprobes.o	46	obj-$(CONFIG_KPROBES) += kprobes.o
47	obj-$(CONFIG_FUNCTION_TRACER) += $(if $(CONFIG_64BIT),mcount64.o,mcount.o)	47	obj-$(CONFIG_FUNCTION_TRACER) += $(if $(CONFIG_64BIT),mcount64.o,mcount.o)
48	obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o	48	obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o
49	obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o	49	obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o
50	obj-$(CONFIG_FTRACE_SYSCALLS) += ftrace.o	50	obj-$(CONFIG_FTRACE_SYSCALLS) += ftrace.o
51		51
52	# Kexec part	52	# Kexec part
53	S390_KEXEC_OBJS := machine_kexec.o crash.o	53	S390_KEXEC_OBJS := machine_kexec.o crash.o
54	S390_KEXEC_OBJS += $(if $(CONFIG_64BIT),relocate_kernel64.o,relocate_kernel.o)	54	S390_KEXEC_OBJS += $(if $(CONFIG_64BIT),relocate_kernel64.o,relocate_kernel.o)
55	obj-$(CONFIG_KEXEC) += $(S390_KEXEC_OBJS)	55	obj-$(CONFIG_KEXEC) += $(S390_KEXEC_OBJS)
56		56
57	# vdso	57	# vdso
58	obj-$(CONFIG_64BIT) += vdso64/	58	obj-$(CONFIG_64BIT) += vdso64/
59	obj-$(CONFIG_32BIT) += vdso32/	59	obj-$(CONFIG_32BIT) += vdso32/
60	obj-$(CONFIG_COMPAT) += vdso32/	60	obj-$(CONFIG_COMPAT) += vdso32/
61		61