mirror of
https://gitee.com/openharmony/kernel_linux
synced 2024-12-14 10:20:33 +00:00
Merge branch 'for-linus' of git://git390.osdl.marist.edu/pub/scm/linux-2.6
* 'for-linus' of git://git390.osdl.marist.edu/pub/scm/linux-2.6: (44 commits) [S390] hypfs crashes with invalid mount option. [S390] cio: subchannel evaluation function operates without lock [S390] cio: always query all paths on path verification. [S390] cio: update path groups on logical CHPID changes. [S390] cio: subchannels in no-path state. [S390] Replace nopav-message on VM. [S390] set modalias for ccw bus uevents. [S390] Get rid of DBG macro. [S390] Use alternative user-copy operations for new hardware. [S390] Make user-copy operations run-time configurable. [S390] Cleanup in signal handling code. [S390] Cleanup in page table related code. [S390] Linux API for writing z/VM APPLDATA Monitor records. [S390] xpram off by one error. [S390] Remove kexec experimental flag. [S390] cleanup appldata. [S390] fix typo in vmcp. [S390] Kernel stack overflow handling. [S390] qdio slsb processing state. [S390] Missing initialization in common i/o layer. ...
This commit is contained in:
commit
a489d15922
@ -2452,6 +2452,8 @@ S: Maintained
|
||||
S390
|
||||
P: Martin Schwidefsky
|
||||
M: schwidefsky@de.ibm.com
|
||||
P: Heiko Carstens
|
||||
M: heiko.carstens@de.ibm.com
|
||||
M: linux390@de.ibm.com
|
||||
L: linux-390@vm.marist.edu
|
||||
W: http://www.ibm.com/developerworks/linux/linux390/
|
||||
|
@ -460,8 +460,7 @@ config S390_HYPFS_FS
|
||||
information in an s390 hypervisor environment.
|
||||
|
||||
config KEXEC
|
||||
bool "kexec system call (EXPERIMENTAL)"
|
||||
depends on EXPERIMENTAL
|
||||
bool "kexec system call"
|
||||
help
|
||||
kexec is a system call that implements the ability to shutdown your
|
||||
current kernel, and to start another kernel. It is like a reboot
|
||||
@ -487,8 +486,22 @@ source "drivers/net/Kconfig"
|
||||
|
||||
source "fs/Kconfig"
|
||||
|
||||
menu "Instrumentation Support"
|
||||
|
||||
source "arch/s390/oprofile/Kconfig"
|
||||
|
||||
config KPROBES
|
||||
bool "Kprobes (EXPERIMENTAL)"
|
||||
depends on EXPERIMENTAL && MODULES
|
||||
help
|
||||
Kprobes allows you to trap at almost any kernel address and
|
||||
execute a callback function. register_kprobe() establishes
|
||||
a probepoint and specifies the callback. Kprobes is useful
|
||||
for kernel debugging, non-intrusive instrumentation and testing.
|
||||
If in doubt, say "N".
|
||||
|
||||
endmenu
|
||||
|
||||
source "arch/s390/Kconfig.debug"
|
||||
|
||||
source "security/Kconfig"
|
||||
|
@ -29,22 +29,6 @@
|
||||
#define CTL_APPLDATA_NET_SUM 2125
|
||||
#define CTL_APPLDATA_PROC 2126
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
|
||||
#define APPLDATA_START_INTERVAL_REC 0x00 /* Function codes for */
|
||||
#define APPLDATA_STOP_REC 0x01 /* DIAG 0xDC */
|
||||
#define APPLDATA_GEN_EVENT_RECORD 0x02
|
||||
#define APPLDATA_START_CONFIG_REC 0x03
|
||||
|
||||
#else
|
||||
|
||||
#define APPLDATA_START_INTERVAL_REC 0x80
|
||||
#define APPLDATA_STOP_REC 0x81
|
||||
#define APPLDATA_GEN_EVENT_RECORD 0x82
|
||||
#define APPLDATA_START_CONFIG_REC 0x83
|
||||
|
||||
#endif /* CONFIG_64BIT */
|
||||
|
||||
#define P_INFO(x...) printk(KERN_INFO MY_PRINT_NAME " info: " x)
|
||||
#define P_ERROR(x...) printk(KERN_ERR MY_PRINT_NAME " error: " x)
|
||||
#define P_WARNING(x...) printk(KERN_WARNING MY_PRINT_NAME " status: " x)
|
||||
|
@ -14,20 +14,20 @@
|
||||
#include <linux/init.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/errno.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/smp.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/page-flags.h>
|
||||
#include <linux/swap.h>
|
||||
#include <linux/pagemap.h>
|
||||
#include <linux/sysctl.h>
|
||||
#include <asm/timer.h>
|
||||
//#include <linux/kernel_stat.h>
|
||||
#include <linux/notifier.h>
|
||||
#include <linux/cpu.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <asm/appldata.h>
|
||||
#include <asm/timer.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/smp.h>
|
||||
|
||||
#include "appldata.h"
|
||||
|
||||
@ -39,34 +39,6 @@
|
||||
|
||||
#define TOD_MICRO 0x01000 /* nr. of TOD clock units
|
||||
for 1 microsecond */
|
||||
|
||||
/*
|
||||
* Parameter list for DIAGNOSE X'DC'
|
||||
*/
|
||||
#ifndef CONFIG_64BIT
|
||||
struct appldata_parameter_list {
|
||||
u16 diag; /* The DIAGNOSE code X'00DC' */
|
||||
u8 function; /* The function code for the DIAGNOSE */
|
||||
u8 parlist_length; /* Length of the parameter list */
|
||||
u32 product_id_addr; /* Address of the 16-byte product ID */
|
||||
u16 reserved;
|
||||
u16 buffer_length; /* Length of the application data buffer */
|
||||
u32 buffer_addr; /* Address of the application data buffer */
|
||||
};
|
||||
#else
|
||||
struct appldata_parameter_list {
|
||||
u16 diag;
|
||||
u8 function;
|
||||
u8 parlist_length;
|
||||
u32 unused01;
|
||||
u16 reserved;
|
||||
u16 buffer_length;
|
||||
u32 unused02;
|
||||
u64 product_id_addr;
|
||||
u64 buffer_addr;
|
||||
};
|
||||
#endif /* CONFIG_64BIT */
|
||||
|
||||
/*
|
||||
* /proc entries (sysctl)
|
||||
*/
|
||||
@ -181,46 +153,17 @@ static void appldata_work_fn(void *data)
|
||||
int appldata_diag(char record_nr, u16 function, unsigned long buffer,
|
||||
u16 length, char *mod_lvl)
|
||||
{
|
||||
unsigned long ry;
|
||||
struct appldata_product_id {
|
||||
char prod_nr[7]; /* product nr. */
|
||||
char prod_fn[2]; /* product function */
|
||||
char record_nr; /* record nr. */
|
||||
char version_nr[2]; /* version */
|
||||
char release_nr[2]; /* release */
|
||||
char mod_lvl[2]; /* modification lvl. */
|
||||
} appldata_product_id = {
|
||||
/* all strings are EBCDIC, record_nr is byte */
|
||||
struct appldata_product_id id = {
|
||||
.prod_nr = {0xD3, 0xC9, 0xD5, 0xE4,
|
||||
0xE7, 0xD2, 0xD9}, /* "LINUXKR" */
|
||||
.prod_fn = {0xD5, 0xD3}, /* "NL" */
|
||||
0xE7, 0xD2, 0xD9}, /* "LINUXKR" */
|
||||
.prod_fn = 0xD5D3, /* "NL" */
|
||||
.record_nr = record_nr,
|
||||
.version_nr = {0xF2, 0xF6}, /* "26" */
|
||||
.release_nr = {0xF0, 0xF1}, /* "01" */
|
||||
.mod_lvl = {mod_lvl[0], mod_lvl[1]},
|
||||
};
|
||||
struct appldata_parameter_list appldata_parameter_list = {
|
||||
.diag = 0xDC,
|
||||
.function = function,
|
||||
.parlist_length =
|
||||
sizeof(appldata_parameter_list),
|
||||
.buffer_length = length,
|
||||
.product_id_addr =
|
||||
(unsigned long) &appldata_product_id,
|
||||
.buffer_addr = virt_to_phys((void *) buffer)
|
||||
.version_nr = 0xF2F6, /* "26" */
|
||||
.release_nr = 0xF0F1, /* "01" */
|
||||
.mod_lvl = (mod_lvl[0]) << 8 | mod_lvl[1],
|
||||
};
|
||||
|
||||
if (!MACHINE_IS_VM)
|
||||
return -ENOSYS;
|
||||
ry = -1;
|
||||
asm volatile(
|
||||
"diag %1,%0,0xDC\n\t"
|
||||
: "=d" (ry)
|
||||
: "d" (&appldata_parameter_list),
|
||||
"m" (appldata_parameter_list),
|
||||
"m" (appldata_product_id)
|
||||
: "cc");
|
||||
return (int) ry;
|
||||
return appldata_asm(&id, function, (void *) buffer, length);
|
||||
}
|
||||
/************************ timer, work, DIAG <END> ****************************/
|
||||
|
||||
|
@ -16,6 +16,7 @@
|
||||
#include <linux/kernel_stat.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <linux/sched.h>
|
||||
#include <asm/appldata.h>
|
||||
#include <asm/smp.h>
|
||||
|
||||
#include "appldata.h"
|
||||
|
@ -428,6 +428,7 @@ CONFIG_S390_TAPE_34XX=m
|
||||
# CONFIG_VMLOGRDR is not set
|
||||
# CONFIG_VMCP is not set
|
||||
# CONFIG_MONREADER is not set
|
||||
CONFIG_MONWRITER=m
|
||||
|
||||
#
|
||||
# Cryptographic devices
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* fs/hypfs/hypfs.h
|
||||
* arch/s390/hypfs/hypfs.h
|
||||
* Hypervisor filesystem for Linux on s390.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* fs/hypfs/hypfs_diag.c
|
||||
* arch/s390/hypfs/hypfs_diag.c
|
||||
* Hypervisor filesystem for Linux on s390. Diag 204 and 224
|
||||
* implementation.
|
||||
*
|
||||
@ -432,12 +432,14 @@ static int diag204_probe(void)
|
||||
|
||||
buf = diag204_get_buffer(INFO_EXT, &pages);
|
||||
if (!IS_ERR(buf)) {
|
||||
if (diag204(SUBC_STIB7 | INFO_EXT, pages, buf) >= 0) {
|
||||
if (diag204((unsigned long)SUBC_STIB7 |
|
||||
(unsigned long)INFO_EXT, pages, buf) >= 0) {
|
||||
diag204_store_sc = SUBC_STIB7;
|
||||
diag204_info_type = INFO_EXT;
|
||||
goto out;
|
||||
}
|
||||
if (diag204(SUBC_STIB6 | INFO_EXT, pages, buf) >= 0) {
|
||||
if (diag204((unsigned long)SUBC_STIB6 |
|
||||
(unsigned long)INFO_EXT, pages, buf) >= 0) {
|
||||
diag204_store_sc = SUBC_STIB7;
|
||||
diag204_info_type = INFO_EXT;
|
||||
goto out;
|
||||
@ -452,7 +454,8 @@ static int diag204_probe(void)
|
||||
rc = PTR_ERR(buf);
|
||||
goto fail_alloc;
|
||||
}
|
||||
if (diag204(SUBC_STIB4 | INFO_SIMPLE, pages, buf) >= 0) {
|
||||
if (diag204((unsigned long)SUBC_STIB4 |
|
||||
(unsigned long)INFO_SIMPLE, pages, buf) >= 0) {
|
||||
diag204_store_sc = SUBC_STIB4;
|
||||
diag204_info_type = INFO_SIMPLE;
|
||||
goto out;
|
||||
@ -476,7 +479,8 @@ static void *diag204_store(void)
|
||||
buf = diag204_get_buffer(diag204_info_type, &pages);
|
||||
if (IS_ERR(buf))
|
||||
goto out;
|
||||
if (diag204(diag204_store_sc | diag204_info_type, pages, buf) < 0)
|
||||
if (diag204((unsigned long)diag204_store_sc |
|
||||
(unsigned long)diag204_info_type, pages, buf) < 0)
|
||||
return ERR_PTR(-ENOSYS);
|
||||
out:
|
||||
return buf;
|
||||
@ -531,7 +535,7 @@ __init int hypfs_diag_init(void)
|
||||
return rc;
|
||||
}
|
||||
|
||||
__exit void hypfs_diag_exit(void)
|
||||
void hypfs_diag_exit(void)
|
||||
{
|
||||
diag224_delete_name_table();
|
||||
diag204_free_buffer();
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* fs/hypfs/hypfs_diag.h
|
||||
* arch/s390/hypfs_diag.h
|
||||
* Hypervisor filesystem for Linux on s390.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* fs/hypfs/inode.c
|
||||
* arch/s390/hypfs/inode.c
|
||||
* Hypervisor filesystem for Linux on s390.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
@ -312,10 +312,12 @@ static void hypfs_kill_super(struct super_block *sb)
|
||||
{
|
||||
struct hypfs_sb_info *sb_info = sb->s_fs_info;
|
||||
|
||||
hypfs_delete_tree(sb->s_root);
|
||||
hypfs_remove(sb_info->update_file);
|
||||
kfree(sb->s_fs_info);
|
||||
sb->s_fs_info = NULL;
|
||||
if (sb->s_root) {
|
||||
hypfs_delete_tree(sb->s_root);
|
||||
hypfs_remove(sb_info->update_file);
|
||||
kfree(sb->s_fs_info);
|
||||
sb->s_fs_info = NULL;
|
||||
}
|
||||
kill_litter_super(sb);
|
||||
}
|
||||
|
||||
|
@ -6,7 +6,7 @@ EXTRA_AFLAGS := -traditional
|
||||
|
||||
obj-y := bitmap.o traps.o time.o process.o \
|
||||
setup.o sys_s390.o ptrace.o signal.o cpcmd.o ebcdic.o \
|
||||
semaphore.o s390_ext.o debug.o profile.o irq.o reipl_diag.o
|
||||
semaphore.o s390_ext.o debug.o profile.o irq.o ipl.o
|
||||
|
||||
obj-y += $(if $(CONFIG_64BIT),entry64.o,entry.o)
|
||||
obj-y += $(if $(CONFIG_64BIT),reipl64.o,reipl.o)
|
||||
@ -24,6 +24,7 @@ obj-$(CONFIG_COMPAT) += compat_linux.o compat_signal.o \
|
||||
|
||||
obj-$(CONFIG_VIRT_TIMER) += vtime.o
|
||||
obj-$(CONFIG_STACKTRACE) += stacktrace.o
|
||||
obj-$(CONFIG_KPROBES) += kprobes.o
|
||||
|
||||
# Kexec part
|
||||
S390_KEXEC_OBJS := machine_kexec.o crash.o
|
||||
|
@ -505,6 +505,8 @@ pgm_no_vtime2:
|
||||
mvc __THREAD_per+__PER_address(4,%r1),__LC_PER_ADDRESS
|
||||
mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
|
||||
oi __TI_flags+3(%r9),_TIF_SINGLE_STEP # set TIF_SINGLE_STEP
|
||||
tm SP_PSW+1(%r15),0x01 # kernel per event ?
|
||||
bz BASED(kernel_per)
|
||||
l %r3,__LC_PGM_ILC # load program interruption code
|
||||
la %r8,0x7f
|
||||
nr %r8,%r3 # clear per-event-bit and ilc
|
||||
@ -536,6 +538,16 @@ pgm_no_vtime3:
|
||||
stosm __SF_EMPTY(%r15),0x03 # reenable interrupts
|
||||
b BASED(sysc_do_svc)
|
||||
|
||||
#
|
||||
# per was called from kernel, must be kprobes
|
||||
#
|
||||
kernel_per:
|
||||
mvi SP_TRAP+1(%r15),0x28 # set trap indication to pgm check
|
||||
la %r2,SP_PTREGS(%r15) # address of register-save area
|
||||
l %r1,BASED(.Lhandle_per) # load adr. of per handler
|
||||
la %r14,BASED(sysc_leave) # load adr. of system return
|
||||
br %r1 # branch to do_single_step
|
||||
|
||||
/*
|
||||
* IO interrupt handler routine
|
||||
*/
|
||||
|
@ -518,6 +518,8 @@ pgm_no_vtime2:
|
||||
#endif
|
||||
lg %r9,__LC_THREAD_INFO # load pointer to thread_info struct
|
||||
lg %r1,__TI_task(%r9)
|
||||
tm SP_PSW+1(%r15),0x01 # kernel per event ?
|
||||
jz kernel_per
|
||||
mvc __THREAD_per+__PER_atmid(2,%r1),__LC_PER_ATMID
|
||||
mvc __THREAD_per+__PER_address(8,%r1),__LC_PER_ADDRESS
|
||||
mvc __THREAD_per+__PER_access_id(1,%r1),__LC_PER_ACCESS_ID
|
||||
@ -553,6 +555,16 @@ pgm_no_vtime3:
|
||||
stosm __SF_EMPTY(%r15),0x03 # reenable interrupts
|
||||
j sysc_do_svc
|
||||
|
||||
#
|
||||
# per was called from kernel, must be kprobes
|
||||
#
|
||||
kernel_per:
|
||||
lhi %r0,__LC_PGM_OLD_PSW
|
||||
sth %r0,SP_TRAP(%r15) # set trap indication to pgm check
|
||||
la %r2,SP_PTREGS(%r15) # address of register-save area
|
||||
larl %r14,sysc_leave # load adr. of system ret, no work
|
||||
jg do_single_step # branch to do_single_step
|
||||
|
||||
/*
|
||||
* IO interrupt handler routine
|
||||
*/
|
||||
@ -815,7 +827,7 @@ restart_go:
|
||||
*/
|
||||
stack_overflow:
|
||||
lg %r15,__LC_PANIC_STACK # change to panic stack
|
||||
aghi %r1,-SP_SIZE
|
||||
aghi %r15,-SP_SIZE
|
||||
mvc SP_PSW(16,%r15),0(%r12) # move user PSW to stack
|
||||
stmg %r0,%r11,SP_R0(%r15) # store gprs %r0-%r11 to kernel stack
|
||||
la %r1,__LC_SAVE_AREA
|
||||
@ -823,7 +835,7 @@ stack_overflow:
|
||||
je 0f
|
||||
chi %r12,__LC_PGM_OLD_PSW
|
||||
je 0f
|
||||
la %r1,__LC_SAVE_AREA+16
|
||||
la %r1,__LC_SAVE_AREA+32
|
||||
0: mvc SP_R12(32,%r15),0(%r1) # move %r12-%r15 to stack
|
||||
xc __SF_BACKCHAIN(8,%r15),__SF_BACKCHAIN(%r15) # clear back chain
|
||||
la %r2,SP_PTREGS(%r15) # load pt_regs
|
||||
|
@ -272,7 +272,7 @@ iplstart:
|
||||
# load parameter file from ipl device
|
||||
#
|
||||
.Lagain1:
|
||||
l %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # ramdisk loc. is temp
|
||||
l %r2,.Linitrd # ramdisk loc. is temp
|
||||
bas %r14,.Lloader # load parameter file
|
||||
ltr %r2,%r2 # got anything ?
|
||||
bz .Lnopf
|
||||
@ -280,7 +280,7 @@ iplstart:
|
||||
bnh .Lnotrunc
|
||||
la %r2,895
|
||||
.Lnotrunc:
|
||||
l %r4,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
|
||||
l %r4,.Linitrd
|
||||
clc 0(3,%r4),.L_hdr # if it is HDRx
|
||||
bz .Lagain1 # skip dataset header
|
||||
clc 0(3,%r4),.L_eof # if it is EOFx
|
||||
@ -323,14 +323,15 @@ iplstart:
|
||||
# load ramdisk from ipl device
|
||||
#
|
||||
.Lagain2:
|
||||
l %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # addr of ramdisk
|
||||
l %r2,.Linitrd # addr of ramdisk
|
||||
st %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
|
||||
bas %r14,.Lloader # load ramdisk
|
||||
st %r2,INITRD_SIZE+ARCH_OFFSET-PARMAREA(%r12) # store size of ramdisk
|
||||
ltr %r2,%r2
|
||||
bnz .Lrdcont
|
||||
st %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12) # no ramdisk found
|
||||
.Lrdcont:
|
||||
l %r2,INITRD_START+ARCH_OFFSET-PARMAREA(%r12)
|
||||
l %r2,.Linitrd
|
||||
|
||||
clc 0(3,%r2),.L_hdr # skip HDRx and EOFx
|
||||
bz .Lagain2
|
||||
@ -379,6 +380,7 @@ iplstart:
|
||||
l %r1,.Lstartup
|
||||
br %r1
|
||||
|
||||
.Linitrd:.long _end + 0x400000 # default address of initrd
|
||||
.Lparm: .long PARMAREA
|
||||
.Lstartup: .long startup
|
||||
.Lcvtab:.long _ebcasc # ebcdic to ascii table
|
||||
@ -479,65 +481,6 @@ start:
|
||||
.byte 0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7
|
||||
.byte 0xf8,0xf9,0xfa,0xfb,0xfc,0xfd,0xfe,0xff
|
||||
|
||||
.macro GET_IPL_DEVICE
|
||||
.Lget_ipl_device:
|
||||
l %r1,0xb8 # get sid
|
||||
sll %r1,15 # test if subchannel is enabled
|
||||
srl %r1,31
|
||||
ltr %r1,%r1
|
||||
bz 2f-.LPG1(%r13) # subchannel disabled
|
||||
l %r1,0xb8
|
||||
la %r5,.Lipl_schib-.LPG1(%r13)
|
||||
stsch 0(%r5) # get schib of subchannel
|
||||
bnz 2f-.LPG1(%r13) # schib not available
|
||||
tm 5(%r5),0x01 # devno valid?
|
||||
bno 2f-.LPG1(%r13)
|
||||
la %r6,ipl_parameter_flags-.LPG1(%r13)
|
||||
oi 3(%r6),0x01 # set flag
|
||||
la %r2,ipl_devno-.LPG1(%r13)
|
||||
mvc 0(2,%r2),6(%r5) # store devno
|
||||
tm 4(%r5),0x80 # qdio capable device?
|
||||
bno 2f-.LPG1(%r13)
|
||||
oi 3(%r6),0x02 # set flag
|
||||
|
||||
# copy ipl parameters
|
||||
|
||||
lhi %r0,4096
|
||||
l %r2,20(%r0) # get address of parameter list
|
||||
lhi %r3,IPL_PARMBLOCK_ORIGIN
|
||||
st %r3,20(%r0)
|
||||
lhi %r4,1
|
||||
cr %r2,%r3 # start parameters < destination ?
|
||||
jl 0f
|
||||
lhi %r1,1 # copy direction is upwards
|
||||
j 1f
|
||||
0: lhi %r1,-1 # copy direction is downwards
|
||||
ar %r2,%r0
|
||||
ar %r3,%r0
|
||||
ar %r2,%r1
|
||||
ar %r3,%r1
|
||||
1: mvc 0(1,%r3),0(%r2) # finally copy ipl parameters
|
||||
ar %r3,%r1
|
||||
ar %r2,%r1
|
||||
sr %r0,%r4
|
||||
jne 1b
|
||||
b 2f-.LPG1(%r13)
|
||||
|
||||
.align 4
|
||||
.Lipl_schib:
|
||||
.rept 13
|
||||
.long 0
|
||||
.endr
|
||||
|
||||
.globl ipl_parameter_flags
|
||||
ipl_parameter_flags:
|
||||
.long 0
|
||||
.globl ipl_devno
|
||||
ipl_devno:
|
||||
.word 0
|
||||
2:
|
||||
.endm
|
||||
|
||||
#ifdef CONFIG_64BIT
|
||||
#include "head64.S"
|
||||
#else
|
||||
|
@ -26,8 +26,8 @@ startup:basr %r13,0 # get base
|
||||
#
|
||||
.org PARMAREA
|
||||
.long 0,0 # IPL_DEVICE
|
||||
.long 0,RAMDISK_ORIGIN # INITRD_START
|
||||
.long 0,RAMDISK_SIZE # INITRD_SIZE
|
||||
.long 0,0 # INITRD_START
|
||||
.long 0,0 # INITRD_SIZE
|
||||
|
||||
.org COMMAND_LINE
|
||||
.byte "root=/dev/ram0 ro"
|
||||
@ -37,12 +37,23 @@ startup:basr %r13,0 # get base
|
||||
|
||||
startup_continue:
|
||||
basr %r13,0 # get base
|
||||
.LPG1: GET_IPL_DEVICE
|
||||
.LPG1: mvi __LC_AR_MODE_ID,0 # set ESA flag (mode 0)
|
||||
lctl %c0,%c15,.Lctl-.LPG1(%r13) # load control registers
|
||||
l %r12,.Lparmaddr-.LPG1(%r13) # pointer to parameter area
|
||||
# move IPL device to lowcore
|
||||
mvc __LC_IPLDEV(4),IPL_DEVICE-PARMAREA(%r12)
|
||||
#
|
||||
# Setup stack
|
||||
#
|
||||
l %r15,.Linittu-.LPG1(%r13)
|
||||
mvc __LC_CURRENT(4),__TI_task(%r15)
|
||||
ahi %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union+THREAD_SIZE
|
||||
st %r15,__LC_KERNEL_STACK # set end of kernel stack
|
||||
ahi %r15,-96
|
||||
xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
|
||||
|
||||
l %r14,.Lipl_save_parameters-.LPG1(%r13)
|
||||
basr %r14,%r14
|
||||
#
|
||||
# clear bss memory
|
||||
#
|
||||
@ -114,6 +125,10 @@ startup_continue:
|
||||
b .Lfchunk-.LPG1(%r13)
|
||||
|
||||
.align 4
|
||||
.Lipl_save_parameters:
|
||||
.long ipl_save_parameters
|
||||
.Linittu:
|
||||
.long init_thread_union
|
||||
.Lpmask:
|
||||
.byte 0
|
||||
.align 8
|
||||
@ -273,7 +288,23 @@ startup_continue:
|
||||
.Lbss_end: .long _end
|
||||
.Lparmaddr: .long PARMAREA
|
||||
.Lsccbaddr: .long .Lsccb
|
||||
|
||||
.globl ipl_schib
|
||||
ipl_schib:
|
||||
.rept 13
|
||||
.long 0
|
||||
.endr
|
||||
|
||||
.globl ipl_flags
|
||||
ipl_flags:
|
||||
.long 0
|
||||
.globl ipl_devno
|
||||
ipl_devno:
|
||||
.word 0
|
||||
|
||||
.org 0x12000
|
||||
.globl s390_readinfo_sccb
|
||||
s390_readinfo_sccb:
|
||||
.Lsccb:
|
||||
.hword 0x1000 # length, one page
|
||||
.byte 0x00,0x00,0x00
|
||||
@ -302,16 +333,6 @@ startup_continue:
|
||||
.globl _stext
|
||||
_stext: basr %r13,0 # get base
|
||||
.LPG3:
|
||||
#
|
||||
# Setup stack
|
||||
#
|
||||
l %r15,.Linittu-.LPG3(%r13)
|
||||
mvc __LC_CURRENT(4),__TI_task(%r15)
|
||||
ahi %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union+THREAD_SIZE
|
||||
st %r15,__LC_KERNEL_STACK # set end of kernel stack
|
||||
ahi %r15,-96
|
||||
xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
|
||||
|
||||
# check control registers
|
||||
stctl %c0,%c15,0(%r15)
|
||||
oi 2(%r15),0x40 # enable sigp emergency signal
|
||||
@ -330,6 +351,5 @@ _stext: basr %r13,0 # get base
|
||||
#
|
||||
.align 8
|
||||
.Ldw: .long 0x000a0000,0x00000000
|
||||
.Linittu:.long init_thread_union
|
||||
.Lstart:.long start_kernel
|
||||
.Laregs:.long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
||||
|
@ -26,8 +26,8 @@ startup:basr %r13,0 # get base
|
||||
#
|
||||
.org PARMAREA
|
||||
.quad 0 # IPL_DEVICE
|
||||
.quad RAMDISK_ORIGIN # INITRD_START
|
||||
.quad RAMDISK_SIZE # INITRD_SIZE
|
||||
.quad 0 # INITRD_START
|
||||
.quad 0 # INITRD_SIZE
|
||||
|
||||
.org COMMAND_LINE
|
||||
.byte "root=/dev/ram0 ro"
|
||||
@ -39,8 +39,8 @@ startup_continue:
|
||||
basr %r13,0 # get base
|
||||
.LPG1: sll %r13,1 # remove high order bit
|
||||
srl %r13,1
|
||||
GET_IPL_DEVICE
|
||||
lhi %r1,1 # mode 1 = esame
|
||||
mvi __LC_AR_MODE_ID,1 # set esame flag
|
||||
slr %r0,%r0 # set cpuid to zero
|
||||
sigp %r1,%r0,0x12 # switch to esame mode
|
||||
sam64 # switch to 64 bit mode
|
||||
@ -48,7 +48,18 @@ startup_continue:
|
||||
lg %r12,.Lparmaddr-.LPG1(%r13)# pointer to parameter area
|
||||
# move IPL device to lowcore
|
||||
mvc __LC_IPLDEV(4),IPL_DEVICE+4-PARMAREA(%r12)
|
||||
#
|
||||
# Setup stack
|
||||
#
|
||||
larl %r15,init_thread_union
|
||||
lg %r14,__TI_task(%r15) # cache current in lowcore
|
||||
stg %r14,__LC_CURRENT
|
||||
aghi %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
|
||||
stg %r15,__LC_KERNEL_STACK # set end of kernel stack
|
||||
aghi %r15,-160
|
||||
xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
|
||||
|
||||
brasl %r14,ipl_save_parameters
|
||||
#
|
||||
# clear bss memory
|
||||
#
|
||||
@ -239,6 +250,19 @@ startup_continue:
|
||||
oi 7(%r12),0x80 # set IDTE flag
|
||||
0:
|
||||
|
||||
#
|
||||
# find out if we have the MVCOS instruction
|
||||
#
|
||||
la %r1,0f-.LPG1(%r13) # set program check address
|
||||
stg %r1,__LC_PGM_NEW_PSW+8
|
||||
.short 0xc800 # mvcos 0(%r0),0(%r0),%r0
|
||||
.short 0x0000
|
||||
.short 0x0000
|
||||
0: tm 0x8f,0x13 # special-operation exception?
|
||||
bno 1f-.LPG1(%r13) # if yes, MVCOS is present
|
||||
oi 6(%r12),2 # set MVCOS flag
|
||||
1:
|
||||
|
||||
lpswe .Lentry-.LPG1(13) # jump to _stext in primary-space,
|
||||
# virtual and never return ...
|
||||
.align 16
|
||||
@ -268,7 +292,22 @@ startup_continue:
|
||||
.Lparmaddr:
|
||||
.quad PARMAREA
|
||||
|
||||
.globl ipl_schib
|
||||
ipl_schib:
|
||||
.rept 13
|
||||
.long 0
|
||||
.endr
|
||||
|
||||
.globl ipl_flags
|
||||
ipl_flags:
|
||||
.long 0
|
||||
.globl ipl_devno
|
||||
ipl_devno:
|
||||
.word 0
|
||||
|
||||
.org 0x12000
|
||||
.globl s390_readinfo_sccb
|
||||
s390_readinfo_sccb:
|
||||
.Lsccb:
|
||||
.hword 0x1000 # length, one page
|
||||
.byte 0x00,0x00,0x00
|
||||
@ -297,24 +336,12 @@ startup_continue:
|
||||
.globl _stext
|
||||
_stext: basr %r13,0 # get base
|
||||
.LPG3:
|
||||
#
|
||||
# Setup stack
|
||||
#
|
||||
larl %r15,init_thread_union
|
||||
lg %r14,__TI_task(%r15) # cache current in lowcore
|
||||
stg %r14,__LC_CURRENT
|
||||
aghi %r15,1<<(PAGE_SHIFT+THREAD_ORDER) # init_task_union + THREAD_SIZE
|
||||
stg %r15,__LC_KERNEL_STACK # set end of kernel stack
|
||||
aghi %r15,-160
|
||||
xc __SF_BACKCHAIN(4,%r15),__SF_BACKCHAIN(%r15) # clear backchain
|
||||
|
||||
# check control registers
|
||||
stctg %c0,%c15,0(%r15)
|
||||
oi 6(%r15),0x40 # enable sigp emergency signal
|
||||
oi 4(%r15),0x10 # switch on low address proctection
|
||||
lctlg %c0,%c15,0(%r15)
|
||||
|
||||
#
|
||||
lam 0,15,.Laregs-.LPG3(%r13) # load access regs needed by uaccess
|
||||
brasl %r14,start_kernel # go to C code
|
||||
#
|
||||
@ -322,7 +349,7 @@ _stext: basr %r13,0 # get base
|
||||
#
|
||||
basr %r13,0
|
||||
lpswe .Ldw-.(%r13) # load disabled wait psw
|
||||
#
|
||||
|
||||
.align 8
|
||||
.Ldw: .quad 0x0002000180000000,0x0000000000000000
|
||||
.Laregs: .long 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
|
||||
|
942
arch/s390/kernel/ipl.c
Normal file
942
arch/s390/kernel/ipl.c
Normal file
@ -0,0 +1,942 @@
|
||||
/*
|
||||
* arch/s390/kernel/ipl.c
|
||||
* ipl/reipl/dump support for Linux on s390.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2005,2006
|
||||
* Author(s): Michael Holzheu <holzheu@de.ibm.com>
|
||||
* Heiko Carstens <heiko.carstens@de.ibm.com>
|
||||
* Volker Sameske <sameske@de.ibm.com>
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/reboot.h>
|
||||
#include <asm/smp.h>
|
||||
#include <asm/setup.h>
|
||||
#include <asm/cpcmd.h>
|
||||
#include <asm/cio.h>
|
||||
|
||||
#define IPL_PARM_BLOCK_VERSION 0
|
||||
|
||||
enum ipl_type {
|
||||
IPL_TYPE_NONE = 1,
|
||||
IPL_TYPE_UNKNOWN = 2,
|
||||
IPL_TYPE_CCW = 4,
|
||||
IPL_TYPE_FCP = 8,
|
||||
};
|
||||
|
||||
#define IPL_NONE_STR "none"
|
||||
#define IPL_UNKNOWN_STR "unknown"
|
||||
#define IPL_CCW_STR "ccw"
|
||||
#define IPL_FCP_STR "fcp"
|
||||
|
||||
static char *ipl_type_str(enum ipl_type type)
|
||||
{
|
||||
switch (type) {
|
||||
case IPL_TYPE_NONE:
|
||||
return IPL_NONE_STR;
|
||||
case IPL_TYPE_CCW:
|
||||
return IPL_CCW_STR;
|
||||
case IPL_TYPE_FCP:
|
||||
return IPL_FCP_STR;
|
||||
case IPL_TYPE_UNKNOWN:
|
||||
default:
|
||||
return IPL_UNKNOWN_STR;
|
||||
}
|
||||
}
|
||||
|
||||
enum ipl_method {
|
||||
IPL_METHOD_NONE,
|
||||
IPL_METHOD_CCW_CIO,
|
||||
IPL_METHOD_CCW_DIAG,
|
||||
IPL_METHOD_CCW_VM,
|
||||
IPL_METHOD_FCP_RO_DIAG,
|
||||
IPL_METHOD_FCP_RW_DIAG,
|
||||
IPL_METHOD_FCP_RO_VM,
|
||||
};
|
||||
|
||||
enum shutdown_action {
|
||||
SHUTDOWN_REIPL,
|
||||
SHUTDOWN_DUMP,
|
||||
SHUTDOWN_STOP,
|
||||
};
|
||||
|
||||
#define SHUTDOWN_REIPL_STR "reipl"
|
||||
#define SHUTDOWN_DUMP_STR "dump"
|
||||
#define SHUTDOWN_STOP_STR "stop"
|
||||
|
||||
static char *shutdown_action_str(enum shutdown_action action)
|
||||
{
|
||||
switch (action) {
|
||||
case SHUTDOWN_REIPL:
|
||||
return SHUTDOWN_REIPL_STR;
|
||||
case SHUTDOWN_DUMP:
|
||||
return SHUTDOWN_DUMP_STR;
|
||||
case SHUTDOWN_STOP:
|
||||
return SHUTDOWN_STOP_STR;
|
||||
default:
|
||||
BUG();
|
||||
}
|
||||
}
|
||||
|
||||
enum diag308_subcode {
|
||||
DIAG308_IPL = 3,
|
||||
DIAG308_DUMP = 4,
|
||||
DIAG308_SET = 5,
|
||||
DIAG308_STORE = 6,
|
||||
};
|
||||
|
||||
enum diag308_ipl_type {
|
||||
DIAG308_IPL_TYPE_FCP = 0,
|
||||
DIAG308_IPL_TYPE_CCW = 2,
|
||||
};
|
||||
|
||||
enum diag308_opt {
|
||||
DIAG308_IPL_OPT_IPL = 0x10,
|
||||
DIAG308_IPL_OPT_DUMP = 0x20,
|
||||
};
|
||||
|
||||
enum diag308_rc {
|
||||
DIAG308_RC_OK = 1,
|
||||
};
|
||||
|
||||
static int diag308_set_works = 0;
|
||||
|
||||
static int reipl_capabilities = IPL_TYPE_UNKNOWN;
|
||||
static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
|
||||
static enum ipl_method reipl_method = IPL_METHOD_NONE;
|
||||
static struct ipl_parameter_block *reipl_block_fcp;
|
||||
static struct ipl_parameter_block *reipl_block_ccw;
|
||||
|
||||
static int dump_capabilities = IPL_TYPE_NONE;
|
||||
static enum ipl_type dump_type = IPL_TYPE_NONE;
|
||||
static enum ipl_method dump_method = IPL_METHOD_NONE;
|
||||
static struct ipl_parameter_block *dump_block_fcp;
|
||||
static struct ipl_parameter_block *dump_block_ccw;
|
||||
|
||||
static enum shutdown_action on_panic_action = SHUTDOWN_STOP;
|
||||
|
||||
static int diag308(unsigned long subcode, void *addr)
|
||||
{
|
||||
register unsigned long _addr asm("0") = (unsigned long)addr;
|
||||
register unsigned long _rc asm("1") = 0;
|
||||
|
||||
asm volatile (
|
||||
" diag %0,%2,0x308\n"
|
||||
"0: \n"
|
||||
".section __ex_table,\"a\"\n"
|
||||
#ifdef CONFIG_64BIT
|
||||
" .align 8\n"
|
||||
" .quad 0b, 0b\n"
|
||||
#else
|
||||
" .align 4\n"
|
||||
" .long 0b, 0b\n"
|
||||
#endif
|
||||
".previous\n"
|
||||
: "+d" (_addr), "+d" (_rc)
|
||||
: "d" (subcode) : "cc", "memory" );
|
||||
|
||||
return _rc;
|
||||
}
|
||||
|
||||
/* SYSFS */
|
||||
|
||||
#define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value) \
|
||||
static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
|
||||
char *page) \
|
||||
{ \
|
||||
return sprintf(page, _format, _value); \
|
||||
} \
|
||||
static struct subsys_attribute sys_##_prefix##_##_name##_attr = \
|
||||
__ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL);
|
||||
|
||||
#define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value) \
|
||||
static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
|
||||
char *page) \
|
||||
{ \
|
||||
return sprintf(page, _fmt_out, \
|
||||
(unsigned long long) _value); \
|
||||
} \
|
||||
static ssize_t sys_##_prefix##_##_name##_store(struct subsystem *subsys,\
|
||||
const char *buf, size_t len) \
|
||||
{ \
|
||||
unsigned long long value; \
|
||||
if (sscanf(buf, _fmt_in, &value) != 1) \
|
||||
return -EINVAL; \
|
||||
_value = value; \
|
||||
return len; \
|
||||
} \
|
||||
static struct subsys_attribute sys_##_prefix##_##_name##_attr = \
|
||||
__ATTR(_name,(S_IRUGO | S_IWUSR), \
|
||||
sys_##_prefix##_##_name##_show, \
|
||||
sys_##_prefix##_##_name##_store);
|
||||
|
||||
static void make_attrs_ro(struct attribute **attrs)
|
||||
{
|
||||
while (*attrs) {
|
||||
(*attrs)->mode = S_IRUGO;
|
||||
attrs++;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* ipl section
|
||||
*/
|
||||
|
||||
static enum ipl_type ipl_get_type(void)
|
||||
{
|
||||
struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
|
||||
|
||||
if (!(ipl_flags & IPL_DEVNO_VALID))
|
||||
return IPL_TYPE_UNKNOWN;
|
||||
if (!(ipl_flags & IPL_PARMBLOCK_VALID))
|
||||
return IPL_TYPE_CCW;
|
||||
if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION)
|
||||
return IPL_TYPE_UNKNOWN;
|
||||
if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
|
||||
return IPL_TYPE_UNKNOWN;
|
||||
return IPL_TYPE_FCP;
|
||||
}
|
||||
|
||||
static ssize_t ipl_type_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
return sprintf(page, "%s\n", ipl_type_str(ipl_get_type()));
|
||||
}
|
||||
|
||||
static struct subsys_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
|
||||
|
||||
static ssize_t sys_ipl_device_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
|
||||
|
||||
switch (ipl_get_type()) {
|
||||
case IPL_TYPE_CCW:
|
||||
return sprintf(page, "0.0.%04x\n", ipl_devno);
|
||||
case IPL_TYPE_FCP:
|
||||
return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static struct subsys_attribute sys_ipl_device_attr =
|
||||
__ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
|
||||
|
||||
static ssize_t ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off,
|
||||
size_t count)
|
||||
{
|
||||
unsigned int size = IPL_PARMBLOCK_SIZE;
|
||||
|
||||
if (off > size)
|
||||
return 0;
|
||||
if (off + count > size)
|
||||
count = size - off;
|
||||
memcpy(buf, (void *)IPL_PARMBLOCK_START + off, count);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct bin_attribute ipl_parameter_attr = {
|
||||
.attr = {
|
||||
.name = "binary_parameter",
|
||||
.mode = S_IRUGO,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.size = PAGE_SIZE,
|
||||
.read = &ipl_parameter_read,
|
||||
};
|
||||
|
||||
static ssize_t ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off,
|
||||
size_t count)
|
||||
{
|
||||
unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len;
|
||||
void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data;
|
||||
|
||||
if (off > size)
|
||||
return 0;
|
||||
if (off + count > size)
|
||||
count = size - off;
|
||||
memcpy(buf, scp_data + off, count);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct bin_attribute ipl_scp_data_attr = {
|
||||
.attr = {
|
||||
.name = "scp_data",
|
||||
.mode = S_IRUGO,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.size = PAGE_SIZE,
|
||||
.read = &ipl_scp_data_read,
|
||||
};
|
||||
|
||||
/* FCP ipl device attributes */
|
||||
|
||||
DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->ipl_info.fcp.wwpn);
|
||||
DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->ipl_info.fcp.lun);
|
||||
DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->ipl_info.fcp.bootprog);
|
||||
DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->ipl_info.fcp.br_lba);
|
||||
|
||||
static struct attribute *ipl_fcp_attrs[] = {
|
||||
&sys_ipl_type_attr.attr,
|
||||
&sys_ipl_device_attr.attr,
|
||||
&sys_ipl_fcp_wwpn_attr.attr,
|
||||
&sys_ipl_fcp_lun_attr.attr,
|
||||
&sys_ipl_fcp_bootprog_attr.attr,
|
||||
&sys_ipl_fcp_br_lba_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_fcp_attr_group = {
|
||||
.attrs = ipl_fcp_attrs,
|
||||
};
|
||||
|
||||
/* CCW ipl device attributes */
|
||||
|
||||
static struct attribute *ipl_ccw_attrs[] = {
|
||||
&sys_ipl_type_attr.attr,
|
||||
&sys_ipl_device_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_ccw_attr_group = {
|
||||
.attrs = ipl_ccw_attrs,
|
||||
};
|
||||
|
||||
/* UNKNOWN ipl device attributes */
|
||||
|
||||
static struct attribute *ipl_unknown_attrs[] = {
|
||||
&sys_ipl_type_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_unknown_attr_group = {
|
||||
.attrs = ipl_unknown_attrs,
|
||||
};
|
||||
|
||||
static decl_subsys(ipl, NULL, NULL);
|
||||
|
||||
/*
|
||||
* reipl section
|
||||
*/
|
||||
|
||||
/* FCP reipl device attributes */
|
||||
|
||||
DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%016llx\n",
|
||||
reipl_block_fcp->ipl_info.fcp.wwpn);
|
||||
DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%016llx\n",
|
||||
reipl_block_fcp->ipl_info.fcp.lun);
|
||||
DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
|
||||
reipl_block_fcp->ipl_info.fcp.bootprog);
|
||||
DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
|
||||
reipl_block_fcp->ipl_info.fcp.br_lba);
|
||||
DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
|
||||
reipl_block_fcp->ipl_info.fcp.devno);
|
||||
|
||||
static struct attribute *reipl_fcp_attrs[] = {
|
||||
&sys_reipl_fcp_device_attr.attr,
|
||||
&sys_reipl_fcp_wwpn_attr.attr,
|
||||
&sys_reipl_fcp_lun_attr.attr,
|
||||
&sys_reipl_fcp_bootprog_attr.attr,
|
||||
&sys_reipl_fcp_br_lba_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group reipl_fcp_attr_group = {
|
||||
.name = IPL_FCP_STR,
|
||||
.attrs = reipl_fcp_attrs,
|
||||
};
|
||||
|
||||
/* CCW reipl device attributes */
|
||||
|
||||
DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
|
||||
reipl_block_ccw->ipl_info.ccw.devno);
|
||||
|
||||
static struct attribute *reipl_ccw_attrs[] = {
|
||||
&sys_reipl_ccw_device_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group reipl_ccw_attr_group = {
|
||||
.name = IPL_CCW_STR,
|
||||
.attrs = reipl_ccw_attrs,
|
||||
};
|
||||
|
||||
/* reipl type */
|
||||
|
||||
static int reipl_set_type(enum ipl_type type)
|
||||
{
|
||||
if (!(reipl_capabilities & type))
|
||||
return -EINVAL;
|
||||
|
||||
switch(type) {
|
||||
case IPL_TYPE_CCW:
|
||||
if (MACHINE_IS_VM)
|
||||
reipl_method = IPL_METHOD_CCW_VM;
|
||||
else
|
||||
reipl_method = IPL_METHOD_CCW_CIO;
|
||||
break;
|
||||
case IPL_TYPE_FCP:
|
||||
if (diag308_set_works)
|
||||
reipl_method = IPL_METHOD_FCP_RW_DIAG;
|
||||
else if (MACHINE_IS_VM)
|
||||
reipl_method = IPL_METHOD_FCP_RO_VM;
|
||||
else
|
||||
reipl_method = IPL_METHOD_FCP_RO_DIAG;
|
||||
break;
|
||||
default:
|
||||
reipl_method = IPL_METHOD_NONE;
|
||||
}
|
||||
reipl_type = type;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t reipl_type_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
return sprintf(page, "%s\n", ipl_type_str(reipl_type));
|
||||
}
|
||||
|
||||
static ssize_t reipl_type_store(struct subsystem *subsys, const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
int rc = -EINVAL;
|
||||
|
||||
if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
|
||||
rc = reipl_set_type(IPL_TYPE_CCW);
|
||||
else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
|
||||
rc = reipl_set_type(IPL_TYPE_FCP);
|
||||
return (rc != 0) ? rc : len;
|
||||
}
|
||||
|
||||
static struct subsys_attribute reipl_type_attr =
|
||||
__ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
|
||||
|
||||
static decl_subsys(reipl, NULL, NULL);
|
||||
|
||||
/*
|
||||
* dump section
|
||||
*/
|
||||
|
||||
/* FCP dump device attributes */
|
||||
|
||||
DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%016llx\n",
|
||||
dump_block_fcp->ipl_info.fcp.wwpn);
|
||||
DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%016llx\n",
|
||||
dump_block_fcp->ipl_info.fcp.lun);
|
||||
DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
|
||||
dump_block_fcp->ipl_info.fcp.bootprog);
|
||||
DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
|
||||
dump_block_fcp->ipl_info.fcp.br_lba);
|
||||
DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
|
||||
dump_block_fcp->ipl_info.fcp.devno);
|
||||
|
||||
static struct attribute *dump_fcp_attrs[] = {
|
||||
&sys_dump_fcp_device_attr.attr,
|
||||
&sys_dump_fcp_wwpn_attr.attr,
|
||||
&sys_dump_fcp_lun_attr.attr,
|
||||
&sys_dump_fcp_bootprog_attr.attr,
|
||||
&sys_dump_fcp_br_lba_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group dump_fcp_attr_group = {
|
||||
.name = IPL_FCP_STR,
|
||||
.attrs = dump_fcp_attrs,
|
||||
};
|
||||
|
||||
/* CCW dump device attributes */
|
||||
|
||||
DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
|
||||
dump_block_ccw->ipl_info.ccw.devno);
|
||||
|
||||
static struct attribute *dump_ccw_attrs[] = {
|
||||
&sys_dump_ccw_device_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group dump_ccw_attr_group = {
|
||||
.name = IPL_CCW_STR,
|
||||
.attrs = dump_ccw_attrs,
|
||||
};
|
||||
|
||||
/* dump type */
|
||||
|
||||
static int dump_set_type(enum ipl_type type)
|
||||
{
|
||||
if (!(dump_capabilities & type))
|
||||
return -EINVAL;
|
||||
switch(type) {
|
||||
case IPL_TYPE_CCW:
|
||||
if (MACHINE_IS_VM)
|
||||
dump_method = IPL_METHOD_CCW_VM;
|
||||
else
|
||||
dump_method = IPL_METHOD_CCW_CIO;
|
||||
break;
|
||||
case IPL_TYPE_FCP:
|
||||
dump_method = IPL_METHOD_FCP_RW_DIAG;
|
||||
break;
|
||||
default:
|
||||
dump_method = IPL_METHOD_NONE;
|
||||
}
|
||||
dump_type = type;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t dump_type_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
return sprintf(page, "%s\n", ipl_type_str(dump_type));
|
||||
}
|
||||
|
||||
static ssize_t dump_type_store(struct subsystem *subsys, const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
int rc = -EINVAL;
|
||||
|
||||
if (strncmp(buf, IPL_NONE_STR, strlen(IPL_NONE_STR)) == 0)
|
||||
rc = dump_set_type(IPL_TYPE_NONE);
|
||||
else if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
|
||||
rc = dump_set_type(IPL_TYPE_CCW);
|
||||
else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
|
||||
rc = dump_set_type(IPL_TYPE_FCP);
|
||||
return (rc != 0) ? rc : len;
|
||||
}
|
||||
|
||||
static struct subsys_attribute dump_type_attr =
|
||||
__ATTR(dump_type, 0644, dump_type_show, dump_type_store);
|
||||
|
||||
static decl_subsys(dump, NULL, NULL);
|
||||
|
||||
#ifdef CONFIG_SMP
|
||||
static void dump_smp_stop_all(void)
|
||||
{
|
||||
int cpu;
|
||||
preempt_disable();
|
||||
for_each_online_cpu(cpu) {
|
||||
if (cpu == smp_processor_id())
|
||||
continue;
|
||||
while (signal_processor(cpu, sigp_stop) == sigp_busy)
|
||||
udelay(10);
|
||||
}
|
||||
preempt_enable();
|
||||
}
|
||||
#else
|
||||
#define dump_smp_stop_all() do { } while (0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Shutdown actions section
|
||||
*/
|
||||
|
||||
static decl_subsys(shutdown_actions, NULL, NULL);
|
||||
|
||||
/* on panic */
|
||||
|
||||
static ssize_t on_panic_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
return sprintf(page, "%s\n", shutdown_action_str(on_panic_action));
|
||||
}
|
||||
|
||||
static ssize_t on_panic_store(struct subsystem *subsys, const char *buf,
|
||||
size_t len)
|
||||
{
|
||||
if (strncmp(buf, SHUTDOWN_REIPL_STR, strlen(SHUTDOWN_REIPL_STR)) == 0)
|
||||
on_panic_action = SHUTDOWN_REIPL;
|
||||
else if (strncmp(buf, SHUTDOWN_DUMP_STR,
|
||||
strlen(SHUTDOWN_DUMP_STR)) == 0)
|
||||
on_panic_action = SHUTDOWN_DUMP;
|
||||
else if (strncmp(buf, SHUTDOWN_STOP_STR,
|
||||
strlen(SHUTDOWN_STOP_STR)) == 0)
|
||||
on_panic_action = SHUTDOWN_STOP;
|
||||
else
|
||||
return -EINVAL;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static struct subsys_attribute on_panic_attr =
|
||||
__ATTR(on_panic, 0644, on_panic_show, on_panic_store);
|
||||
|
||||
static void print_fcp_block(struct ipl_parameter_block *fcp_block)
|
||||
{
|
||||
printk(KERN_EMERG "wwpn: %016llx\n",
|
||||
(unsigned long long)fcp_block->ipl_info.fcp.wwpn);
|
||||
printk(KERN_EMERG "lun: %016llx\n",
|
||||
(unsigned long long)fcp_block->ipl_info.fcp.lun);
|
||||
printk(KERN_EMERG "bootprog: %lld\n",
|
||||
(unsigned long long)fcp_block->ipl_info.fcp.bootprog);
|
||||
printk(KERN_EMERG "br_lba: %lld\n",
|
||||
(unsigned long long)fcp_block->ipl_info.fcp.br_lba);
|
||||
printk(KERN_EMERG "device: %llx\n",
|
||||
(unsigned long long)fcp_block->ipl_info.fcp.devno);
|
||||
printk(KERN_EMERG "opt: %x\n", fcp_block->ipl_info.fcp.opt);
|
||||
}
|
||||
|
||||
void do_reipl(void)
|
||||
{
|
||||
struct ccw_dev_id devid;
|
||||
static char buf[100];
|
||||
|
||||
switch (reipl_type) {
|
||||
case IPL_TYPE_CCW:
|
||||
printk(KERN_EMERG "reboot on ccw device: 0.0.%04x\n",
|
||||
reipl_block_ccw->ipl_info.ccw.devno);
|
||||
break;
|
||||
case IPL_TYPE_FCP:
|
||||
printk(KERN_EMERG "reboot on fcp device:\n");
|
||||
print_fcp_block(reipl_block_fcp);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
switch (reipl_method) {
|
||||
case IPL_METHOD_CCW_CIO:
|
||||
devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
|
||||
devid.ssid = 0;
|
||||
reipl_ccw_dev(&devid);
|
||||
break;
|
||||
case IPL_METHOD_CCW_VM:
|
||||
sprintf(buf, "IPL %X", reipl_block_ccw->ipl_info.ccw.devno);
|
||||
cpcmd(buf, NULL, 0, NULL);
|
||||
break;
|
||||
case IPL_METHOD_CCW_DIAG:
|
||||
diag308(DIAG308_SET, reipl_block_ccw);
|
||||
diag308(DIAG308_IPL, NULL);
|
||||
break;
|
||||
case IPL_METHOD_FCP_RW_DIAG:
|
||||
diag308(DIAG308_SET, reipl_block_fcp);
|
||||
diag308(DIAG308_IPL, NULL);
|
||||
break;
|
||||
case IPL_METHOD_FCP_RO_DIAG:
|
||||
diag308(DIAG308_IPL, NULL);
|
||||
break;
|
||||
case IPL_METHOD_FCP_RO_VM:
|
||||
cpcmd("IPL", NULL, 0, NULL);
|
||||
break;
|
||||
case IPL_METHOD_NONE:
|
||||
default:
|
||||
if (MACHINE_IS_VM)
|
||||
cpcmd("IPL", NULL, 0, NULL);
|
||||
diag308(DIAG308_IPL, NULL);
|
||||
break;
|
||||
}
|
||||
panic("reipl failed!\n");
|
||||
}
|
||||
|
||||
static void do_dump(void)
|
||||
{
|
||||
struct ccw_dev_id devid;
|
||||
static char buf[100];
|
||||
|
||||
switch (dump_type) {
|
||||
case IPL_TYPE_CCW:
|
||||
printk(KERN_EMERG "Automatic dump on ccw device: 0.0.%04x\n",
|
||||
dump_block_ccw->ipl_info.ccw.devno);
|
||||
break;
|
||||
case IPL_TYPE_FCP:
|
||||
printk(KERN_EMERG "Automatic dump on fcp device:\n");
|
||||
print_fcp_block(dump_block_fcp);
|
||||
break;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
switch (dump_method) {
|
||||
case IPL_METHOD_CCW_CIO:
|
||||
dump_smp_stop_all();
|
||||
devid.devno = dump_block_ccw->ipl_info.ccw.devno;
|
||||
devid.ssid = 0;
|
||||
reipl_ccw_dev(&devid);
|
||||
break;
|
||||
case IPL_METHOD_CCW_VM:
|
||||
dump_smp_stop_all();
|
||||
sprintf(buf, "STORE STATUS");
|
||||
cpcmd(buf, NULL, 0, NULL);
|
||||
sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
|
||||
cpcmd(buf, NULL, 0, NULL);
|
||||
break;
|
||||
case IPL_METHOD_CCW_DIAG:
|
||||
diag308(DIAG308_SET, dump_block_ccw);
|
||||
diag308(DIAG308_DUMP, NULL);
|
||||
break;
|
||||
case IPL_METHOD_FCP_RW_DIAG:
|
||||
diag308(DIAG308_SET, dump_block_fcp);
|
||||
diag308(DIAG308_DUMP, NULL);
|
||||
break;
|
||||
case IPL_METHOD_NONE:
|
||||
default:
|
||||
return;
|
||||
}
|
||||
printk(KERN_EMERG "Dump failed!\n");
|
||||
}
|
||||
|
||||
/* init functions */
|
||||
|
||||
static int __init ipl_register_fcp_files(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_fcp_attr_group);
|
||||
if (rc)
|
||||
goto out;
|
||||
rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
|
||||
&ipl_parameter_attr);
|
||||
if (rc)
|
||||
goto out_ipl_parm;
|
||||
rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
|
||||
&ipl_scp_data_attr);
|
||||
if (!rc)
|
||||
goto out;
|
||||
|
||||
sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
|
||||
|
||||
out_ipl_parm:
|
||||
sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
|
||||
out:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int __init ipl_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = firmware_register(&ipl_subsys);
|
||||
if (rc)
|
||||
return rc;
|
||||
switch (ipl_get_type()) {
|
||||
case IPL_TYPE_CCW:
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_ccw_attr_group);
|
||||
break;
|
||||
case IPL_TYPE_FCP:
|
||||
rc = ipl_register_fcp_files();
|
||||
break;
|
||||
default:
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_unknown_attr_group);
|
||||
break;
|
||||
}
|
||||
if (rc)
|
||||
firmware_unregister(&ipl_subsys);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static void __init reipl_probe(void)
|
||||
{
|
||||
void *buffer;
|
||||
|
||||
buffer = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!buffer)
|
||||
return;
|
||||
if (diag308(DIAG308_STORE, buffer) == DIAG308_RC_OK)
|
||||
diag308_set_works = 1;
|
||||
free_page((unsigned long)buffer);
|
||||
}
|
||||
|
||||
static int __init reipl_ccw_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!reipl_block_ccw)
|
||||
return -ENOMEM;
|
||||
rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_ccw_attr_group);
|
||||
if (rc) {
|
||||
free_page((unsigned long)reipl_block_ccw);
|
||||
return rc;
|
||||
}
|
||||
reipl_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
|
||||
reipl_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
|
||||
reipl_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
|
||||
reipl_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
|
||||
if (ipl_get_type() == IPL_TYPE_CCW)
|
||||
reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
|
||||
reipl_capabilities |= IPL_TYPE_CCW;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init reipl_fcp_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if ((!diag308_set_works) && (ipl_get_type() != IPL_TYPE_FCP))
|
||||
return 0;
|
||||
if ((!diag308_set_works) && (ipl_get_type() == IPL_TYPE_FCP))
|
||||
make_attrs_ro(reipl_fcp_attrs);
|
||||
|
||||
reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!reipl_block_fcp)
|
||||
return -ENOMEM;
|
||||
rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_fcp_attr_group);
|
||||
if (rc) {
|
||||
free_page((unsigned long)reipl_block_fcp);
|
||||
return rc;
|
||||
}
|
||||
if (ipl_get_type() == IPL_TYPE_FCP) {
|
||||
memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
|
||||
} else {
|
||||
reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
|
||||
reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
|
||||
reipl_block_fcp->hdr.blk0_len =
|
||||
sizeof(reipl_block_fcp->ipl_info.fcp);
|
||||
reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
|
||||
reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
|
||||
}
|
||||
reipl_capabilities |= IPL_TYPE_FCP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init reipl_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = firmware_register(&reipl_subsys);
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = subsys_create_file(&reipl_subsys, &reipl_type_attr);
|
||||
if (rc) {
|
||||
firmware_unregister(&reipl_subsys);
|
||||
return rc;
|
||||
}
|
||||
rc = reipl_ccw_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = reipl_fcp_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = reipl_set_type(ipl_get_type());
|
||||
if (rc)
|
||||
return rc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init dump_ccw_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!dump_block_ccw)
|
||||
return -ENOMEM;
|
||||
rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_ccw_attr_group);
|
||||
if (rc) {
|
||||
free_page((unsigned long)dump_block_ccw);
|
||||
return rc;
|
||||
}
|
||||
dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
|
||||
dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
|
||||
dump_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
|
||||
dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
|
||||
dump_capabilities |= IPL_TYPE_CCW;
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern char s390_readinfo_sccb[];
|
||||
|
||||
static int __init dump_fcp_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if(!(s390_readinfo_sccb[91] & 0x2))
|
||||
return 0; /* LDIPL DUMP is not installed */
|
||||
if (!diag308_set_works)
|
||||
return 0;
|
||||
dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!dump_block_fcp)
|
||||
return -ENOMEM;
|
||||
rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_fcp_attr_group);
|
||||
if (rc) {
|
||||
free_page((unsigned long)dump_block_fcp);
|
||||
return rc;
|
||||
}
|
||||
dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
|
||||
dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
|
||||
dump_block_fcp->hdr.blk0_len = sizeof(dump_block_fcp->ipl_info.fcp);
|
||||
dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
|
||||
dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
|
||||
dump_capabilities |= IPL_TYPE_FCP;
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define SHUTDOWN_ON_PANIC_PRIO 0
|
||||
|
||||
static int shutdown_on_panic_notify(struct notifier_block *self,
|
||||
unsigned long event, void *data)
|
||||
{
|
||||
if (on_panic_action == SHUTDOWN_DUMP)
|
||||
do_dump();
|
||||
else if (on_panic_action == SHUTDOWN_REIPL)
|
||||
do_reipl();
|
||||
return NOTIFY_OK;
|
||||
}
|
||||
|
||||
static struct notifier_block shutdown_on_panic_nb = {
|
||||
.notifier_call = shutdown_on_panic_notify,
|
||||
.priority = SHUTDOWN_ON_PANIC_PRIO
|
||||
};
|
||||
|
||||
static int __init dump_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = firmware_register(&dump_subsys);
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = subsys_create_file(&dump_subsys, &dump_type_attr);
|
||||
if (rc) {
|
||||
firmware_unregister(&dump_subsys);
|
||||
return rc;
|
||||
}
|
||||
rc = dump_ccw_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = dump_fcp_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
dump_set_type(IPL_TYPE_NONE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init shutdown_actions_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = firmware_register(&shutdown_actions_subsys);
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = subsys_create_file(&shutdown_actions_subsys, &on_panic_attr);
|
||||
if (rc) {
|
||||
firmware_unregister(&shutdown_actions_subsys);
|
||||
return rc;
|
||||
}
|
||||
atomic_notifier_chain_register(&panic_notifier_list,
|
||||
&shutdown_on_panic_nb);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init s390_ipl_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
reipl_probe();
|
||||
rc = ipl_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = reipl_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = dump_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
rc = shutdown_actions_init();
|
||||
if (rc)
|
||||
return rc;
|
||||
return 0;
|
||||
}
|
||||
|
||||
__initcall(s390_ipl_init);
|
657
arch/s390/kernel/kprobes.c
Normal file
657
arch/s390/kernel/kprobes.c
Normal file
@ -0,0 +1,657 @@
|
||||
/*
|
||||
* Kernel Probes (KProbes)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* Copyright (C) IBM Corporation, 2002, 2006
|
||||
*
|
||||
* s390 port, used ppc64 as template. Mike Grundy <grundym@us.ibm.com>
|
||||
*/
|
||||
|
||||
#include <linux/config.h>
|
||||
#include <linux/kprobes.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/preempt.h>
|
||||
#include <linux/stop_machine.h>
|
||||
#include <asm/cacheflush.h>
|
||||
#include <asm/kdebug.h>
|
||||
#include <asm/sections.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <linux/module.h>
|
||||
|
||||
DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
|
||||
DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
|
||||
|
||||
int __kprobes arch_prepare_kprobe(struct kprobe *p)
|
||||
{
|
||||
/* Make sure the probe isn't going on a difficult instruction */
|
||||
if (is_prohibited_opcode((kprobe_opcode_t *) p->addr))
|
||||
return -EINVAL;
|
||||
|
||||
if ((unsigned long)p->addr & 0x01) {
|
||||
printk("Attempt to register kprobe at an unaligned address\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Use the get_insn_slot() facility for correctness */
|
||||
if (!(p->ainsn.insn = get_insn_slot()))
|
||||
return -ENOMEM;
|
||||
|
||||
memcpy(p->ainsn.insn, p->addr, MAX_INSN_SIZE * sizeof(kprobe_opcode_t));
|
||||
|
||||
get_instruction_type(&p->ainsn);
|
||||
p->opcode = *p->addr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int __kprobes is_prohibited_opcode(kprobe_opcode_t *instruction)
|
||||
{
|
||||
switch (*(__u8 *) instruction) {
|
||||
case 0x0c: /* bassm */
|
||||
case 0x0b: /* bsm */
|
||||
case 0x83: /* diag */
|
||||
case 0x44: /* ex */
|
||||
return -EINVAL;
|
||||
}
|
||||
switch (*(__u16 *) instruction) {
|
||||
case 0x0101: /* pr */
|
||||
case 0xb25a: /* bsa */
|
||||
case 0xb240: /* bakr */
|
||||
case 0xb258: /* bsg */
|
||||
case 0xb218: /* pc */
|
||||
case 0xb228: /* pt */
|
||||
return -EINVAL;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __kprobes get_instruction_type(struct arch_specific_insn *ainsn)
|
||||
{
|
||||
/* default fixup method */
|
||||
ainsn->fixup = FIXUP_PSW_NORMAL;
|
||||
|
||||
/* save r1 operand */
|
||||
ainsn->reg = (*ainsn->insn & 0xf0) >> 4;
|
||||
|
||||
/* save the instruction length (pop 5-5) in bytes */
|
||||
switch (*(__u8 *) (ainsn->insn) >> 4) {
|
||||
case 0:
|
||||
ainsn->ilen = 2;
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
ainsn->ilen = 4;
|
||||
break;
|
||||
case 3:
|
||||
ainsn->ilen = 6;
|
||||
break;
|
||||
}
|
||||
|
||||
switch (*(__u8 *) ainsn->insn) {
|
||||
case 0x05: /* balr */
|
||||
case 0x0d: /* basr */
|
||||
ainsn->fixup = FIXUP_RETURN_REGISTER;
|
||||
/* if r2 = 0, no branch will be taken */
|
||||
if ((*ainsn->insn & 0x0f) == 0)
|
||||
ainsn->fixup |= FIXUP_BRANCH_NOT_TAKEN;
|
||||
break;
|
||||
case 0x06: /* bctr */
|
||||
case 0x07: /* bcr */
|
||||
ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
|
||||
break;
|
||||
case 0x45: /* bal */
|
||||
case 0x4d: /* bas */
|
||||
ainsn->fixup = FIXUP_RETURN_REGISTER;
|
||||
break;
|
||||
case 0x47: /* bc */
|
||||
case 0x46: /* bct */
|
||||
case 0x86: /* bxh */
|
||||
case 0x87: /* bxle */
|
||||
ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
|
||||
break;
|
||||
case 0x82: /* lpsw */
|
||||
ainsn->fixup = FIXUP_NOT_REQUIRED;
|
||||
break;
|
||||
case 0xb2: /* lpswe */
|
||||
if (*(((__u8 *) ainsn->insn) + 1) == 0xb2) {
|
||||
ainsn->fixup = FIXUP_NOT_REQUIRED;
|
||||
}
|
||||
break;
|
||||
case 0xa7: /* bras */
|
||||
if ((*ainsn->insn & 0x0f) == 0x05) {
|
||||
ainsn->fixup |= FIXUP_RETURN_REGISTER;
|
||||
}
|
||||
break;
|
||||
case 0xc0:
|
||||
if ((*ainsn->insn & 0x0f) == 0x00 /* larl */
|
||||
|| (*ainsn->insn & 0x0f) == 0x05) /* brasl */
|
||||
ainsn->fixup |= FIXUP_RETURN_REGISTER;
|
||||
break;
|
||||
case 0xeb:
|
||||
if (*(((__u8 *) ainsn->insn) + 5 ) == 0x44 || /* bxhg */
|
||||
*(((__u8 *) ainsn->insn) + 5) == 0x45) {/* bxleg */
|
||||
ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
|
||||
}
|
||||
break;
|
||||
case 0xe3: /* bctg */
|
||||
if (*(((__u8 *) ainsn->insn) + 5) == 0x46) {
|
||||
ainsn->fixup = FIXUP_BRANCH_NOT_TAKEN;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int __kprobes swap_instruction(void *aref)
|
||||
{
|
||||
struct ins_replace_args *args = aref;
|
||||
int err = -EFAULT;
|
||||
|
||||
asm volatile(
|
||||
"0: mvc 0(2,%2),0(%3)\n"
|
||||
"1: la %0,0\n"
|
||||
"2:\n"
|
||||
EX_TABLE(0b,2b)
|
||||
: "+d" (err), "=m" (*args->ptr)
|
||||
: "a" (args->ptr), "a" (&args->new), "m" (args->new));
|
||||
return err;
|
||||
}
|
||||
|
||||
void __kprobes arch_arm_kprobe(struct kprobe *p)
|
||||
{
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
unsigned long status = kcb->kprobe_status;
|
||||
struct ins_replace_args args;
|
||||
|
||||
args.ptr = p->addr;
|
||||
args.old = p->opcode;
|
||||
args.new = BREAKPOINT_INSTRUCTION;
|
||||
|
||||
kcb->kprobe_status = KPROBE_SWAP_INST;
|
||||
stop_machine_run(swap_instruction, &args, NR_CPUS);
|
||||
kcb->kprobe_status = status;
|
||||
}
|
||||
|
||||
void __kprobes arch_disarm_kprobe(struct kprobe *p)
|
||||
{
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
unsigned long status = kcb->kprobe_status;
|
||||
struct ins_replace_args args;
|
||||
|
||||
args.ptr = p->addr;
|
||||
args.old = BREAKPOINT_INSTRUCTION;
|
||||
args.new = p->opcode;
|
||||
|
||||
kcb->kprobe_status = KPROBE_SWAP_INST;
|
||||
stop_machine_run(swap_instruction, &args, NR_CPUS);
|
||||
kcb->kprobe_status = status;
|
||||
}
|
||||
|
||||
void __kprobes arch_remove_kprobe(struct kprobe *p)
|
||||
{
|
||||
mutex_lock(&kprobe_mutex);
|
||||
free_insn_slot(p->ainsn.insn);
|
||||
mutex_unlock(&kprobe_mutex);
|
||||
}
|
||||
|
||||
static void __kprobes prepare_singlestep(struct kprobe *p, struct pt_regs *regs)
|
||||
{
|
||||
per_cr_bits kprobe_per_regs[1];
|
||||
|
||||
memset(kprobe_per_regs, 0, sizeof(per_cr_bits));
|
||||
regs->psw.addr = (unsigned long)p->ainsn.insn | PSW_ADDR_AMODE;
|
||||
|
||||
/* Set up the per control reg info, will pass to lctl */
|
||||
kprobe_per_regs[0].em_instruction_fetch = 1;
|
||||
kprobe_per_regs[0].starting_addr = (unsigned long)p->ainsn.insn;
|
||||
kprobe_per_regs[0].ending_addr = (unsigned long)p->ainsn.insn + 1;
|
||||
|
||||
/* Set the PER control regs, turns on single step for this address */
|
||||
__ctl_load(kprobe_per_regs, 9, 11);
|
||||
regs->psw.mask |= PSW_MASK_PER;
|
||||
regs->psw.mask &= ~(PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK);
|
||||
}
|
||||
|
||||
static void __kprobes save_previous_kprobe(struct kprobe_ctlblk *kcb)
|
||||
{
|
||||
kcb->prev_kprobe.kp = kprobe_running();
|
||||
kcb->prev_kprobe.status = kcb->kprobe_status;
|
||||
kcb->prev_kprobe.kprobe_saved_imask = kcb->kprobe_saved_imask;
|
||||
memcpy(kcb->prev_kprobe.kprobe_saved_ctl, kcb->kprobe_saved_ctl,
|
||||
sizeof(kcb->kprobe_saved_ctl));
|
||||
}
|
||||
|
||||
static void __kprobes restore_previous_kprobe(struct kprobe_ctlblk *kcb)
|
||||
{
|
||||
__get_cpu_var(current_kprobe) = kcb->prev_kprobe.kp;
|
||||
kcb->kprobe_status = kcb->prev_kprobe.status;
|
||||
kcb->kprobe_saved_imask = kcb->prev_kprobe.kprobe_saved_imask;
|
||||
memcpy(kcb->kprobe_saved_ctl, kcb->prev_kprobe.kprobe_saved_ctl,
|
||||
sizeof(kcb->kprobe_saved_ctl));
|
||||
}
|
||||
|
||||
static void __kprobes set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
|
||||
struct kprobe_ctlblk *kcb)
|
||||
{
|
||||
__get_cpu_var(current_kprobe) = p;
|
||||
/* Save the interrupt and per flags */
|
||||
kcb->kprobe_saved_imask = regs->psw.mask &
|
||||
(PSW_MASK_PER | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK);
|
||||
/* Save the control regs that govern PER */
|
||||
__ctl_store(kcb->kprobe_saved_ctl, 9, 11);
|
||||
}
|
||||
|
||||
/* Called with kretprobe_lock held */
|
||||
void __kprobes arch_prepare_kretprobe(struct kretprobe *rp,
|
||||
struct pt_regs *regs)
|
||||
{
|
||||
struct kretprobe_instance *ri;
|
||||
|
||||
if ((ri = get_free_rp_inst(rp)) != NULL) {
|
||||
ri->rp = rp;
|
||||
ri->task = current;
|
||||
ri->ret_addr = (kprobe_opcode_t *) regs->gprs[14];
|
||||
|
||||
/* Replace the return addr with trampoline addr */
|
||||
regs->gprs[14] = (unsigned long)&kretprobe_trampoline;
|
||||
|
||||
add_rp_inst(ri);
|
||||
} else {
|
||||
rp->nmissed++;
|
||||
}
|
||||
}
|
||||
|
||||
static int __kprobes kprobe_handler(struct pt_regs *regs)
|
||||
{
|
||||
struct kprobe *p;
|
||||
int ret = 0;
|
||||
unsigned long *addr = (unsigned long *)
|
||||
((regs->psw.addr & PSW_ADDR_INSN) - 2);
|
||||
struct kprobe_ctlblk *kcb;
|
||||
|
||||
/*
|
||||
* We don't want to be preempted for the entire
|
||||
* duration of kprobe processing
|
||||
*/
|
||||
preempt_disable();
|
||||
kcb = get_kprobe_ctlblk();
|
||||
|
||||
/* Check we're not actually recursing */
|
||||
if (kprobe_running()) {
|
||||
p = get_kprobe(addr);
|
||||
if (p) {
|
||||
if (kcb->kprobe_status == KPROBE_HIT_SS &&
|
||||
*p->ainsn.insn == BREAKPOINT_INSTRUCTION) {
|
||||
regs->psw.mask &= ~PSW_MASK_PER;
|
||||
regs->psw.mask |= kcb->kprobe_saved_imask;
|
||||
goto no_kprobe;
|
||||
}
|
||||
/* We have reentered the kprobe_handler(), since
|
||||
* another probe was hit while within the handler.
|
||||
* We here save the original kprobes variables and
|
||||
* just single step on the instruction of the new probe
|
||||
* without calling any user handlers.
|
||||
*/
|
||||
save_previous_kprobe(kcb);
|
||||
set_current_kprobe(p, regs, kcb);
|
||||
kprobes_inc_nmissed_count(p);
|
||||
prepare_singlestep(p, regs);
|
||||
kcb->kprobe_status = KPROBE_REENTER;
|
||||
return 1;
|
||||
} else {
|
||||
p = __get_cpu_var(current_kprobe);
|
||||
if (p->break_handler && p->break_handler(p, regs)) {
|
||||
goto ss_probe;
|
||||
}
|
||||
}
|
||||
goto no_kprobe;
|
||||
}
|
||||
|
||||
p = get_kprobe(addr);
|
||||
if (!p) {
|
||||
if (*addr != BREAKPOINT_INSTRUCTION) {
|
||||
/*
|
||||
* The breakpoint instruction was removed right
|
||||
* after we hit it. Another cpu has removed
|
||||
* either a probepoint or a debugger breakpoint
|
||||
* at this address. In either case, no further
|
||||
* handling of this interrupt is appropriate.
|
||||
*
|
||||
*/
|
||||
ret = 1;
|
||||
}
|
||||
/* Not one of ours: let kernel handle it */
|
||||
goto no_kprobe;
|
||||
}
|
||||
|
||||
kcb->kprobe_status = KPROBE_HIT_ACTIVE;
|
||||
set_current_kprobe(p, regs, kcb);
|
||||
if (p->pre_handler && p->pre_handler(p, regs))
|
||||
/* handler has already set things up, so skip ss setup */
|
||||
return 1;
|
||||
|
||||
ss_probe:
|
||||
prepare_singlestep(p, regs);
|
||||
kcb->kprobe_status = KPROBE_HIT_SS;
|
||||
return 1;
|
||||
|
||||
no_kprobe:
|
||||
preempt_enable_no_resched();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* Function return probe trampoline:
|
||||
* - init_kprobes() establishes a probepoint here
|
||||
* - When the probed function returns, this probe
|
||||
* causes the handlers to fire
|
||||
*/
|
||||
void __kprobes kretprobe_trampoline_holder(void)
|
||||
{
|
||||
asm volatile(".global kretprobe_trampoline\n"
|
||||
"kretprobe_trampoline: bcr 0,0\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* Called when the probe at kretprobe trampoline is hit
|
||||
*/
|
||||
int __kprobes trampoline_probe_handler(struct kprobe *p, struct pt_regs *regs)
|
||||
{
|
||||
struct kretprobe_instance *ri = NULL;
|
||||
struct hlist_head *head;
|
||||
struct hlist_node *node, *tmp;
|
||||
unsigned long flags, orig_ret_address = 0;
|
||||
unsigned long trampoline_address = (unsigned long)&kretprobe_trampoline;
|
||||
|
||||
spin_lock_irqsave(&kretprobe_lock, flags);
|
||||
head = kretprobe_inst_table_head(current);
|
||||
|
||||
/*
|
||||
* It is possible to have multiple instances associated with a given
|
||||
* task either because an multiple functions in the call path
|
||||
* have a return probe installed on them, and/or more then one return
|
||||
* return probe was registered for a target function.
|
||||
*
|
||||
* We can handle this because:
|
||||
* - instances are always inserted at the head of the list
|
||||
* - when multiple return probes are registered for the same
|
||||
* function, the first instance's ret_addr will point to the
|
||||
* real return address, and all the rest will point to
|
||||
* kretprobe_trampoline
|
||||
*/
|
||||
hlist_for_each_entry_safe(ri, node, tmp, head, hlist) {
|
||||
if (ri->task != current)
|
||||
/* another task is sharing our hash bucket */
|
||||
continue;
|
||||
|
||||
if (ri->rp && ri->rp->handler)
|
||||
ri->rp->handler(ri, regs);
|
||||
|
||||
orig_ret_address = (unsigned long)ri->ret_addr;
|
||||
recycle_rp_inst(ri);
|
||||
|
||||
if (orig_ret_address != trampoline_address) {
|
||||
/*
|
||||
* This is the real return address. Any other
|
||||
* instances associated with this task are for
|
||||
* other calls deeper on the call stack
|
||||
*/
|
||||
break;
|
||||
}
|
||||
}
|
||||
BUG_ON(!orig_ret_address || (orig_ret_address == trampoline_address));
|
||||
regs->psw.addr = orig_ret_address | PSW_ADDR_AMODE;
|
||||
|
||||
reset_current_kprobe();
|
||||
spin_unlock_irqrestore(&kretprobe_lock, flags);
|
||||
preempt_enable_no_resched();
|
||||
|
||||
/*
|
||||
* By returning a non-zero value, we are telling
|
||||
* kprobe_handler() that we don't want the post_handler
|
||||
* to run (and have re-enabled preemption)
|
||||
*/
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Called after single-stepping. p->addr is the address of the
|
||||
* instruction whose first byte has been replaced by the "breakpoint"
|
||||
* instruction. To avoid the SMP problems that can occur when we
|
||||
* temporarily put back the original opcode to single-step, we
|
||||
* single-stepped a copy of the instruction. The address of this
|
||||
* copy is p->ainsn.insn.
|
||||
*/
|
||||
static void __kprobes resume_execution(struct kprobe *p, struct pt_regs *regs)
|
||||
{
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
|
||||
regs->psw.addr &= PSW_ADDR_INSN;
|
||||
|
||||
if (p->ainsn.fixup & FIXUP_PSW_NORMAL)
|
||||
regs->psw.addr = (unsigned long)p->addr +
|
||||
((unsigned long)regs->psw.addr -
|
||||
(unsigned long)p->ainsn.insn);
|
||||
|
||||
if (p->ainsn.fixup & FIXUP_BRANCH_NOT_TAKEN)
|
||||
if ((unsigned long)regs->psw.addr -
|
||||
(unsigned long)p->ainsn.insn == p->ainsn.ilen)
|
||||
regs->psw.addr = (unsigned long)p->addr + p->ainsn.ilen;
|
||||
|
||||
if (p->ainsn.fixup & FIXUP_RETURN_REGISTER)
|
||||
regs->gprs[p->ainsn.reg] = ((unsigned long)p->addr +
|
||||
(regs->gprs[p->ainsn.reg] -
|
||||
(unsigned long)p->ainsn.insn))
|
||||
| PSW_ADDR_AMODE;
|
||||
|
||||
regs->psw.addr |= PSW_ADDR_AMODE;
|
||||
/* turn off PER mode */
|
||||
regs->psw.mask &= ~PSW_MASK_PER;
|
||||
/* Restore the original per control regs */
|
||||
__ctl_load(kcb->kprobe_saved_ctl, 9, 11);
|
||||
regs->psw.mask |= kcb->kprobe_saved_imask;
|
||||
}
|
||||
|
||||
static int __kprobes post_kprobe_handler(struct pt_regs *regs)
|
||||
{
|
||||
struct kprobe *cur = kprobe_running();
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
|
||||
if (!cur)
|
||||
return 0;
|
||||
|
||||
if ((kcb->kprobe_status != KPROBE_REENTER) && cur->post_handler) {
|
||||
kcb->kprobe_status = KPROBE_HIT_SSDONE;
|
||||
cur->post_handler(cur, regs, 0);
|
||||
}
|
||||
|
||||
resume_execution(cur, regs);
|
||||
|
||||
/*Restore back the original saved kprobes variables and continue. */
|
||||
if (kcb->kprobe_status == KPROBE_REENTER) {
|
||||
restore_previous_kprobe(kcb);
|
||||
goto out;
|
||||
}
|
||||
reset_current_kprobe();
|
||||
out:
|
||||
preempt_enable_no_resched();
|
||||
|
||||
/*
|
||||
* if somebody else is singlestepping across a probe point, psw mask
|
||||
* will have PER set, in which case, continue the remaining processing
|
||||
* of do_single_step, as if this is not a probe hit.
|
||||
*/
|
||||
if (regs->psw.mask & PSW_MASK_PER) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int __kprobes kprobe_fault_handler(struct pt_regs *regs, int trapnr)
|
||||
{
|
||||
struct kprobe *cur = kprobe_running();
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
const struct exception_table_entry *entry;
|
||||
|
||||
switch(kcb->kprobe_status) {
|
||||
case KPROBE_SWAP_INST:
|
||||
/* We are here because the instruction replacement failed */
|
||||
return 0;
|
||||
case KPROBE_HIT_SS:
|
||||
case KPROBE_REENTER:
|
||||
/*
|
||||
* We are here because the instruction being single
|
||||
* stepped caused a page fault. We reset the current
|
||||
* kprobe and the nip points back to the probe address
|
||||
* and allow the page fault handler to continue as a
|
||||
* normal page fault.
|
||||
*/
|
||||
regs->psw.addr = (unsigned long)cur->addr | PSW_ADDR_AMODE;
|
||||
regs->psw.mask &= ~PSW_MASK_PER;
|
||||
regs->psw.mask |= kcb->kprobe_saved_imask;
|
||||
if (kcb->kprobe_status == KPROBE_REENTER)
|
||||
restore_previous_kprobe(kcb);
|
||||
else
|
||||
reset_current_kprobe();
|
||||
preempt_enable_no_resched();
|
||||
break;
|
||||
case KPROBE_HIT_ACTIVE:
|
||||
case KPROBE_HIT_SSDONE:
|
||||
/*
|
||||
* We increment the nmissed count for accounting,
|
||||
* we can also use npre/npostfault count for accouting
|
||||
* these specific fault cases.
|
||||
*/
|
||||
kprobes_inc_nmissed_count(cur);
|
||||
|
||||
/*
|
||||
* We come here because instructions in the pre/post
|
||||
* handler caused the page_fault, this could happen
|
||||
* if handler tries to access user space by
|
||||
* copy_from_user(), get_user() etc. Let the
|
||||
* user-specified handler try to fix it first.
|
||||
*/
|
||||
if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
|
||||
return 1;
|
||||
|
||||
/*
|
||||
* In case the user-specified fault handler returned
|
||||
* zero, try to fix up.
|
||||
*/
|
||||
entry = search_exception_tables(regs->psw.addr & PSW_ADDR_INSN);
|
||||
if (entry) {
|
||||
regs->psw.addr = entry->fixup | PSW_ADDR_AMODE;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* fixup_exception() could not handle it,
|
||||
* Let do_page_fault() fix it.
|
||||
*/
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Wrapper routine to for handling exceptions.
|
||||
*/
|
||||
int __kprobes kprobe_exceptions_notify(struct notifier_block *self,
|
||||
unsigned long val, void *data)
|
||||
{
|
||||
struct die_args *args = (struct die_args *)data;
|
||||
int ret = NOTIFY_DONE;
|
||||
|
||||
switch (val) {
|
||||
case DIE_BPT:
|
||||
if (kprobe_handler(args->regs))
|
||||
ret = NOTIFY_STOP;
|
||||
break;
|
||||
case DIE_SSTEP:
|
||||
if (post_kprobe_handler(args->regs))
|
||||
ret = NOTIFY_STOP;
|
||||
break;
|
||||
case DIE_TRAP:
|
||||
case DIE_PAGE_FAULT:
|
||||
/* kprobe_running() needs smp_processor_id() */
|
||||
preempt_disable();
|
||||
if (kprobe_running() &&
|
||||
kprobe_fault_handler(args->regs, args->trapnr))
|
||||
ret = NOTIFY_STOP;
|
||||
preempt_enable();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int __kprobes setjmp_pre_handler(struct kprobe *p, struct pt_regs *regs)
|
||||
{
|
||||
struct jprobe *jp = container_of(p, struct jprobe, kp);
|
||||
unsigned long addr;
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
|
||||
memcpy(&kcb->jprobe_saved_regs, regs, sizeof(struct pt_regs));
|
||||
|
||||
/* setup return addr to the jprobe handler routine */
|
||||
regs->psw.addr = (unsigned long)(jp->entry) | PSW_ADDR_AMODE;
|
||||
|
||||
/* r14 is the function return address */
|
||||
kcb->jprobe_saved_r14 = (unsigned long)regs->gprs[14];
|
||||
/* r15 is the stack pointer */
|
||||
kcb->jprobe_saved_r15 = (unsigned long)regs->gprs[15];
|
||||
addr = (unsigned long)kcb->jprobe_saved_r15;
|
||||
|
||||
memcpy(kcb->jprobes_stack, (kprobe_opcode_t *) addr,
|
||||
MIN_STACK_SIZE(addr));
|
||||
return 1;
|
||||
}
|
||||
|
||||
void __kprobes jprobe_return(void)
|
||||
{
|
||||
asm volatile(".word 0x0002");
|
||||
}
|
||||
|
||||
void __kprobes jprobe_return_end(void)
|
||||
{
|
||||
asm volatile("bcr 0,0");
|
||||
}
|
||||
|
||||
int __kprobes longjmp_break_handler(struct kprobe *p, struct pt_regs *regs)
|
||||
{
|
||||
struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
|
||||
unsigned long stack_addr = (unsigned long)(kcb->jprobe_saved_r15);
|
||||
|
||||
/* Put the regs back */
|
||||
memcpy(regs, &kcb->jprobe_saved_regs, sizeof(struct pt_regs));
|
||||
/* put the stack back */
|
||||
memcpy((kprobe_opcode_t *) stack_addr, kcb->jprobes_stack,
|
||||
MIN_STACK_SIZE(stack_addr));
|
||||
preempt_enable_no_resched();
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct kprobe trampoline_p = {
|
||||
.addr = (kprobe_opcode_t *) & kretprobe_trampoline,
|
||||
.pre_handler = trampoline_probe_handler
|
||||
};
|
||||
|
||||
int __init arch_init_kprobes(void)
|
||||
{
|
||||
return register_kprobe(&trampoline_p);
|
||||
}
|
@ -8,13 +8,30 @@
|
||||
|
||||
#include <asm/lowcore.h>
|
||||
|
||||
.globl do_reipl
|
||||
do_reipl: basr %r13,0
|
||||
.globl do_reipl_asm
|
||||
do_reipl_asm: basr %r13,0
|
||||
.Lpg0: lpsw .Lnewpsw-.Lpg0(%r13)
|
||||
.Lpg1: lctl %c6,%c6,.Lall-.Lpg0(%r13)
|
||||
stctl %c0,%c0,.Lctlsave-.Lpg0(%r13)
|
||||
ni .Lctlsave-.Lpg0(%r13),0xef
|
||||
lctl %c0,%c0,.Lctlsave-.Lpg0(%r13)
|
||||
|
||||
# switch off lowcore protection
|
||||
|
||||
.Lpg1: stctl %c0,%c0,.Lctlsave1-.Lpg0(%r13)
|
||||
stctl %c0,%c0,.Lctlsave2-.Lpg0(%r13)
|
||||
ni .Lctlsave1-.Lpg0(%r13),0xef
|
||||
lctl %c0,%c0,.Lctlsave1-.Lpg0(%r13)
|
||||
|
||||
# do store status of all registers
|
||||
|
||||
stm %r0,%r15,__LC_GPREGS_SAVE_AREA
|
||||
stctl %c0,%c15,__LC_CREGS_SAVE_AREA
|
||||
mvc __LC_CREGS_SAVE_AREA(4),.Lctlsave2-.Lpg0(%r13)
|
||||
stam %a0,%a15,__LC_AREGS_SAVE_AREA
|
||||
stpx __LC_PREFIX_SAVE_AREA
|
||||
stckc .Lclkcmp-.Lpg0(%r13)
|
||||
mvc __LC_CLOCK_COMP_SAVE_AREA(8),.Lclkcmp-.Lpg0(%r13)
|
||||
stpt __LC_CPU_TIMER_SAVE_AREA
|
||||
st %r13, __LC_PSW_SAVE_AREA+4
|
||||
|
||||
lctl %c6,%c6,.Lall-.Lpg0(%r13)
|
||||
lr %r1,%r2
|
||||
mvc __LC_PGM_NEW_PSW(8),.Lpcnew-.Lpg0(%r13)
|
||||
stsch .Lschib-.Lpg0(%r13)
|
||||
@ -46,9 +63,11 @@ do_reipl: basr %r13,0
|
||||
.Ldisab: st %r14,.Ldispsw+4-.Lpg0(%r13)
|
||||
lpsw .Ldispsw-.Lpg0(%r13)
|
||||
.align 8
|
||||
.Lclkcmp: .quad 0x0000000000000000
|
||||
.Lall: .long 0xff000000
|
||||
.Lnull: .long 0x00000000
|
||||
.Lctlsave: .long 0x00000000
|
||||
.Lctlsave1: .long 0x00000000
|
||||
.Lctlsave2: .long 0x00000000
|
||||
.align 8
|
||||
.Lnewpsw: .long 0x00080000,0x80000000+.Lpg1
|
||||
.Lpcnew: .long 0x00080000,0x80000000+.Lecs
|
||||
|
@ -8,13 +8,30 @@
|
||||
*/
|
||||
|
||||
#include <asm/lowcore.h>
|
||||
.globl do_reipl
|
||||
do_reipl: basr %r13,0
|
||||
.Lpg0: lpswe .Lnewpsw-.Lpg0(%r13)
|
||||
.globl do_reipl_asm
|
||||
do_reipl_asm: basr %r13,0
|
||||
|
||||
# do store status of all registers
|
||||
|
||||
.Lpg0: stg %r1,.Lregsave-.Lpg0(%r13)
|
||||
lghi %r1,0x1000
|
||||
stmg %r0,%r15,__LC_GPREGS_SAVE_AREA-0x1000(%r1)
|
||||
lg %r0,.Lregsave-.Lpg0(%r13)
|
||||
stg %r0,__LC_GPREGS_SAVE_AREA-0x1000+8(%r1)
|
||||
stctg %c0,%c15,__LC_CREGS_SAVE_AREA-0x1000(%r1)
|
||||
stam %a0,%a15,__LC_AREGS_SAVE_AREA-0x1000(%r1)
|
||||
stpx __LC_PREFIX_SAVE_AREA-0x1000(%r1)
|
||||
stfpc __LC_FP_CREG_SAVE_AREA-0x1000(%r1)
|
||||
stckc .Lclkcmp-.Lpg0(%r13)
|
||||
mvc __LC_CLOCK_COMP_SAVE_AREA-0x1000(8,%r1),.Lclkcmp-.Lpg0(%r13)
|
||||
stpt __LC_CPU_TIMER_SAVE_AREA-0x1000(%r1)
|
||||
stg %r13, __LC_PSW_SAVE_AREA-0x1000+8(%r1)
|
||||
|
||||
lpswe .Lnewpsw-.Lpg0(%r13)
|
||||
.Lpg1: lctlg %c6,%c6,.Lall-.Lpg0(%r13)
|
||||
stctg %c0,%c0,.Lctlsave-.Lpg0(%r13)
|
||||
ni .Lctlsave+4-.Lpg0(%r13),0xef
|
||||
lctlg %c0,%c0,.Lctlsave-.Lpg0(%r13)
|
||||
stctg %c0,%c0,.Lregsave-.Lpg0(%r13)
|
||||
ni .Lregsave+4-.Lpg0(%r13),0xef
|
||||
lctlg %c0,%c0,.Lregsave-.Lpg0(%r13)
|
||||
lgr %r1,%r2
|
||||
mvc __LC_PGM_NEW_PSW(16),.Lpcnew-.Lpg0(%r13)
|
||||
stsch .Lschib-.Lpg0(%r13)
|
||||
@ -50,8 +67,9 @@ do_reipl: basr %r13,0
|
||||
st %r14,.Ldispsw+12-.Lpg0(%r13)
|
||||
lpswe .Ldispsw-.Lpg0(%r13)
|
||||
.align 8
|
||||
.Lclkcmp: .quad 0x0000000000000000
|
||||
.Lall: .quad 0x00000000ff000000
|
||||
.Lctlsave: .quad 0x0000000000000000
|
||||
.Lregsave: .quad 0x0000000000000000
|
||||
.Lnull: .long 0x0000000000000000
|
||||
.align 16
|
||||
/*
|
||||
@ -92,5 +110,3 @@ do_reipl: basr %r13,0
|
||||
.long 0x00000000,0x00000000
|
||||
.long 0x00000000,0x00000000
|
||||
|
||||
|
||||
|
||||
|
@ -1,39 +0,0 @@
|
||||
/*
|
||||
* This file contains the implementation of the
|
||||
* Linux re-IPL support
|
||||
*
|
||||
* (C) Copyright IBM Corp. 2005
|
||||
*
|
||||
* Author(s): Volker Sameske (sameske@de.ibm.com)
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/kernel.h>
|
||||
|
||||
static unsigned int reipl_diag_rc1;
|
||||
static unsigned int reipl_diag_rc2;
|
||||
|
||||
/*
|
||||
* re-IPL the system using the last used IPL parameters
|
||||
*/
|
||||
void reipl_diag(void)
|
||||
{
|
||||
asm volatile (
|
||||
" la %%r4,0\n"
|
||||
" la %%r5,0\n"
|
||||
" diag %%r4,%2,0x308\n"
|
||||
"0:\n"
|
||||
" st %%r4,%0\n"
|
||||
" st %%r5,%1\n"
|
||||
".section __ex_table,\"a\"\n"
|
||||
#ifdef CONFIG_64BIT
|
||||
" .align 8\n"
|
||||
" .quad 0b, 0b\n"
|
||||
#else
|
||||
" .align 4\n"
|
||||
" .long 0b, 0b\n"
|
||||
#endif
|
||||
".previous\n"
|
||||
: "=m" (reipl_diag_rc1), "=m" (reipl_diag_rc2)
|
||||
: "d" (3) : "cc", "4", "5" );
|
||||
}
|
@ -25,12 +25,6 @@ EXPORT_SYMBOL(_oi_bitmap);
|
||||
EXPORT_SYMBOL(_ni_bitmap);
|
||||
EXPORT_SYMBOL(_zb_findmap);
|
||||
EXPORT_SYMBOL(_sb_findmap);
|
||||
EXPORT_SYMBOL(__copy_from_user_asm);
|
||||
EXPORT_SYMBOL(__copy_to_user_asm);
|
||||
EXPORT_SYMBOL(__copy_in_user_asm);
|
||||
EXPORT_SYMBOL(__clear_user_asm);
|
||||
EXPORT_SYMBOL(__strncpy_from_user_asm);
|
||||
EXPORT_SYMBOL(__strnlen_user_asm);
|
||||
EXPORT_SYMBOL(diag10);
|
||||
|
||||
/*
|
||||
|
@ -37,6 +37,7 @@
|
||||
#include <linux/kernel_stat.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/notifier.h>
|
||||
#include <linux/pfn.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/system.h>
|
||||
@ -49,6 +50,12 @@
|
||||
#include <asm/ptrace.h>
|
||||
#include <asm/sections.h>
|
||||
|
||||
/*
|
||||
* User copy operations.
|
||||
*/
|
||||
struct uaccess_ops uaccess;
|
||||
EXPORT_SYMBOL_GPL(uaccess);
|
||||
|
||||
/*
|
||||
* Machine setup..
|
||||
*/
|
||||
@ -284,16 +291,9 @@ void (*_machine_power_off)(void) = machine_power_off_smp;
|
||||
/*
|
||||
* Reboot, halt and power_off routines for non SMP.
|
||||
*/
|
||||
extern void reipl(unsigned long devno);
|
||||
extern void reipl_diag(void);
|
||||
static void do_machine_restart_nonsmp(char * __unused)
|
||||
{
|
||||
reipl_diag();
|
||||
|
||||
if (MACHINE_IS_VM)
|
||||
cpcmd ("IPL", NULL, 0, NULL);
|
||||
else
|
||||
reipl (0x10000 | S390_lowcore.ipl_device);
|
||||
do_reipl();
|
||||
}
|
||||
|
||||
static void do_machine_halt_nonsmp(void)
|
||||
@ -501,13 +501,47 @@ setup_memory(void)
|
||||
* partially used pages are not usable - thus
|
||||
* we are rounding upwards:
|
||||
*/
|
||||
start_pfn = (__pa(&_end) + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
||||
end_pfn = max_pfn = memory_end >> PAGE_SHIFT;
|
||||
start_pfn = PFN_UP(__pa(&_end));
|
||||
end_pfn = max_pfn = PFN_DOWN(memory_end);
|
||||
|
||||
/* Initialize storage key for kernel pages */
|
||||
for (init_pfn = 0 ; init_pfn < start_pfn; init_pfn++)
|
||||
page_set_storage_key(init_pfn << PAGE_SHIFT, PAGE_DEFAULT_KEY);
|
||||
|
||||
#ifdef CONFIG_BLK_DEV_INITRD
|
||||
/*
|
||||
* Move the initrd in case the bitmap of the bootmem allocater
|
||||
* would overwrite it.
|
||||
*/
|
||||
|
||||
if (INITRD_START && INITRD_SIZE) {
|
||||
unsigned long bmap_size;
|
||||
unsigned long start;
|
||||
|
||||
bmap_size = bootmem_bootmap_pages(end_pfn - start_pfn + 1);
|
||||
bmap_size = PFN_PHYS(bmap_size);
|
||||
|
||||
if (PFN_PHYS(start_pfn) + bmap_size > INITRD_START) {
|
||||
start = PFN_PHYS(start_pfn) + bmap_size + PAGE_SIZE;
|
||||
|
||||
if (start + INITRD_SIZE > memory_end) {
|
||||
printk("initrd extends beyond end of memory "
|
||||
"(0x%08lx > 0x%08lx)\n"
|
||||
"disabling initrd\n",
|
||||
start + INITRD_SIZE, memory_end);
|
||||
INITRD_START = INITRD_SIZE = 0;
|
||||
} else {
|
||||
printk("Moving initrd (0x%08lx -> 0x%08lx, "
|
||||
"size: %ld)\n",
|
||||
INITRD_START, start, INITRD_SIZE);
|
||||
memmove((void *) start, (void *) INITRD_START,
|
||||
INITRD_SIZE);
|
||||
INITRD_START = start;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Initialize the boot-time allocator (with low memory only):
|
||||
*/
|
||||
@ -559,7 +593,7 @@ setup_memory(void)
|
||||
reserve_bootmem(start_pfn << PAGE_SHIFT, bootmap_size);
|
||||
|
||||
#ifdef CONFIG_BLK_DEV_INITRD
|
||||
if (INITRD_START) {
|
||||
if (INITRD_START && INITRD_SIZE) {
|
||||
if (INITRD_START + INITRD_SIZE <= memory_end) {
|
||||
reserve_bootmem(INITRD_START, INITRD_SIZE);
|
||||
initrd_start = INITRD_START;
|
||||
@ -613,6 +647,11 @@ setup_arch(char **cmdline_p)
|
||||
|
||||
memory_end = memory_size;
|
||||
|
||||
if (MACHINE_HAS_MVCOS)
|
||||
memcpy(&uaccess, &uaccess_mvcos, sizeof(uaccess));
|
||||
else
|
||||
memcpy(&uaccess, &uaccess_std, sizeof(uaccess));
|
||||
|
||||
parse_early_param();
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
@ -720,214 +759,3 @@ struct seq_operations cpuinfo_op = {
|
||||
.show = show_cpuinfo,
|
||||
};
|
||||
|
||||
#define DEFINE_IPL_ATTR(_name, _format, _value) \
|
||||
static ssize_t ipl_##_name##_show(struct subsystem *subsys, \
|
||||
char *page) \
|
||||
{ \
|
||||
return sprintf(page, _format, _value); \
|
||||
} \
|
||||
static struct subsys_attribute ipl_##_name##_attr = \
|
||||
__ATTR(_name, S_IRUGO, ipl_##_name##_show, NULL);
|
||||
|
||||
DEFINE_IPL_ATTR(wwpn, "0x%016llx\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->fcp.wwpn);
|
||||
DEFINE_IPL_ATTR(lun, "0x%016llx\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->fcp.lun);
|
||||
DEFINE_IPL_ATTR(bootprog, "%lld\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->fcp.bootprog);
|
||||
DEFINE_IPL_ATTR(br_lba, "%lld\n", (unsigned long long)
|
||||
IPL_PARMBLOCK_START->fcp.br_lba);
|
||||
|
||||
enum ipl_type_type {
|
||||
ipl_type_unknown,
|
||||
ipl_type_ccw,
|
||||
ipl_type_fcp,
|
||||
};
|
||||
|
||||
static enum ipl_type_type
|
||||
get_ipl_type(void)
|
||||
{
|
||||
struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
|
||||
|
||||
if (!IPL_DEVNO_VALID)
|
||||
return ipl_type_unknown;
|
||||
if (!IPL_PARMBLOCK_VALID)
|
||||
return ipl_type_ccw;
|
||||
if (ipl->hdr.header.version > IPL_MAX_SUPPORTED_VERSION)
|
||||
return ipl_type_unknown;
|
||||
if (ipl->fcp.pbt != IPL_TYPE_FCP)
|
||||
return ipl_type_unknown;
|
||||
return ipl_type_fcp;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
ipl_type_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
switch (get_ipl_type()) {
|
||||
case ipl_type_ccw:
|
||||
return sprintf(page, "ccw\n");
|
||||
case ipl_type_fcp:
|
||||
return sprintf(page, "fcp\n");
|
||||
default:
|
||||
return sprintf(page, "unknown\n");
|
||||
}
|
||||
}
|
||||
|
||||
static struct subsys_attribute ipl_type_attr = __ATTR_RO(ipl_type);
|
||||
|
||||
static ssize_t
|
||||
ipl_device_show(struct subsystem *subsys, char *page)
|
||||
{
|
||||
struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
|
||||
|
||||
switch (get_ipl_type()) {
|
||||
case ipl_type_ccw:
|
||||
return sprintf(page, "0.0.%04x\n", ipl_devno);
|
||||
case ipl_type_fcp:
|
||||
return sprintf(page, "0.0.%04x\n", ipl->fcp.devno);
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static struct subsys_attribute ipl_device_attr =
|
||||
__ATTR(device, S_IRUGO, ipl_device_show, NULL);
|
||||
|
||||
static struct attribute *ipl_fcp_attrs[] = {
|
||||
&ipl_type_attr.attr,
|
||||
&ipl_device_attr.attr,
|
||||
&ipl_wwpn_attr.attr,
|
||||
&ipl_lun_attr.attr,
|
||||
&ipl_bootprog_attr.attr,
|
||||
&ipl_br_lba_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_fcp_attr_group = {
|
||||
.attrs = ipl_fcp_attrs,
|
||||
};
|
||||
|
||||
static struct attribute *ipl_ccw_attrs[] = {
|
||||
&ipl_type_attr.attr,
|
||||
&ipl_device_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_ccw_attr_group = {
|
||||
.attrs = ipl_ccw_attrs,
|
||||
};
|
||||
|
||||
static struct attribute *ipl_unknown_attrs[] = {
|
||||
&ipl_type_attr.attr,
|
||||
NULL,
|
||||
};
|
||||
|
||||
static struct attribute_group ipl_unknown_attr_group = {
|
||||
.attrs = ipl_unknown_attrs,
|
||||
};
|
||||
|
||||
static ssize_t
|
||||
ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
|
||||
{
|
||||
unsigned int size = IPL_PARMBLOCK_SIZE;
|
||||
|
||||
if (off > size)
|
||||
return 0;
|
||||
if (off + count > size)
|
||||
count = size - off;
|
||||
|
||||
memcpy(buf, (void *) IPL_PARMBLOCK_START + off, count);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct bin_attribute ipl_parameter_attr = {
|
||||
.attr = {
|
||||
.name = "binary_parameter",
|
||||
.mode = S_IRUGO,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.size = PAGE_SIZE,
|
||||
.read = &ipl_parameter_read,
|
||||
};
|
||||
|
||||
static ssize_t
|
||||
ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off, size_t count)
|
||||
{
|
||||
unsigned int size = IPL_PARMBLOCK_START->fcp.scp_data_len;
|
||||
void *scp_data = &IPL_PARMBLOCK_START->fcp.scp_data;
|
||||
|
||||
if (off > size)
|
||||
return 0;
|
||||
if (off + count > size)
|
||||
count = size - off;
|
||||
|
||||
memcpy(buf, scp_data + off, count);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct bin_attribute ipl_scp_data_attr = {
|
||||
.attr = {
|
||||
.name = "scp_data",
|
||||
.mode = S_IRUGO,
|
||||
.owner = THIS_MODULE,
|
||||
},
|
||||
.size = PAGE_SIZE,
|
||||
.read = &ipl_scp_data_read,
|
||||
};
|
||||
|
||||
static decl_subsys(ipl, NULL, NULL);
|
||||
|
||||
static int ipl_register_fcp_files(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_fcp_attr_group);
|
||||
if (rc)
|
||||
goto out;
|
||||
rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
|
||||
&ipl_parameter_attr);
|
||||
if (rc)
|
||||
goto out_ipl_parm;
|
||||
rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
|
||||
&ipl_scp_data_attr);
|
||||
if (!rc)
|
||||
goto out;
|
||||
|
||||
sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
|
||||
|
||||
out_ipl_parm:
|
||||
sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
|
||||
out:
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int __init
|
||||
ipl_device_sysfs_register(void) {
|
||||
int rc;
|
||||
|
||||
rc = firmware_register(&ipl_subsys);
|
||||
if (rc)
|
||||
goto out;
|
||||
|
||||
switch (get_ipl_type()) {
|
||||
case ipl_type_ccw:
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_ccw_attr_group);
|
||||
break;
|
||||
case ipl_type_fcp:
|
||||
rc = ipl_register_fcp_files();
|
||||
break;
|
||||
default:
|
||||
rc = sysfs_create_group(&ipl_subsys.kset.kobj,
|
||||
&ipl_unknown_attr_group);
|
||||
break;
|
||||
}
|
||||
|
||||
if (rc)
|
||||
firmware_unregister(&ipl_subsys);
|
||||
out:
|
||||
return rc;
|
||||
}
|
||||
|
||||
__initcall(ipl_device_sysfs_register);
|
||||
|
@ -114,29 +114,26 @@ sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
|
||||
static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
|
||||
{
|
||||
unsigned long old_mask = regs->psw.mask;
|
||||
int err;
|
||||
|
||||
_sigregs user_sregs;
|
||||
|
||||
save_access_regs(current->thread.acrs);
|
||||
|
||||
/* Copy a 'clean' PSW mask to the user to avoid leaking
|
||||
information about whether PER is currently on. */
|
||||
regs->psw.mask = PSW_MASK_MERGE(PSW_USER_BITS, regs->psw.mask);
|
||||
err = __copy_to_user(&sregs->regs.psw, ®s->psw,
|
||||
sizeof(sregs->regs.psw)+sizeof(sregs->regs.gprs));
|
||||
memcpy(&user_sregs.regs.psw, ®s->psw, sizeof(sregs->regs.psw) +
|
||||
sizeof(sregs->regs.gprs));
|
||||
regs->psw.mask = old_mask;
|
||||
if (err != 0)
|
||||
return err;
|
||||
err = __copy_to_user(&sregs->regs.acrs, current->thread.acrs,
|
||||
sizeof(sregs->regs.acrs));
|
||||
if (err != 0)
|
||||
return err;
|
||||
memcpy(&user_sregs.regs.acrs, current->thread.acrs,
|
||||
sizeof(sregs->regs.acrs));
|
||||
/*
|
||||
* We have to store the fp registers to current->thread.fp_regs
|
||||
* to merge them with the emulated registers.
|
||||
*/
|
||||
save_fp_regs(¤t->thread.fp_regs);
|
||||
return __copy_to_user(&sregs->fpregs, ¤t->thread.fp_regs,
|
||||
sizeof(s390_fp_regs));
|
||||
memcpy(&user_sregs.fpregs, ¤t->thread.fp_regs,
|
||||
sizeof(s390_fp_regs));
|
||||
return __copy_to_user(sregs, &user_sregs, sizeof(_sigregs));
|
||||
}
|
||||
|
||||
/* Returns positive number on error */
|
||||
@ -144,27 +141,25 @@ static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
|
||||
{
|
||||
unsigned long old_mask = regs->psw.mask;
|
||||
int err;
|
||||
_sigregs user_sregs;
|
||||
|
||||
/* Alwys make any pending restarted system call return -EINTR */
|
||||
current_thread_info()->restart_block.fn = do_no_restart_syscall;
|
||||
|
||||
err = __copy_from_user(®s->psw, &sregs->regs.psw,
|
||||
sizeof(sregs->regs.psw)+sizeof(sregs->regs.gprs));
|
||||
err = __copy_from_user(&user_sregs, sregs, sizeof(_sigregs));
|
||||
regs->psw.mask = PSW_MASK_MERGE(old_mask, regs->psw.mask);
|
||||
regs->psw.addr |= PSW_ADDR_AMODE;
|
||||
if (err)
|
||||
return err;
|
||||
err = __copy_from_user(¤t->thread.acrs, &sregs->regs.acrs,
|
||||
sizeof(sregs->regs.acrs));
|
||||
if (err)
|
||||
return err;
|
||||
memcpy(®s->psw, &user_sregs.regs.psw, sizeof(sregs->regs.psw) +
|
||||
sizeof(sregs->regs.gprs));
|
||||
memcpy(¤t->thread.acrs, &user_sregs.regs.acrs,
|
||||
sizeof(sregs->regs.acrs));
|
||||
restore_access_regs(current->thread.acrs);
|
||||
|
||||
err = __copy_from_user(¤t->thread.fp_regs, &sregs->fpregs,
|
||||
sizeof(s390_fp_regs));
|
||||
memcpy(¤t->thread.fp_regs, &user_sregs.fpregs,
|
||||
sizeof(s390_fp_regs));
|
||||
current->thread.fp_regs.fpc &= FPC_VALID_MASK;
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
restore_fp_regs(¤t->thread.fp_regs);
|
||||
regs->trap = -1; /* disable syscall checks */
|
||||
@ -457,6 +452,7 @@ void do_signal(struct pt_regs *regs)
|
||||
case -ERESTART_RESTARTBLOCK:
|
||||
regs->gprs[2] = -EINTR;
|
||||
}
|
||||
regs->trap = -1; /* Don't deal with this again. */
|
||||
}
|
||||
|
||||
/* Get signal to deliver. When running under ptrace, at this point
|
||||
|
@ -59,9 +59,6 @@ static struct task_struct *current_set[NR_CPUS];
|
||||
extern char vmhalt_cmd[];
|
||||
extern char vmpoff_cmd[];
|
||||
|
||||
extern void reipl(unsigned long devno);
|
||||
extern void reipl_diag(void);
|
||||
|
||||
static void smp_ext_bitcall(int, ec_bit_sig);
|
||||
static void smp_ext_bitcall_others(ec_bit_sig);
|
||||
|
||||
@ -279,12 +276,7 @@ static void do_machine_restart(void * __unused)
|
||||
* interrupted by an external interrupt and s390irq
|
||||
* locks are always held disabled).
|
||||
*/
|
||||
reipl_diag();
|
||||
|
||||
if (MACHINE_IS_VM)
|
||||
cpcmd ("IPL", NULL, 0, NULL);
|
||||
else
|
||||
reipl (0x10000 | S390_lowcore.ipl_device);
|
||||
do_reipl();
|
||||
}
|
||||
|
||||
void machine_restart_smp(char * __unused)
|
||||
|
@ -29,6 +29,7 @@
|
||||
#include <linux/module.h>
|
||||
#include <linux/kallsyms.h>
|
||||
#include <linux/reboot.h>
|
||||
#include <linux/kprobes.h>
|
||||
|
||||
#include <asm/system.h>
|
||||
#include <asm/uaccess.h>
|
||||
@ -39,6 +40,7 @@
|
||||
#include <asm/s390_ext.h>
|
||||
#include <asm/lowcore.h>
|
||||
#include <asm/debug.h>
|
||||
#include <asm/kdebug.h>
|
||||
|
||||
/* Called from entry.S only */
|
||||
extern void handle_per_exception(struct pt_regs *regs);
|
||||
@ -74,6 +76,20 @@ static int kstack_depth_to_print = 12;
|
||||
static int kstack_depth_to_print = 20;
|
||||
#endif /* CONFIG_64BIT */
|
||||
|
||||
ATOMIC_NOTIFIER_HEAD(s390die_chain);
|
||||
|
||||
int register_die_notifier(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_register(&s390die_chain, nb);
|
||||
}
|
||||
EXPORT_SYMBOL(register_die_notifier);
|
||||
|
||||
int unregister_die_notifier(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_unregister(&s390die_chain, nb);
|
||||
}
|
||||
EXPORT_SYMBOL(unregister_die_notifier);
|
||||
|
||||
/*
|
||||
* For show_trace we have tree different stack to consider:
|
||||
* - the panic stack which is used if the kernel stack has overflown
|
||||
@ -305,8 +321,9 @@ report_user_fault(long interruption_code, struct pt_regs *regs)
|
||||
#endif
|
||||
}
|
||||
|
||||
static void inline do_trap(long interruption_code, int signr, char *str,
|
||||
struct pt_regs *regs, siginfo_t *info)
|
||||
static void __kprobes inline do_trap(long interruption_code, int signr,
|
||||
char *str, struct pt_regs *regs,
|
||||
siginfo_t *info)
|
||||
{
|
||||
/*
|
||||
* We got all needed information from the lowcore and can
|
||||
@ -315,6 +332,10 @@ static void inline do_trap(long interruption_code, int signr, char *str,
|
||||
if (regs->psw.mask & PSW_MASK_PSTATE)
|
||||
local_irq_enable();
|
||||
|
||||
if (notify_die(DIE_TRAP, str, regs, interruption_code,
|
||||
interruption_code, signr) == NOTIFY_STOP)
|
||||
return;
|
||||
|
||||
if (regs->psw.mask & PSW_MASK_PSTATE) {
|
||||
struct task_struct *tsk = current;
|
||||
|
||||
@ -336,8 +357,12 @@ static inline void __user *get_check_address(struct pt_regs *regs)
|
||||
return (void __user *)((regs->psw.addr-S390_lowcore.pgm_ilc) & PSW_ADDR_INSN);
|
||||
}
|
||||
|
||||
void do_single_step(struct pt_regs *regs)
|
||||
void __kprobes do_single_step(struct pt_regs *regs)
|
||||
{
|
||||
if (notify_die(DIE_SSTEP, "sstep", regs, 0, 0,
|
||||
SIGTRAP) == NOTIFY_STOP){
|
||||
return;
|
||||
}
|
||||
if ((current->ptrace & PT_PTRACED) != 0)
|
||||
force_sig(SIGTRAP, current);
|
||||
}
|
||||
|
@ -24,6 +24,7 @@ SECTIONS
|
||||
*(.text)
|
||||
SCHED_TEXT
|
||||
LOCK_TEXT
|
||||
KPROBES_TEXT
|
||||
*(.fixup)
|
||||
*(.gnu.warning)
|
||||
} = 0x0700
|
||||
@ -117,7 +118,7 @@ SECTIONS
|
||||
|
||||
/* Sections to be discarded */
|
||||
/DISCARD/ : {
|
||||
*(.exitcall.exit)
|
||||
*(.exit.text) *(.exit.data) *(.exitcall.exit)
|
||||
}
|
||||
|
||||
/* Stabs debugging sections. */
|
||||
|
@ -4,6 +4,6 @@
|
||||
|
||||
EXTRA_AFLAGS := -traditional
|
||||
|
||||
lib-y += delay.o string.o
|
||||
lib-y += $(if $(CONFIG_64BIT),uaccess64.o,uaccess.o)
|
||||
lib-y += delay.o string.o uaccess_std.o
|
||||
lib-$(CONFIG_64BIT) += uaccess_mvcos.o
|
||||
lib-$(CONFIG_SMP) += spinlock.o
|
||||
|
@ -1,211 +0,0 @@
|
||||
/*
|
||||
* arch/s390/lib/uaccess.S
|
||||
* __copy_{from|to}_user functions.
|
||||
*
|
||||
* s390
|
||||
* Copyright (C) 2000,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
|
||||
* Authors(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
|
||||
*
|
||||
* These functions have standard call interface
|
||||
*/
|
||||
|
||||
#include <linux/errno.h>
|
||||
#include <asm/lowcore.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
|
||||
.text
|
||||
.align 4
|
||||
.globl __copy_from_user_asm
|
||||
# %r2 = to, %r3 = n, %r4 = from
|
||||
__copy_from_user_asm:
|
||||
slr %r0,%r0
|
||||
0: mvcp 0(%r3,%r2),0(%r4),%r0
|
||||
jnz 1f
|
||||
slr %r2,%r2
|
||||
br %r14
|
||||
1: la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
ahi %r3,-256
|
||||
2: mvcp 0(%r3,%r2),0(%r4),%r0
|
||||
jnz 1b
|
||||
3: slr %r2,%r2
|
||||
br %r14
|
||||
4: lhi %r0,-4096
|
||||
lr %r5,%r4
|
||||
slr %r5,%r0
|
||||
nr %r5,%r0 # %r5 = (%r4 + 4096) & -4096
|
||||
slr %r5,%r4 # %r5 = #bytes to next user page boundary
|
||||
clr %r3,%r5 # copy crosses next page boundary ?
|
||||
jnh 6f # no, the current page faulted
|
||||
# move with the reduced length which is < 256
|
||||
5: mvcp 0(%r5,%r2),0(%r4),%r0
|
||||
slr %r3,%r5
|
||||
6: lr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 0b,4b
|
||||
.long 2b,4b
|
||||
.long 5b,6b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __copy_to_user_asm
|
||||
# %r2 = from, %r3 = n, %r4 = to
|
||||
__copy_to_user_asm:
|
||||
slr %r0,%r0
|
||||
0: mvcs 0(%r3,%r4),0(%r2),%r0
|
||||
jnz 1f
|
||||
slr %r2,%r2
|
||||
br %r14
|
||||
1: la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
ahi %r3,-256
|
||||
2: mvcs 0(%r3,%r4),0(%r2),%r0
|
||||
jnz 1b
|
||||
3: slr %r2,%r2
|
||||
br %r14
|
||||
4: lhi %r0,-4096
|
||||
lr %r5,%r4
|
||||
slr %r5,%r0
|
||||
nr %r5,%r0 # %r5 = (%r4 + 4096) & -4096
|
||||
slr %r5,%r4 # %r5 = #bytes to next user page boundary
|
||||
clr %r3,%r5 # copy crosses next page boundary ?
|
||||
jnh 6f # no, the current page faulted
|
||||
# move with the reduced length which is < 256
|
||||
5: mvcs 0(%r5,%r4),0(%r2),%r0
|
||||
slr %r3,%r5
|
||||
6: lr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 0b,4b
|
||||
.long 2b,4b
|
||||
.long 5b,6b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __copy_in_user_asm
|
||||
# %r2 = from, %r3 = n, %r4 = to
|
||||
__copy_in_user_asm:
|
||||
ahi %r3,-1
|
||||
jo 6f
|
||||
sacf 256
|
||||
bras %r1,4f
|
||||
0: ahi %r3,257
|
||||
1: mvc 0(1,%r4),0(%r2)
|
||||
la %r2,1(%r2)
|
||||
la %r4,1(%r4)
|
||||
ahi %r3,-1
|
||||
jnz 1b
|
||||
2: lr %r2,%r3
|
||||
br %r14
|
||||
3: mvc 0(256,%r4),0(%r2)
|
||||
la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
4: ahi %r3,-256
|
||||
jnm 3b
|
||||
5: ex %r3,4(%r1)
|
||||
sacf 0
|
||||
6: slr %r2,%r2
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 1b,2b
|
||||
.long 3b,0b
|
||||
.long 5b,0b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __clear_user_asm
|
||||
# %r2 = to, %r3 = n
|
||||
__clear_user_asm:
|
||||
bras %r5,0f
|
||||
.long empty_zero_page
|
||||
0: l %r5,0(%r5)
|
||||
slr %r0,%r0
|
||||
1: mvcs 0(%r3,%r2),0(%r5),%r0
|
||||
jnz 2f
|
||||
slr %r2,%r2
|
||||
br %r14
|
||||
2: la %r2,256(%r2)
|
||||
ahi %r3,-256
|
||||
3: mvcs 0(%r3,%r2),0(%r5),%r0
|
||||
jnz 2b
|
||||
4: slr %r2,%r2
|
||||
br %r14
|
||||
5: lhi %r0,-4096
|
||||
lr %r4,%r2
|
||||
slr %r4,%r0
|
||||
nr %r4,%r0 # %r4 = (%r2 + 4096) & -4096
|
||||
slr %r4,%r2 # %r4 = #bytes to next user page boundary
|
||||
clr %r3,%r4 # clear crosses next page boundary ?
|
||||
jnh 7f # no, the current page faulted
|
||||
# clear with the reduced length which is < 256
|
||||
6: mvcs 0(%r4,%r2),0(%r5),%r0
|
||||
slr %r3,%r4
|
||||
7: lr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 1b,5b
|
||||
.long 3b,5b
|
||||
.long 6b,7b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __strncpy_from_user_asm
|
||||
# %r2 = count, %r3 = dst, %r4 = src
|
||||
__strncpy_from_user_asm:
|
||||
lhi %r0,0
|
||||
lr %r1,%r4
|
||||
la %r4,0(%r4) # clear high order bit from %r4
|
||||
la %r2,0(%r2,%r4) # %r2 points to first byte after string
|
||||
sacf 256
|
||||
0: srst %r2,%r1
|
||||
jo 0b
|
||||
sacf 0
|
||||
lr %r1,%r2
|
||||
jh 1f # \0 found in string ?
|
||||
ahi %r1,1 # include \0 in copy
|
||||
1: slr %r1,%r4 # %r1 = copy length (without \0)
|
||||
slr %r2,%r4 # %r2 = return length (including \0)
|
||||
2: mvcp 0(%r1,%r3),0(%r4),%r0
|
||||
jnz 3f
|
||||
br %r14
|
||||
3: la %r3,256(%r3)
|
||||
la %r4,256(%r4)
|
||||
ahi %r1,-256
|
||||
mvcp 0(%r1,%r3),0(%r4),%r0
|
||||
jnz 3b
|
||||
br %r14
|
||||
4: sacf 0
|
||||
lhi %r2,-EFAULT
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 0b,4b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __strnlen_user_asm
|
||||
# %r2 = count, %r3 = src
|
||||
__strnlen_user_asm:
|
||||
lhi %r0,0
|
||||
lr %r1,%r3
|
||||
la %r3,0(%r3) # clear high order bit from %r4
|
||||
la %r2,0(%r2,%r3) # %r2 points to first byte after string
|
||||
sacf 256
|
||||
0: srst %r2,%r1
|
||||
jo 0b
|
||||
sacf 0
|
||||
ahi %r2,1 # strnlen_user result includes the \0
|
||||
# or return count+1 if \0 not found
|
||||
slr %r2,%r3
|
||||
br %r14
|
||||
2: sacf 0
|
||||
slr %r2,%r2 # return 0 on exception
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.long 0b,2b
|
||||
.previous
|
@ -1,207 +0,0 @@
|
||||
/*
|
||||
* arch/s390x/lib/uaccess.S
|
||||
* __copy_{from|to}_user functions.
|
||||
*
|
||||
* s390
|
||||
* Copyright (C) 2000,2002 IBM Deutschland Entwicklung GmbH, IBM Corporation
|
||||
* Authors(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
|
||||
*
|
||||
* These functions have standard call interface
|
||||
*/
|
||||
|
||||
#include <linux/errno.h>
|
||||
#include <asm/lowcore.h>
|
||||
#include <asm/asm-offsets.h>
|
||||
|
||||
.text
|
||||
.align 4
|
||||
.globl __copy_from_user_asm
|
||||
# %r2 = to, %r3 = n, %r4 = from
|
||||
__copy_from_user_asm:
|
||||
slgr %r0,%r0
|
||||
0: mvcp 0(%r3,%r2),0(%r4),%r0
|
||||
jnz 1f
|
||||
slgr %r2,%r2
|
||||
br %r14
|
||||
1: la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
aghi %r3,-256
|
||||
2: mvcp 0(%r3,%r2),0(%r4),%r0
|
||||
jnz 1b
|
||||
3: slgr %r2,%r2
|
||||
br %r14
|
||||
4: lghi %r0,-4096
|
||||
lgr %r5,%r4
|
||||
slgr %r5,%r0
|
||||
ngr %r5,%r0 # %r5 = (%r4 + 4096) & -4096
|
||||
slgr %r5,%r4 # %r5 = #bytes to next user page boundary
|
||||
clgr %r3,%r5 # copy crosses next page boundary ?
|
||||
jnh 6f # no, the current page faulted
|
||||
# move with the reduced length which is < 256
|
||||
5: mvcp 0(%r5,%r2),0(%r4),%r0
|
||||
slgr %r3,%r5
|
||||
6: lgr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.quad 0b,4b
|
||||
.quad 2b,4b
|
||||
.quad 5b,6b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __copy_to_user_asm
|
||||
# %r2 = from, %r3 = n, %r4 = to
|
||||
__copy_to_user_asm:
|
||||
slgr %r0,%r0
|
||||
0: mvcs 0(%r3,%r4),0(%r2),%r0
|
||||
jnz 1f
|
||||
slgr %r2,%r2
|
||||
br %r14
|
||||
1: la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
aghi %r3,-256
|
||||
2: mvcs 0(%r3,%r4),0(%r2),%r0
|
||||
jnz 1b
|
||||
3: slgr %r2,%r2
|
||||
br %r14
|
||||
4: lghi %r0,-4096
|
||||
lgr %r5,%r4
|
||||
slgr %r5,%r0
|
||||
ngr %r5,%r0 # %r5 = (%r4 + 4096) & -4096
|
||||
slgr %r5,%r4 # %r5 = #bytes to next user page boundary
|
||||
clgr %r3,%r5 # copy crosses next page boundary ?
|
||||
jnh 6f # no, the current page faulted
|
||||
# move with the reduced length which is < 256
|
||||
5: mvcs 0(%r5,%r4),0(%r2),%r0
|
||||
slgr %r3,%r5
|
||||
6: lgr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.quad 0b,4b
|
||||
.quad 2b,4b
|
||||
.quad 5b,6b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __copy_in_user_asm
|
||||
# %r2 = from, %r3 = n, %r4 = to
|
||||
__copy_in_user_asm:
|
||||
aghi %r3,-1
|
||||
jo 6f
|
||||
sacf 256
|
||||
bras %r1,4f
|
||||
0: aghi %r3,257
|
||||
1: mvc 0(1,%r4),0(%r2)
|
||||
la %r2,1(%r2)
|
||||
la %r4,1(%r4)
|
||||
aghi %r3,-1
|
||||
jnz 1b
|
||||
2: lgr %r2,%r3
|
||||
br %r14
|
||||
3: mvc 0(256,%r4),0(%r2)
|
||||
la %r2,256(%r2)
|
||||
la %r4,256(%r4)
|
||||
4: aghi %r3,-256
|
||||
jnm 3b
|
||||
5: ex %r3,4(%r1)
|
||||
sacf 0
|
||||
6: slgr %r2,%r2
|
||||
br 14
|
||||
.section __ex_table,"a"
|
||||
.quad 1b,2b
|
||||
.quad 3b,0b
|
||||
.quad 5b,0b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __clear_user_asm
|
||||
# %r2 = to, %r3 = n
|
||||
__clear_user_asm:
|
||||
slgr %r0,%r0
|
||||
larl %r5,empty_zero_page
|
||||
1: mvcs 0(%r3,%r2),0(%r5),%r0
|
||||
jnz 2f
|
||||
slgr %r2,%r2
|
||||
br %r14
|
||||
2: la %r2,256(%r2)
|
||||
aghi %r3,-256
|
||||
3: mvcs 0(%r3,%r2),0(%r5),%r0
|
||||
jnz 2b
|
||||
4: slgr %r2,%r2
|
||||
br %r14
|
||||
5: lghi %r0,-4096
|
||||
lgr %r4,%r2
|
||||
slgr %r4,%r0
|
||||
ngr %r4,%r0 # %r4 = (%r2 + 4096) & -4096
|
||||
slgr %r4,%r2 # %r4 = #bytes to next user page boundary
|
||||
clgr %r3,%r4 # clear crosses next page boundary ?
|
||||
jnh 7f # no, the current page faulted
|
||||
# clear with the reduced length which is < 256
|
||||
6: mvcs 0(%r4,%r2),0(%r5),%r0
|
||||
slgr %r3,%r4
|
||||
7: lgr %r2,%r3
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.quad 1b,5b
|
||||
.quad 3b,5b
|
||||
.quad 6b,7b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __strncpy_from_user_asm
|
||||
# %r2 = count, %r3 = dst, %r4 = src
|
||||
__strncpy_from_user_asm:
|
||||
lghi %r0,0
|
||||
lgr %r1,%r4
|
||||
la %r2,0(%r2,%r4) # %r2 points to first byte after string
|
||||
sacf 256
|
||||
0: srst %r2,%r1
|
||||
jo 0b
|
||||
sacf 0
|
||||
lgr %r1,%r2
|
||||
jh 1f # \0 found in string ?
|
||||
aghi %r1,1 # include \0 in copy
|
||||
1: slgr %r1,%r4 # %r1 = copy length (without \0)
|
||||
slgr %r2,%r4 # %r2 = return length (including \0)
|
||||
2: mvcp 0(%r1,%r3),0(%r4),%r0
|
||||
jnz 3f
|
||||
br %r14
|
||||
3: la %r3,256(%r3)
|
||||
la %r4,256(%r4)
|
||||
aghi %r1,-256
|
||||
mvcp 0(%r1,%r3),0(%r4),%r0
|
||||
jnz 3b
|
||||
br %r14
|
||||
4: sacf 0
|
||||
lghi %r2,-EFAULT
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.quad 0b,4b
|
||||
.previous
|
||||
|
||||
.align 4
|
||||
.text
|
||||
.globl __strnlen_user_asm
|
||||
# %r2 = count, %r3 = src
|
||||
__strnlen_user_asm:
|
||||
lghi %r0,0
|
||||
lgr %r1,%r3
|
||||
la %r2,0(%r2,%r3) # %r2 points to first byte after string
|
||||
sacf 256
|
||||
0: srst %r2,%r1
|
||||
jo 0b
|
||||
sacf 0
|
||||
aghi %r2,1 # strnlen_user result includes the \0
|
||||
# or return count+1 if \0 not found
|
||||
slgr %r2,%r3
|
||||
br %r14
|
||||
2: sacf 0
|
||||
slgr %r2,%r2 # return 0 on exception
|
||||
br %r14
|
||||
.section __ex_table,"a"
|
||||
.quad 0b,2b
|
||||
.previous
|
156
arch/s390/lib/uaccess_mvcos.c
Normal file
156
arch/s390/lib/uaccess_mvcos.c
Normal file
@ -0,0 +1,156 @@
|
||||
/*
|
||||
* arch/s390/lib/uaccess_mvcos.c
|
||||
*
|
||||
* Optimized user space space access functions based on mvcos.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
|
||||
* Gerald Schaefer (gerald.schaefer@de.ibm.com)
|
||||
*/
|
||||
|
||||
#include <linux/errno.h>
|
||||
#include <linux/mm.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/futex.h>
|
||||
|
||||
#ifndef __s390x__
|
||||
#define AHI "ahi"
|
||||
#define ALR "alr"
|
||||
#define CLR "clr"
|
||||
#define LHI "lhi"
|
||||
#define SLR "slr"
|
||||
#else
|
||||
#define AHI "aghi"
|
||||
#define ALR "algr"
|
||||
#define CLR "clgr"
|
||||
#define LHI "lghi"
|
||||
#define SLR "slgr"
|
||||
#endif
|
||||
|
||||
size_t copy_from_user_mvcos(size_t size, const void __user *ptr, void *x)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0x81UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -4096UL;
|
||||
asm volatile(
|
||||
"0: .insn ss,0xc80000000000,0(%0,%2),0(%1),0\n"
|
||||
" jz 4f\n"
|
||||
"1:"ALR" %0,%3\n"
|
||||
" "SLR" %1,%3\n"
|
||||
" "SLR" %2,%3\n"
|
||||
" j 0b\n"
|
||||
"2: la %4,4095(%1)\n"/* %4 = ptr + 4095 */
|
||||
" nr %4,%3\n" /* %4 = (ptr + 4095) & -4096 */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 5f\n"
|
||||
"3: .insn ss,0xc80000000000,0(%4,%2),0(%1),0\n"
|
||||
" "SLR" %0,%4\n"
|
||||
" j 5f\n"
|
||||
"4:"SLR" %0,%0\n"
|
||||
"5: \n"
|
||||
EX_TABLE(0b,2b) EX_TABLE(3b,5b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: "d" (reg0) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_to_user_mvcos(size_t size, void __user *ptr, const void *x)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0x810000UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -4096UL;
|
||||
asm volatile(
|
||||
"0: .insn ss,0xc80000000000,0(%0,%1),0(%2),0\n"
|
||||
" jz 4f\n"
|
||||
"1:"ALR" %0,%3\n"
|
||||
" "SLR" %1,%3\n"
|
||||
" "SLR" %2,%3\n"
|
||||
" j 0b\n"
|
||||
"2: la %4,4095(%1)\n"/* %4 = ptr + 4095 */
|
||||
" nr %4,%3\n" /* %4 = (ptr + 4095) & -4096 */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 5f\n"
|
||||
"3: .insn ss,0xc80000000000,0(%4,%1),0(%2),0\n"
|
||||
" "SLR" %0,%4\n"
|
||||
" j 5f\n"
|
||||
"4:"SLR" %0,%0\n"
|
||||
"5: \n"
|
||||
EX_TABLE(0b,2b) EX_TABLE(3b,5b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: "d" (reg0) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_in_user_mvcos(size_t size, void __user *to, const void __user *from)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0x810081UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -4096UL;
|
||||
/* FIXME: copy with reduced length. */
|
||||
asm volatile(
|
||||
"0: .insn ss,0xc80000000000,0(%0,%1),0(%2),0\n"
|
||||
" jz 2f\n"
|
||||
"1:"ALR" %0,%3\n"
|
||||
" "SLR" %1,%3\n"
|
||||
" "SLR" %2,%3\n"
|
||||
" j 0b\n"
|
||||
"2:"SLR" %0,%0\n"
|
||||
"3: \n"
|
||||
EX_TABLE(0b,3b)
|
||||
: "+a" (size), "+a" (to), "+a" (from), "+a" (tmp1), "=a" (tmp2)
|
||||
: "d" (reg0) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t clear_user_mvcos(size_t size, void __user *to)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0x810000UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -4096UL;
|
||||
asm volatile(
|
||||
"0: .insn ss,0xc80000000000,0(%0,%1),0(%4),0\n"
|
||||
" jz 4f\n"
|
||||
"1:"ALR" %0,%2\n"
|
||||
" "SLR" %1,%2\n"
|
||||
" j 0b\n"
|
||||
"2: la %3,4095(%1)\n"/* %4 = to + 4095 */
|
||||
" nr %3,%2\n" /* %4 = (to + 4095) & -4096 */
|
||||
" "SLR" %3,%1\n"
|
||||
" "CLR" %0,%3\n" /* copy crosses next page boundary? */
|
||||
" jnh 5f\n"
|
||||
"3: .insn ss,0xc80000000000,0(%3,%1),0(%4),0\n"
|
||||
" "SLR" %0,%3\n"
|
||||
" j 5f\n"
|
||||
"4:"SLR" %0,%0\n"
|
||||
"5: \n"
|
||||
EX_TABLE(0b,2b) EX_TABLE(3b,5b)
|
||||
: "+a" (size), "+a" (to), "+a" (tmp1), "=a" (tmp2)
|
||||
: "a" (empty_zero_page), "d" (reg0) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
extern size_t copy_from_user_std_small(size_t, const void __user *, void *);
|
||||
extern size_t copy_to_user_std_small(size_t, void __user *, const void *);
|
||||
extern size_t strnlen_user_std(size_t, const char __user *);
|
||||
extern size_t strncpy_from_user_std(size_t, const char __user *, char *);
|
||||
extern int futex_atomic_op(int, int __user *, int, int *);
|
||||
extern int futex_atomic_cmpxchg(int __user *, int, int);
|
||||
|
||||
struct uaccess_ops uaccess_mvcos = {
|
||||
.copy_from_user = copy_from_user_mvcos,
|
||||
.copy_from_user_small = copy_from_user_std_small,
|
||||
.copy_to_user = copy_to_user_mvcos,
|
||||
.copy_to_user_small = copy_to_user_std_small,
|
||||
.copy_in_user = copy_in_user_mvcos,
|
||||
.clear_user = clear_user_mvcos,
|
||||
.strnlen_user = strnlen_user_std,
|
||||
.strncpy_from_user = strncpy_from_user_std,
|
||||
.futex_atomic_op = futex_atomic_op,
|
||||
.futex_atomic_cmpxchg = futex_atomic_cmpxchg,
|
||||
};
|
340
arch/s390/lib/uaccess_std.c
Normal file
340
arch/s390/lib/uaccess_std.c
Normal file
@ -0,0 +1,340 @@
|
||||
/*
|
||||
* arch/s390/lib/uaccess_std.c
|
||||
*
|
||||
* Standard user space access functions based on mvcp/mvcs and doing
|
||||
* interesting things in the secondary space mode.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
* Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com),
|
||||
* Gerald Schaefer (gerald.schaefer@de.ibm.com)
|
||||
*/
|
||||
|
||||
#include <linux/errno.h>
|
||||
#include <linux/mm.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/futex.h>
|
||||
|
||||
#ifndef __s390x__
|
||||
#define AHI "ahi"
|
||||
#define ALR "alr"
|
||||
#define CLR "clr"
|
||||
#define LHI "lhi"
|
||||
#define SLR "slr"
|
||||
#else
|
||||
#define AHI "aghi"
|
||||
#define ALR "algr"
|
||||
#define CLR "clgr"
|
||||
#define LHI "lghi"
|
||||
#define SLR "slgr"
|
||||
#endif
|
||||
|
||||
size_t copy_from_user_std(size_t size, const void __user *ptr, void *x)
|
||||
{
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -256UL;
|
||||
asm volatile(
|
||||
"0: mvcp 0(%0,%2),0(%1),%3\n"
|
||||
" jz 5f\n"
|
||||
"1:"ALR" %0,%3\n"
|
||||
" la %1,256(%1)\n"
|
||||
" la %2,256(%2)\n"
|
||||
"2: mvcp 0(%0,%2),0(%1),%3\n"
|
||||
" jnz 1b\n"
|
||||
" j 5f\n"
|
||||
"3: la %4,255(%1)\n" /* %4 = ptr + 255 */
|
||||
" "LHI" %3,-4096\n"
|
||||
" nr %4,%3\n" /* %4 = (ptr + 255) & -4096 */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 6f\n"
|
||||
"4: mvcp 0(%4,%2),0(%1),%3\n"
|
||||
" "SLR" %0,%4\n"
|
||||
" j 6f\n"
|
||||
"5:"SLR" %0,%0\n"
|
||||
"6: \n"
|
||||
EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_from_user_std_small(size_t size, const void __user *ptr, void *x)
|
||||
{
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = 0UL;
|
||||
asm volatile(
|
||||
"0: mvcp 0(%0,%2),0(%1),%3\n"
|
||||
" "SLR" %0,%0\n"
|
||||
" j 3f\n"
|
||||
"1: la %4,255(%1)\n" /* %4 = ptr + 255 */
|
||||
" "LHI" %3,-4096\n"
|
||||
" nr %4,%3\n" /* %4 = (ptr + 255) & -4096 */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 3f\n"
|
||||
"2: mvcp 0(%4,%2),0(%1),%3\n"
|
||||
" "SLR" %0,%4\n"
|
||||
"3:\n"
|
||||
EX_TABLE(0b,1b) EX_TABLE(2b,3b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_to_user_std(size_t size, void __user *ptr, const void *x)
|
||||
{
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = -256UL;
|
||||
asm volatile(
|
||||
"0: mvcs 0(%0,%1),0(%2),%3\n"
|
||||
" jz 5f\n"
|
||||
"1:"ALR" %0,%3\n"
|
||||
" la %1,256(%1)\n"
|
||||
" la %2,256(%2)\n"
|
||||
"2: mvcs 0(%0,%1),0(%2),%3\n"
|
||||
" jnz 1b\n"
|
||||
" j 5f\n"
|
||||
"3: la %4,255(%1)\n" /* %4 = ptr + 255 */
|
||||
" "LHI" %3,-4096\n"
|
||||
" nr %4,%3\n" /* %4 = (ptr + 255) & -4096 */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 6f\n"
|
||||
"4: mvcs 0(%4,%1),0(%2),%3\n"
|
||||
" "SLR" %0,%4\n"
|
||||
" j 6f\n"
|
||||
"5:"SLR" %0,%0\n"
|
||||
"6: \n"
|
||||
EX_TABLE(0b,3b) EX_TABLE(2b,3b) EX_TABLE(4b,6b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_to_user_std_small(size_t size, void __user *ptr, const void *x)
|
||||
{
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
tmp1 = 0UL;
|
||||
asm volatile(
|
||||
"0: mvcs 0(%0,%1),0(%2),%3\n"
|
||||
" "SLR" %0,%0\n"
|
||||
" j 3f\n"
|
||||
"1: la %4,255(%1)\n" /* ptr + 255 */
|
||||
" "LHI" %3,-4096\n"
|
||||
" nr %4,%3\n" /* (ptr + 255) & -4096UL */
|
||||
" "SLR" %4,%1\n"
|
||||
" "CLR" %0,%4\n" /* copy crosses next page boundary? */
|
||||
" jnh 3f\n"
|
||||
"2: mvcs 0(%4,%1),0(%2),%3\n"
|
||||
" "SLR" %0,%4\n"
|
||||
"3:\n"
|
||||
EX_TABLE(0b,1b) EX_TABLE(2b,3b)
|
||||
: "+a" (size), "+a" (ptr), "+a" (x), "+a" (tmp1), "=a" (tmp2)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t copy_in_user_std(size_t size, void __user *to, const void __user *from)
|
||||
{
|
||||
unsigned long tmp1;
|
||||
|
||||
asm volatile(
|
||||
" "AHI" %0,-1\n"
|
||||
" jo 5f\n"
|
||||
" sacf 256\n"
|
||||
" bras %3,3f\n"
|
||||
"0:"AHI" %0,257\n"
|
||||
"1: mvc 0(1,%1),0(%2)\n"
|
||||
" la %1,1(%1)\n"
|
||||
" la %2,1(%2)\n"
|
||||
" "AHI" %0,-1\n"
|
||||
" jnz 1b\n"
|
||||
" j 5f\n"
|
||||
"2: mvc 0(256,%1),0(%2)\n"
|
||||
" la %1,256(%1)\n"
|
||||
" la %2,256(%2)\n"
|
||||
"3:"AHI" %0,-256\n"
|
||||
" jnm 2b\n"
|
||||
"4: ex %0,1b-0b(%3)\n"
|
||||
" sacf 0\n"
|
||||
"5: "SLR" %0,%0\n"
|
||||
"6:\n"
|
||||
EX_TABLE(1b,6b) EX_TABLE(2b,0b) EX_TABLE(4b,0b)
|
||||
: "+a" (size), "+a" (to), "+a" (from), "=a" (tmp1)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t clear_user_std(size_t size, void __user *to)
|
||||
{
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
asm volatile(
|
||||
" "AHI" %0,-1\n"
|
||||
" jo 5f\n"
|
||||
" sacf 256\n"
|
||||
" bras %3,3f\n"
|
||||
" xc 0(1,%1),0(%1)\n"
|
||||
"0:"AHI" %0,257\n"
|
||||
" la %2,255(%1)\n" /* %2 = ptr + 255 */
|
||||
" srl %2,12\n"
|
||||
" sll %2,12\n" /* %2 = (ptr + 255) & -4096 */
|
||||
" "SLR" %2,%1\n"
|
||||
" "CLR" %0,%2\n" /* clear crosses next page boundary? */
|
||||
" jnh 5f\n"
|
||||
" "AHI" %2,-1\n"
|
||||
"1: ex %2,0(%3)\n"
|
||||
" "AHI" %2,1\n"
|
||||
" "SLR" %0,%2\n"
|
||||
" j 5f\n"
|
||||
"2: xc 0(256,%1),0(%1)\n"
|
||||
" la %1,256(%1)\n"
|
||||
"3:"AHI" %0,-256\n"
|
||||
" jnm 2b\n"
|
||||
"4: ex %0,0(%3)\n"
|
||||
" sacf 0\n"
|
||||
"5: "SLR" %0,%0\n"
|
||||
"6:\n"
|
||||
EX_TABLE(1b,6b) EX_TABLE(2b,0b) EX_TABLE(4b,0b)
|
||||
: "+a" (size), "+a" (to), "=a" (tmp1), "=a" (tmp2)
|
||||
: : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t strnlen_user_std(size_t size, const char __user *src)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
asm volatile(
|
||||
" la %2,0(%1)\n"
|
||||
" la %3,0(%0,%1)\n"
|
||||
" "SLR" %0,%0\n"
|
||||
" sacf 256\n"
|
||||
"0: srst %3,%2\n"
|
||||
" jo 0b\n"
|
||||
" la %0,1(%3)\n" /* strnlen_user results includes \0 */
|
||||
" "SLR" %0,%1\n"
|
||||
"1: sacf 0\n"
|
||||
EX_TABLE(0b,1b)
|
||||
: "+a" (size), "+a" (src), "=a" (tmp1), "=a" (tmp2)
|
||||
: "d" (reg0) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
size_t strncpy_from_user_std(size_t size, const char __user *src, char *dst)
|
||||
{
|
||||
register unsigned long reg0 asm("0") = 0UL;
|
||||
unsigned long tmp1, tmp2;
|
||||
|
||||
asm volatile(
|
||||
" la %3,0(%1)\n"
|
||||
" la %4,0(%0,%1)\n"
|
||||
" sacf 256\n"
|
||||
"0: srst %4,%3\n"
|
||||
" jo 0b\n"
|
||||
" sacf 0\n"
|
||||
" la %0,0(%4)\n"
|
||||
" jh 1f\n" /* found \0 in string ? */
|
||||
" "AHI" %4,1\n" /* include \0 in copy */
|
||||
"1:"SLR" %0,%1\n" /* %0 = return length (without \0) */
|
||||
" "SLR" %4,%1\n" /* %4 = copy length (including \0) */
|
||||
"2: mvcp 0(%4,%2),0(%1),%5\n"
|
||||
" jz 9f\n"
|
||||
"3:"AHI" %4,-256\n"
|
||||
" la %1,256(%1)\n"
|
||||
" la %2,256(%2)\n"
|
||||
"4: mvcp 0(%4,%2),0(%1),%5\n"
|
||||
" jnz 3b\n"
|
||||
" j 9f\n"
|
||||
"7: sacf 0\n"
|
||||
"8:"LHI" %0,%6\n"
|
||||
"9:\n"
|
||||
EX_TABLE(0b,7b) EX_TABLE(2b,8b) EX_TABLE(4b,8b)
|
||||
: "+a" (size), "+a" (src), "+d" (dst), "=a" (tmp1), "=a" (tmp2)
|
||||
: "d" (reg0), "K" (-EFAULT) : "cc", "memory");
|
||||
return size;
|
||||
}
|
||||
|
||||
#define __futex_atomic_op(insn, ret, oldval, newval, uaddr, oparg) \
|
||||
asm volatile( \
|
||||
" sacf 256\n" \
|
||||
"0: l %1,0(%6)\n" \
|
||||
"1:"insn \
|
||||
"2: cs %1,%2,0(%6)\n" \
|
||||
"3: jl 1b\n" \
|
||||
" lhi %0,0\n" \
|
||||
"4: sacf 0\n" \
|
||||
EX_TABLE(0b,4b) EX_TABLE(2b,4b) EX_TABLE(3b,4b) \
|
||||
: "=d" (ret), "=&d" (oldval), "=&d" (newval), \
|
||||
"=m" (*uaddr) \
|
||||
: "0" (-EFAULT), "d" (oparg), "a" (uaddr), \
|
||||
"m" (*uaddr) : "cc");
|
||||
|
||||
int futex_atomic_op(int op, int __user *uaddr, int oparg, int *old)
|
||||
{
|
||||
int oldval = 0, newval, ret;
|
||||
|
||||
inc_preempt_count();
|
||||
|
||||
switch (op) {
|
||||
case FUTEX_OP_SET:
|
||||
__futex_atomic_op("lr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_ADD:
|
||||
__futex_atomic_op("lr %2,%1\nar %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_OR:
|
||||
__futex_atomic_op("lr %2,%1\nor %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_ANDN:
|
||||
__futex_atomic_op("lr %2,%1\nnr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_XOR:
|
||||
__futex_atomic_op("lr %2,%1\nxr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
default:
|
||||
ret = -ENOSYS;
|
||||
}
|
||||
dec_preempt_count();
|
||||
*old = oldval;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int futex_atomic_cmpxchg(int __user *uaddr, int oldval, int newval)
|
||||
{
|
||||
int ret;
|
||||
|
||||
asm volatile(
|
||||
" sacf 256\n"
|
||||
" cs %1,%4,0(%5)\n"
|
||||
"0: lr %0,%1\n"
|
||||
"1: sacf 0\n"
|
||||
EX_TABLE(0b,1b)
|
||||
: "=d" (ret), "+d" (oldval), "=m" (*uaddr)
|
||||
: "0" (-EFAULT), "d" (newval), "a" (uaddr), "m" (*uaddr)
|
||||
: "cc", "memory" );
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct uaccess_ops uaccess_std = {
|
||||
.copy_from_user = copy_from_user_std,
|
||||
.copy_from_user_small = copy_from_user_std_small,
|
||||
.copy_to_user = copy_to_user_std,
|
||||
.copy_to_user_small = copy_to_user_std_small,
|
||||
.copy_in_user = copy_in_user_std,
|
||||
.clear_user = clear_user_std,
|
||||
.strnlen_user = strnlen_user_std,
|
||||
.strncpy_from_user = strncpy_from_user_std,
|
||||
.futex_atomic_op = futex_atomic_op,
|
||||
.futex_atomic_cmpxchg = futex_atomic_cmpxchg,
|
||||
};
|
@ -52,22 +52,6 @@ static struct timer_list cmm_timer;
|
||||
static void cmm_timer_fn(unsigned long);
|
||||
static void cmm_set_timer(void);
|
||||
|
||||
static long
|
||||
cmm_strtoul(const char *cp, char **endp)
|
||||
{
|
||||
unsigned int base = 10;
|
||||
|
||||
if (*cp == '0') {
|
||||
base = 8;
|
||||
cp++;
|
||||
if ((*cp == 'x' || *cp == 'X') && isxdigit(cp[1])) {
|
||||
base = 16;
|
||||
cp++;
|
||||
}
|
||||
}
|
||||
return simple_strtoul(cp, endp, base);
|
||||
}
|
||||
|
||||
static long
|
||||
cmm_alloc_pages(long pages, long *counter, struct cmm_page_array **list)
|
||||
{
|
||||
@ -276,7 +260,7 @@ cmm_pages_handler(ctl_table *ctl, int write, struct file *filp,
|
||||
return -EFAULT;
|
||||
buf[sizeof(buf) - 1] = '\0';
|
||||
cmm_skip_blanks(buf, &p);
|
||||
pages = cmm_strtoul(p, &p);
|
||||
pages = simple_strtoul(p, &p, 0);
|
||||
if (ctl == &cmm_table[0])
|
||||
cmm_set_pages(pages);
|
||||
else
|
||||
@ -317,9 +301,9 @@ cmm_timeout_handler(ctl_table *ctl, int write, struct file *filp,
|
||||
return -EFAULT;
|
||||
buf[sizeof(buf) - 1] = '\0';
|
||||
cmm_skip_blanks(buf, &p);
|
||||
pages = cmm_strtoul(p, &p);
|
||||
pages = simple_strtoul(p, &p, 0);
|
||||
cmm_skip_blanks(p, &p);
|
||||
seconds = cmm_strtoul(p, &p);
|
||||
seconds = simple_strtoul(p, &p, 0);
|
||||
cmm_set_timeout(pages, seconds);
|
||||
} else {
|
||||
len = sprintf(buf, "%ld %ld\n",
|
||||
@ -382,24 +366,24 @@ cmm_smsg_target(char *from, char *msg)
|
||||
if (strncmp(msg, "SHRINK", 6) == 0) {
|
||||
if (!cmm_skip_blanks(msg + 6, &msg))
|
||||
return;
|
||||
pages = cmm_strtoul(msg, &msg);
|
||||
pages = simple_strtoul(msg, &msg, 0);
|
||||
cmm_skip_blanks(msg, &msg);
|
||||
if (*msg == '\0')
|
||||
cmm_set_pages(pages);
|
||||
} else if (strncmp(msg, "RELEASE", 7) == 0) {
|
||||
if (!cmm_skip_blanks(msg + 7, &msg))
|
||||
return;
|
||||
pages = cmm_strtoul(msg, &msg);
|
||||
pages = simple_strtoul(msg, &msg, 0);
|
||||
cmm_skip_blanks(msg, &msg);
|
||||
if (*msg == '\0')
|
||||
cmm_add_timed_pages(pages);
|
||||
} else if (strncmp(msg, "REUSE", 5) == 0) {
|
||||
if (!cmm_skip_blanks(msg + 5, &msg))
|
||||
return;
|
||||
pages = cmm_strtoul(msg, &msg);
|
||||
pages = simple_strtoul(msg, &msg, 0);
|
||||
if (!cmm_skip_blanks(msg, &msg))
|
||||
return;
|
||||
seconds = cmm_strtoul(msg, &msg);
|
||||
seconds = simple_strtoul(msg, &msg, 0);
|
||||
cmm_skip_blanks(msg, &msg);
|
||||
if (*msg == '\0')
|
||||
cmm_set_timeout(pages, seconds);
|
||||
|
@ -25,10 +25,12 @@
|
||||
#include <linux/console.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/hardirq.h>
|
||||
#include <linux/kprobes.h>
|
||||
|
||||
#include <asm/system.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/pgtable.h>
|
||||
#include <asm/kdebug.h>
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
#define __FAIL_ADDR_MASK 0x7ffff000
|
||||
@ -48,6 +50,38 @@ extern int sysctl_userprocess_debug;
|
||||
|
||||
extern void die(const char *,struct pt_regs *,long);
|
||||
|
||||
#ifdef CONFIG_KPROBES
|
||||
ATOMIC_NOTIFIER_HEAD(notify_page_fault_chain);
|
||||
int register_page_fault_notifier(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_register(¬ify_page_fault_chain, nb);
|
||||
}
|
||||
|
||||
int unregister_page_fault_notifier(struct notifier_block *nb)
|
||||
{
|
||||
return atomic_notifier_chain_unregister(¬ify_page_fault_chain, nb);
|
||||
}
|
||||
|
||||
static inline int notify_page_fault(enum die_val val, const char *str,
|
||||
struct pt_regs *regs, long err, int trap, int sig)
|
||||
{
|
||||
struct die_args args = {
|
||||
.regs = regs,
|
||||
.str = str,
|
||||
.err = err,
|
||||
.trapnr = trap,
|
||||
.signr = sig
|
||||
};
|
||||
return atomic_notifier_call_chain(¬ify_page_fault_chain, val, &args);
|
||||
}
|
||||
#else
|
||||
static inline int notify_page_fault(enum die_val val, const char *str,
|
||||
struct pt_regs *regs, long err, int trap, int sig)
|
||||
{
|
||||
return NOTIFY_DONE;
|
||||
}
|
||||
#endif
|
||||
|
||||
extern spinlock_t timerlist_lock;
|
||||
|
||||
/*
|
||||
@ -159,7 +193,7 @@ static void do_sigsegv(struct pt_regs *regs, unsigned long error_code,
|
||||
* 11 Page translation -> Not present (nullification)
|
||||
* 3b Region third trans. -> Not present (nullification)
|
||||
*/
|
||||
static inline void
|
||||
static inline void __kprobes
|
||||
do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection)
|
||||
{
|
||||
struct task_struct *tsk;
|
||||
@ -173,6 +207,10 @@ do_exception(struct pt_regs *regs, unsigned long error_code, int is_protection)
|
||||
tsk = current;
|
||||
mm = tsk->mm;
|
||||
|
||||
if (notify_page_fault(DIE_PAGE_FAULT, "page fault", regs, error_code, 14,
|
||||
SIGSEGV) == NOTIFY_STOP)
|
||||
return;
|
||||
|
||||
/*
|
||||
* Check for low-address protection. This needs to be treated
|
||||
* as a special case because the translation exception code
|
||||
|
@ -108,16 +108,23 @@ void __init paging_init(void)
|
||||
unsigned long pgdir_k = (__pa(swapper_pg_dir) & PAGE_MASK) | _KERNSEG_TABLE;
|
||||
static const int ssm_mask = 0x04000000L;
|
||||
unsigned long ro_start_pfn, ro_end_pfn;
|
||||
unsigned long zones_size[MAX_NR_ZONES];
|
||||
|
||||
ro_start_pfn = PFN_DOWN((unsigned long)&__start_rodata);
|
||||
ro_end_pfn = PFN_UP((unsigned long)&__end_rodata);
|
||||
|
||||
memset(zones_size, 0, sizeof(zones_size));
|
||||
zones_size[ZONE_DMA] = max_low_pfn;
|
||||
free_area_init_node(0, &contig_page_data, zones_size,
|
||||
__pa(PAGE_OFFSET) >> PAGE_SHIFT,
|
||||
zholes_size);
|
||||
|
||||
/* unmap whole virtual address space */
|
||||
|
||||
pg_dir = swapper_pg_dir;
|
||||
|
||||
for (i=0;i<KERNEL_PGD_PTRS;i++)
|
||||
pmd_clear((pmd_t*)pg_dir++);
|
||||
for (i = 0; i < PTRS_PER_PGD; i++)
|
||||
pmd_clear((pmd_t *) pg_dir++);
|
||||
|
||||
/*
|
||||
* map whole physical memory to virtual memory (identity mapping)
|
||||
@ -131,10 +138,7 @@ void __init paging_init(void)
|
||||
*/
|
||||
pg_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);
|
||||
|
||||
pg_dir->pgd0 = (_PAGE_TABLE | __pa(pg_table));
|
||||
pg_dir->pgd1 = (_PAGE_TABLE | (__pa(pg_table)+1024));
|
||||
pg_dir->pgd2 = (_PAGE_TABLE | (__pa(pg_table)+2048));
|
||||
pg_dir->pgd3 = (_PAGE_TABLE | (__pa(pg_table)+3072));
|
||||
pmd_populate_kernel(&init_mm, (pmd_t *) pg_dir, pg_table);
|
||||
pg_dir++;
|
||||
|
||||
for (tmp = 0 ; tmp < PTRS_PER_PTE ; tmp++,pg_table++) {
|
||||
@ -143,8 +147,8 @@ void __init paging_init(void)
|
||||
else
|
||||
pte = pfn_pte(pfn, PAGE_KERNEL);
|
||||
if (pfn >= max_low_pfn)
|
||||
pte_clear(&init_mm, 0, &pte);
|
||||
set_pte(pg_table, pte);
|
||||
pte_val(pte) = _PAGE_TYPE_EMPTY;
|
||||
set_pte(pg_table, pte);
|
||||
pfn++;
|
||||
}
|
||||
}
|
||||
@ -159,16 +163,6 @@ void __init paging_init(void)
|
||||
: : "m" (pgdir_k), "m" (ssm_mask));
|
||||
|
||||
local_flush_tlb();
|
||||
|
||||
{
|
||||
unsigned long zones_size[MAX_NR_ZONES];
|
||||
|
||||
memset(zones_size, 0, sizeof(zones_size));
|
||||
zones_size[ZONE_DMA] = max_low_pfn;
|
||||
free_area_init_node(0, &contig_page_data, zones_size,
|
||||
__pa(PAGE_OFFSET) >> PAGE_SHIFT,
|
||||
zholes_size);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
@ -236,10 +230,8 @@ void __init paging_init(void)
|
||||
pte = pfn_pte(pfn, __pgprot(_PAGE_RO));
|
||||
else
|
||||
pte = pfn_pte(pfn, PAGE_KERNEL);
|
||||
if (pfn >= max_low_pfn) {
|
||||
pte_clear(&init_mm, 0, &pte);
|
||||
continue;
|
||||
}
|
||||
if (pfn >= max_low_pfn)
|
||||
pte_val(pte) = _PAGE_TYPE_EMPTY;
|
||||
set_pte(pt_dir, pte);
|
||||
pfn++;
|
||||
}
|
||||
|
@ -1,8 +1,9 @@
|
||||
/*
|
||||
* hypervisor.c - /sys/hypervisor subsystem.
|
||||
*
|
||||
* This file is released under the GPLv2
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
*
|
||||
* This file is released under the GPLv2
|
||||
*/
|
||||
|
||||
#include <linux/kobject.h>
|
||||
|
@ -213,17 +213,35 @@ config MONREADER
|
||||
help
|
||||
Character device driver for reading z/VM monitor service records
|
||||
|
||||
config MONWRITER
|
||||
tristate "API for writing z/VM monitor service records"
|
||||
default "m"
|
||||
help
|
||||
Character device driver for writing z/VM monitor service records
|
||||
|
||||
endmenu
|
||||
|
||||
menu "Cryptographic devices"
|
||||
|
||||
config Z90CRYPT
|
||||
config ZCRYPT
|
||||
tristate "Support for PCI-attached cryptographic adapters"
|
||||
default "m"
|
||||
help
|
||||
select ZCRYPT_MONOLITHIC if ZCRYPT="y"
|
||||
default "m"
|
||||
help
|
||||
Select this option if you want to use a PCI-attached cryptographic
|
||||
adapter like the PCI Cryptographic Accelerator (PCICA) or the PCI
|
||||
Cryptographic Coprocessor (PCICC). This option is also available
|
||||
as a module called z90crypt.ko.
|
||||
adapter like:
|
||||
+ PCI Cryptographic Accelerator (PCICA)
|
||||
+ PCI Cryptographic Coprocessor (PCICC)
|
||||
+ PCI-X Cryptographic Coprocessor (PCIXCC)
|
||||
+ Crypto Express2 Coprocessor (CEX2C)
|
||||
+ Crypto Express2 Accelerator (CEX2A)
|
||||
|
||||
config ZCRYPT_MONOLITHIC
|
||||
bool "Monolithic zcrypt module"
|
||||
depends on ZCRYPT="m"
|
||||
help
|
||||
Select this option if you want to have a single module z90crypt.ko
|
||||
that contains all parts of the crypto device driver (ap bus,
|
||||
request router and all the card drivers).
|
||||
|
||||
endmenu
|
||||
|
@ -184,7 +184,7 @@ dasd_state_known_to_basic(struct dasd_device * device)
|
||||
device->debug_area = debug_register(device->cdev->dev.bus_id, 1, 2,
|
||||
8 * sizeof (long));
|
||||
debug_register_view(device->debug_area, &debug_sprintf_view);
|
||||
debug_set_level(device->debug_area, DBF_EMERG);
|
||||
debug_set_level(device->debug_area, DBF_WARNING);
|
||||
DBF_DEV_EVENT(DBF_EMERG, device, "%s", "debug area created");
|
||||
|
||||
device->state = DASD_STATE_BASIC;
|
||||
@ -893,7 +893,7 @@ dasd_handle_killed_request(struct ccw_device *cdev, unsigned long intparm)
|
||||
|
||||
device = (struct dasd_device *) cqr->device;
|
||||
if (device == NULL ||
|
||||
device != dasd_device_from_cdev(cdev) ||
|
||||
device != dasd_device_from_cdev_locked(cdev) ||
|
||||
strncmp(device->discipline->ebcname, (char *) &cqr->magic, 4)) {
|
||||
MESSAGE(KERN_DEBUG, "invalid device in request: bus_id %s",
|
||||
cdev->dev.bus_id);
|
||||
@ -970,7 +970,7 @@ dasd_int_handler(struct ccw_device *cdev, unsigned long intparm,
|
||||
/* first of all check for state change pending interrupt */
|
||||
mask = DEV_STAT_ATTENTION | DEV_STAT_DEV_END | DEV_STAT_UNIT_EXCEP;
|
||||
if ((irb->scsw.dstat & mask) == mask) {
|
||||
device = dasd_device_from_cdev(cdev);
|
||||
device = dasd_device_from_cdev_locked(cdev);
|
||||
if (!IS_ERR(device)) {
|
||||
dasd_handle_state_change_pending(device);
|
||||
dasd_put_device(device);
|
||||
@ -2169,7 +2169,7 @@ dasd_init(void)
|
||||
goto failed;
|
||||
}
|
||||
debug_register_view(dasd_debug_area, &debug_sprintf_view);
|
||||
debug_set_level(dasd_debug_area, DBF_EMERG);
|
||||
debug_set_level(dasd_debug_area, DBF_WARNING);
|
||||
|
||||
DBF_EVENT(DBF_EMERG, "%s", "debug area created");
|
||||
|
||||
|
@ -258,8 +258,12 @@ dasd_parse_keyword( char *parsestring ) {
|
||||
return residual_str;
|
||||
}
|
||||
if (strncmp("nopav", parsestring, length) == 0) {
|
||||
dasd_nopav = 1;
|
||||
MESSAGE(KERN_INFO, "%s", "disable PAV mode");
|
||||
if (MACHINE_IS_VM)
|
||||
MESSAGE(KERN_INFO, "%s", "'nopav' not supported on VM");
|
||||
else {
|
||||
dasd_nopav = 1;
|
||||
MESSAGE(KERN_INFO, "%s", "disable PAV mode");
|
||||
}
|
||||
return residual_str;
|
||||
}
|
||||
if (strncmp("fixedbuffers", parsestring, length) == 0) {
|
||||
@ -523,17 +527,17 @@ dasd_create_device(struct ccw_device *cdev)
|
||||
{
|
||||
struct dasd_devmap *devmap;
|
||||
struct dasd_device *device;
|
||||
unsigned long flags;
|
||||
int rc;
|
||||
|
||||
devmap = dasd_devmap_from_cdev(cdev);
|
||||
if (IS_ERR(devmap))
|
||||
return (void *) devmap;
|
||||
cdev->dev.driver_data = devmap;
|
||||
|
||||
device = dasd_alloc_device();
|
||||
if (IS_ERR(device))
|
||||
return device;
|
||||
atomic_set(&device->ref_count, 2);
|
||||
atomic_set(&device->ref_count, 3);
|
||||
|
||||
spin_lock(&dasd_devmap_lock);
|
||||
if (!devmap->device) {
|
||||
@ -552,6 +556,11 @@ dasd_create_device(struct ccw_device *cdev)
|
||||
dasd_free_device(device);
|
||||
return ERR_PTR(rc);
|
||||
}
|
||||
|
||||
spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
|
||||
cdev->dev.driver_data = device;
|
||||
spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
|
||||
|
||||
return device;
|
||||
}
|
||||
|
||||
@ -569,6 +578,7 @@ dasd_delete_device(struct dasd_device *device)
|
||||
{
|
||||
struct ccw_device *cdev;
|
||||
struct dasd_devmap *devmap;
|
||||
unsigned long flags;
|
||||
|
||||
/* First remove device pointer from devmap. */
|
||||
devmap = dasd_find_busid(device->cdev->dev.bus_id);
|
||||
@ -582,9 +592,16 @@ dasd_delete_device(struct dasd_device *device)
|
||||
devmap->device = NULL;
|
||||
spin_unlock(&dasd_devmap_lock);
|
||||
|
||||
/* Drop ref_count by 2, one for the devmap reference and
|
||||
* one for the passed reference. */
|
||||
atomic_sub(2, &device->ref_count);
|
||||
/* Disconnect dasd_device structure from ccw_device structure. */
|
||||
spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
|
||||
device->cdev->dev.driver_data = NULL;
|
||||
spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
|
||||
|
||||
/*
|
||||
* Drop ref_count by 3, one for the devmap reference, one for
|
||||
* the cdev reference and one for the passed reference.
|
||||
*/
|
||||
atomic_sub(3, &device->ref_count);
|
||||
|
||||
/* Wait for reference counter to drop to zero. */
|
||||
wait_event(dasd_delete_wq, atomic_read(&device->ref_count) == 0);
|
||||
@ -593,9 +610,6 @@ dasd_delete_device(struct dasd_device *device)
|
||||
cdev = device->cdev;
|
||||
device->cdev = NULL;
|
||||
|
||||
/* Disconnect dasd_devmap structure from ccw_device structure. */
|
||||
cdev->dev.driver_data = NULL;
|
||||
|
||||
/* Put ccw_device structure. */
|
||||
put_device(&cdev->dev);
|
||||
|
||||
@ -613,23 +627,34 @@ dasd_put_device_wake(struct dasd_device *device)
|
||||
wake_up(&dasd_delete_wq);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return dasd_device structure associated with cdev.
|
||||
* This function needs to be called with the ccw device
|
||||
* lock held. It can be used from interrupt context.
|
||||
*/
|
||||
struct dasd_device *
|
||||
dasd_device_from_cdev_locked(struct ccw_device *cdev)
|
||||
{
|
||||
struct dasd_device *device = cdev->dev.driver_data;
|
||||
|
||||
if (!device)
|
||||
return ERR_PTR(-ENODEV);
|
||||
dasd_get_device(device);
|
||||
return device;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return dasd_device structure associated with cdev.
|
||||
*/
|
||||
struct dasd_device *
|
||||
dasd_device_from_cdev(struct ccw_device *cdev)
|
||||
{
|
||||
struct dasd_devmap *devmap;
|
||||
struct dasd_device *device;
|
||||
unsigned long flags;
|
||||
|
||||
device = ERR_PTR(-ENODEV);
|
||||
spin_lock(&dasd_devmap_lock);
|
||||
devmap = cdev->dev.driver_data;
|
||||
if (devmap && devmap->device) {
|
||||
device = devmap->device;
|
||||
dasd_get_device(device);
|
||||
}
|
||||
spin_unlock(&dasd_devmap_lock);
|
||||
spin_lock_irqsave(get_ccwdev_lock(cdev), flags);
|
||||
device = dasd_device_from_cdev_locked(cdev);
|
||||
spin_unlock_irqrestore(get_ccwdev_lock(cdev), flags);
|
||||
return device;
|
||||
}
|
||||
|
||||
@ -730,16 +755,17 @@ static ssize_t
|
||||
dasd_discipline_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct dasd_devmap *devmap;
|
||||
char *dname;
|
||||
struct dasd_device *device;
|
||||
ssize_t len;
|
||||
|
||||
spin_lock(&dasd_devmap_lock);
|
||||
dname = "none";
|
||||
devmap = dev->driver_data;
|
||||
if (devmap && devmap->device && devmap->device->discipline)
|
||||
dname = devmap->device->discipline->name;
|
||||
spin_unlock(&dasd_devmap_lock);
|
||||
return snprintf(buf, PAGE_SIZE, "%s\n", dname);
|
||||
device = dasd_device_from_cdev(to_ccwdev(dev));
|
||||
if (!IS_ERR(device) && device->discipline) {
|
||||
len = snprintf(buf, PAGE_SIZE, "%s\n",
|
||||
device->discipline->name);
|
||||
dasd_put_device(device);
|
||||
} else
|
||||
len = snprintf(buf, PAGE_SIZE, "none\n");
|
||||
return len;
|
||||
}
|
||||
|
||||
static DEVICE_ATTR(discipline, 0444, dasd_discipline_show, NULL);
|
||||
|
@ -678,7 +678,7 @@ int __init dasd_eer_init(void)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void __exit dasd_eer_exit(void)
|
||||
void dasd_eer_exit(void)
|
||||
{
|
||||
WARN_ON(misc_deregister(&dasd_eer_dev) != 0);
|
||||
}
|
||||
|
@ -534,6 +534,7 @@ int dasd_add_sysfs_files(struct ccw_device *);
|
||||
void dasd_remove_sysfs_files(struct ccw_device *);
|
||||
|
||||
struct dasd_device *dasd_device_from_cdev(struct ccw_device *);
|
||||
struct dasd_device *dasd_device_from_cdev_locked(struct ccw_device *);
|
||||
struct dasd_device *dasd_device_from_devindex(int);
|
||||
|
||||
int dasd_parse(void);
|
||||
|
@ -453,7 +453,7 @@ static int __init xpram_init(void)
|
||||
PRINT_WARN("No expanded memory available\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
xpram_pages = xpram_highest_page_index();
|
||||
xpram_pages = xpram_highest_page_index() + 1;
|
||||
PRINT_INFO(" %u pages expanded memory found (%lu KB).\n",
|
||||
xpram_pages, (unsigned long) xpram_pages*4);
|
||||
rc = xpram_setup_sizes(xpram_pages);
|
||||
|
@ -28,3 +28,4 @@ obj-$(CONFIG_S390_TAPE) += tape.o tape_class.o
|
||||
obj-$(CONFIG_S390_TAPE_34XX) += tape_34xx.o
|
||||
obj-$(CONFIG_S390_TAPE_3590) += tape_3590.o
|
||||
obj-$(CONFIG_MONREADER) += monreader.o
|
||||
obj-$(CONFIG_MONWRITER) += monwriter.o
|
||||
|
292
drivers/s390/char/monwriter.c
Normal file
292
drivers/s390/char/monwriter.c
Normal file
@ -0,0 +1,292 @@
|
||||
/*
|
||||
* drivers/s390/char/monwriter.c
|
||||
*
|
||||
* Character device driver for writing z/VM *MONITOR service records.
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
*
|
||||
* Author(s): Melissa Howland <Melissa.Howland@us.ibm.com>
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/errno.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/miscdevice.h>
|
||||
#include <linux/ctype.h>
|
||||
#include <linux/poll.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/ebcdic.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/appldata.h>
|
||||
#include <asm/monwriter.h>
|
||||
|
||||
#define MONWRITE_MAX_DATALEN 4024
|
||||
|
||||
static int mon_max_bufs = 255;
|
||||
|
||||
struct mon_buf {
|
||||
struct list_head list;
|
||||
struct monwrite_hdr hdr;
|
||||
int diag_done;
|
||||
char *data;
|
||||
};
|
||||
|
||||
struct mon_private {
|
||||
struct list_head list;
|
||||
struct monwrite_hdr hdr;
|
||||
size_t hdr_to_read;
|
||||
size_t data_to_read;
|
||||
struct mon_buf *current_buf;
|
||||
int mon_buf_count;
|
||||
};
|
||||
|
||||
/*
|
||||
* helper functions
|
||||
*/
|
||||
|
||||
static int monwrite_diag(struct monwrite_hdr *myhdr, char *buffer, int fcn)
|
||||
{
|
||||
struct appldata_product_id id;
|
||||
int rc;
|
||||
|
||||
strcpy(id.prod_nr, "LNXAPPL");
|
||||
id.prod_fn = myhdr->applid;
|
||||
id.record_nr = myhdr->record_num;
|
||||
id.version_nr = myhdr->version;
|
||||
id.release_nr = myhdr->release;
|
||||
id.mod_lvl = myhdr->mod_level;
|
||||
rc = appldata_asm(&id, fcn, (void *) buffer, myhdr->datalen);
|
||||
if (rc <= 0)
|
||||
return rc;
|
||||
if (rc == 5)
|
||||
return -EPERM;
|
||||
printk("DIAG X'DC' error with return code: %i\n", rc);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline struct mon_buf *monwrite_find_hdr(struct mon_private *monpriv,
|
||||
struct monwrite_hdr *monhdr)
|
||||
{
|
||||
struct mon_buf *entry, *next;
|
||||
|
||||
list_for_each_entry_safe(entry, next, &monpriv->list, list)
|
||||
if (entry->hdr.applid == monhdr->applid &&
|
||||
entry->hdr.record_num == monhdr->record_num &&
|
||||
entry->hdr.version == monhdr->version &&
|
||||
entry->hdr.release == monhdr->release &&
|
||||
entry->hdr.mod_level == monhdr->mod_level)
|
||||
return entry;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int monwrite_new_hdr(struct mon_private *monpriv)
|
||||
{
|
||||
struct monwrite_hdr *monhdr = &monpriv->hdr;
|
||||
struct mon_buf *monbuf;
|
||||
int rc;
|
||||
|
||||
if (monhdr->datalen > MONWRITE_MAX_DATALEN ||
|
||||
monhdr->mon_function > MONWRITE_START_CONFIG ||
|
||||
monhdr->hdrlen != sizeof(struct monwrite_hdr))
|
||||
return -EINVAL;
|
||||
monbuf = monwrite_find_hdr(monpriv, monhdr);
|
||||
if (monbuf) {
|
||||
if (monhdr->mon_function == MONWRITE_STOP_INTERVAL) {
|
||||
monhdr->datalen = monbuf->hdr.datalen;
|
||||
rc = monwrite_diag(monhdr, monbuf->data,
|
||||
APPLDATA_STOP_REC);
|
||||
list_del(&monbuf->list);
|
||||
monpriv->mon_buf_count--;
|
||||
kfree(monbuf->data);
|
||||
kfree(monbuf);
|
||||
monbuf = NULL;
|
||||
}
|
||||
} else {
|
||||
if (monpriv->mon_buf_count >= mon_max_bufs)
|
||||
return -ENOSPC;
|
||||
monbuf = kzalloc(sizeof(struct mon_buf), GFP_KERNEL);
|
||||
if (!monbuf)
|
||||
return -ENOMEM;
|
||||
monbuf->data = kzalloc(monbuf->hdr.datalen,
|
||||
GFP_KERNEL | GFP_DMA);
|
||||
if (!monbuf->data) {
|
||||
kfree(monbuf);
|
||||
return -ENOMEM;
|
||||
}
|
||||
monbuf->hdr = *monhdr;
|
||||
list_add_tail(&monbuf->list, &monpriv->list);
|
||||
monpriv->mon_buf_count++;
|
||||
}
|
||||
monpriv->current_buf = monbuf;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int monwrite_new_data(struct mon_private *monpriv)
|
||||
{
|
||||
struct monwrite_hdr *monhdr = &monpriv->hdr;
|
||||
struct mon_buf *monbuf = monpriv->current_buf;
|
||||
int rc = 0;
|
||||
|
||||
switch (monhdr->mon_function) {
|
||||
case MONWRITE_START_INTERVAL:
|
||||
if (!monbuf->diag_done) {
|
||||
rc = monwrite_diag(monhdr, monbuf->data,
|
||||
APPLDATA_START_INTERVAL_REC);
|
||||
monbuf->diag_done = 1;
|
||||
}
|
||||
break;
|
||||
case MONWRITE_START_CONFIG:
|
||||
if (!monbuf->diag_done) {
|
||||
rc = monwrite_diag(monhdr, monbuf->data,
|
||||
APPLDATA_START_CONFIG_REC);
|
||||
monbuf->diag_done = 1;
|
||||
}
|
||||
break;
|
||||
case MONWRITE_GEN_EVENT:
|
||||
rc = monwrite_diag(monhdr, monbuf->data,
|
||||
APPLDATA_GEN_EVENT_REC);
|
||||
list_del(&monpriv->current_buf->list);
|
||||
kfree(monpriv->current_buf->data);
|
||||
kfree(monpriv->current_buf);
|
||||
monpriv->current_buf = NULL;
|
||||
break;
|
||||
default:
|
||||
/* monhdr->mon_function is checked in monwrite_new_hdr */
|
||||
BUG();
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
/*
|
||||
* file operations
|
||||
*/
|
||||
|
||||
static int monwrite_open(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct mon_private *monpriv;
|
||||
|
||||
monpriv = kzalloc(sizeof(struct mon_private), GFP_KERNEL);
|
||||
if (!monpriv)
|
||||
return -ENOMEM;
|
||||
INIT_LIST_HEAD(&monpriv->list);
|
||||
monpriv->hdr_to_read = sizeof(monpriv->hdr);
|
||||
filp->private_data = monpriv;
|
||||
return nonseekable_open(inode, filp);
|
||||
}
|
||||
|
||||
static int monwrite_close(struct inode *inode, struct file *filp)
|
||||
{
|
||||
struct mon_private *monpriv = filp->private_data;
|
||||
struct mon_buf *entry, *next;
|
||||
|
||||
list_for_each_entry_safe(entry, next, &monpriv->list, list) {
|
||||
if (entry->hdr.mon_function != MONWRITE_GEN_EVENT)
|
||||
monwrite_diag(&entry->hdr, entry->data,
|
||||
APPLDATA_STOP_REC);
|
||||
monpriv->mon_buf_count--;
|
||||
list_del(&entry->list);
|
||||
kfree(entry->data);
|
||||
kfree(entry);
|
||||
}
|
||||
kfree(monpriv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static ssize_t monwrite_write(struct file *filp, const char __user *data,
|
||||
size_t count, loff_t *ppos)
|
||||
{
|
||||
struct mon_private *monpriv = filp->private_data;
|
||||
size_t len, written;
|
||||
void *to;
|
||||
int rc;
|
||||
|
||||
for (written = 0; written < count; ) {
|
||||
if (monpriv->hdr_to_read) {
|
||||
len = min(count - written, monpriv->hdr_to_read);
|
||||
to = (char *) &monpriv->hdr +
|
||||
sizeof(monpriv->hdr) - monpriv->hdr_to_read;
|
||||
if (copy_from_user(to, data + written, len)) {
|
||||
rc = -EFAULT;
|
||||
goto out_error;
|
||||
}
|
||||
monpriv->hdr_to_read -= len;
|
||||
written += len;
|
||||
if (monpriv->hdr_to_read > 0)
|
||||
continue;
|
||||
rc = monwrite_new_hdr(monpriv);
|
||||
if (rc)
|
||||
goto out_error;
|
||||
monpriv->data_to_read = monpriv->current_buf ?
|
||||
monpriv->current_buf->hdr.datalen : 0;
|
||||
}
|
||||
|
||||
if (monpriv->data_to_read) {
|
||||
len = min(count - written, monpriv->data_to_read);
|
||||
to = monpriv->current_buf->data +
|
||||
monpriv->hdr.datalen - monpriv->data_to_read;
|
||||
if (copy_from_user(to, data + written, len)) {
|
||||
rc = -EFAULT;
|
||||
goto out_error;
|
||||
}
|
||||
monpriv->data_to_read -= len;
|
||||
written += len;
|
||||
if (monpriv->data_to_read > 0)
|
||||
continue;
|
||||
rc = monwrite_new_data(monpriv);
|
||||
if (rc)
|
||||
goto out_error;
|
||||
}
|
||||
monpriv->hdr_to_read = sizeof(monpriv->hdr);
|
||||
}
|
||||
return written;
|
||||
|
||||
out_error:
|
||||
monpriv->data_to_read = 0;
|
||||
monpriv->hdr_to_read = sizeof(struct monwrite_hdr);
|
||||
return rc;
|
||||
}
|
||||
|
||||
static struct file_operations monwrite_fops = {
|
||||
.owner = THIS_MODULE,
|
||||
.open = &monwrite_open,
|
||||
.release = &monwrite_close,
|
||||
.write = &monwrite_write,
|
||||
};
|
||||
|
||||
static struct miscdevice mon_dev = {
|
||||
.name = "monwriter",
|
||||
.fops = &monwrite_fops,
|
||||
.minor = MISC_DYNAMIC_MINOR,
|
||||
};
|
||||
|
||||
/*
|
||||
* module init/exit
|
||||
*/
|
||||
|
||||
static int __init mon_init(void)
|
||||
{
|
||||
if (MACHINE_IS_VM)
|
||||
return misc_register(&mon_dev);
|
||||
else
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
static void __exit mon_exit(void)
|
||||
{
|
||||
WARN_ON(misc_deregister(&mon_dev) != 0);
|
||||
}
|
||||
|
||||
module_init(mon_init);
|
||||
module_exit(mon_exit);
|
||||
|
||||
module_param_named(max_bufs, mon_max_bufs, int, 0644);
|
||||
MODULE_PARM_DESC(max_bufs, "Maximum number of sample monitor data buffers"
|
||||
"that can be active at one time");
|
||||
|
||||
MODULE_AUTHOR("Melissa Howland <Melissa.Howland@us.ibm.com>");
|
||||
MODULE_DESCRIPTION("Character device driver for writing z/VM "
|
||||
"APPLDATA monitor records.");
|
||||
MODULE_LICENSE("GPL");
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Copyright (C) 2004,2005 IBM Corporation
|
||||
* Interface implementation for communication with the v/VM control program
|
||||
* Interface implementation for communication with the z/VM control program
|
||||
* Author(s): Christian Borntraeger <cborntra@de.ibm.com>
|
||||
*
|
||||
*
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Copyright (C) 2004, 2005 IBM Corporation
|
||||
* Interface implementation for communication with the v/VM control program
|
||||
* Interface implementation for communication with the z/VM control program
|
||||
* Version 1.0
|
||||
* Author(s): Christian Borntraeger <cborntra@de.ibm.com>
|
||||
*
|
||||
|
@ -256,7 +256,7 @@ s390_subchannel_remove_chpid(struct device *dev, void *data)
|
||||
/* trigger path verification. */
|
||||
if (sch->driver && sch->driver->verify)
|
||||
sch->driver->verify(&sch->dev);
|
||||
else if (sch->vpm == mask)
|
||||
else if (sch->lpm == mask)
|
||||
goto out_unreg;
|
||||
out_unlock:
|
||||
spin_unlock_irq(&sch->lock);
|
||||
@ -378,6 +378,7 @@ __s390_process_res_acc(struct subchannel_id schid, void *data)
|
||||
|
||||
if (chp_mask == 0) {
|
||||
spin_unlock_irq(&sch->lock);
|
||||
put_device(&sch->dev);
|
||||
return 0;
|
||||
}
|
||||
old_lpm = sch->lpm;
|
||||
@ -392,7 +393,7 @@ __s390_process_res_acc(struct subchannel_id schid, void *data)
|
||||
|
||||
spin_unlock_irq(&sch->lock);
|
||||
put_device(&sch->dev);
|
||||
return (res_data->fla_mask == 0xffff) ? -ENODEV : 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
@ -16,11 +16,10 @@
|
||||
#include <linux/device.h>
|
||||
#include <linux/kernel_stat.h>
|
||||
#include <linux/interrupt.h>
|
||||
|
||||
#include <asm/cio.h>
|
||||
#include <asm/delay.h>
|
||||
#include <asm/irq.h>
|
||||
|
||||
#include <asm/setup.h>
|
||||
#include "airq.h"
|
||||
#include "cio.h"
|
||||
#include "css.h"
|
||||
@ -192,7 +191,7 @@ cio_start_key (struct subchannel *sch, /* subchannel structure */
|
||||
sch->orb.pfch = sch->options.prefetch == 0;
|
||||
sch->orb.spnd = sch->options.suspend;
|
||||
sch->orb.ssic = sch->options.suspend && sch->options.inter;
|
||||
sch->orb.lpm = (lpm != 0) ? (lpm & sch->opm) : sch->lpm;
|
||||
sch->orb.lpm = (lpm != 0) ? lpm : sch->lpm;
|
||||
#ifdef CONFIG_64BIT
|
||||
/*
|
||||
* for 64 bit we always support 64 bit IDAWs with 4k page size only
|
||||
@ -570,10 +569,7 @@ cio_validate_subchannel (struct subchannel *sch, struct subchannel_id schid)
|
||||
sch->opm = 0xff;
|
||||
if (!cio_is_console(sch->schid))
|
||||
chsc_validate_chpids(sch);
|
||||
sch->lpm = sch->schib.pmcw.pim &
|
||||
sch->schib.pmcw.pam &
|
||||
sch->schib.pmcw.pom &
|
||||
sch->opm;
|
||||
sch->lpm = sch->schib.pmcw.pam & sch->opm;
|
||||
|
||||
CIO_DEBUG(KERN_INFO, 0,
|
||||
"Detected device %04x on subchannel 0.%x.%04X"
|
||||
@ -841,14 +837,26 @@ __clear_subchannel_easy(struct subchannel_id schid)
|
||||
return -EBUSY;
|
||||
}
|
||||
|
||||
extern void do_reipl(unsigned long devno);
|
||||
static int
|
||||
__shutdown_subchannel_easy(struct subchannel_id schid, void *data)
|
||||
struct sch_match_id {
|
||||
struct subchannel_id schid;
|
||||
struct ccw_dev_id devid;
|
||||
int rc;
|
||||
};
|
||||
|
||||
static int __shutdown_subchannel_easy_and_match(struct subchannel_id schid,
|
||||
void *data)
|
||||
{
|
||||
struct schib schib;
|
||||
struct sch_match_id *match_id = data;
|
||||
|
||||
if (stsch_err(schid, &schib))
|
||||
return -ENXIO;
|
||||
if (match_id && schib.pmcw.dnv &&
|
||||
(schib.pmcw.dev == match_id->devid.devno) &&
|
||||
(schid.ssid == match_id->devid.ssid)) {
|
||||
match_id->schid = schid;
|
||||
match_id->rc = 0;
|
||||
}
|
||||
if (!schib.pmcw.ena)
|
||||
return 0;
|
||||
switch(__disable_subchannel_easy(schid, &schib)) {
|
||||
@ -864,18 +872,71 @@ __shutdown_subchannel_easy(struct subchannel_id schid, void *data)
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
clear_all_subchannels(void)
|
||||
static int clear_all_subchannels_and_match(struct ccw_dev_id *devid,
|
||||
struct subchannel_id *schid)
|
||||
{
|
||||
struct sch_match_id match_id;
|
||||
|
||||
match_id.devid = *devid;
|
||||
match_id.rc = -ENODEV;
|
||||
local_irq_disable();
|
||||
for_each_subchannel(__shutdown_subchannel_easy, NULL);
|
||||
for_each_subchannel(__shutdown_subchannel_easy_and_match, &match_id);
|
||||
if (match_id.rc == 0)
|
||||
*schid = match_id.schid;
|
||||
return match_id.rc;
|
||||
}
|
||||
|
||||
/* Make sure all subchannels are quiet before we re-ipl an lpar. */
|
||||
void
|
||||
reipl(unsigned long devno)
|
||||
|
||||
void clear_all_subchannels(void)
|
||||
{
|
||||
clear_all_subchannels();
|
||||
cio_reset_channel_paths();
|
||||
do_reipl(devno);
|
||||
local_irq_disable();
|
||||
for_each_subchannel(__shutdown_subchannel_easy_and_match, NULL);
|
||||
}
|
||||
|
||||
extern void do_reipl_asm(__u32 schid);
|
||||
|
||||
/* Make sure all subchannels are quiet before we re-ipl an lpar. */
|
||||
void reipl_ccw_dev(struct ccw_dev_id *devid)
|
||||
{
|
||||
struct subchannel_id schid;
|
||||
|
||||
if (clear_all_subchannels_and_match(devid, &schid))
|
||||
panic("IPL Device not found\n");
|
||||
cio_reset_channel_paths();
|
||||
do_reipl_asm(*((__u32*)&schid));
|
||||
}
|
||||
|
||||
extern struct schib ipl_schib;
|
||||
|
||||
/*
|
||||
* ipl_save_parameters gets called very early. It is not allowed to access
|
||||
* anything in the bss section at all. The bss section is not cleared yet,
|
||||
* but may contain some ipl parameters written by the firmware.
|
||||
* These parameters (if present) are copied to 0x2000.
|
||||
* To avoid corruption of the ipl parameters, all variables used by this
|
||||
* function must reside on the stack or in the data section.
|
||||
*/
|
||||
void ipl_save_parameters(void)
|
||||
{
|
||||
struct subchannel_id schid;
|
||||
unsigned int *ipl_ptr;
|
||||
void *src, *dst;
|
||||
|
||||
schid = *(struct subchannel_id *)__LC_SUBCHANNEL_ID;
|
||||
if (!schid.one)
|
||||
return;
|
||||
if (stsch(schid, &ipl_schib))
|
||||
return;
|
||||
if (!ipl_schib.pmcw.dnv)
|
||||
return;
|
||||
ipl_devno = ipl_schib.pmcw.dev;
|
||||
ipl_flags |= IPL_DEVNO_VALID;
|
||||
if (!ipl_schib.pmcw.qf)
|
||||
return;
|
||||
ipl_flags |= IPL_PARMBLOCK_VALID;
|
||||
ipl_ptr = (unsigned int *)__LC_IPL_PARMBLOCK_PTR;
|
||||
src = (void *)(unsigned long)*ipl_ptr;
|
||||
dst = (void *)IPL_PARMBLOCK_ORIGIN;
|
||||
memmove(dst, src, PAGE_SIZE);
|
||||
*ipl_ptr = IPL_PARMBLOCK_ORIGIN;
|
||||
}
|
||||
|
@ -182,136 +182,141 @@ get_subchannel_by_schid(struct subchannel_id schid)
|
||||
return dev ? to_subchannel(dev) : NULL;
|
||||
}
|
||||
|
||||
|
||||
static inline int
|
||||
css_get_subchannel_status(struct subchannel *sch, struct subchannel_id schid)
|
||||
static inline int css_get_subchannel_status(struct subchannel *sch)
|
||||
{
|
||||
struct schib schib;
|
||||
int cc;
|
||||
|
||||
cc = stsch(schid, &schib);
|
||||
if (cc)
|
||||
if (stsch(sch->schid, &schib) || !schib.pmcw.dnv)
|
||||
return CIO_GONE;
|
||||
if (!schib.pmcw.dnv)
|
||||
return CIO_GONE;
|
||||
if (sch && sch->schib.pmcw.dnv &&
|
||||
(schib.pmcw.dev != sch->schib.pmcw.dev))
|
||||
if (sch->schib.pmcw.dnv && (schib.pmcw.dev != sch->schib.pmcw.dev))
|
||||
return CIO_REVALIDATE;
|
||||
if (sch && !sch->lpm)
|
||||
if (!sch->lpm)
|
||||
return CIO_NO_PATH;
|
||||
return CIO_OPER;
|
||||
}
|
||||
|
||||
static int
|
||||
css_evaluate_subchannel(struct subchannel_id schid, int slow)
|
||||
|
||||
static int css_evaluate_known_subchannel(struct subchannel *sch, int slow)
|
||||
{
|
||||
int event, ret, disc;
|
||||
struct subchannel *sch;
|
||||
unsigned long flags;
|
||||
enum { NONE, UNREGISTER, UNREGISTER_PROBE, REPROBE } action;
|
||||
|
||||
sch = get_subchannel_by_schid(schid);
|
||||
disc = sch ? device_is_disconnected(sch) : 0;
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
disc = device_is_disconnected(sch);
|
||||
if (disc && slow) {
|
||||
if (sch)
|
||||
put_device(&sch->dev);
|
||||
return 0; /* Already processed. */
|
||||
/* Disconnected devices are evaluated directly only.*/
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
* We've got a machine check, so running I/O won't get an interrupt.
|
||||
* Kill any pending timers.
|
||||
*/
|
||||
if (sch)
|
||||
device_kill_pending_timer(sch);
|
||||
/* No interrupt after machine check - kill pending timers. */
|
||||
device_kill_pending_timer(sch);
|
||||
if (!disc && !slow) {
|
||||
if (sch)
|
||||
put_device(&sch->dev);
|
||||
return -EAGAIN; /* Will be done on the slow path. */
|
||||
/* Non-disconnected devices are evaluated on the slow path. */
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
return -EAGAIN;
|
||||
}
|
||||
event = css_get_subchannel_status(sch, schid);
|
||||
event = css_get_subchannel_status(sch);
|
||||
CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, %s, %s path.\n",
|
||||
schid.ssid, schid.sch_no, event,
|
||||
sch?(disc?"disconnected":"normal"):"unknown",
|
||||
slow?"slow":"fast");
|
||||
sch->schid.ssid, sch->schid.sch_no, event,
|
||||
disc ? "disconnected" : "normal",
|
||||
slow ? "slow" : "fast");
|
||||
/* Analyze subchannel status. */
|
||||
action = NONE;
|
||||
switch (event) {
|
||||
case CIO_NO_PATH:
|
||||
if (disc) {
|
||||
/* Check if paths have become available. */
|
||||
action = REPROBE;
|
||||
break;
|
||||
}
|
||||
/* fall through */
|
||||
case CIO_GONE:
|
||||
if (!sch) {
|
||||
/* Never used this subchannel. Ignore. */
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
if (disc && (event == CIO_NO_PATH)) {
|
||||
/*
|
||||
* Uargh, hack again. Because we don't get a machine
|
||||
* check on configure on, our path bookkeeping can
|
||||
* be out of date here (it's fine while we only do
|
||||
* logical varying or get chsc machine checks). We
|
||||
* need to force reprobing or we might miss devices
|
||||
* coming operational again. It won't do harm in real
|
||||
* no path situations.
|
||||
*/
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
device_trigger_reprobe(sch);
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
if (sch->driver && sch->driver->notify &&
|
||||
sch->driver->notify(&sch->dev, event)) {
|
||||
cio_disable_subchannel(sch);
|
||||
device_set_disconnected(sch);
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
/*
|
||||
* Unregister subchannel.
|
||||
* The device will be killed automatically.
|
||||
*/
|
||||
/* Prevent unwanted effects when opening lock. */
|
||||
cio_disable_subchannel(sch);
|
||||
device_set_disconnected(sch);
|
||||
/* Ask driver what to do with device. */
|
||||
action = UNREGISTER;
|
||||
if (sch->driver && sch->driver->notify) {
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
ret = sch->driver->notify(&sch->dev, event);
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
if (ret)
|
||||
action = NONE;
|
||||
}
|
||||
break;
|
||||
case CIO_REVALIDATE:
|
||||
/* Device will be removed, so no notify necessary. */
|
||||
if (disc)
|
||||
/* Reprobe because immediate unregister might block. */
|
||||
action = REPROBE;
|
||||
else
|
||||
action = UNREGISTER_PROBE;
|
||||
break;
|
||||
case CIO_OPER:
|
||||
if (disc)
|
||||
/* Get device operational again. */
|
||||
action = REPROBE;
|
||||
break;
|
||||
}
|
||||
/* Perform action. */
|
||||
ret = 0;
|
||||
switch (action) {
|
||||
case UNREGISTER:
|
||||
case UNREGISTER_PROBE:
|
||||
/* Unregister device (will use subchannel lock). */
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
css_sch_device_unregister(sch);
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
|
||||
/* Reset intparm to zeroes. */
|
||||
sch->schib.pmcw.intparm = 0;
|
||||
cio_modify(sch);
|
||||
put_device(&sch->dev);
|
||||
ret = 0;
|
||||
|
||||
/* Probe if necessary. */
|
||||
if (action == UNREGISTER_PROBE)
|
||||
ret = css_probe_device(sch->schid);
|
||||
break;
|
||||
case CIO_REVALIDATE:
|
||||
/*
|
||||
* Revalidation machine check. Sick.
|
||||
* We don't notify the driver since we have to throw the device
|
||||
* away in any case.
|
||||
*/
|
||||
if (!disc) {
|
||||
css_sch_device_unregister(sch);
|
||||
/* Reset intparm to zeroes. */
|
||||
sch->schib.pmcw.intparm = 0;
|
||||
cio_modify(sch);
|
||||
put_device(&sch->dev);
|
||||
ret = css_probe_device(schid);
|
||||
} else {
|
||||
/*
|
||||
* We can't immediately deregister the disconnected
|
||||
* device since it might block.
|
||||
*/
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
device_trigger_reprobe(sch);
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
ret = 0;
|
||||
}
|
||||
break;
|
||||
case CIO_OPER:
|
||||
if (disc) {
|
||||
spin_lock_irqsave(&sch->lock, flags);
|
||||
/* Get device operational again. */
|
||||
device_trigger_reprobe(sch);
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
}
|
||||
ret = sch ? 0 : css_probe_device(schid);
|
||||
case REPROBE:
|
||||
device_trigger_reprobe(sch);
|
||||
break;
|
||||
default:
|
||||
BUG();
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
spin_unlock_irqrestore(&sch->lock, flags);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int css_evaluate_new_subchannel(struct subchannel_id schid, int slow)
|
||||
{
|
||||
struct schib schib;
|
||||
|
||||
if (!slow) {
|
||||
/* Will be done on the slow path. */
|
||||
return -EAGAIN;
|
||||
}
|
||||
if (stsch(schid, &schib) || !schib.pmcw.dnv) {
|
||||
/* Unusable - ignore. */
|
||||
return 0;
|
||||
}
|
||||
CIO_MSG_EVENT(4, "Evaluating schid 0.%x.%04x, event %d, unknown, "
|
||||
"slow path.\n", schid.ssid, schid.sch_no, CIO_OPER);
|
||||
|
||||
return css_probe_device(schid);
|
||||
}
|
||||
|
||||
static int css_evaluate_subchannel(struct subchannel_id schid, int slow)
|
||||
{
|
||||
struct subchannel *sch;
|
||||
int ret;
|
||||
|
||||
sch = get_subchannel_by_schid(schid);
|
||||
if (sch) {
|
||||
ret = css_evaluate_known_subchannel(sch, slow);
|
||||
put_device(&sch->dev);
|
||||
} else
|
||||
ret = css_evaluate_new_subchannel(schid, slow);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
@ -52,53 +52,81 @@ ccw_bus_match (struct device * dev, struct device_driver * drv)
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Hotplugging interface for ccw devices.
|
||||
* Heavily modeled on pci and usb hotplug.
|
||||
*/
|
||||
static int
|
||||
ccw_uevent (struct device *dev, char **envp, int num_envp,
|
||||
char *buffer, int buffer_size)
|
||||
/* Store modalias string delimited by prefix/suffix string into buffer with
|
||||
* specified size. Return length of resulting string (excluding trailing '\0')
|
||||
* even if string doesn't fit buffer (snprintf semantics). */
|
||||
static int snprint_alias(char *buf, size_t size, const char *prefix,
|
||||
struct ccw_device_id *id, const char *suffix)
|
||||
{
|
||||
int len;
|
||||
|
||||
len = snprintf(buf, size, "%sccw:t%04Xm%02X", prefix, id->cu_type,
|
||||
id->cu_model);
|
||||
if (len > size)
|
||||
return len;
|
||||
buf += len;
|
||||
size -= len;
|
||||
|
||||
if (id->dev_type != 0)
|
||||
len += snprintf(buf, size, "dt%04Xdm%02X%s", id->dev_type,
|
||||
id->dev_model, suffix);
|
||||
else
|
||||
len += snprintf(buf, size, "dtdm%s", suffix);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
/* Set up environment variables for ccw device uevent. Return 0 on success,
|
||||
* non-zero otherwise. */
|
||||
static int ccw_uevent(struct device *dev, char **envp, int num_envp,
|
||||
char *buffer, int buffer_size)
|
||||
{
|
||||
struct ccw_device *cdev = to_ccwdev(dev);
|
||||
struct ccw_device_id *id = &(cdev->id);
|
||||
int i = 0;
|
||||
int length = 0;
|
||||
int len;
|
||||
|
||||
if (!cdev)
|
||||
return -ENODEV;
|
||||
|
||||
/* what we want to pass to /sbin/hotplug */
|
||||
|
||||
envp[i++] = buffer;
|
||||
length += scnprintf(buffer, buffer_size - length, "CU_TYPE=%04X",
|
||||
cdev->id.cu_type);
|
||||
if ((buffer_size - length <= 0) || (i >= num_envp))
|
||||
/* CU_TYPE= */
|
||||
len = snprintf(buffer, buffer_size, "CU_TYPE=%04X", id->cu_type) + 1;
|
||||
if (len > buffer_size || i >= num_envp)
|
||||
return -ENOMEM;
|
||||
++length;
|
||||
buffer += length;
|
||||
|
||||
envp[i++] = buffer;
|
||||
length += scnprintf(buffer, buffer_size - length, "CU_MODEL=%02X",
|
||||
cdev->id.cu_model);
|
||||
if ((buffer_size - length <= 0) || (i >= num_envp))
|
||||
buffer += len;
|
||||
buffer_size -= len;
|
||||
|
||||
/* CU_MODEL= */
|
||||
len = snprintf(buffer, buffer_size, "CU_MODEL=%02X", id->cu_model) + 1;
|
||||
if (len > buffer_size || i >= num_envp)
|
||||
return -ENOMEM;
|
||||
++length;
|
||||
buffer += length;
|
||||
envp[i++] = buffer;
|
||||
buffer += len;
|
||||
buffer_size -= len;
|
||||
|
||||
/* The next two can be zero, that's ok for us */
|
||||
envp[i++] = buffer;
|
||||
length += scnprintf(buffer, buffer_size - length, "DEV_TYPE=%04X",
|
||||
cdev->id.dev_type);
|
||||
if ((buffer_size - length <= 0) || (i >= num_envp))
|
||||
/* DEV_TYPE= */
|
||||
len = snprintf(buffer, buffer_size, "DEV_TYPE=%04X", id->dev_type) + 1;
|
||||
if (len > buffer_size || i >= num_envp)
|
||||
return -ENOMEM;
|
||||
++length;
|
||||
buffer += length;
|
||||
envp[i++] = buffer;
|
||||
buffer += len;
|
||||
buffer_size -= len;
|
||||
|
||||
envp[i++] = buffer;
|
||||
length += scnprintf(buffer, buffer_size - length, "DEV_MODEL=%02X",
|
||||
cdev->id.dev_model);
|
||||
if ((buffer_size - length <= 0) || (i >= num_envp))
|
||||
/* DEV_MODEL= */
|
||||
len = snprintf(buffer, buffer_size, "DEV_MODEL=%02X",
|
||||
(unsigned char) id->dev_model) + 1;
|
||||
if (len > buffer_size || i >= num_envp)
|
||||
return -ENOMEM;
|
||||
envp[i++] = buffer;
|
||||
buffer += len;
|
||||
buffer_size -= len;
|
||||
|
||||
/* MODALIAS= */
|
||||
len = snprint_alias(buffer, buffer_size, "MODALIAS=", id, "") + 1;
|
||||
if (len > buffer_size || i >= num_envp)
|
||||
return -ENOMEM;
|
||||
envp[i++] = buffer;
|
||||
buffer += len;
|
||||
buffer_size -= len;
|
||||
|
||||
envp[i] = NULL;
|
||||
|
||||
@ -251,16 +279,11 @@ modalias_show (struct device *dev, struct device_attribute *attr, char *buf)
|
||||
{
|
||||
struct ccw_device *cdev = to_ccwdev(dev);
|
||||
struct ccw_device_id *id = &(cdev->id);
|
||||
int ret;
|
||||
int len;
|
||||
|
||||
ret = sprintf(buf, "ccw:t%04Xm%02X",
|
||||
id->cu_type, id->cu_model);
|
||||
if (id->dev_type != 0)
|
||||
ret += sprintf(buf + ret, "dt%04Xdm%02X\n",
|
||||
id->dev_type, id->dev_model);
|
||||
else
|
||||
ret += sprintf(buf + ret, "dtdm\n");
|
||||
return ret;
|
||||
len = snprint_alias(buf, PAGE_SIZE, "", id, "\n") + 1;
|
||||
|
||||
return len > PAGE_SIZE ? PAGE_SIZE : len;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
|
@ -232,10 +232,7 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
|
||||
*/
|
||||
old_lpm = sch->lpm;
|
||||
stsch(sch->schid, &sch->schib);
|
||||
sch->lpm = sch->schib.pmcw.pim &
|
||||
sch->schib.pmcw.pam &
|
||||
sch->schib.pmcw.pom &
|
||||
sch->opm;
|
||||
sch->lpm = sch->schib.pmcw.pam & sch->opm;
|
||||
/* Check since device may again have become not operational. */
|
||||
if (!sch->schib.pmcw.dnv)
|
||||
state = DEV_STATE_NOT_OPER;
|
||||
@ -267,6 +264,7 @@ ccw_device_recog_done(struct ccw_device *cdev, int state)
|
||||
notify = 1;
|
||||
}
|
||||
/* fill out sense information */
|
||||
memset(&cdev->id, 0, sizeof(cdev->id));
|
||||
cdev->id.cu_type = cdev->private->senseid.cu_type;
|
||||
cdev->id.cu_model = cdev->private->senseid.cu_model;
|
||||
cdev->id.dev_type = cdev->private->senseid.dev_type;
|
||||
@ -454,8 +452,8 @@ ccw_device_sense_pgid_done(struct ccw_device *cdev, int err)
|
||||
return;
|
||||
}
|
||||
/* Start Path Group verification. */
|
||||
sch->vpm = 0; /* Start with no path groups set. */
|
||||
cdev->private->state = DEV_STATE_VERIFY;
|
||||
cdev->private->flags.doverify = 0;
|
||||
ccw_device_verify_start(cdev);
|
||||
}
|
||||
|
||||
@ -555,7 +553,19 @@ ccw_device_nopath_notify(void *data)
|
||||
void
|
||||
ccw_device_verify_done(struct ccw_device *cdev, int err)
|
||||
{
|
||||
cdev->private->flags.doverify = 0;
|
||||
struct subchannel *sch;
|
||||
|
||||
sch = to_subchannel(cdev->dev.parent);
|
||||
/* Update schib - pom may have changed. */
|
||||
stsch(sch->schid, &sch->schib);
|
||||
/* Update lpm with verified path mask. */
|
||||
sch->lpm = sch->vpm;
|
||||
/* Repeat path verification? */
|
||||
if (cdev->private->flags.doverify) {
|
||||
cdev->private->flags.doverify = 0;
|
||||
ccw_device_verify_start(cdev);
|
||||
return;
|
||||
}
|
||||
switch (err) {
|
||||
case -EOPNOTSUPP: /* path grouping not supported, just set online. */
|
||||
cdev->private->options.pgroup = 0;
|
||||
@ -613,6 +623,7 @@ ccw_device_online(struct ccw_device *cdev)
|
||||
if (!cdev->private->options.pgroup) {
|
||||
/* Start initial path verification. */
|
||||
cdev->private->state = DEV_STATE_VERIFY;
|
||||
cdev->private->flags.doverify = 0;
|
||||
ccw_device_verify_start(cdev);
|
||||
return 0;
|
||||
}
|
||||
@ -659,7 +670,6 @@ ccw_device_offline(struct ccw_device *cdev)
|
||||
/* Are we doing path grouping? */
|
||||
if (!cdev->private->options.pgroup) {
|
||||
/* No, set state offline immediately. */
|
||||
sch->vpm = 0;
|
||||
ccw_device_done(cdev, DEV_STATE_OFFLINE);
|
||||
return 0;
|
||||
}
|
||||
@ -780,6 +790,7 @@ ccw_device_online_verify(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
}
|
||||
/* Device is idle, we can do the path verification. */
|
||||
cdev->private->state = DEV_STATE_VERIFY;
|
||||
cdev->private->flags.doverify = 0;
|
||||
ccw_device_verify_start(cdev);
|
||||
}
|
||||
|
||||
@ -1042,9 +1053,9 @@ ccw_device_wait4io_timeout(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
}
|
||||
|
||||
static void
|
||||
ccw_device_wait4io_verify(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
ccw_device_delay_verify(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
{
|
||||
/* When the I/O has terminated, we have to start verification. */
|
||||
/* Start verification after current task finished. */
|
||||
cdev->private->flags.doverify = 1;
|
||||
}
|
||||
|
||||
@ -1110,10 +1121,7 @@ device_trigger_reprobe(struct subchannel *sch)
|
||||
* The pim, pam, pom values may not be accurate, but they are the best
|
||||
* we have before performing device selection :/
|
||||
*/
|
||||
sch->lpm = sch->schib.pmcw.pim &
|
||||
sch->schib.pmcw.pam &
|
||||
sch->schib.pmcw.pom &
|
||||
sch->opm;
|
||||
sch->lpm = sch->schib.pmcw.pam & sch->opm;
|
||||
/* Re-set some bits in the pmcw that were lost. */
|
||||
sch->schib.pmcw.isc = 3;
|
||||
sch->schib.pmcw.csense = 1;
|
||||
@ -1237,7 +1245,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
|
||||
[DEV_EVENT_INTERRUPT] = ccw_device_verify_irq,
|
||||
[DEV_EVENT_TIMEOUT] = ccw_device_onoff_timeout,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_nop,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_delay_verify,
|
||||
},
|
||||
[DEV_STATE_ONLINE] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
|
||||
@ -1280,7 +1288,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_online_notoper,
|
||||
[DEV_EVENT_INTERRUPT] = ccw_device_wait4io_irq,
|
||||
[DEV_EVENT_TIMEOUT] = ccw_device_wait4io_timeout,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_wait4io_verify,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_delay_verify,
|
||||
},
|
||||
[DEV_STATE_QUIESCE] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_quiesce_done,
|
||||
@ -1293,7 +1301,7 @@ fsm_func_t *dev_jumptable[NR_DEV_STATES][NR_DEV_EVENTS] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_nop,
|
||||
[DEV_EVENT_INTERRUPT] = ccw_device_start_id,
|
||||
[DEV_EVENT_TIMEOUT] = ccw_device_bug,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_nop,
|
||||
[DEV_EVENT_VERIFY] = ccw_device_start_id,
|
||||
},
|
||||
[DEV_STATE_DISCONNECTED_SENSE_ID] = {
|
||||
[DEV_EVENT_NOTOPER] = ccw_device_recog_notoper,
|
||||
|
@ -96,6 +96,12 @@ ccw_device_start_key(struct ccw_device *cdev, struct ccw1 *cpa,
|
||||
ret = cio_set_options (sch, flags);
|
||||
if (ret)
|
||||
return ret;
|
||||
/* Adjust requested path mask to excluded varied off paths. */
|
||||
if (lpm) {
|
||||
lpm &= sch->opm;
|
||||
if (lpm == 0)
|
||||
return -EACCES;
|
||||
}
|
||||
ret = cio_start_key (sch, cpa, lpm, key);
|
||||
if (ret == 0)
|
||||
cdev->private->intparm = intparm;
|
||||
@ -250,7 +256,7 @@ ccw_device_get_path_mask(struct ccw_device *cdev)
|
||||
if (!sch)
|
||||
return 0;
|
||||
else
|
||||
return sch->vpm;
|
||||
return sch->lpm;
|
||||
}
|
||||
|
||||
static void
|
||||
@ -304,7 +310,7 @@ __ccw_device_retry_loop(struct ccw_device *cdev, struct ccw1 *ccw, long magic, _
|
||||
sch = to_subchannel(cdev->dev.parent);
|
||||
do {
|
||||
ret = cio_start (sch, ccw, lpm);
|
||||
if ((ret == -EBUSY) || (ret == -EACCES)) {
|
||||
if (ret == -EBUSY) {
|
||||
/* Try again later. */
|
||||
spin_unlock_irq(&sch->lock);
|
||||
msleep(10);
|
||||
@ -433,6 +439,13 @@ read_conf_data_lpm (struct ccw_device *cdev, void **buffer, int *length, __u8 lp
|
||||
if (!ciw || ciw->cmd == 0)
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
/* Adjust requested path mask to excluded varied off paths. */
|
||||
if (lpm) {
|
||||
lpm &= sch->opm;
|
||||
if (lpm == 0)
|
||||
return -EACCES;
|
||||
}
|
||||
|
||||
rcd_ccw = kzalloc(sizeof(struct ccw1), GFP_KERNEL | GFP_DMA);
|
||||
if (!rcd_ccw)
|
||||
return -ENOMEM;
|
||||
|
@ -245,18 +245,17 @@ __ccw_device_do_pgid(struct ccw_device *cdev, __u8 func)
|
||||
memset(&cdev->private->irb, 0, sizeof(struct irb));
|
||||
|
||||
/* Try multiple times. */
|
||||
ret = -ENODEV;
|
||||
ret = -EACCES;
|
||||
if (cdev->private->iretry > 0) {
|
||||
cdev->private->iretry--;
|
||||
ret = cio_start (sch, cdev->private->iccws,
|
||||
cdev->private->imask);
|
||||
/* ret is 0, -EBUSY, -EACCES or -ENODEV */
|
||||
if ((ret != -EACCES) && (ret != -ENODEV))
|
||||
/* We expect an interrupt in case of success or busy
|
||||
* indication. */
|
||||
if ((ret == 0) || (ret == -EBUSY))
|
||||
return ret;
|
||||
}
|
||||
/* PGID command failed on this path. Switch it off. */
|
||||
sch->lpm &= ~cdev->private->imask;
|
||||
sch->vpm &= ~cdev->private->imask;
|
||||
/* PGID command failed on this path. */
|
||||
CIO_MSG_EVENT(2, "SPID - Device %04x on Subchannel "
|
||||
"0.%x.%04x, lpm %02X, became 'not operational'\n",
|
||||
cdev->private->devno, sch->schid.ssid,
|
||||
@ -286,18 +285,17 @@ static int __ccw_device_do_nop(struct ccw_device *cdev)
|
||||
memset(&cdev->private->irb, 0, sizeof(struct irb));
|
||||
|
||||
/* Try multiple times. */
|
||||
ret = -ENODEV;
|
||||
ret = -EACCES;
|
||||
if (cdev->private->iretry > 0) {
|
||||
cdev->private->iretry--;
|
||||
ret = cio_start (sch, cdev->private->iccws,
|
||||
cdev->private->imask);
|
||||
/* ret is 0, -EBUSY, -EACCES or -ENODEV */
|
||||
if ((ret != -EACCES) && (ret != -ENODEV))
|
||||
/* We expect an interrupt in case of success or busy
|
||||
* indication. */
|
||||
if ((ret == 0) || (ret == -EBUSY))
|
||||
return ret;
|
||||
}
|
||||
/* nop command failed on this path. Switch it off. */
|
||||
sch->lpm &= ~cdev->private->imask;
|
||||
sch->vpm &= ~cdev->private->imask;
|
||||
/* nop command failed on this path. */
|
||||
CIO_MSG_EVENT(2, "NOP - Device %04x on Subchannel "
|
||||
"0.%x.%04x, lpm %02X, became 'not operational'\n",
|
||||
cdev->private->devno, sch->schid.ssid,
|
||||
@ -372,27 +370,32 @@ static void
|
||||
__ccw_device_verify_start(struct ccw_device *cdev)
|
||||
{
|
||||
struct subchannel *sch;
|
||||
__u8 imask, func;
|
||||
__u8 func;
|
||||
int ret;
|
||||
|
||||
sch = to_subchannel(cdev->dev.parent);
|
||||
while (sch->vpm != sch->lpm) {
|
||||
/* Find first unequal bit in vpm vs. lpm */
|
||||
for (imask = 0x80; imask != 0; imask >>= 1)
|
||||
if ((sch->vpm & imask) != (sch->lpm & imask))
|
||||
break;
|
||||
cdev->private->imask = imask;
|
||||
/* Repeat for all paths. */
|
||||
for (; cdev->private->imask; cdev->private->imask >>= 1,
|
||||
cdev->private->iretry = 5) {
|
||||
if ((cdev->private->imask & sch->schib.pmcw.pam) == 0)
|
||||
/* Path not available, try next. */
|
||||
continue;
|
||||
if (cdev->private->options.pgroup) {
|
||||
func = (sch->vpm & imask) ?
|
||||
SPID_FUNC_RESIGN : SPID_FUNC_ESTABLISH;
|
||||
if (sch->opm & cdev->private->imask)
|
||||
func = SPID_FUNC_ESTABLISH;
|
||||
else
|
||||
func = SPID_FUNC_RESIGN;
|
||||
ret = __ccw_device_do_pgid(cdev, func);
|
||||
} else
|
||||
ret = __ccw_device_do_nop(cdev);
|
||||
/* We expect an interrupt in case of success or busy
|
||||
* indication. */
|
||||
if (ret == 0 || ret == -EBUSY)
|
||||
return;
|
||||
cdev->private->iretry = 5;
|
||||
/* Permanent path failure, try next. */
|
||||
}
|
||||
ccw_device_verify_done(cdev, (sch->lpm != 0) ? 0 : -ENODEV);
|
||||
/* Done with all paths. */
|
||||
ccw_device_verify_done(cdev, (sch->vpm != 0) ? 0 : -ENODEV);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -421,14 +424,14 @@ ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
else
|
||||
ret = __ccw_device_check_nop(cdev);
|
||||
memset(&cdev->private->irb, 0, sizeof(struct irb));
|
||||
|
||||
switch (ret) {
|
||||
/* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
|
||||
case 0:
|
||||
/* Establish or Resign Path Group done. Update vpm. */
|
||||
if ((sch->lpm & cdev->private->imask) != 0)
|
||||
sch->vpm |= cdev->private->imask;
|
||||
else
|
||||
sch->vpm &= ~cdev->private->imask;
|
||||
/* Path verification ccw finished successfully, update lpm. */
|
||||
sch->vpm |= sch->opm & cdev->private->imask;
|
||||
/* Go on with next path. */
|
||||
cdev->private->imask >>= 1;
|
||||
cdev->private->iretry = 5;
|
||||
__ccw_device_verify_start(cdev);
|
||||
break;
|
||||
@ -441,6 +444,10 @@ ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
cdev->private->options.pgroup = 0;
|
||||
else
|
||||
cdev->private->flags.pgid_single = 1;
|
||||
/* Retry */
|
||||
sch->vpm = 0;
|
||||
cdev->private->imask = 0x80;
|
||||
cdev->private->iretry = 5;
|
||||
/* fall through. */
|
||||
case -EAGAIN: /* Try again. */
|
||||
__ccw_device_verify_start(cdev);
|
||||
@ -449,8 +456,7 @@ ccw_device_verify_irq(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
ccw_device_verify_done(cdev, -ETIME);
|
||||
break;
|
||||
case -EACCES: /* channel is not operational. */
|
||||
sch->lpm &= ~cdev->private->imask;
|
||||
sch->vpm &= ~cdev->private->imask;
|
||||
cdev->private->imask >>= 1;
|
||||
cdev->private->iretry = 5;
|
||||
__ccw_device_verify_start(cdev);
|
||||
break;
|
||||
@ -463,19 +469,17 @@ ccw_device_verify_start(struct ccw_device *cdev)
|
||||
struct subchannel *sch = to_subchannel(cdev->dev.parent);
|
||||
|
||||
cdev->private->flags.pgid_single = 0;
|
||||
cdev->private->imask = 0x80;
|
||||
cdev->private->iretry = 5;
|
||||
/*
|
||||
* Update sch->lpm with current values to catch paths becoming
|
||||
* available again.
|
||||
*/
|
||||
|
||||
/* Start with empty vpm. */
|
||||
sch->vpm = 0;
|
||||
|
||||
/* Get current pam. */
|
||||
if (stsch(sch->schid, &sch->schib)) {
|
||||
ccw_device_verify_done(cdev, -ENODEV);
|
||||
return;
|
||||
}
|
||||
sch->lpm = sch->schib.pmcw.pim &
|
||||
sch->schib.pmcw.pam &
|
||||
sch->schib.pmcw.pom &
|
||||
sch->opm;
|
||||
__ccw_device_verify_start(cdev);
|
||||
}
|
||||
|
||||
@ -524,7 +528,6 @@ ccw_device_disband_irq(struct ccw_device *cdev, enum dev_event dev_event)
|
||||
switch (ret) {
|
||||
/* 0, -ETIME, -EAGAIN, -EOPNOTSUPP or -EACCES */
|
||||
case 0: /* disband successful. */
|
||||
sch->vpm = 0;
|
||||
ccw_device_disband_done(cdev, ret);
|
||||
break;
|
||||
case -EOPNOTSUPP:
|
||||
|
@ -115,7 +115,7 @@ qdio_min(int a,int b)
|
||||
static inline __u64
|
||||
qdio_get_micros(void)
|
||||
{
|
||||
return (get_clock() >> 10); /* time>>12 is microseconds */
|
||||
return (get_clock() >> 12); /* time>>12 is microseconds */
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1129,7 +1129,7 @@ out:
|
||||
|
||||
#ifdef QDIO_USE_PROCESSING_STATE
|
||||
if (last_position>=0)
|
||||
set_slsb(q, &last_position, SLSB_P_INPUT_NOT_INIT, &count);
|
||||
set_slsb(q, &last_position, SLSB_P_INPUT_PROCESSING, &count);
|
||||
#endif /* QDIO_USE_PROCESSING_STATE */
|
||||
|
||||
QDIO_DBF_HEX4(0,trace,&q->first_to_check,sizeof(int));
|
||||
|
@ -191,49 +191,49 @@ enum qdio_irq_states {
|
||||
#if QDIO_VERBOSE_LEVEL>8
|
||||
#define QDIO_PRINT_STUPID(x...) printk( KERN_DEBUG QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_STUPID(x...)
|
||||
#define QDIO_PRINT_STUPID(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>7
|
||||
#define QDIO_PRINT_ALL(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_ALL(x...)
|
||||
#define QDIO_PRINT_ALL(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>6
|
||||
#define QDIO_PRINT_INFO(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_INFO(x...)
|
||||
#define QDIO_PRINT_INFO(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>5
|
||||
#define QDIO_PRINT_WARN(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_WARN(x...)
|
||||
#define QDIO_PRINT_WARN(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>4
|
||||
#define QDIO_PRINT_ERR(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_ERR(x...)
|
||||
#define QDIO_PRINT_ERR(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>3
|
||||
#define QDIO_PRINT_CRIT(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_CRIT(x...)
|
||||
#define QDIO_PRINT_CRIT(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>2
|
||||
#define QDIO_PRINT_ALERT(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_ALERT(x...)
|
||||
#define QDIO_PRINT_ALERT(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#if QDIO_VERBOSE_LEVEL>1
|
||||
#define QDIO_PRINT_EMERG(x...) printk( QDIO_PRINTK_HEADER x)
|
||||
#else
|
||||
#define QDIO_PRINT_EMERG(x...)
|
||||
#define QDIO_PRINT_EMERG(x...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#define HEXDUMP16(importance,header,ptr) \
|
||||
|
@ -2,5 +2,16 @@
|
||||
# S/390 crypto devices
|
||||
#
|
||||
|
||||
z90crypt-objs := z90main.o z90hardware.o
|
||||
obj-$(CONFIG_Z90CRYPT) += z90crypt.o
|
||||
ifdef CONFIG_ZCRYPT_MONOLITHIC
|
||||
|
||||
z90crypt-objs := zcrypt_mono.o ap_bus.o zcrypt_api.o \
|
||||
zcrypt_pcica.o zcrypt_pcicc.o zcrypt_pcixcc.o zcrypt_cex2a.o
|
||||
obj-$(CONFIG_ZCRYPT) += z90crypt.o
|
||||
|
||||
else
|
||||
|
||||
ap-objs := ap_bus.o
|
||||
obj-$(CONFIG_ZCRYPT) += ap.o zcrypt_api.o zcrypt_pcicc.o zcrypt_pcixcc.o
|
||||
obj-$(CONFIG_ZCRYPT) += zcrypt_pcica.o zcrypt_cex2a.o
|
||||
|
||||
endif
|
||||
|
1221
drivers/s390/crypto/ap_bus.c
Normal file
1221
drivers/s390/crypto/ap_bus.c
Normal file
File diff suppressed because it is too large
Load Diff
158
drivers/s390/crypto/ap_bus.h
Normal file
158
drivers/s390/crypto/ap_bus.h
Normal file
@ -0,0 +1,158 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/ap_bus.h
|
||||
*
|
||||
* Copyright (C) 2006 IBM Corporation
|
||||
* Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
|
||||
* Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* Adjunct processor bus header file.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _AP_BUS_H_
|
||||
#define _AP_BUS_H_
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/mod_devicetable.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#define AP_DEVICES 64 /* Number of AP devices. */
|
||||
#define AP_DOMAINS 16 /* Number of AP domains. */
|
||||
#define AP_MAX_RESET 90 /* Maximum number of resets. */
|
||||
#define AP_CONFIG_TIME 30 /* Time in seconds between AP bus rescans. */
|
||||
#define AP_POLL_TIME 1 /* Time in ticks between receive polls. */
|
||||
|
||||
extern int ap_domain_index;
|
||||
|
||||
/**
|
||||
* The ap_qid_t identifier of an ap queue. It contains a
|
||||
* 6 bit device index and a 4 bit queue index (domain).
|
||||
*/
|
||||
typedef unsigned int ap_qid_t;
|
||||
|
||||
#define AP_MKQID(_device,_queue) (((_device) & 63) << 8 | ((_queue) & 15))
|
||||
#define AP_QID_DEVICE(_qid) (((_qid) >> 8) & 63)
|
||||
#define AP_QID_QUEUE(_qid) ((_qid) & 15)
|
||||
|
||||
/**
|
||||
* The ap queue status word is returned by all three AP functions
|
||||
* (PQAP, NQAP and DQAP). There's a set of flags in the first
|
||||
* byte, followed by a 1 byte response code.
|
||||
*/
|
||||
struct ap_queue_status {
|
||||
unsigned int queue_empty : 1;
|
||||
unsigned int replies_waiting : 1;
|
||||
unsigned int queue_full : 1;
|
||||
unsigned int pad1 : 5;
|
||||
unsigned int response_code : 8;
|
||||
unsigned int pad2 : 16;
|
||||
};
|
||||
|
||||
#define AP_RESPONSE_NORMAL 0x00
|
||||
#define AP_RESPONSE_Q_NOT_AVAIL 0x01
|
||||
#define AP_RESPONSE_RESET_IN_PROGRESS 0x02
|
||||
#define AP_RESPONSE_DECONFIGURED 0x03
|
||||
#define AP_RESPONSE_CHECKSTOPPED 0x04
|
||||
#define AP_RESPONSE_BUSY 0x05
|
||||
#define AP_RESPONSE_Q_FULL 0x10
|
||||
#define AP_RESPONSE_NO_PENDING_REPLY 0x10
|
||||
#define AP_RESPONSE_INDEX_TOO_BIG 0x11
|
||||
#define AP_RESPONSE_NO_FIRST_PART 0x13
|
||||
#define AP_RESPONSE_MESSAGE_TOO_BIG 0x15
|
||||
|
||||
/**
|
||||
* Known device types
|
||||
*/
|
||||
#define AP_DEVICE_TYPE_PCICC 3
|
||||
#define AP_DEVICE_TYPE_PCICA 4
|
||||
#define AP_DEVICE_TYPE_PCIXCC 5
|
||||
#define AP_DEVICE_TYPE_CEX2A 6
|
||||
#define AP_DEVICE_TYPE_CEX2C 7
|
||||
|
||||
struct ap_device;
|
||||
struct ap_message;
|
||||
|
||||
struct ap_driver {
|
||||
struct device_driver driver;
|
||||
struct ap_device_id *ids;
|
||||
|
||||
int (*probe)(struct ap_device *);
|
||||
void (*remove)(struct ap_device *);
|
||||
/* receive is called from tasklet context */
|
||||
void (*receive)(struct ap_device *, struct ap_message *,
|
||||
struct ap_message *);
|
||||
};
|
||||
|
||||
#define to_ap_drv(x) container_of((x), struct ap_driver, driver)
|
||||
|
||||
int ap_driver_register(struct ap_driver *, struct module *, char *);
|
||||
void ap_driver_unregister(struct ap_driver *);
|
||||
|
||||
struct ap_device {
|
||||
struct device device;
|
||||
struct ap_driver *drv; /* Pointer to AP device driver. */
|
||||
spinlock_t lock; /* Per device lock. */
|
||||
|
||||
ap_qid_t qid; /* AP queue id. */
|
||||
int queue_depth; /* AP queue depth.*/
|
||||
int device_type; /* AP device type. */
|
||||
int unregistered; /* marks AP device as unregistered */
|
||||
|
||||
int queue_count; /* # messages currently on AP queue. */
|
||||
|
||||
struct list_head pendingq; /* List of message sent to AP queue. */
|
||||
int pendingq_count; /* # requests on pendingq list. */
|
||||
struct list_head requestq; /* List of message yet to be sent. */
|
||||
int requestq_count; /* # requests on requestq list. */
|
||||
int total_request_count; /* # requests ever for this AP device. */
|
||||
|
||||
struct ap_message *reply; /* Per device reply message. */
|
||||
|
||||
void *private; /* ap driver private pointer. */
|
||||
};
|
||||
|
||||
#define to_ap_dev(x) container_of((x), struct ap_device, device)
|
||||
|
||||
struct ap_message {
|
||||
struct list_head list; /* Request queueing. */
|
||||
unsigned long long psmid; /* Message id. */
|
||||
void *message; /* Pointer to message buffer. */
|
||||
size_t length; /* Message length. */
|
||||
|
||||
void *private; /* ap driver private pointer. */
|
||||
};
|
||||
|
||||
#define AP_DEVICE(dt) \
|
||||
.dev_type=(dt), \
|
||||
.match_flags=AP_DEVICE_ID_MATCH_DEVICE_TYPE,
|
||||
|
||||
/**
|
||||
* Note: don't use ap_send/ap_recv after using ap_queue_message
|
||||
* for the first time. Otherwise the ap message queue will get
|
||||
* confused.
|
||||
*/
|
||||
int ap_send(ap_qid_t, unsigned long long, void *, size_t);
|
||||
int ap_recv(ap_qid_t, unsigned long long *, void *, size_t);
|
||||
|
||||
void ap_queue_message(struct ap_device *ap_dev, struct ap_message *ap_msg);
|
||||
void ap_cancel_message(struct ap_device *ap_dev, struct ap_message *ap_msg);
|
||||
void ap_flush_queue(struct ap_device *ap_dev);
|
||||
|
||||
int ap_module_init(void);
|
||||
void ap_module_exit(void);
|
||||
|
||||
#endif /* _AP_BUS_H_ */
|
@ -1,166 +0,0 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/z90common.h
|
||||
*
|
||||
* z90crypt 1.3.3
|
||||
*
|
||||
* Copyright (C) 2001, 2005 IBM Corporation
|
||||
* Author(s): Robert Burroughs (burrough@us.ibm.com)
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _Z90COMMON_H_
|
||||
#define _Z90COMMON_H_
|
||||
|
||||
|
||||
#define RESPBUFFSIZE 256
|
||||
#define PCI_FUNC_KEY_DECRYPT 0x5044
|
||||
#define PCI_FUNC_KEY_ENCRYPT 0x504B
|
||||
extern int ext_bitlens;
|
||||
|
||||
enum devstat {
|
||||
DEV_GONE,
|
||||
DEV_ONLINE,
|
||||
DEV_QUEUE_FULL,
|
||||
DEV_EMPTY,
|
||||
DEV_NO_WORK,
|
||||
DEV_BAD_MESSAGE,
|
||||
DEV_TSQ_EXCEPTION,
|
||||
DEV_RSQ_EXCEPTION,
|
||||
DEV_SEN_EXCEPTION,
|
||||
DEV_REC_EXCEPTION
|
||||
};
|
||||
|
||||
enum hdstat {
|
||||
HD_NOT_THERE,
|
||||
HD_BUSY,
|
||||
HD_DECONFIGURED,
|
||||
HD_CHECKSTOPPED,
|
||||
HD_ONLINE,
|
||||
HD_TSQ_EXCEPTION
|
||||
};
|
||||
|
||||
#define Z90C_NO_DEVICES 1
|
||||
#define Z90C_AMBIGUOUS_DOMAIN 2
|
||||
#define Z90C_INCORRECT_DOMAIN 3
|
||||
#define ENOTINIT 4
|
||||
|
||||
#define SEN_BUSY 7
|
||||
#define SEN_USER_ERROR 8
|
||||
#define SEN_QUEUE_FULL 11
|
||||
#define SEN_NOT_AVAIL 16
|
||||
#define SEN_PAD_ERROR 17
|
||||
#define SEN_RETRY 18
|
||||
#define SEN_RELEASED 24
|
||||
|
||||
#define REC_EMPTY 4
|
||||
#define REC_BUSY 6
|
||||
#define REC_OPERAND_INV 8
|
||||
#define REC_OPERAND_SIZE 9
|
||||
#define REC_EVEN_MOD 10
|
||||
#define REC_NO_WORK 11
|
||||
#define REC_HARDWAR_ERR 12
|
||||
#define REC_NO_RESPONSE 13
|
||||
#define REC_RETRY_DEV 14
|
||||
#define REC_USER_GONE 15
|
||||
#define REC_BAD_MESSAGE 16
|
||||
#define REC_INVALID_PAD 17
|
||||
#define REC_USE_PCICA 18
|
||||
|
||||
#define WRONG_DEVICE_TYPE 20
|
||||
|
||||
#define REC_FATAL_ERROR 32
|
||||
#define SEN_FATAL_ERROR 33
|
||||
#define TSQ_FATAL_ERROR 34
|
||||
#define RSQ_FATAL_ERROR 35
|
||||
|
||||
#define Z90CRYPT_NUM_TYPES 6
|
||||
#define PCICA 0
|
||||
#define PCICC 1
|
||||
#define PCIXCC_MCL2 2
|
||||
#define PCIXCC_MCL3 3
|
||||
#define CEX2C 4
|
||||
#define CEX2A 5
|
||||
#define NILDEV -1
|
||||
#define ANYDEV -1
|
||||
#define PCIXCC_UNK -2
|
||||
|
||||
enum hdevice_type {
|
||||
PCICC_HW = 3,
|
||||
PCICA_HW = 4,
|
||||
PCIXCC_HW = 5,
|
||||
CEX2A_HW = 6,
|
||||
CEX2C_HW = 7
|
||||
};
|
||||
|
||||
struct CPRBX {
|
||||
unsigned short cprb_len;
|
||||
unsigned char cprb_ver_id;
|
||||
unsigned char pad_000[3];
|
||||
unsigned char func_id[2];
|
||||
unsigned char cprb_flags[4];
|
||||
unsigned int req_parml;
|
||||
unsigned int req_datal;
|
||||
unsigned int rpl_msgbl;
|
||||
unsigned int rpld_parml;
|
||||
unsigned int rpl_datal;
|
||||
unsigned int rpld_datal;
|
||||
unsigned int req_extbl;
|
||||
unsigned char pad_001[4];
|
||||
unsigned int rpld_extbl;
|
||||
unsigned char req_parmb[16];
|
||||
unsigned char req_datab[16];
|
||||
unsigned char rpl_parmb[16];
|
||||
unsigned char rpl_datab[16];
|
||||
unsigned char req_extb[16];
|
||||
unsigned char rpl_extb[16];
|
||||
unsigned short ccp_rtcode;
|
||||
unsigned short ccp_rscode;
|
||||
unsigned int mac_data_len;
|
||||
unsigned char logon_id[8];
|
||||
unsigned char mac_value[8];
|
||||
unsigned char mac_content_flgs;
|
||||
unsigned char pad_002;
|
||||
unsigned short domain;
|
||||
unsigned char pad_003[12];
|
||||
unsigned char pad_004[36];
|
||||
};
|
||||
|
||||
#ifndef DEV_NAME
|
||||
#define DEV_NAME "z90crypt"
|
||||
#endif
|
||||
#define PRINTK(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#define PRINTKN(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": " fmt, ## args)
|
||||
#define PRINTKW(fmt, args...) \
|
||||
printk(KERN_WARNING DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#define PRINTKC(fmt, args...) \
|
||||
printk(KERN_CRIT DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
|
||||
#ifdef Z90CRYPT_DEBUG
|
||||
#define PDEBUG(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#else
|
||||
#define PDEBUG(fmt, args...) do {} while (0)
|
||||
#endif
|
||||
|
||||
#define UMIN(a,b) ((a) < (b) ? (a) : (b))
|
||||
#define IS_EVEN(x) ((x) == (2 * ((x) / 2)))
|
||||
|
||||
#endif
|
@ -1,71 +0,0 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/z90crypt.h
|
||||
*
|
||||
* z90crypt 1.3.3 (kernel-private header)
|
||||
*
|
||||
* Copyright (C) 2001, 2005 IBM Corporation
|
||||
* Author(s): Robert Burroughs (burrough@us.ibm.com)
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _Z90CRYPT_H_
|
||||
#define _Z90CRYPT_H_
|
||||
|
||||
#include <asm/z90crypt.h>
|
||||
|
||||
/**
|
||||
* local errno definitions
|
||||
*/
|
||||
#define ENOBUFF 129 // filp->private_data->...>work_elem_p->buffer is NULL
|
||||
#define EWORKPEND 130 // user issues ioctl while another pending
|
||||
#define ERELEASED 131 // user released while ioctl pending
|
||||
#define EQUIESCE 132 // z90crypt quiescing (no more work allowed)
|
||||
#define ETIMEOUT 133 // request timed out
|
||||
#define EUNKNOWN 134 // some unrecognized error occured (retry may succeed)
|
||||
#define EGETBUFF 135 // Error getting buffer or hardware lacks capability
|
||||
// (retry in software)
|
||||
|
||||
/**
|
||||
* DEPRECATED STRUCTURES
|
||||
*/
|
||||
|
||||
/**
|
||||
* This structure is DEPRECATED and the corresponding ioctl() has been
|
||||
* replaced with individual ioctl()s for each piece of data!
|
||||
* This structure will NOT survive past version 1.3.1, so switch to the
|
||||
* new ioctl()s.
|
||||
*/
|
||||
#define MASK_LENGTH 64 // mask length
|
||||
struct ica_z90_status {
|
||||
int totalcount;
|
||||
int leedslitecount; // PCICA
|
||||
int leeds2count; // PCICC
|
||||
// int PCIXCCCount; is not in struct for backward compatibility
|
||||
int requestqWaitCount;
|
||||
int pendingqWaitCount;
|
||||
int totalOpenCount;
|
||||
int cryptoDomain;
|
||||
// status: 0=not there, 1=PCICA, 2=PCICC, 3=PCIXCC_MCL2, 4=PCIXCC_MCL3,
|
||||
// 5=CEX2C
|
||||
unsigned char status[MASK_LENGTH];
|
||||
// qdepth: # work elements waiting for each device
|
||||
unsigned char qdepth[MASK_LENGTH];
|
||||
};
|
||||
|
||||
#endif /* _Z90CRYPT_H_ */
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
1091
drivers/s390/crypto/zcrypt_api.c
Normal file
1091
drivers/s390/crypto/zcrypt_api.c
Normal file
File diff suppressed because it is too large
Load Diff
141
drivers/s390/crypto/zcrypt_api.h
Normal file
141
drivers/s390/crypto/zcrypt_api.h
Normal file
@ -0,0 +1,141 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_api.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
* Cornelia Huck <cornelia.huck@de.ibm.com>
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_API_H_
|
||||
#define _ZCRYPT_API_H_
|
||||
|
||||
/**
|
||||
* Macro definitions
|
||||
*
|
||||
* PDEBUG debugs in the form "zcrypt: function_name -> message"
|
||||
*
|
||||
* PRINTK is like PDEBUG, except that it is always enabled
|
||||
* PRINTKN is like PRINTK, except that it does not include the function name
|
||||
* PRINTKW is like PRINTK, except that it uses KERN_WARNING
|
||||
* PRINTKC is like PRINTK, except that it uses KERN_CRIT
|
||||
*/
|
||||
#define DEV_NAME "zcrypt"
|
||||
|
||||
#define PRINTK(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#define PRINTKN(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": " fmt, ## args)
|
||||
#define PRINTKW(fmt, args...) \
|
||||
printk(KERN_WARNING DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#define PRINTKC(fmt, args...) \
|
||||
printk(KERN_CRIT DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
|
||||
#ifdef ZCRYPT_DEBUG
|
||||
#define PDEBUG(fmt, args...) \
|
||||
printk(KERN_DEBUG DEV_NAME ": %s -> " fmt, __FUNCTION__ , ## args)
|
||||
#else
|
||||
#define PDEBUG(fmt, args...) do {} while (0)
|
||||
#endif
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include <asm/zcrypt.h>
|
||||
|
||||
/* deprecated status calls */
|
||||
#define ICAZ90STATUS _IOR(ZCRYPT_IOCTL_MAGIC, 0x10, struct ica_z90_status)
|
||||
#define Z90STAT_PCIXCCCOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x43, int)
|
||||
|
||||
/**
|
||||
* This structure is deprecated and the corresponding ioctl() has been
|
||||
* replaced with individual ioctl()s for each piece of data!
|
||||
*/
|
||||
struct ica_z90_status {
|
||||
int totalcount;
|
||||
int leedslitecount; // PCICA
|
||||
int leeds2count; // PCICC
|
||||
// int PCIXCCCount; is not in struct for backward compatibility
|
||||
int requestqWaitCount;
|
||||
int pendingqWaitCount;
|
||||
int totalOpenCount;
|
||||
int cryptoDomain;
|
||||
// status: 0=not there, 1=PCICA, 2=PCICC, 3=PCIXCC_MCL2, 4=PCIXCC_MCL3,
|
||||
// 5=CEX2C
|
||||
unsigned char status[64];
|
||||
// qdepth: # work elements waiting for each device
|
||||
unsigned char qdepth[64];
|
||||
};
|
||||
|
||||
/**
|
||||
* device type for an actual device is either PCICA, PCICC, PCIXCC_MCL2,
|
||||
* PCIXCC_MCL3, CEX2C, or CEX2A
|
||||
*
|
||||
* NOTE: PCIXCC_MCL3 refers to a PCIXCC with May 2004 version of Licensed
|
||||
* Internal Code (LIC) (EC J12220 level 29).
|
||||
* PCIXCC_MCL2 refers to any LIC before this level.
|
||||
*/
|
||||
#define ZCRYPT_PCICA 1
|
||||
#define ZCRYPT_PCICC 2
|
||||
#define ZCRYPT_PCIXCC_MCL2 3
|
||||
#define ZCRYPT_PCIXCC_MCL3 4
|
||||
#define ZCRYPT_CEX2C 5
|
||||
#define ZCRYPT_CEX2A 6
|
||||
|
||||
struct zcrypt_device;
|
||||
|
||||
struct zcrypt_ops {
|
||||
long (*rsa_modexpo)(struct zcrypt_device *, struct ica_rsa_modexpo *);
|
||||
long (*rsa_modexpo_crt)(struct zcrypt_device *,
|
||||
struct ica_rsa_modexpo_crt *);
|
||||
long (*send_cprb)(struct zcrypt_device *, struct ica_xcRB *);
|
||||
};
|
||||
|
||||
struct zcrypt_device {
|
||||
struct list_head list; /* Device list. */
|
||||
spinlock_t lock; /* Per device lock. */
|
||||
struct kref refcount; /* device refcounting */
|
||||
struct ap_device *ap_dev; /* The "real" ap device. */
|
||||
struct zcrypt_ops *ops; /* Crypto operations. */
|
||||
int online; /* User online/offline */
|
||||
|
||||
int user_space_type; /* User space device id. */
|
||||
char *type_string; /* User space device name. */
|
||||
int min_mod_size; /* Min number of bits. */
|
||||
int max_mod_size; /* Max number of bits. */
|
||||
int short_crt; /* Card has crt length restriction. */
|
||||
int speed_rating; /* Speed of the crypto device. */
|
||||
|
||||
int request_count; /* # current requests. */
|
||||
|
||||
struct ap_message reply; /* Per-device reply structure. */
|
||||
};
|
||||
|
||||
struct zcrypt_device *zcrypt_device_alloc(size_t);
|
||||
void zcrypt_device_free(struct zcrypt_device *);
|
||||
void zcrypt_device_get(struct zcrypt_device *);
|
||||
int zcrypt_device_put(struct zcrypt_device *);
|
||||
int zcrypt_device_register(struct zcrypt_device *);
|
||||
void zcrypt_device_unregister(struct zcrypt_device *);
|
||||
int zcrypt_api_init(void);
|
||||
void zcrypt_api_exit(void);
|
||||
|
||||
#endif /* _ZCRYPT_API_H_ */
|
350
drivers/s390/crypto/zcrypt_cca_key.h
Normal file
350
drivers/s390/crypto/zcrypt_cca_key.h
Normal file
@ -0,0 +1,350 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_cca_key.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_CCA_KEY_H_
|
||||
#define _ZCRYPT_CCA_KEY_H_
|
||||
|
||||
struct T6_keyBlock_hdr {
|
||||
unsigned short blen;
|
||||
unsigned short ulen;
|
||||
unsigned short flags;
|
||||
};
|
||||
|
||||
/**
|
||||
* mapping for the cca private ME key token.
|
||||
* Three parts of interest here: the header, the private section and
|
||||
* the public section.
|
||||
*
|
||||
* mapping for the cca key token header
|
||||
*/
|
||||
struct cca_token_hdr {
|
||||
unsigned char token_identifier;
|
||||
unsigned char version;
|
||||
unsigned short token_length;
|
||||
unsigned char reserved[4];
|
||||
} __attribute__((packed));
|
||||
|
||||
#define CCA_TKN_HDR_ID_EXT 0x1E
|
||||
|
||||
/**
|
||||
* mapping for the cca private ME section
|
||||
*/
|
||||
struct cca_private_ext_ME_sec {
|
||||
unsigned char section_identifier;
|
||||
unsigned char version;
|
||||
unsigned short section_length;
|
||||
unsigned char private_key_hash[20];
|
||||
unsigned char reserved1[4];
|
||||
unsigned char key_format;
|
||||
unsigned char reserved2;
|
||||
unsigned char key_name_hash[20];
|
||||
unsigned char key_use_flags[4];
|
||||
unsigned char reserved3[6];
|
||||
unsigned char reserved4[24];
|
||||
unsigned char confounder[24];
|
||||
unsigned char exponent[128];
|
||||
unsigned char modulus[128];
|
||||
} __attribute__((packed));
|
||||
|
||||
#define CCA_PVT_USAGE_ALL 0x80
|
||||
|
||||
/**
|
||||
* mapping for the cca public section
|
||||
* In a private key, the modulus doesn't appear in the public
|
||||
* section. So, an arbitrary public exponent of 0x010001 will be
|
||||
* used, for a section length of 0x0F always.
|
||||
*/
|
||||
struct cca_public_sec {
|
||||
unsigned char section_identifier;
|
||||
unsigned char version;
|
||||
unsigned short section_length;
|
||||
unsigned char reserved[2];
|
||||
unsigned short exponent_len;
|
||||
unsigned short modulus_bit_len;
|
||||
unsigned short modulus_byte_len; /* In a private key, this is 0 */
|
||||
} __attribute__((packed));
|
||||
|
||||
/**
|
||||
* mapping for the cca private CRT key 'token'
|
||||
* The first three parts (the only parts considered in this release)
|
||||
* are: the header, the private section and the public section.
|
||||
* The header and public section are the same as for the
|
||||
* struct cca_private_ext_ME
|
||||
*
|
||||
* Following the structure are the quantities p, q, dp, dq, u, pad,
|
||||
* and modulus, in that order, where pad_len is the modulo 8
|
||||
* complement of the residue modulo 8 of the sum of
|
||||
* (p_len + q_len + dp_len + dq_len + u_len).
|
||||
*/
|
||||
struct cca_pvt_ext_CRT_sec {
|
||||
unsigned char section_identifier;
|
||||
unsigned char version;
|
||||
unsigned short section_length;
|
||||
unsigned char private_key_hash[20];
|
||||
unsigned char reserved1[4];
|
||||
unsigned char key_format;
|
||||
unsigned char reserved2;
|
||||
unsigned char key_name_hash[20];
|
||||
unsigned char key_use_flags[4];
|
||||
unsigned short p_len;
|
||||
unsigned short q_len;
|
||||
unsigned short dp_len;
|
||||
unsigned short dq_len;
|
||||
unsigned short u_len;
|
||||
unsigned short mod_len;
|
||||
unsigned char reserved3[4];
|
||||
unsigned short pad_len;
|
||||
unsigned char reserved4[52];
|
||||
unsigned char confounder[8];
|
||||
} __attribute__((packed));
|
||||
|
||||
#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08
|
||||
#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40
|
||||
|
||||
/**
|
||||
* Set up private key fields of a type6 MEX message.
|
||||
* Note that all numerics in the key token are big-endian,
|
||||
* while the entries in the key block header are little-endian.
|
||||
*
|
||||
* @mex: pointer to user input data
|
||||
* @p: pointer to memory area for the key
|
||||
*
|
||||
* Returns the size of the key area or -EFAULT
|
||||
*/
|
||||
static inline int zcrypt_type6_mex_key_de(struct ica_rsa_modexpo *mex,
|
||||
void *p, int big_endian)
|
||||
{
|
||||
static struct cca_token_hdr static_pvt_me_hdr = {
|
||||
.token_identifier = 0x1E,
|
||||
.token_length = 0x0183,
|
||||
};
|
||||
static struct cca_private_ext_ME_sec static_pvt_me_sec = {
|
||||
.section_identifier = 0x02,
|
||||
.section_length = 0x016C,
|
||||
.key_use_flags = {0x80,0x00,0x00,0x00},
|
||||
};
|
||||
static struct cca_public_sec static_pub_me_sec = {
|
||||
.section_identifier = 0x04,
|
||||
.section_length = 0x000F,
|
||||
.exponent_len = 0x0003,
|
||||
};
|
||||
static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
|
||||
struct {
|
||||
struct T6_keyBlock_hdr t6_hdr;
|
||||
struct cca_token_hdr pvtMeHdr;
|
||||
struct cca_private_ext_ME_sec pvtMeSec;
|
||||
struct cca_public_sec pubMeSec;
|
||||
char exponent[3];
|
||||
} __attribute__((packed)) *key = p;
|
||||
unsigned char *temp;
|
||||
|
||||
memset(key, 0, sizeof(*key));
|
||||
|
||||
if (big_endian) {
|
||||
key->t6_hdr.blen = cpu_to_be16(0x189);
|
||||
key->t6_hdr.ulen = cpu_to_be16(0x189 - 2);
|
||||
} else {
|
||||
key->t6_hdr.blen = cpu_to_le16(0x189);
|
||||
key->t6_hdr.ulen = cpu_to_le16(0x189 - 2);
|
||||
}
|
||||
key->pvtMeHdr = static_pvt_me_hdr;
|
||||
key->pvtMeSec = static_pvt_me_sec;
|
||||
key->pubMeSec = static_pub_me_sec;
|
||||
/**
|
||||
* In a private key, the modulus doesn't appear in the public
|
||||
* section. So, an arbitrary public exponent of 0x010001 will be
|
||||
* used.
|
||||
*/
|
||||
memcpy(key->exponent, pk_exponent, 3);
|
||||
|
||||
/* key parameter block */
|
||||
temp = key->pvtMeSec.exponent +
|
||||
sizeof(key->pvtMeSec.exponent) - mex->inputdatalength;
|
||||
if (copy_from_user(temp, mex->b_key, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
/* modulus */
|
||||
temp = key->pvtMeSec.modulus +
|
||||
sizeof(key->pvtMeSec.modulus) - mex->inputdatalength;
|
||||
if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
key->pubMeSec.modulus_bit_len = 8 * mex->inputdatalength;
|
||||
return sizeof(*key);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up private key fields of a type6 MEX message. The _pad variant
|
||||
* strips leading zeroes from the b_key.
|
||||
* Note that all numerics in the key token are big-endian,
|
||||
* while the entries in the key block header are little-endian.
|
||||
*
|
||||
* @mex: pointer to user input data
|
||||
* @p: pointer to memory area for the key
|
||||
*
|
||||
* Returns the size of the key area or -EFAULT
|
||||
*/
|
||||
static inline int zcrypt_type6_mex_key_en(struct ica_rsa_modexpo *mex,
|
||||
void *p, int big_endian)
|
||||
{
|
||||
static struct cca_token_hdr static_pub_hdr = {
|
||||
.token_identifier = 0x1E,
|
||||
};
|
||||
static struct cca_public_sec static_pub_sec = {
|
||||
.section_identifier = 0x04,
|
||||
};
|
||||
struct {
|
||||
struct T6_keyBlock_hdr t6_hdr;
|
||||
struct cca_token_hdr pubHdr;
|
||||
struct cca_public_sec pubSec;
|
||||
char exponent[0];
|
||||
} __attribute__((packed)) *key = p;
|
||||
unsigned char *temp;
|
||||
int i;
|
||||
|
||||
memset(key, 0, sizeof(*key));
|
||||
|
||||
key->pubHdr = static_pub_hdr;
|
||||
key->pubSec = static_pub_sec;
|
||||
|
||||
/* key parameter block */
|
||||
temp = key->exponent;
|
||||
if (copy_from_user(temp, mex->b_key, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
/* Strip leading zeroes from b_key. */
|
||||
for (i = 0; i < mex->inputdatalength; i++)
|
||||
if (temp[i])
|
||||
break;
|
||||
if (i >= mex->inputdatalength)
|
||||
return -EINVAL;
|
||||
memmove(temp, temp + i, mex->inputdatalength - i);
|
||||
temp += mex->inputdatalength - i;
|
||||
/* modulus */
|
||||
if (copy_from_user(temp, mex->n_modulus, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
key->pubSec.modulus_bit_len = 8 * mex->inputdatalength;
|
||||
key->pubSec.modulus_byte_len = mex->inputdatalength;
|
||||
key->pubSec.exponent_len = mex->inputdatalength - i;
|
||||
key->pubSec.section_length = sizeof(key->pubSec) +
|
||||
2*mex->inputdatalength - i;
|
||||
key->pubHdr.token_length =
|
||||
key->pubSec.section_length + sizeof(key->pubHdr);
|
||||
if (big_endian) {
|
||||
key->t6_hdr.ulen = cpu_to_be16(key->pubHdr.token_length + 4);
|
||||
key->t6_hdr.blen = cpu_to_be16(key->pubHdr.token_length + 6);
|
||||
} else {
|
||||
key->t6_hdr.ulen = cpu_to_le16(key->pubHdr.token_length + 4);
|
||||
key->t6_hdr.blen = cpu_to_le16(key->pubHdr.token_length + 6);
|
||||
}
|
||||
return sizeof(*key) + 2*mex->inputdatalength - i;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up private key fields of a type6 CRT message.
|
||||
* Note that all numerics in the key token are big-endian,
|
||||
* while the entries in the key block header are little-endian.
|
||||
*
|
||||
* @mex: pointer to user input data
|
||||
* @p: pointer to memory area for the key
|
||||
*
|
||||
* Returns the size of the key area or -EFAULT
|
||||
*/
|
||||
static inline int zcrypt_type6_crt_key(struct ica_rsa_modexpo_crt *crt,
|
||||
void *p, int big_endian)
|
||||
{
|
||||
static struct cca_public_sec static_cca_pub_sec = {
|
||||
.section_identifier = 4,
|
||||
.section_length = 0x000f,
|
||||
.exponent_len = 0x0003,
|
||||
};
|
||||
static char pk_exponent[3] = { 0x01, 0x00, 0x01 };
|
||||
struct {
|
||||
struct T6_keyBlock_hdr t6_hdr;
|
||||
struct cca_token_hdr token;
|
||||
struct cca_pvt_ext_CRT_sec pvt;
|
||||
char key_parts[0];
|
||||
} __attribute__((packed)) *key = p;
|
||||
struct cca_public_sec *pub;
|
||||
int short_len, long_len, pad_len, key_len, size;
|
||||
|
||||
memset(key, 0, sizeof(*key));
|
||||
|
||||
short_len = crt->inputdatalength / 2;
|
||||
long_len = short_len + 8;
|
||||
pad_len = -(3*long_len + 2*short_len) & 7;
|
||||
key_len = 3*long_len + 2*short_len + pad_len + crt->inputdatalength;
|
||||
size = sizeof(*key) + key_len + sizeof(*pub) + 3;
|
||||
|
||||
/* parameter block.key block */
|
||||
if (big_endian) {
|
||||
key->t6_hdr.blen = cpu_to_be16(size);
|
||||
key->t6_hdr.ulen = cpu_to_be16(size - 2);
|
||||
} else {
|
||||
key->t6_hdr.blen = cpu_to_le16(size);
|
||||
key->t6_hdr.ulen = cpu_to_le16(size - 2);
|
||||
}
|
||||
|
||||
/* key token header */
|
||||
key->token.token_identifier = CCA_TKN_HDR_ID_EXT;
|
||||
key->token.token_length = size - 6;
|
||||
|
||||
/* private section */
|
||||
key->pvt.section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
|
||||
key->pvt.section_length = sizeof(key->pvt) + key_len;
|
||||
key->pvt.key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
|
||||
key->pvt.key_use_flags[0] = CCA_PVT_USAGE_ALL;
|
||||
key->pvt.p_len = key->pvt.dp_len = key->pvt.u_len = long_len;
|
||||
key->pvt.q_len = key->pvt.dq_len = short_len;
|
||||
key->pvt.mod_len = crt->inputdatalength;
|
||||
key->pvt.pad_len = pad_len;
|
||||
|
||||
/* key parts */
|
||||
if (copy_from_user(key->key_parts, crt->np_prime, long_len) ||
|
||||
copy_from_user(key->key_parts + long_len,
|
||||
crt->nq_prime, short_len) ||
|
||||
copy_from_user(key->key_parts + long_len + short_len,
|
||||
crt->bp_key, long_len) ||
|
||||
copy_from_user(key->key_parts + 2*long_len + short_len,
|
||||
crt->bq_key, short_len) ||
|
||||
copy_from_user(key->key_parts + 2*long_len + 2*short_len,
|
||||
crt->u_mult_inv, long_len))
|
||||
return -EFAULT;
|
||||
memset(key->key_parts + 3*long_len + 2*short_len + pad_len,
|
||||
0xff, crt->inputdatalength);
|
||||
pub = (struct cca_public_sec *)(key->key_parts + key_len);
|
||||
*pub = static_cca_pub_sec;
|
||||
pub->modulus_bit_len = 8 * crt->inputdatalength;
|
||||
/**
|
||||
* In a private key, the modulus doesn't appear in the public
|
||||
* section. So, an arbitrary public exponent of 0x010001 will be
|
||||
* used.
|
||||
*/
|
||||
memcpy((char *) (pub + 1), pk_exponent, 3);
|
||||
return size;
|
||||
}
|
||||
|
||||
#endif /* _ZCRYPT_CCA_KEY_H_ */
|
435
drivers/s390/crypto/zcrypt_cex2a.c
Normal file
435
drivers/s390/crypto/zcrypt_cex2a.c
Normal file
@ -0,0 +1,435 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_cex2a.c
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include "zcrypt_api.h"
|
||||
#include "zcrypt_error.h"
|
||||
#include "zcrypt_cex2a.h"
|
||||
|
||||
#define CEX2A_MIN_MOD_SIZE 1 /* 8 bits */
|
||||
#define CEX2A_MAX_MOD_SIZE 256 /* 2048 bits */
|
||||
|
||||
#define CEX2A_SPEED_RATING 970
|
||||
|
||||
#define CEX2A_MAX_MESSAGE_SIZE 0x390 /* sizeof(struct type50_crb2_msg) */
|
||||
#define CEX2A_MAX_RESPONSE_SIZE 0x110 /* max outputdatalength + type80_hdr */
|
||||
|
||||
#define CEX2A_CLEANUP_TIME (15*HZ)
|
||||
|
||||
static struct ap_device_id zcrypt_cex2a_ids[] = {
|
||||
{ AP_DEVICE(AP_DEVICE_TYPE_CEX2A) },
|
||||
{ /* end of list */ },
|
||||
};
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
MODULE_DEVICE_TABLE(ap, zcrypt_cex2a_ids);
|
||||
MODULE_AUTHOR("IBM Corporation");
|
||||
MODULE_DESCRIPTION("CEX2A Cryptographic Coprocessor device driver, "
|
||||
"Copyright 2001, 2006 IBM Corporation");
|
||||
MODULE_LICENSE("GPL");
|
||||
#endif
|
||||
|
||||
static int zcrypt_cex2a_probe(struct ap_device *ap_dev);
|
||||
static void zcrypt_cex2a_remove(struct ap_device *ap_dev);
|
||||
static void zcrypt_cex2a_receive(struct ap_device *, struct ap_message *,
|
||||
struct ap_message *);
|
||||
|
||||
static struct ap_driver zcrypt_cex2a_driver = {
|
||||
.probe = zcrypt_cex2a_probe,
|
||||
.remove = zcrypt_cex2a_remove,
|
||||
.receive = zcrypt_cex2a_receive,
|
||||
.ids = zcrypt_cex2a_ids,
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a ICAMEX message to a type50 MEX message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @mex: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICAMEX_msg_to_type50MEX_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
unsigned char *mod, *exp, *inp;
|
||||
int mod_len;
|
||||
|
||||
mod_len = mex->inputdatalength;
|
||||
|
||||
if (mod_len <= 128) {
|
||||
struct type50_meb1_msg *meb1 = ap_msg->message;
|
||||
memset(meb1, 0, sizeof(*meb1));
|
||||
ap_msg->length = sizeof(*meb1);
|
||||
meb1->header.msg_type_code = TYPE50_TYPE_CODE;
|
||||
meb1->header.msg_len = sizeof(*meb1);
|
||||
meb1->keyblock_type = TYPE50_MEB1_FMT;
|
||||
mod = meb1->modulus + sizeof(meb1->modulus) - mod_len;
|
||||
exp = meb1->exponent + sizeof(meb1->exponent) - mod_len;
|
||||
inp = meb1->message + sizeof(meb1->message) - mod_len;
|
||||
} else {
|
||||
struct type50_meb2_msg *meb2 = ap_msg->message;
|
||||
memset(meb2, 0, sizeof(*meb2));
|
||||
ap_msg->length = sizeof(*meb2);
|
||||
meb2->header.msg_type_code = TYPE50_TYPE_CODE;
|
||||
meb2->header.msg_len = sizeof(*meb2);
|
||||
meb2->keyblock_type = TYPE50_MEB2_FMT;
|
||||
mod = meb2->modulus + sizeof(meb2->modulus) - mod_len;
|
||||
exp = meb2->exponent + sizeof(meb2->exponent) - mod_len;
|
||||
inp = meb2->message + sizeof(meb2->message) - mod_len;
|
||||
}
|
||||
|
||||
if (copy_from_user(mod, mex->n_modulus, mod_len) ||
|
||||
copy_from_user(exp, mex->b_key, mod_len) ||
|
||||
copy_from_user(inp, mex->inputdata, mod_len))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a ICACRT message to a type50 CRT message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @crt: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICACRT_msg_to_type50CRT_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
int mod_len, short_len, long_len, long_offset;
|
||||
unsigned char *p, *q, *dp, *dq, *u, *inp;
|
||||
|
||||
mod_len = crt->inputdatalength;
|
||||
short_len = mod_len / 2;
|
||||
long_len = mod_len / 2 + 8;
|
||||
|
||||
/*
|
||||
* CEX2A cannot handle p, dp, or U > 128 bytes.
|
||||
* If we have one of these, we need to do extra checking.
|
||||
*/
|
||||
if (long_len > 128) {
|
||||
/*
|
||||
* zcrypt_rsa_crt already checked for the leading
|
||||
* zeroes of np_prime, bp_key and u_mult_inc.
|
||||
*/
|
||||
long_offset = long_len - 128;
|
||||
long_len = 128;
|
||||
} else
|
||||
long_offset = 0;
|
||||
|
||||
/*
|
||||
* Instead of doing extra work for p, dp, U > 64 bytes, we'll just use
|
||||
* the larger message structure.
|
||||
*/
|
||||
if (long_len <= 64) {
|
||||
struct type50_crb1_msg *crb1 = ap_msg->message;
|
||||
memset(crb1, 0, sizeof(*crb1));
|
||||
ap_msg->length = sizeof(*crb1);
|
||||
crb1->header.msg_type_code = TYPE50_TYPE_CODE;
|
||||
crb1->header.msg_len = sizeof(*crb1);
|
||||
crb1->keyblock_type = TYPE50_CRB1_FMT;
|
||||
p = crb1->p + sizeof(crb1->p) - long_len;
|
||||
q = crb1->q + sizeof(crb1->q) - short_len;
|
||||
dp = crb1->dp + sizeof(crb1->dp) - long_len;
|
||||
dq = crb1->dq + sizeof(crb1->dq) - short_len;
|
||||
u = crb1->u + sizeof(crb1->u) - long_len;
|
||||
inp = crb1->message + sizeof(crb1->message) - mod_len;
|
||||
} else {
|
||||
struct type50_crb2_msg *crb2 = ap_msg->message;
|
||||
memset(crb2, 0, sizeof(*crb2));
|
||||
ap_msg->length = sizeof(*crb2);
|
||||
crb2->header.msg_type_code = TYPE50_TYPE_CODE;
|
||||
crb2->header.msg_len = sizeof(*crb2);
|
||||
crb2->keyblock_type = TYPE50_CRB2_FMT;
|
||||
p = crb2->p + sizeof(crb2->p) - long_len;
|
||||
q = crb2->q + sizeof(crb2->q) - short_len;
|
||||
dp = crb2->dp + sizeof(crb2->dp) - long_len;
|
||||
dq = crb2->dq + sizeof(crb2->dq) - short_len;
|
||||
u = crb2->u + sizeof(crb2->u) - long_len;
|
||||
inp = crb2->message + sizeof(crb2->message) - mod_len;
|
||||
}
|
||||
|
||||
if (copy_from_user(p, crt->np_prime + long_offset, long_len) ||
|
||||
copy_from_user(q, crt->nq_prime, short_len) ||
|
||||
copy_from_user(dp, crt->bp_key + long_offset, long_len) ||
|
||||
copy_from_user(dq, crt->bq_key, short_len) ||
|
||||
copy_from_user(u, crt->u_mult_inv + long_offset, long_len) ||
|
||||
copy_from_user(inp, crt->inputdata, mod_len))
|
||||
return -EFAULT;
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy results from a type 80 reply message back to user space.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @reply: reply AP message.
|
||||
* @data: pointer to user output data
|
||||
* @length: size of user output data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int convert_type80(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
struct type80_hdr *t80h = reply->message;
|
||||
unsigned char *data;
|
||||
|
||||
if (t80h->len < sizeof(*t80h) + outputdatalength) {
|
||||
/* The result is too short, the CEX2A card may not do that.. */
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
BUG_ON(t80h->len > CEX2A_MAX_RESPONSE_SIZE);
|
||||
data = reply->message + t80h->len - outputdatalength;
|
||||
if (copy_to_user(outputdata, data, outputdatalength))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int convert_response(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
/* Response type byte is the second byte in the response. */
|
||||
switch (((unsigned char *) reply->message)[1]) {
|
||||
case TYPE82_RSP_CODE:
|
||||
case TYPE88_RSP_CODE:
|
||||
return convert_error(zdev, reply);
|
||||
case TYPE80_RSP_CODE:
|
||||
return convert_type80(zdev, reply,
|
||||
outputdata, outputdatalength);
|
||||
default: /* Unknown response type, this should NEVER EVER happen */
|
||||
PRINTK("Unrecognized Message Header: %08x%08x\n",
|
||||
*(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message+4));
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is called from the AP bus code after a crypto request
|
||||
* "msg" has finished with the reply message "reply".
|
||||
* It is called from tasklet context.
|
||||
* @ap_dev: pointer to the AP device
|
||||
* @msg: pointer to the AP message
|
||||
* @reply: pointer to the AP reply message
|
||||
*/
|
||||
static void zcrypt_cex2a_receive(struct ap_device *ap_dev,
|
||||
struct ap_message *msg,
|
||||
struct ap_message *reply)
|
||||
{
|
||||
static struct error_hdr error_reply = {
|
||||
.type = TYPE82_RSP_CODE,
|
||||
.reply_code = REP82_ERROR_MACHINE_FAILURE,
|
||||
};
|
||||
struct type80_hdr *t80h = reply->message;
|
||||
int length;
|
||||
|
||||
/* Copy the reply message to the request message buffer. */
|
||||
if (IS_ERR(reply))
|
||||
memcpy(msg->message, &error_reply, sizeof(error_reply));
|
||||
else if (t80h->type == TYPE80_RSP_CODE) {
|
||||
length = min(CEX2A_MAX_RESPONSE_SIZE, (int) t80h->len);
|
||||
memcpy(msg->message, reply->message, length);
|
||||
} else
|
||||
memcpy(msg->message, reply->message, sizeof error_reply);
|
||||
complete((struct completion *) msg->private);
|
||||
}
|
||||
|
||||
static atomic_t zcrypt_step = ATOMIC_INIT(0);
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the CEX2A
|
||||
* device to handle a modexpo request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* CEX2A device to the request distributor
|
||||
* @mex: pointer to the modexpo request buffer
|
||||
*/
|
||||
static long zcrypt_cex2a_modexpo(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICAMEX_msg_to_type50MEX_msg(zdev, &ap_msg, mex);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, CEX2A_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, mex->outputdata,
|
||||
mex->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
kfree(ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the CEX2A
|
||||
* device to handle a modexpo_crt request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* CEX2A device to the request distributor
|
||||
* @crt: pointer to the modexpoc_crt request buffer
|
||||
*/
|
||||
static long zcrypt_cex2a_modexpo_crt(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) kmalloc(CEX2A_MAX_MESSAGE_SIZE, GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICACRT_msg_to_type50CRT_msg(zdev, &ap_msg, crt);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, CEX2A_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, crt->outputdata,
|
||||
crt->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
kfree(ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The crypto operations for a CEX2A card.
|
||||
*/
|
||||
static struct zcrypt_ops zcrypt_cex2a_ops = {
|
||||
.rsa_modexpo = zcrypt_cex2a_modexpo,
|
||||
.rsa_modexpo_crt = zcrypt_cex2a_modexpo_crt,
|
||||
};
|
||||
|
||||
/**
|
||||
* Probe function for CEX2A cards. It always accepts the AP device
|
||||
* since the bus_match already checked the hardware type.
|
||||
* @ap_dev: pointer to the AP device.
|
||||
*/
|
||||
static int zcrypt_cex2a_probe(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev;
|
||||
int rc;
|
||||
|
||||
zdev = zcrypt_device_alloc(CEX2A_MAX_RESPONSE_SIZE);
|
||||
if (!zdev)
|
||||
return -ENOMEM;
|
||||
zdev->ap_dev = ap_dev;
|
||||
zdev->ops = &zcrypt_cex2a_ops;
|
||||
zdev->online = 1;
|
||||
zdev->user_space_type = ZCRYPT_CEX2A;
|
||||
zdev->type_string = "CEX2A";
|
||||
zdev->min_mod_size = CEX2A_MIN_MOD_SIZE;
|
||||
zdev->max_mod_size = CEX2A_MAX_MOD_SIZE;
|
||||
zdev->short_crt = 1;
|
||||
zdev->speed_rating = CEX2A_SPEED_RATING;
|
||||
ap_dev->reply = &zdev->reply;
|
||||
ap_dev->private = zdev;
|
||||
rc = zcrypt_device_register(zdev);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
return 0;
|
||||
|
||||
out_free:
|
||||
ap_dev->private = NULL;
|
||||
zcrypt_device_free(zdev);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called to remove the extended CEX2A driver information
|
||||
* if an AP device is removed.
|
||||
*/
|
||||
static void zcrypt_cex2a_remove(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev = ap_dev->private;
|
||||
|
||||
zcrypt_device_unregister(zdev);
|
||||
}
|
||||
|
||||
int __init zcrypt_cex2a_init(void)
|
||||
{
|
||||
return ap_driver_register(&zcrypt_cex2a_driver, THIS_MODULE, "cex2a");
|
||||
}
|
||||
|
||||
void __exit zcrypt_cex2a_exit(void)
|
||||
{
|
||||
ap_driver_unregister(&zcrypt_cex2a_driver);
|
||||
}
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
module_init(zcrypt_cex2a_init);
|
||||
module_exit(zcrypt_cex2a_exit);
|
||||
#endif
|
126
drivers/s390/crypto/zcrypt_cex2a.h
Normal file
126
drivers/s390/crypto/zcrypt_cex2a.h
Normal file
@ -0,0 +1,126 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_cex2a.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_CEX2A_H_
|
||||
#define _ZCRYPT_CEX2A_H_
|
||||
|
||||
/**
|
||||
* The type 50 message family is associated with a CEX2A card.
|
||||
*
|
||||
* The four members of the family are described below.
|
||||
*
|
||||
* Note that all unsigned char arrays are right-justified and left-padded
|
||||
* with zeroes.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
struct type50_hdr {
|
||||
unsigned char reserved1;
|
||||
unsigned char msg_type_code; /* 0x50 */
|
||||
unsigned short msg_len;
|
||||
unsigned char reserved2;
|
||||
unsigned char ignored;
|
||||
unsigned short reserved3;
|
||||
} __attribute__((packed));
|
||||
|
||||
#define TYPE50_TYPE_CODE 0x50
|
||||
|
||||
#define TYPE50_MEB1_FMT 0x0001
|
||||
#define TYPE50_MEB2_FMT 0x0002
|
||||
#define TYPE50_CRB1_FMT 0x0011
|
||||
#define TYPE50_CRB2_FMT 0x0012
|
||||
|
||||
/* Mod-Exp, with a small modulus */
|
||||
struct type50_meb1_msg {
|
||||
struct type50_hdr header;
|
||||
unsigned short keyblock_type; /* 0x0001 */
|
||||
unsigned char reserved[6];
|
||||
unsigned char exponent[128];
|
||||
unsigned char modulus[128];
|
||||
unsigned char message[128];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* Mod-Exp, with a large modulus */
|
||||
struct type50_meb2_msg {
|
||||
struct type50_hdr header;
|
||||
unsigned short keyblock_type; /* 0x0002 */
|
||||
unsigned char reserved[6];
|
||||
unsigned char exponent[256];
|
||||
unsigned char modulus[256];
|
||||
unsigned char message[256];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* CRT, with a small modulus */
|
||||
struct type50_crb1_msg {
|
||||
struct type50_hdr header;
|
||||
unsigned short keyblock_type; /* 0x0011 */
|
||||
unsigned char reserved[6];
|
||||
unsigned char p[64];
|
||||
unsigned char q[64];
|
||||
unsigned char dp[64];
|
||||
unsigned char dq[64];
|
||||
unsigned char u[64];
|
||||
unsigned char message[128];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* CRT, with a large modulus */
|
||||
struct type50_crb2_msg {
|
||||
struct type50_hdr header;
|
||||
unsigned short keyblock_type; /* 0x0012 */
|
||||
unsigned char reserved[6];
|
||||
unsigned char p[128];
|
||||
unsigned char q[128];
|
||||
unsigned char dp[128];
|
||||
unsigned char dq[128];
|
||||
unsigned char u[128];
|
||||
unsigned char message[256];
|
||||
} __attribute__((packed));
|
||||
|
||||
/**
|
||||
* The type 80 response family is associated with a CEX2A card.
|
||||
*
|
||||
* Note that all unsigned char arrays are right-justified and left-padded
|
||||
* with zeroes.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
|
||||
#define TYPE80_RSP_CODE 0x80
|
||||
|
||||
struct type80_hdr {
|
||||
unsigned char reserved1;
|
||||
unsigned char type; /* 0x80 */
|
||||
unsigned short len;
|
||||
unsigned char code; /* 0x00 */
|
||||
unsigned char reserved2[3];
|
||||
unsigned char reserved3[8];
|
||||
} __attribute__((packed));
|
||||
|
||||
int zcrypt_cex2a_init(void);
|
||||
void zcrypt_cex2a_exit(void);
|
||||
|
||||
#endif /* _ZCRYPT_CEX2A_H_ */
|
133
drivers/s390/crypto/zcrypt_error.h
Normal file
133
drivers/s390/crypto/zcrypt_error.h
Normal file
@ -0,0 +1,133 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_error.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_ERROR_H_
|
||||
#define _ZCRYPT_ERROR_H_
|
||||
|
||||
#include "zcrypt_api.h"
|
||||
|
||||
/**
|
||||
* Reply Messages
|
||||
*
|
||||
* Error reply messages are of two types:
|
||||
* 82: Error (see below)
|
||||
* 88: Error (see below)
|
||||
* Both type 82 and type 88 have the same structure in the header.
|
||||
*
|
||||
* Request reply messages are of three known types:
|
||||
* 80: Reply from a Type 50 Request (see CEX2A-RELATED STRUCTS)
|
||||
* 84: Reply from a Type 4 Request (see PCICA-RELATED STRUCTS)
|
||||
* 86: Reply from a Type 6 Request (see PCICC/PCIXCC/CEX2C-RELATED STRUCTS)
|
||||
*
|
||||
*/
|
||||
struct error_hdr {
|
||||
unsigned char reserved1; /* 0x00 */
|
||||
unsigned char type; /* 0x82 or 0x88 */
|
||||
unsigned char reserved2[2]; /* 0x0000 */
|
||||
unsigned char reply_code; /* reply code */
|
||||
unsigned char reserved3[3]; /* 0x000000 */
|
||||
};
|
||||
|
||||
#define TYPE82_RSP_CODE 0x82
|
||||
#define TYPE88_RSP_CODE 0x88
|
||||
|
||||
#define REP82_ERROR_MACHINE_FAILURE 0x10
|
||||
#define REP82_ERROR_PREEMPT_FAILURE 0x12
|
||||
#define REP82_ERROR_CHECKPT_FAILURE 0x14
|
||||
#define REP82_ERROR_MESSAGE_TYPE 0x20
|
||||
#define REP82_ERROR_INVALID_COMM_CD 0x21 /* Type 84 */
|
||||
#define REP82_ERROR_INVALID_MSG_LEN 0x23
|
||||
#define REP82_ERROR_RESERVD_FIELD 0x24 /* was 0x50 */
|
||||
#define REP82_ERROR_FORMAT_FIELD 0x29
|
||||
#define REP82_ERROR_INVALID_COMMAND 0x30
|
||||
#define REP82_ERROR_MALFORMED_MSG 0x40
|
||||
#define REP82_ERROR_RESERVED_FIELDO 0x50 /* old value */
|
||||
#define REP82_ERROR_WORD_ALIGNMENT 0x60
|
||||
#define REP82_ERROR_MESSAGE_LENGTH 0x80
|
||||
#define REP82_ERROR_OPERAND_INVALID 0x82
|
||||
#define REP82_ERROR_OPERAND_SIZE 0x84
|
||||
#define REP82_ERROR_EVEN_MOD_IN_OPND 0x85
|
||||
#define REP82_ERROR_RESERVED_FIELD 0x88
|
||||
#define REP82_ERROR_TRANSPORT_FAIL 0x90
|
||||
#define REP82_ERROR_PACKET_TRUNCATED 0xA0
|
||||
#define REP82_ERROR_ZERO_BUFFER_LEN 0xB0
|
||||
|
||||
#define REP88_ERROR_MODULE_FAILURE 0x10
|
||||
|
||||
#define REP88_ERROR_MESSAGE_TYPE 0x20
|
||||
#define REP88_ERROR_MESSAGE_MALFORMD 0x22
|
||||
#define REP88_ERROR_MESSAGE_LENGTH 0x23
|
||||
#define REP88_ERROR_RESERVED_FIELD 0x24
|
||||
#define REP88_ERROR_KEY_TYPE 0x34
|
||||
#define REP88_ERROR_INVALID_KEY 0x82 /* CEX2A */
|
||||
#define REP88_ERROR_OPERAND 0x84 /* CEX2A */
|
||||
#define REP88_ERROR_OPERAND_EVEN_MOD 0x85 /* CEX2A */
|
||||
|
||||
static inline int convert_error(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply)
|
||||
{
|
||||
struct error_hdr *ehdr = reply->message;
|
||||
|
||||
PRINTK("Hardware error : Type %02x Message Header: %08x%08x\n",
|
||||
ehdr->type, *(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message + 4));
|
||||
|
||||
switch (ehdr->reply_code) {
|
||||
case REP82_ERROR_OPERAND_INVALID:
|
||||
case REP82_ERROR_OPERAND_SIZE:
|
||||
case REP82_ERROR_EVEN_MOD_IN_OPND:
|
||||
case REP88_ERROR_MESSAGE_MALFORMD:
|
||||
// REP88_ERROR_INVALID_KEY // '82' CEX2A
|
||||
// REP88_ERROR_OPERAND // '84' CEX2A
|
||||
// REP88_ERROR_OPERAND_EVEN_MOD // '85' CEX2A
|
||||
/* Invalid input data. */
|
||||
return -EINVAL;
|
||||
case REP82_ERROR_MESSAGE_TYPE:
|
||||
// REP88_ERROR_MESSAGE_TYPE // '20' CEX2A
|
||||
/**
|
||||
* To sent a message of the wrong type is a bug in the
|
||||
* device driver. Warn about it, disable the device
|
||||
* and then repeat the request.
|
||||
*/
|
||||
WARN_ON(1);
|
||||
zdev->online = 0;
|
||||
return -EAGAIN;
|
||||
case REP82_ERROR_TRANSPORT_FAIL:
|
||||
case REP82_ERROR_MACHINE_FAILURE:
|
||||
// REP88_ERROR_MODULE_FAILURE // '10' CEX2A
|
||||
/* If a card fails disable it and repeat the request. */
|
||||
zdev->online = 0;
|
||||
return -EAGAIN;
|
||||
default:
|
||||
PRINTKW("unknown type %02x reply code = %d\n",
|
||||
ehdr->type, ehdr->reply_code);
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* _ZCRYPT_ERROR_H_ */
|
100
drivers/s390/crypto/zcrypt_mono.c
Normal file
100
drivers/s390/crypto/zcrypt_mono.c
Normal file
@ -0,0 +1,100 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_mono.c
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/miscdevice.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/proc_fs.h>
|
||||
#include <linux/compat.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include "zcrypt_api.h"
|
||||
#include "zcrypt_pcica.h"
|
||||
#include "zcrypt_pcicc.h"
|
||||
#include "zcrypt_pcixcc.h"
|
||||
#include "zcrypt_cex2a.h"
|
||||
|
||||
/**
|
||||
* The module initialization code.
|
||||
*/
|
||||
int __init zcrypt_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
rc = ap_module_init();
|
||||
if (rc)
|
||||
goto out;
|
||||
rc = zcrypt_api_init();
|
||||
if (rc)
|
||||
goto out_ap;
|
||||
rc = zcrypt_pcica_init();
|
||||
if (rc)
|
||||
goto out_api;
|
||||
rc = zcrypt_pcicc_init();
|
||||
if (rc)
|
||||
goto out_pcica;
|
||||
rc = zcrypt_pcixcc_init();
|
||||
if (rc)
|
||||
goto out_pcicc;
|
||||
rc = zcrypt_cex2a_init();
|
||||
if (rc)
|
||||
goto out_pcixcc;
|
||||
return 0;
|
||||
|
||||
out_pcixcc:
|
||||
zcrypt_pcixcc_exit();
|
||||
out_pcicc:
|
||||
zcrypt_pcicc_exit();
|
||||
out_pcica:
|
||||
zcrypt_pcica_exit();
|
||||
out_api:
|
||||
zcrypt_api_exit();
|
||||
out_ap:
|
||||
ap_module_exit();
|
||||
out:
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The module termination code.
|
||||
*/
|
||||
void __exit zcrypt_exit(void)
|
||||
{
|
||||
zcrypt_cex2a_exit();
|
||||
zcrypt_pcixcc_exit();
|
||||
zcrypt_pcicc_exit();
|
||||
zcrypt_pcica_exit();
|
||||
zcrypt_api_exit();
|
||||
ap_module_exit();
|
||||
}
|
||||
|
||||
module_init(zcrypt_init);
|
||||
module_exit(zcrypt_exit);
|
418
drivers/s390/crypto/zcrypt_pcica.c
Normal file
418
drivers/s390/crypto/zcrypt_pcica.c
Normal file
@ -0,0 +1,418 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcica.c
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include "zcrypt_api.h"
|
||||
#include "zcrypt_error.h"
|
||||
#include "zcrypt_pcica.h"
|
||||
|
||||
#define PCICA_MIN_MOD_SIZE 1 /* 8 bits */
|
||||
#define PCICA_MAX_MOD_SIZE 256 /* 2048 bits */
|
||||
|
||||
#define PCICA_SPEED_RATING 2800
|
||||
|
||||
#define PCICA_MAX_MESSAGE_SIZE 0x3a0 /* sizeof(struct type4_lcr) */
|
||||
#define PCICA_MAX_RESPONSE_SIZE 0x110 /* max outputdatalength + type80_hdr */
|
||||
|
||||
#define PCICA_CLEANUP_TIME (15*HZ)
|
||||
|
||||
static struct ap_device_id zcrypt_pcica_ids[] = {
|
||||
{ AP_DEVICE(AP_DEVICE_TYPE_PCICA) },
|
||||
{ /* end of list */ },
|
||||
};
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
MODULE_DEVICE_TABLE(ap, zcrypt_pcica_ids);
|
||||
MODULE_AUTHOR("IBM Corporation");
|
||||
MODULE_DESCRIPTION("PCICA Cryptographic Coprocessor device driver, "
|
||||
"Copyright 2001, 2006 IBM Corporation");
|
||||
MODULE_LICENSE("GPL");
|
||||
#endif
|
||||
|
||||
static int zcrypt_pcica_probe(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcica_remove(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcica_receive(struct ap_device *, struct ap_message *,
|
||||
struct ap_message *);
|
||||
|
||||
static struct ap_driver zcrypt_pcica_driver = {
|
||||
.probe = zcrypt_pcica_probe,
|
||||
.remove = zcrypt_pcica_remove,
|
||||
.receive = zcrypt_pcica_receive,
|
||||
.ids = zcrypt_pcica_ids,
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a ICAMEX message to a type4 MEX message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @mex: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICAMEX_msg_to_type4MEX_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
unsigned char *modulus, *exponent, *message;
|
||||
int mod_len;
|
||||
|
||||
mod_len = mex->inputdatalength;
|
||||
|
||||
if (mod_len <= 128) {
|
||||
struct type4_sme *sme = ap_msg->message;
|
||||
memset(sme, 0, sizeof(*sme));
|
||||
ap_msg->length = sizeof(*sme);
|
||||
sme->header.msg_fmt = TYPE4_SME_FMT;
|
||||
sme->header.msg_len = sizeof(*sme);
|
||||
sme->header.msg_type_code = TYPE4_TYPE_CODE;
|
||||
sme->header.request_code = TYPE4_REQU_CODE;
|
||||
modulus = sme->modulus + sizeof(sme->modulus) - mod_len;
|
||||
exponent = sme->exponent + sizeof(sme->exponent) - mod_len;
|
||||
message = sme->message + sizeof(sme->message) - mod_len;
|
||||
} else {
|
||||
struct type4_lme *lme = ap_msg->message;
|
||||
memset(lme, 0, sizeof(*lme));
|
||||
ap_msg->length = sizeof(*lme);
|
||||
lme->header.msg_fmt = TYPE4_LME_FMT;
|
||||
lme->header.msg_len = sizeof(*lme);
|
||||
lme->header.msg_type_code = TYPE4_TYPE_CODE;
|
||||
lme->header.request_code = TYPE4_REQU_CODE;
|
||||
modulus = lme->modulus + sizeof(lme->modulus) - mod_len;
|
||||
exponent = lme->exponent + sizeof(lme->exponent) - mod_len;
|
||||
message = lme->message + sizeof(lme->message) - mod_len;
|
||||
}
|
||||
|
||||
if (copy_from_user(modulus, mex->n_modulus, mod_len) ||
|
||||
copy_from_user(exponent, mex->b_key, mod_len) ||
|
||||
copy_from_user(message, mex->inputdata, mod_len))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a ICACRT message to a type4 CRT message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @crt: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICACRT_msg_to_type4CRT_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
unsigned char *p, *q, *dp, *dq, *u, *inp;
|
||||
int mod_len, short_len, long_len;
|
||||
|
||||
mod_len = crt->inputdatalength;
|
||||
short_len = mod_len / 2;
|
||||
long_len = mod_len / 2 + 8;
|
||||
|
||||
if (mod_len <= 128) {
|
||||
struct type4_scr *scr = ap_msg->message;
|
||||
memset(scr, 0, sizeof(*scr));
|
||||
ap_msg->length = sizeof(*scr);
|
||||
scr->header.msg_type_code = TYPE4_TYPE_CODE;
|
||||
scr->header.request_code = TYPE4_REQU_CODE;
|
||||
scr->header.msg_fmt = TYPE4_SCR_FMT;
|
||||
scr->header.msg_len = sizeof(*scr);
|
||||
p = scr->p + sizeof(scr->p) - long_len;
|
||||
q = scr->q + sizeof(scr->q) - short_len;
|
||||
dp = scr->dp + sizeof(scr->dp) - long_len;
|
||||
dq = scr->dq + sizeof(scr->dq) - short_len;
|
||||
u = scr->u + sizeof(scr->u) - long_len;
|
||||
inp = scr->message + sizeof(scr->message) - mod_len;
|
||||
} else {
|
||||
struct type4_lcr *lcr = ap_msg->message;
|
||||
memset(lcr, 0, sizeof(*lcr));
|
||||
ap_msg->length = sizeof(*lcr);
|
||||
lcr->header.msg_type_code = TYPE4_TYPE_CODE;
|
||||
lcr->header.request_code = TYPE4_REQU_CODE;
|
||||
lcr->header.msg_fmt = TYPE4_LCR_FMT;
|
||||
lcr->header.msg_len = sizeof(*lcr);
|
||||
p = lcr->p + sizeof(lcr->p) - long_len;
|
||||
q = lcr->q + sizeof(lcr->q) - short_len;
|
||||
dp = lcr->dp + sizeof(lcr->dp) - long_len;
|
||||
dq = lcr->dq + sizeof(lcr->dq) - short_len;
|
||||
u = lcr->u + sizeof(lcr->u) - long_len;
|
||||
inp = lcr->message + sizeof(lcr->message) - mod_len;
|
||||
}
|
||||
|
||||
if (copy_from_user(p, crt->np_prime, long_len) ||
|
||||
copy_from_user(q, crt->nq_prime, short_len) ||
|
||||
copy_from_user(dp, crt->bp_key, long_len) ||
|
||||
copy_from_user(dq, crt->bq_key, short_len) ||
|
||||
copy_from_user(u, crt->u_mult_inv, long_len) ||
|
||||
copy_from_user(inp, crt->inputdata, mod_len))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy results from a type 84 reply message back to user space.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @reply: reply AP message.
|
||||
* @data: pointer to user output data
|
||||
* @length: size of user output data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static inline int convert_type84(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
struct type84_hdr *t84h = reply->message;
|
||||
char *data;
|
||||
|
||||
if (t84h->len < sizeof(*t84h) + outputdatalength) {
|
||||
/* The result is too short, the PCICA card may not do that.. */
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
BUG_ON(t84h->len > PCICA_MAX_RESPONSE_SIZE);
|
||||
data = reply->message + t84h->len - outputdatalength;
|
||||
if (copy_to_user(outputdata, data, outputdatalength))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int convert_response(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
/* Response type byte is the second byte in the response. */
|
||||
switch (((unsigned char *) reply->message)[1]) {
|
||||
case TYPE82_RSP_CODE:
|
||||
case TYPE88_RSP_CODE:
|
||||
return convert_error(zdev, reply);
|
||||
case TYPE84_RSP_CODE:
|
||||
return convert_type84(zdev, reply,
|
||||
outputdata, outputdatalength);
|
||||
default: /* Unknown response type, this should NEVER EVER happen */
|
||||
PRINTK("Unrecognized Message Header: %08x%08x\n",
|
||||
*(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message+4));
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is called from the AP bus code after a crypto request
|
||||
* "msg" has finished with the reply message "reply".
|
||||
* It is called from tasklet context.
|
||||
* @ap_dev: pointer to the AP device
|
||||
* @msg: pointer to the AP message
|
||||
* @reply: pointer to the AP reply message
|
||||
*/
|
||||
static void zcrypt_pcica_receive(struct ap_device *ap_dev,
|
||||
struct ap_message *msg,
|
||||
struct ap_message *reply)
|
||||
{
|
||||
static struct error_hdr error_reply = {
|
||||
.type = TYPE82_RSP_CODE,
|
||||
.reply_code = REP82_ERROR_MACHINE_FAILURE,
|
||||
};
|
||||
struct type84_hdr *t84h = reply->message;
|
||||
int length;
|
||||
|
||||
/* Copy the reply message to the request message buffer. */
|
||||
if (IS_ERR(reply))
|
||||
memcpy(msg->message, &error_reply, sizeof(error_reply));
|
||||
else if (t84h->code == TYPE84_RSP_CODE) {
|
||||
length = min(PCICA_MAX_RESPONSE_SIZE, (int) t84h->len);
|
||||
memcpy(msg->message, reply->message, length);
|
||||
} else
|
||||
memcpy(msg->message, reply->message, sizeof error_reply);
|
||||
complete((struct completion *) msg->private);
|
||||
}
|
||||
|
||||
static atomic_t zcrypt_step = ATOMIC_INIT(0);
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCICA
|
||||
* device to handle a modexpo request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCICA device to the request distributor
|
||||
* @mex: pointer to the modexpo request buffer
|
||||
*/
|
||||
static long zcrypt_pcica_modexpo(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICAMEX_msg_to_type4MEX_msg(zdev, &ap_msg, mex);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, PCICA_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, mex->outputdata,
|
||||
mex->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
kfree(ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCICA
|
||||
* device to handle a modexpo_crt request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCICA device to the request distributor
|
||||
* @crt: pointer to the modexpoc_crt request buffer
|
||||
*/
|
||||
static long zcrypt_pcica_modexpo_crt(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) kmalloc(PCICA_MAX_MESSAGE_SIZE, GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICACRT_msg_to_type4CRT_msg(zdev, &ap_msg, crt);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, PCICA_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, crt->outputdata,
|
||||
crt->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
kfree(ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The crypto operations for a PCICA card.
|
||||
*/
|
||||
static struct zcrypt_ops zcrypt_pcica_ops = {
|
||||
.rsa_modexpo = zcrypt_pcica_modexpo,
|
||||
.rsa_modexpo_crt = zcrypt_pcica_modexpo_crt,
|
||||
};
|
||||
|
||||
/**
|
||||
* Probe function for PCICA cards. It always accepts the AP device
|
||||
* since the bus_match already checked the hardware type.
|
||||
* @ap_dev: pointer to the AP device.
|
||||
*/
|
||||
static int zcrypt_pcica_probe(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev;
|
||||
int rc;
|
||||
|
||||
zdev = zcrypt_device_alloc(PCICA_MAX_RESPONSE_SIZE);
|
||||
if (!zdev)
|
||||
return -ENOMEM;
|
||||
zdev->ap_dev = ap_dev;
|
||||
zdev->ops = &zcrypt_pcica_ops;
|
||||
zdev->online = 1;
|
||||
zdev->user_space_type = ZCRYPT_PCICA;
|
||||
zdev->type_string = "PCICA";
|
||||
zdev->min_mod_size = PCICA_MIN_MOD_SIZE;
|
||||
zdev->max_mod_size = PCICA_MAX_MOD_SIZE;
|
||||
zdev->speed_rating = PCICA_SPEED_RATING;
|
||||
ap_dev->reply = &zdev->reply;
|
||||
ap_dev->private = zdev;
|
||||
rc = zcrypt_device_register(zdev);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
return 0;
|
||||
|
||||
out_free:
|
||||
ap_dev->private = NULL;
|
||||
zcrypt_device_free(zdev);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called to remove the extended PCICA driver information
|
||||
* if an AP device is removed.
|
||||
*/
|
||||
static void zcrypt_pcica_remove(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev = ap_dev->private;
|
||||
|
||||
zcrypt_device_unregister(zdev);
|
||||
}
|
||||
|
||||
int __init zcrypt_pcica_init(void)
|
||||
{
|
||||
return ap_driver_register(&zcrypt_pcica_driver, THIS_MODULE, "pcica");
|
||||
}
|
||||
|
||||
void zcrypt_pcica_exit(void)
|
||||
{
|
||||
ap_driver_unregister(&zcrypt_pcica_driver);
|
||||
}
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
module_init(zcrypt_pcica_init);
|
||||
module_exit(zcrypt_pcica_exit);
|
||||
#endif
|
117
drivers/s390/crypto/zcrypt_pcica.h
Normal file
117
drivers/s390/crypto/zcrypt_pcica.h
Normal file
@ -0,0 +1,117 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcica.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_PCICA_H_
|
||||
#define _ZCRYPT_PCICA_H_
|
||||
|
||||
/**
|
||||
* The type 4 message family is associated with a PCICA card.
|
||||
*
|
||||
* The four members of the family are described below.
|
||||
*
|
||||
* Note that all unsigned char arrays are right-justified and left-padded
|
||||
* with zeroes.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
struct type4_hdr {
|
||||
unsigned char reserved1;
|
||||
unsigned char msg_type_code; /* 0x04 */
|
||||
unsigned short msg_len;
|
||||
unsigned char request_code; /* 0x40 */
|
||||
unsigned char msg_fmt;
|
||||
unsigned short reserved2;
|
||||
} __attribute__((packed));
|
||||
|
||||
#define TYPE4_TYPE_CODE 0x04
|
||||
#define TYPE4_REQU_CODE 0x40
|
||||
|
||||
#define TYPE4_SME_FMT 0x00
|
||||
#define TYPE4_LME_FMT 0x10
|
||||
#define TYPE4_SCR_FMT 0x40
|
||||
#define TYPE4_LCR_FMT 0x50
|
||||
|
||||
/* Mod-Exp, with a small modulus */
|
||||
struct type4_sme {
|
||||
struct type4_hdr header;
|
||||
unsigned char message[128];
|
||||
unsigned char exponent[128];
|
||||
unsigned char modulus[128];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* Mod-Exp, with a large modulus */
|
||||
struct type4_lme {
|
||||
struct type4_hdr header;
|
||||
unsigned char message[256];
|
||||
unsigned char exponent[256];
|
||||
unsigned char modulus[256];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* CRT, with a small modulus */
|
||||
struct type4_scr {
|
||||
struct type4_hdr header;
|
||||
unsigned char message[128];
|
||||
unsigned char dp[72];
|
||||
unsigned char dq[64];
|
||||
unsigned char p[72];
|
||||
unsigned char q[64];
|
||||
unsigned char u[72];
|
||||
} __attribute__((packed));
|
||||
|
||||
/* CRT, with a large modulus */
|
||||
struct type4_lcr {
|
||||
struct type4_hdr header;
|
||||
unsigned char message[256];
|
||||
unsigned char dp[136];
|
||||
unsigned char dq[128];
|
||||
unsigned char p[136];
|
||||
unsigned char q[128];
|
||||
unsigned char u[136];
|
||||
} __attribute__((packed));
|
||||
|
||||
/**
|
||||
* The type 84 response family is associated with a PCICA card.
|
||||
*
|
||||
* Note that all unsigned char arrays are right-justified and left-padded
|
||||
* with zeroes.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
|
||||
struct type84_hdr {
|
||||
unsigned char reserved1;
|
||||
unsigned char code;
|
||||
unsigned short len;
|
||||
unsigned char reserved2[4];
|
||||
} __attribute__((packed));
|
||||
|
||||
#define TYPE84_RSP_CODE 0x84
|
||||
|
||||
int zcrypt_pcica_init(void);
|
||||
void zcrypt_pcica_exit(void);
|
||||
|
||||
#endif /* _ZCRYPT_PCICA_H_ */
|
630
drivers/s390/crypto/zcrypt_pcicc.c
Normal file
630
drivers/s390/crypto/zcrypt_pcicc.c
Normal file
@ -0,0 +1,630 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcicc.c
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include "zcrypt_api.h"
|
||||
#include "zcrypt_error.h"
|
||||
#include "zcrypt_pcicc.h"
|
||||
#include "zcrypt_cca_key.h"
|
||||
|
||||
#define PCICC_MIN_MOD_SIZE 64 /* 512 bits */
|
||||
#define PCICC_MAX_MOD_SIZE_OLD 128 /* 1024 bits */
|
||||
#define PCICC_MAX_MOD_SIZE 256 /* 2048 bits */
|
||||
|
||||
/**
|
||||
* PCICC cards need a speed rating of 0. This keeps them at the end of
|
||||
* the zcrypt device list (see zcrypt_api.c). PCICC cards are only
|
||||
* used if no other cards are present because they are slow and can only
|
||||
* cope with PKCS12 padded requests. The logic is queer. PKCS11 padded
|
||||
* requests are rejected. The modexpo function encrypts PKCS12 padded data
|
||||
* and decrypts any non-PKCS12 padded data (except PKCS11) in the assumption
|
||||
* that it's encrypted PKCS12 data. The modexpo_crt function always decrypts
|
||||
* the data in the assumption that its PKCS12 encrypted data.
|
||||
*/
|
||||
#define PCICC_SPEED_RATING 0
|
||||
|
||||
#define PCICC_MAX_MESSAGE_SIZE 0x710 /* max size type6 v1 crt message */
|
||||
#define PCICC_MAX_RESPONSE_SIZE 0x710 /* max size type86 v1 reply */
|
||||
|
||||
#define PCICC_CLEANUP_TIME (15*HZ)
|
||||
|
||||
static struct ap_device_id zcrypt_pcicc_ids[] = {
|
||||
{ AP_DEVICE(AP_DEVICE_TYPE_PCICC) },
|
||||
{ /* end of list */ },
|
||||
};
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
MODULE_DEVICE_TABLE(ap, zcrypt_pcicc_ids);
|
||||
MODULE_AUTHOR("IBM Corporation");
|
||||
MODULE_DESCRIPTION("PCICC Cryptographic Coprocessor device driver, "
|
||||
"Copyright 2001, 2006 IBM Corporation");
|
||||
MODULE_LICENSE("GPL");
|
||||
#endif
|
||||
|
||||
static int zcrypt_pcicc_probe(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcicc_remove(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcicc_receive(struct ap_device *, struct ap_message *,
|
||||
struct ap_message *);
|
||||
|
||||
static struct ap_driver zcrypt_pcicc_driver = {
|
||||
.probe = zcrypt_pcicc_probe,
|
||||
.remove = zcrypt_pcicc_remove,
|
||||
.receive = zcrypt_pcicc_receive,
|
||||
.ids = zcrypt_pcicc_ids,
|
||||
};
|
||||
|
||||
/**
|
||||
* The following is used to initialize the CPRB passed to the PCICC card
|
||||
* in a type6 message. The 3 fields that must be filled in at execution
|
||||
* time are req_parml, rpl_parml and usage_domain. Note that all three
|
||||
* fields are *little*-endian. Actually, everything about this interface
|
||||
* is ascii/little-endian, since the device has 'Intel inside'.
|
||||
*
|
||||
* The CPRB is followed immediately by the parm block.
|
||||
* The parm block contains:
|
||||
* - function code ('PD' 0x5044 or 'PK' 0x504B)
|
||||
* - rule block (0x0A00 'PKCS-1.2' or 0x0A00 'ZERO-PAD')
|
||||
* - VUD block
|
||||
*/
|
||||
static struct CPRB static_cprb = {
|
||||
.cprb_len = __constant_cpu_to_le16(0x0070),
|
||||
.cprb_ver_id = 0x41,
|
||||
.func_id = {0x54,0x32},
|
||||
.checkpoint_flag= 0x01,
|
||||
.svr_namel = __constant_cpu_to_le16(0x0008),
|
||||
.svr_name = {'I','C','S','F',' ',' ',' ',' '}
|
||||
};
|
||||
|
||||
/**
|
||||
* Check the message for PKCS11 padding.
|
||||
*/
|
||||
static inline int is_PKCS11_padded(unsigned char *buffer, int length)
|
||||
{
|
||||
int i;
|
||||
if ((buffer[0] != 0x00) || (buffer[1] != 0x01))
|
||||
return 0;
|
||||
for (i = 2; i < length; i++)
|
||||
if (buffer[i] != 0xFF)
|
||||
break;
|
||||
if (i < 10 || i == length)
|
||||
return 0;
|
||||
if (buffer[i] != 0x00)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check the message for PKCS12 padding.
|
||||
*/
|
||||
static inline int is_PKCS12_padded(unsigned char *buffer, int length)
|
||||
{
|
||||
int i;
|
||||
if ((buffer[0] != 0x00) || (buffer[1] != 0x02))
|
||||
return 0;
|
||||
for (i = 2; i < length; i++)
|
||||
if (buffer[i] == 0x00)
|
||||
break;
|
||||
if ((i < 10) || (i == length))
|
||||
return 0;
|
||||
if (buffer[i] != 0x00)
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a ICAMEX message to a type6 MEX message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @mex: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICAMEX_msg_to_type6MEX_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
static struct type6_hdr static_type6_hdr = {
|
||||
.type = 0x06,
|
||||
.offset1 = 0x00000058,
|
||||
.agent_id = {0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
|
||||
0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
|
||||
.function_code = {'P','K'},
|
||||
};
|
||||
static struct function_and_rules_block static_pke_function_and_rules ={
|
||||
.function_code = {'P','K'},
|
||||
.ulen = __constant_cpu_to_le16(10),
|
||||
.only_rule = {'P','K','C','S','-','1','.','2'}
|
||||
};
|
||||
struct {
|
||||
struct type6_hdr hdr;
|
||||
struct CPRB cprb;
|
||||
struct function_and_rules_block fr;
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed)) *msg = ap_msg->message;
|
||||
int vud_len, pad_len, size;
|
||||
|
||||
/* VUD.ciphertext */
|
||||
if (copy_from_user(msg->text, mex->inputdata, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
if (is_PKCS11_padded(msg->text, mex->inputdatalength))
|
||||
return -EINVAL;
|
||||
|
||||
/* static message header and f&r */
|
||||
msg->hdr = static_type6_hdr;
|
||||
msg->fr = static_pke_function_and_rules;
|
||||
|
||||
if (is_PKCS12_padded(msg->text, mex->inputdatalength)) {
|
||||
/* strip the padding and adjust the data length */
|
||||
pad_len = strnlen(msg->text + 2, mex->inputdatalength - 2) + 3;
|
||||
if (pad_len <= 9 || pad_len >= mex->inputdatalength)
|
||||
return -ENODEV;
|
||||
vud_len = mex->inputdatalength - pad_len;
|
||||
memmove(msg->text, msg->text + pad_len, vud_len);
|
||||
msg->length = cpu_to_le16(vud_len + 2);
|
||||
|
||||
/* Set up key after the variable length text. */
|
||||
size = zcrypt_type6_mex_key_en(mex, msg->text + vud_len, 0);
|
||||
if (size < 0)
|
||||
return size;
|
||||
size += sizeof(*msg) + vud_len; /* total size of msg */
|
||||
} else {
|
||||
vud_len = mex->inputdatalength;
|
||||
msg->length = cpu_to_le16(2 + vud_len);
|
||||
|
||||
msg->hdr.function_code[1] = 'D';
|
||||
msg->fr.function_code[1] = 'D';
|
||||
|
||||
/* Set up key after the variable length text. */
|
||||
size = zcrypt_type6_mex_key_de(mex, msg->text + vud_len, 0);
|
||||
if (size < 0)
|
||||
return size;
|
||||
size += sizeof(*msg) + vud_len; /* total size of msg */
|
||||
}
|
||||
|
||||
/* message header, cprb and f&r */
|
||||
msg->hdr.ToCardLen1 = (size - sizeof(msg->hdr) + 3) & -4;
|
||||
msg->hdr.FromCardLen1 = PCICC_MAX_RESPONSE_SIZE - sizeof(msg->hdr);
|
||||
|
||||
msg->cprb = static_cprb;
|
||||
msg->cprb.usage_domain[0]= AP_QID_QUEUE(zdev->ap_dev->qid);
|
||||
msg->cprb.req_parml = cpu_to_le16(size - sizeof(msg->hdr) -
|
||||
sizeof(msg->cprb));
|
||||
msg->cprb.rpl_parml = cpu_to_le16(msg->hdr.FromCardLen1);
|
||||
|
||||
ap_msg->length = (size + 3) & -4;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a ICACRT message to a type6 CRT message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @zreq: crypto request pointer
|
||||
* @crt: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICACRT_msg_to_type6CRT_msg(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
static struct type6_hdr static_type6_hdr = {
|
||||
.type = 0x06,
|
||||
.offset1 = 0x00000058,
|
||||
.agent_id = {0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
|
||||
0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
|
||||
.function_code = {'P','D'},
|
||||
};
|
||||
static struct function_and_rules_block static_pkd_function_and_rules ={
|
||||
.function_code = {'P','D'},
|
||||
.ulen = __constant_cpu_to_le16(10),
|
||||
.only_rule = {'P','K','C','S','-','1','.','2'}
|
||||
};
|
||||
struct {
|
||||
struct type6_hdr hdr;
|
||||
struct CPRB cprb;
|
||||
struct function_and_rules_block fr;
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed)) *msg = ap_msg->message;
|
||||
int size;
|
||||
|
||||
/* VUD.ciphertext */
|
||||
msg->length = cpu_to_le16(2 + crt->inputdatalength);
|
||||
if (copy_from_user(msg->text, crt->inputdata, crt->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
if (is_PKCS11_padded(msg->text, crt->inputdatalength))
|
||||
return -EINVAL;
|
||||
|
||||
/* Set up key after the variable length text. */
|
||||
size = zcrypt_type6_crt_key(crt, msg->text + crt->inputdatalength, 0);
|
||||
if (size < 0)
|
||||
return size;
|
||||
size += sizeof(*msg) + crt->inputdatalength; /* total size of msg */
|
||||
|
||||
/* message header, cprb and f&r */
|
||||
msg->hdr = static_type6_hdr;
|
||||
msg->hdr.ToCardLen1 = (size - sizeof(msg->hdr) + 3) & -4;
|
||||
msg->hdr.FromCardLen1 = PCICC_MAX_RESPONSE_SIZE - sizeof(msg->hdr);
|
||||
|
||||
msg->cprb = static_cprb;
|
||||
msg->cprb.usage_domain[0] = AP_QID_QUEUE(zdev->ap_dev->qid);
|
||||
msg->cprb.req_parml = msg->cprb.rpl_parml =
|
||||
cpu_to_le16(size - sizeof(msg->hdr) - sizeof(msg->cprb));
|
||||
|
||||
msg->fr = static_pkd_function_and_rules;
|
||||
|
||||
ap_msg->length = (size + 3) & -4;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy results from a type 86 reply message back to user space.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @reply: reply AP message.
|
||||
* @data: pointer to user output data
|
||||
* @length: size of user output data
|
||||
*
|
||||
* Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
|
||||
*/
|
||||
struct type86_reply {
|
||||
struct type86_hdr hdr;
|
||||
struct type86_fmt2_ext fmt2;
|
||||
struct CPRB cprb;
|
||||
unsigned char pad[4]; /* 4 byte function code/rules block ? */
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed));
|
||||
|
||||
static int convert_type86(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
static unsigned char static_pad[] = {
|
||||
0x00,0x02,
|
||||
0x1B,0x7B,0x5D,0xB5,0x75,0x01,0x3D,0xFD,
|
||||
0x8D,0xD1,0xC7,0x03,0x2D,0x09,0x23,0x57,
|
||||
0x89,0x49,0xB9,0x3F,0xBB,0x99,0x41,0x5B,
|
||||
0x75,0x21,0x7B,0x9D,0x3B,0x6B,0x51,0x39,
|
||||
0xBB,0x0D,0x35,0xB9,0x89,0x0F,0x93,0xA5,
|
||||
0x0B,0x47,0xF1,0xD3,0xBB,0xCB,0xF1,0x9D,
|
||||
0x23,0x73,0x71,0xFF,0xF3,0xF5,0x45,0xFB,
|
||||
0x61,0x29,0x23,0xFD,0xF1,0x29,0x3F,0x7F,
|
||||
0x17,0xB7,0x1B,0xA9,0x19,0xBD,0x57,0xA9,
|
||||
0xD7,0x95,0xA3,0xCB,0xED,0x1D,0xDB,0x45,
|
||||
0x7D,0x11,0xD1,0x51,0x1B,0xED,0x71,0xE9,
|
||||
0xB1,0xD1,0xAB,0xAB,0x21,0x2B,0x1B,0x9F,
|
||||
0x3B,0x9F,0xF7,0xF7,0xBD,0x63,0xEB,0xAD,
|
||||
0xDF,0xB3,0x6F,0x5B,0xDB,0x8D,0xA9,0x5D,
|
||||
0xE3,0x7D,0x77,0x49,0x47,0xF5,0xA7,0xFD,
|
||||
0xAB,0x2F,0x27,0x35,0x77,0xD3,0x49,0xC9,
|
||||
0x09,0xEB,0xB1,0xF9,0xBF,0x4B,0xCB,0x2B,
|
||||
0xEB,0xEB,0x05,0xFF,0x7D,0xC7,0x91,0x8B,
|
||||
0x09,0x83,0xB9,0xB9,0x69,0x33,0x39,0x6B,
|
||||
0x79,0x75,0x19,0xBF,0xBB,0x07,0x1D,0xBD,
|
||||
0x29,0xBF,0x39,0x95,0x93,0x1D,0x35,0xC7,
|
||||
0xC9,0x4D,0xE5,0x97,0x0B,0x43,0x9B,0xF1,
|
||||
0x16,0x93,0x03,0x1F,0xA5,0xFB,0xDB,0xF3,
|
||||
0x27,0x4F,0x27,0x61,0x05,0x1F,0xB9,0x23,
|
||||
0x2F,0xC3,0x81,0xA9,0x23,0x71,0x55,0x55,
|
||||
0xEB,0xED,0x41,0xE5,0xF3,0x11,0xF1,0x43,
|
||||
0x69,0x03,0xBD,0x0B,0x37,0x0F,0x51,0x8F,
|
||||
0x0B,0xB5,0x89,0x5B,0x67,0xA9,0xD9,0x4F,
|
||||
0x01,0xF9,0x21,0x77,0x37,0x73,0x79,0xC5,
|
||||
0x7F,0x51,0xC1,0xCF,0x97,0xA1,0x75,0xAD,
|
||||
0x35,0x9D,0xD3,0xD3,0xA7,0x9D,0x5D,0x41,
|
||||
0x6F,0x65,0x1B,0xCF,0xA9,0x87,0x91,0x09
|
||||
};
|
||||
struct type86_reply *msg = reply->message;
|
||||
unsigned short service_rc, service_rs;
|
||||
unsigned int reply_len, pad_len;
|
||||
char *data;
|
||||
|
||||
service_rc = le16_to_cpu(msg->cprb.ccp_rtcode);
|
||||
if (unlikely(service_rc != 0)) {
|
||||
service_rs = le16_to_cpu(msg->cprb.ccp_rscode);
|
||||
if (service_rc == 8 && service_rs == 66) {
|
||||
PDEBUG("Bad block format on PCICC\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 65) {
|
||||
PDEBUG("Probably an even modulus on PCICC\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 770) {
|
||||
PDEBUG("Invalid key length on PCICC\n");
|
||||
zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
|
||||
return -EAGAIN;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 783) {
|
||||
PDEBUG("Extended bitlengths not enabled on PCICC\n");
|
||||
zdev->max_mod_size = PCICC_MAX_MOD_SIZE_OLD;
|
||||
return -EAGAIN;
|
||||
}
|
||||
PRINTK("Unknown service rc/rs (PCICC): %d/%d\n",
|
||||
service_rc, service_rs);
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
data = msg->text;
|
||||
reply_len = le16_to_cpu(msg->length) - 2;
|
||||
if (reply_len > outputdatalength)
|
||||
return -EINVAL;
|
||||
/**
|
||||
* For all encipher requests, the length of the ciphertext (reply_len)
|
||||
* will always equal the modulus length. For MEX decipher requests
|
||||
* the output needs to get padded. Minimum pad size is 10.
|
||||
*
|
||||
* Currently, the cases where padding will be added is for:
|
||||
* - PCIXCC_MCL2 using a CRT form token (since PKD didn't support
|
||||
* ZERO-PAD and CRT is only supported for PKD requests)
|
||||
* - PCICC, always
|
||||
*/
|
||||
pad_len = outputdatalength - reply_len;
|
||||
if (pad_len > 0) {
|
||||
if (pad_len < 10)
|
||||
return -EINVAL;
|
||||
/* 'restore' padding left in the PCICC/PCIXCC card. */
|
||||
if (copy_to_user(outputdata, static_pad, pad_len - 1))
|
||||
return -EFAULT;
|
||||
if (put_user(0, outputdata + pad_len - 1))
|
||||
return -EFAULT;
|
||||
}
|
||||
/* Copy the crypto response to user space. */
|
||||
if (copy_to_user(outputdata + pad_len, data, reply_len))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int convert_response(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
struct type86_reply *msg = reply->message;
|
||||
|
||||
/* Response type byte is the second byte in the response. */
|
||||
switch (msg->hdr.type) {
|
||||
case TYPE82_RSP_CODE:
|
||||
case TYPE88_RSP_CODE:
|
||||
return convert_error(zdev, reply);
|
||||
case TYPE86_RSP_CODE:
|
||||
if (msg->hdr.reply_code)
|
||||
return convert_error(zdev, reply);
|
||||
if (msg->cprb.cprb_ver_id == 0x01)
|
||||
return convert_type86(zdev, reply,
|
||||
outputdata, outputdatalength);
|
||||
/* no break, incorrect cprb version is an unknown response */
|
||||
default: /* Unknown response type, this should NEVER EVER happen */
|
||||
PRINTK("Unrecognized Message Header: %08x%08x\n",
|
||||
*(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message+4));
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is called from the AP bus code after a crypto request
|
||||
* "msg" has finished with the reply message "reply".
|
||||
* It is called from tasklet context.
|
||||
* @ap_dev: pointer to the AP device
|
||||
* @msg: pointer to the AP message
|
||||
* @reply: pointer to the AP reply message
|
||||
*/
|
||||
static void zcrypt_pcicc_receive(struct ap_device *ap_dev,
|
||||
struct ap_message *msg,
|
||||
struct ap_message *reply)
|
||||
{
|
||||
static struct error_hdr error_reply = {
|
||||
.type = TYPE82_RSP_CODE,
|
||||
.reply_code = REP82_ERROR_MACHINE_FAILURE,
|
||||
};
|
||||
struct type86_reply *t86r = reply->message;
|
||||
int length;
|
||||
|
||||
/* Copy the reply message to the request message buffer. */
|
||||
if (IS_ERR(reply))
|
||||
memcpy(msg->message, &error_reply, sizeof(error_reply));
|
||||
else if (t86r->hdr.type == TYPE86_RSP_CODE &&
|
||||
t86r->cprb.cprb_ver_id == 0x01) {
|
||||
length = sizeof(struct type86_reply) + t86r->length - 2;
|
||||
length = min(PCICC_MAX_RESPONSE_SIZE, length);
|
||||
memcpy(msg->message, reply->message, length);
|
||||
} else
|
||||
memcpy(msg->message, reply->message, sizeof error_reply);
|
||||
complete((struct completion *) msg->private);
|
||||
}
|
||||
|
||||
static atomic_t zcrypt_step = ATOMIC_INIT(0);
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCICC
|
||||
* device to handle a modexpo request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCICC device to the request distributor
|
||||
* @mex: pointer to the modexpo request buffer
|
||||
*/
|
||||
static long zcrypt_pcicc_modexpo(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.length = PAGE_SIZE;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICAMEX_msg_to_type6MEX_msg(zdev, &ap_msg, mex);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, PCICC_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, mex->outputdata,
|
||||
mex->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
free_page((unsigned long) ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCICC
|
||||
* device to handle a modexpo_crt request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCICC device to the request distributor
|
||||
* @crt: pointer to the modexpoc_crt request buffer
|
||||
*/
|
||||
static long zcrypt_pcicc_modexpo_crt(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct completion work;
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.length = PAGE_SIZE;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &work;
|
||||
rc = ICACRT_msg_to_type6CRT_msg(zdev, &ap_msg, crt);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&work, PCICC_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response(zdev, &ap_msg, crt->outputdata,
|
||||
crt->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
free_page((unsigned long) ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The crypto operations for a PCICC card.
|
||||
*/
|
||||
static struct zcrypt_ops zcrypt_pcicc_ops = {
|
||||
.rsa_modexpo = zcrypt_pcicc_modexpo,
|
||||
.rsa_modexpo_crt = zcrypt_pcicc_modexpo_crt,
|
||||
};
|
||||
|
||||
/**
|
||||
* Probe function for PCICC cards. It always accepts the AP device
|
||||
* since the bus_match already checked the hardware type.
|
||||
* @ap_dev: pointer to the AP device.
|
||||
*/
|
||||
static int zcrypt_pcicc_probe(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev;
|
||||
int rc;
|
||||
|
||||
zdev = zcrypt_device_alloc(PCICC_MAX_RESPONSE_SIZE);
|
||||
if (!zdev)
|
||||
return -ENOMEM;
|
||||
zdev->ap_dev = ap_dev;
|
||||
zdev->ops = &zcrypt_pcicc_ops;
|
||||
zdev->online = 1;
|
||||
zdev->user_space_type = ZCRYPT_PCICC;
|
||||
zdev->type_string = "PCICC";
|
||||
zdev->min_mod_size = PCICC_MIN_MOD_SIZE;
|
||||
zdev->max_mod_size = PCICC_MAX_MOD_SIZE;
|
||||
zdev->speed_rating = PCICC_SPEED_RATING;
|
||||
ap_dev->reply = &zdev->reply;
|
||||
ap_dev->private = zdev;
|
||||
rc = zcrypt_device_register(zdev);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
return 0;
|
||||
|
||||
out_free:
|
||||
ap_dev->private = NULL;
|
||||
zcrypt_device_free(zdev);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called to remove the extended PCICC driver information
|
||||
* if an AP device is removed.
|
||||
*/
|
||||
static void zcrypt_pcicc_remove(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev = ap_dev->private;
|
||||
|
||||
zcrypt_device_unregister(zdev);
|
||||
}
|
||||
|
||||
int __init zcrypt_pcicc_init(void)
|
||||
{
|
||||
return ap_driver_register(&zcrypt_pcicc_driver, THIS_MODULE, "pcicc");
|
||||
}
|
||||
|
||||
void zcrypt_pcicc_exit(void)
|
||||
{
|
||||
ap_driver_unregister(&zcrypt_pcicc_driver);
|
||||
}
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
module_init(zcrypt_pcicc_init);
|
||||
module_exit(zcrypt_pcicc_exit);
|
||||
#endif
|
176
drivers/s390/crypto/zcrypt_pcicc.h
Normal file
176
drivers/s390/crypto/zcrypt_pcicc.h
Normal file
@ -0,0 +1,176 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcicc.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_PCICC_H_
|
||||
#define _ZCRYPT_PCICC_H_
|
||||
|
||||
/**
|
||||
* The type 6 message family is associated with PCICC or PCIXCC cards.
|
||||
*
|
||||
* It contains a message header followed by a CPRB, both of which
|
||||
* are described below.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
struct type6_hdr {
|
||||
unsigned char reserved1; /* 0x00 */
|
||||
unsigned char type; /* 0x06 */
|
||||
unsigned char reserved2[2]; /* 0x0000 */
|
||||
unsigned char right[4]; /* 0x00000000 */
|
||||
unsigned char reserved3[2]; /* 0x0000 */
|
||||
unsigned char reserved4[2]; /* 0x0000 */
|
||||
unsigned char apfs[4]; /* 0x00000000 */
|
||||
unsigned int offset1; /* 0x00000058 (offset to CPRB) */
|
||||
unsigned int offset2; /* 0x00000000 */
|
||||
unsigned int offset3; /* 0x00000000 */
|
||||
unsigned int offset4; /* 0x00000000 */
|
||||
unsigned char agent_id[16]; /* PCICC: */
|
||||
/* 0x0100 */
|
||||
/* 0x4343412d4150504c202020 */
|
||||
/* 0x010101 */
|
||||
/* PCIXCC: */
|
||||
/* 0x4341000000000000 */
|
||||
/* 0x0000000000000000 */
|
||||
unsigned char rqid[2]; /* rqid. internal to 603 */
|
||||
unsigned char reserved5[2]; /* 0x0000 */
|
||||
unsigned char function_code[2]; /* for PKD, 0x5044 (ascii 'PD') */
|
||||
unsigned char reserved6[2]; /* 0x0000 */
|
||||
unsigned int ToCardLen1; /* (request CPRB len + 3) & -4 */
|
||||
unsigned int ToCardLen2; /* db len 0x00000000 for PKD */
|
||||
unsigned int ToCardLen3; /* 0x00000000 */
|
||||
unsigned int ToCardLen4; /* 0x00000000 */
|
||||
unsigned int FromCardLen1; /* response buffer length */
|
||||
unsigned int FromCardLen2; /* db len 0x00000000 for PKD */
|
||||
unsigned int FromCardLen3; /* 0x00000000 */
|
||||
unsigned int FromCardLen4; /* 0x00000000 */
|
||||
} __attribute__((packed));
|
||||
|
||||
/**
|
||||
* CPRB
|
||||
* Note that all shorts, ints and longs are little-endian.
|
||||
* All pointer fields are 32-bits long, and mean nothing
|
||||
*
|
||||
* A request CPRB is followed by a request_parameter_block.
|
||||
*
|
||||
* The request (or reply) parameter block is organized thus:
|
||||
* function code
|
||||
* VUD block
|
||||
* key block
|
||||
*/
|
||||
struct CPRB {
|
||||
unsigned short cprb_len; /* CPRB length */
|
||||
unsigned char cprb_ver_id; /* CPRB version id. */
|
||||
unsigned char pad_000; /* Alignment pad byte. */
|
||||
unsigned char srpi_rtcode[4]; /* SRPI return code LELONG */
|
||||
unsigned char srpi_verb; /* SRPI verb type */
|
||||
unsigned char flags; /* flags */
|
||||
unsigned char func_id[2]; /* function id */
|
||||
unsigned char checkpoint_flag; /* */
|
||||
unsigned char resv2; /* reserved */
|
||||
unsigned short req_parml; /* request parameter buffer */
|
||||
/* length 16-bit little endian */
|
||||
unsigned char req_parmp[4]; /* request parameter buffer *
|
||||
* pointer (means nothing: the *
|
||||
* parameter buffer follows *
|
||||
* the CPRB). */
|
||||
unsigned char req_datal[4]; /* request data buffer */
|
||||
/* length ULELONG */
|
||||
unsigned char req_datap[4]; /* request data buffer */
|
||||
/* pointer */
|
||||
unsigned short rpl_parml; /* reply parameter buffer */
|
||||
/* length 16-bit little endian */
|
||||
unsigned char pad_001[2]; /* Alignment pad bytes. ULESHORT */
|
||||
unsigned char rpl_parmp[4]; /* reply parameter buffer *
|
||||
* pointer (means nothing: the *
|
||||
* parameter buffer follows *
|
||||
* the CPRB). */
|
||||
unsigned char rpl_datal[4]; /* reply data buffer len ULELONG */
|
||||
unsigned char rpl_datap[4]; /* reply data buffer */
|
||||
/* pointer */
|
||||
unsigned short ccp_rscode; /* server reason code ULESHORT */
|
||||
unsigned short ccp_rtcode; /* server return code ULESHORT */
|
||||
unsigned char repd_parml[2]; /* replied parameter len ULESHORT*/
|
||||
unsigned char mac_data_len[2]; /* Mac Data Length ULESHORT */
|
||||
unsigned char repd_datal[4]; /* replied data length ULELONG */
|
||||
unsigned char req_pc[2]; /* PC identifier */
|
||||
unsigned char res_origin[8]; /* resource origin */
|
||||
unsigned char mac_value[8]; /* Mac Value */
|
||||
unsigned char logon_id[8]; /* Logon Identifier */
|
||||
unsigned char usage_domain[2]; /* cdx */
|
||||
unsigned char resv3[18]; /* reserved for requestor */
|
||||
unsigned short svr_namel; /* server name length ULESHORT */
|
||||
unsigned char svr_name[8]; /* server name */
|
||||
} __attribute__((packed));
|
||||
|
||||
/**
|
||||
* The type 86 message family is associated with PCICC and PCIXCC cards.
|
||||
*
|
||||
* It contains a message header followed by a CPRB. The CPRB is
|
||||
* the same as the request CPRB, which is described above.
|
||||
*
|
||||
* If format is 1, an error condition exists and no data beyond
|
||||
* the 8-byte message header is of interest.
|
||||
*
|
||||
* The non-error message is shown below.
|
||||
*
|
||||
* Note that all reserved fields must be zeroes.
|
||||
*/
|
||||
struct type86_hdr {
|
||||
unsigned char reserved1; /* 0x00 */
|
||||
unsigned char type; /* 0x86 */
|
||||
unsigned char format; /* 0x01 (error) or 0x02 (ok) */
|
||||
unsigned char reserved2; /* 0x00 */
|
||||
unsigned char reply_code; /* reply code (see above) */
|
||||
unsigned char reserved3[3]; /* 0x000000 */
|
||||
} __attribute__((packed));
|
||||
|
||||
#define TYPE86_RSP_CODE 0x86
|
||||
#define TYPE86_FMT2 0x02
|
||||
|
||||
struct type86_fmt2_ext {
|
||||
unsigned char reserved[4]; /* 0x00000000 */
|
||||
unsigned char apfs[4]; /* final status */
|
||||
unsigned int count1; /* length of CPRB + parameters */
|
||||
unsigned int offset1; /* offset to CPRB */
|
||||
unsigned int count2; /* 0x00000000 */
|
||||
unsigned int offset2; /* db offset 0x00000000 for PKD */
|
||||
unsigned int count3; /* 0x00000000 */
|
||||
unsigned int offset3; /* 0x00000000 */
|
||||
unsigned int count4; /* 0x00000000 */
|
||||
unsigned int offset4; /* 0x00000000 */
|
||||
} __attribute__((packed));
|
||||
|
||||
struct function_and_rules_block {
|
||||
unsigned char function_code[2];
|
||||
unsigned short ulen;
|
||||
unsigned char only_rule[8];
|
||||
} __attribute__((packed));
|
||||
|
||||
int zcrypt_pcicc_init(void);
|
||||
void zcrypt_pcicc_exit(void);
|
||||
|
||||
#endif /* _ZCRYPT_PCICC_H_ */
|
951
drivers/s390/crypto/zcrypt_pcixcc.c
Normal file
951
drivers/s390/crypto/zcrypt_pcixcc.c
Normal file
@ -0,0 +1,951 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcixcc.c
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
* Ralph Wuerthner <rwuerthn@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/delay.h>
|
||||
#include <asm/atomic.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#include "ap_bus.h"
|
||||
#include "zcrypt_api.h"
|
||||
#include "zcrypt_error.h"
|
||||
#include "zcrypt_pcicc.h"
|
||||
#include "zcrypt_pcixcc.h"
|
||||
#include "zcrypt_cca_key.h"
|
||||
|
||||
#define PCIXCC_MIN_MOD_SIZE 16 /* 128 bits */
|
||||
#define PCIXCC_MIN_MOD_SIZE_OLD 64 /* 512 bits */
|
||||
#define PCIXCC_MAX_MOD_SIZE 256 /* 2048 bits */
|
||||
|
||||
#define PCIXCC_MCL2_SPEED_RATING 7870 /* FIXME: needs finetuning */
|
||||
#define PCIXCC_MCL3_SPEED_RATING 7870
|
||||
#define CEX2C_SPEED_RATING 8540
|
||||
|
||||
#define PCIXCC_MAX_ICA_MESSAGE_SIZE 0x77c /* max size type6 v2 crt message */
|
||||
#define PCIXCC_MAX_ICA_RESPONSE_SIZE 0x77c /* max size type86 v2 reply */
|
||||
|
||||
#define PCIXCC_MAX_XCRB_MESSAGE_SIZE (12*1024)
|
||||
#define PCIXCC_MAX_XCRB_RESPONSE_SIZE PCIXCC_MAX_XCRB_MESSAGE_SIZE
|
||||
#define PCIXCC_MAX_XCRB_DATA_SIZE (11*1024)
|
||||
#define PCIXCC_MAX_XCRB_REPLY_SIZE (5*1024)
|
||||
|
||||
#define PCIXCC_MAX_RESPONSE_SIZE PCIXCC_MAX_XCRB_RESPONSE_SIZE
|
||||
|
||||
#define PCIXCC_CLEANUP_TIME (15*HZ)
|
||||
|
||||
#define CEIL4(x) ((((x)+3)/4)*4)
|
||||
|
||||
struct response_type {
|
||||
struct completion work;
|
||||
int type;
|
||||
};
|
||||
#define PCIXCC_RESPONSE_TYPE_ICA 0
|
||||
#define PCIXCC_RESPONSE_TYPE_XCRB 1
|
||||
|
||||
static struct ap_device_id zcrypt_pcixcc_ids[] = {
|
||||
{ AP_DEVICE(AP_DEVICE_TYPE_PCIXCC) },
|
||||
{ AP_DEVICE(AP_DEVICE_TYPE_CEX2C) },
|
||||
{ /* end of list */ },
|
||||
};
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
MODULE_DEVICE_TABLE(ap, zcrypt_pcixcc_ids);
|
||||
MODULE_AUTHOR("IBM Corporation");
|
||||
MODULE_DESCRIPTION("PCIXCC Cryptographic Coprocessor device driver, "
|
||||
"Copyright 2001, 2006 IBM Corporation");
|
||||
MODULE_LICENSE("GPL");
|
||||
#endif
|
||||
|
||||
static int zcrypt_pcixcc_probe(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcixcc_remove(struct ap_device *ap_dev);
|
||||
static void zcrypt_pcixcc_receive(struct ap_device *, struct ap_message *,
|
||||
struct ap_message *);
|
||||
|
||||
static struct ap_driver zcrypt_pcixcc_driver = {
|
||||
.probe = zcrypt_pcixcc_probe,
|
||||
.remove = zcrypt_pcixcc_remove,
|
||||
.receive = zcrypt_pcixcc_receive,
|
||||
.ids = zcrypt_pcixcc_ids,
|
||||
};
|
||||
|
||||
/**
|
||||
* The following is used to initialize the CPRBX passed to the PCIXCC/CEX2C
|
||||
* card in a type6 message. The 3 fields that must be filled in at execution
|
||||
* time are req_parml, rpl_parml and usage_domain.
|
||||
* Everything about this interface is ascii/big-endian, since the
|
||||
* device does *not* have 'Intel inside'.
|
||||
*
|
||||
* The CPRBX is followed immediately by the parm block.
|
||||
* The parm block contains:
|
||||
* - function code ('PD' 0x5044 or 'PK' 0x504B)
|
||||
* - rule block (one of:)
|
||||
* + 0x000A 'PKCS-1.2' (MCL2 'PD')
|
||||
* + 0x000A 'ZERO-PAD' (MCL2 'PK')
|
||||
* + 0x000A 'ZERO-PAD' (MCL3 'PD' or CEX2C 'PD')
|
||||
* + 0x000A 'MRP ' (MCL3 'PK' or CEX2C 'PK')
|
||||
* - VUD block
|
||||
*/
|
||||
static struct CPRBX static_cprbx = {
|
||||
.cprb_len = 0x00DC,
|
||||
.cprb_ver_id = 0x02,
|
||||
.func_id = {0x54,0x32},
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert a ICAMEX message to a type6 MEX message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @ap_msg: pointer to AP message
|
||||
* @mex: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICAMEX_msg_to_type6MEX_msgX(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
static struct type6_hdr static_type6_hdrX = {
|
||||
.type = 0x06,
|
||||
.offset1 = 0x00000058,
|
||||
.agent_id = {'C','A',},
|
||||
.function_code = {'P','K'},
|
||||
};
|
||||
static struct function_and_rules_block static_pke_fnr = {
|
||||
.function_code = {'P','K'},
|
||||
.ulen = 10,
|
||||
.only_rule = {'M','R','P',' ',' ',' ',' ',' '}
|
||||
};
|
||||
static struct function_and_rules_block static_pke_fnr_MCL2 = {
|
||||
.function_code = {'P','K'},
|
||||
.ulen = 10,
|
||||
.only_rule = {'Z','E','R','O','-','P','A','D'}
|
||||
};
|
||||
struct {
|
||||
struct type6_hdr hdr;
|
||||
struct CPRBX cprbx;
|
||||
struct function_and_rules_block fr;
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed)) *msg = ap_msg->message;
|
||||
int size;
|
||||
|
||||
/* VUD.ciphertext */
|
||||
msg->length = mex->inputdatalength + 2;
|
||||
if (copy_from_user(msg->text, mex->inputdata, mex->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
/* Set up key which is located after the variable length text. */
|
||||
size = zcrypt_type6_mex_key_en(mex, msg->text+mex->inputdatalength, 1);
|
||||
if (size < 0)
|
||||
return size;
|
||||
size += sizeof(*msg) + mex->inputdatalength;
|
||||
|
||||
/* message header, cprbx and f&r */
|
||||
msg->hdr = static_type6_hdrX;
|
||||
msg->hdr.ToCardLen1 = size - sizeof(msg->hdr);
|
||||
msg->hdr.FromCardLen1 = PCIXCC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
|
||||
|
||||
msg->cprbx = static_cprbx;
|
||||
msg->cprbx.domain = AP_QID_QUEUE(zdev->ap_dev->qid);
|
||||
msg->cprbx.rpl_msgbl = msg->hdr.FromCardLen1;
|
||||
|
||||
msg->fr = (zdev->user_space_type == ZCRYPT_PCIXCC_MCL2) ?
|
||||
static_pke_fnr_MCL2 : static_pke_fnr;
|
||||
|
||||
msg->cprbx.req_parml = size - sizeof(msg->hdr) - sizeof(msg->cprbx);
|
||||
|
||||
ap_msg->length = size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a ICACRT message to a type6 CRT message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @ap_msg: pointer to AP message
|
||||
* @crt: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
static int ICACRT_msg_to_type6CRT_msgX(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
static struct type6_hdr static_type6_hdrX = {
|
||||
.type = 0x06,
|
||||
.offset1 = 0x00000058,
|
||||
.agent_id = {'C','A',},
|
||||
.function_code = {'P','D'},
|
||||
};
|
||||
static struct function_and_rules_block static_pkd_fnr = {
|
||||
.function_code = {'P','D'},
|
||||
.ulen = 10,
|
||||
.only_rule = {'Z','E','R','O','-','P','A','D'}
|
||||
};
|
||||
|
||||
static struct function_and_rules_block static_pkd_fnr_MCL2 = {
|
||||
.function_code = {'P','D'},
|
||||
.ulen = 10,
|
||||
.only_rule = {'P','K','C','S','-','1','.','2'}
|
||||
};
|
||||
struct {
|
||||
struct type6_hdr hdr;
|
||||
struct CPRBX cprbx;
|
||||
struct function_and_rules_block fr;
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed)) *msg = ap_msg->message;
|
||||
int size;
|
||||
|
||||
/* VUD.ciphertext */
|
||||
msg->length = crt->inputdatalength + 2;
|
||||
if (copy_from_user(msg->text, crt->inputdata, crt->inputdatalength))
|
||||
return -EFAULT;
|
||||
|
||||
/* Set up key which is located after the variable length text. */
|
||||
size = zcrypt_type6_crt_key(crt, msg->text + crt->inputdatalength, 1);
|
||||
if (size < 0)
|
||||
return size;
|
||||
size += sizeof(*msg) + crt->inputdatalength; /* total size of msg */
|
||||
|
||||
/* message header, cprbx and f&r */
|
||||
msg->hdr = static_type6_hdrX;
|
||||
msg->hdr.ToCardLen1 = size - sizeof(msg->hdr);
|
||||
msg->hdr.FromCardLen1 = PCIXCC_MAX_ICA_RESPONSE_SIZE - sizeof(msg->hdr);
|
||||
|
||||
msg->cprbx = static_cprbx;
|
||||
msg->cprbx.domain = AP_QID_QUEUE(zdev->ap_dev->qid);
|
||||
msg->cprbx.req_parml = msg->cprbx.rpl_msgbl =
|
||||
size - sizeof(msg->hdr) - sizeof(msg->cprbx);
|
||||
|
||||
msg->fr = (zdev->user_space_type == ZCRYPT_PCIXCC_MCL2) ?
|
||||
static_pkd_fnr_MCL2 : static_pkd_fnr;
|
||||
|
||||
ap_msg->length = size;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert a XCRB message to a type6 CPRB message.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @ap_msg: pointer to AP message
|
||||
* @xcRB: pointer to user input data
|
||||
*
|
||||
* Returns 0 on success or -EFAULT.
|
||||
*/
|
||||
struct type86_fmt2_msg {
|
||||
struct type86_hdr hdr;
|
||||
struct type86_fmt2_ext fmt2;
|
||||
} __attribute__((packed));
|
||||
|
||||
static int XCRB_msg_to_type6CPRB_msgX(struct zcrypt_device *zdev,
|
||||
struct ap_message *ap_msg,
|
||||
struct ica_xcRB *xcRB)
|
||||
{
|
||||
static struct type6_hdr static_type6_hdrX = {
|
||||
.type = 0x06,
|
||||
.offset1 = 0x00000058,
|
||||
};
|
||||
struct {
|
||||
struct type6_hdr hdr;
|
||||
struct ica_CPRBX cprbx;
|
||||
} __attribute__((packed)) *msg = ap_msg->message;
|
||||
|
||||
int rcblen = CEIL4(xcRB->request_control_blk_length);
|
||||
int replylen;
|
||||
char *req_data = ap_msg->message + sizeof(struct type6_hdr) + rcblen;
|
||||
char *function_code;
|
||||
|
||||
/* length checks */
|
||||
ap_msg->length = sizeof(struct type6_hdr) +
|
||||
CEIL4(xcRB->request_control_blk_length) +
|
||||
xcRB->request_data_length;
|
||||
if (ap_msg->length > PCIXCC_MAX_XCRB_MESSAGE_SIZE) {
|
||||
PRINTK("Combined message is too large (%ld/%d/%d).\n",
|
||||
sizeof(struct type6_hdr),
|
||||
xcRB->request_control_blk_length,
|
||||
xcRB->request_data_length);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (CEIL4(xcRB->reply_control_blk_length) >
|
||||
PCIXCC_MAX_XCRB_REPLY_SIZE) {
|
||||
PDEBUG("Reply CPRB length is too large (%d).\n",
|
||||
xcRB->request_control_blk_length);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (CEIL4(xcRB->reply_data_length) > PCIXCC_MAX_XCRB_DATA_SIZE) {
|
||||
PDEBUG("Reply data block length is too large (%d).\n",
|
||||
xcRB->reply_data_length);
|
||||
return -EFAULT;
|
||||
}
|
||||
replylen = CEIL4(xcRB->reply_control_blk_length) +
|
||||
CEIL4(xcRB->reply_data_length) +
|
||||
sizeof(struct type86_fmt2_msg);
|
||||
if (replylen > PCIXCC_MAX_XCRB_RESPONSE_SIZE) {
|
||||
PDEBUG("Reply CPRB + data block > PCIXCC_MAX_XCRB_RESPONSE_SIZE"
|
||||
" (%d/%d/%d).\n",
|
||||
sizeof(struct type86_fmt2_msg),
|
||||
xcRB->reply_control_blk_length,
|
||||
xcRB->reply_data_length);
|
||||
xcRB->reply_control_blk_length = PCIXCC_MAX_XCRB_RESPONSE_SIZE -
|
||||
(sizeof(struct type86_fmt2_msg) +
|
||||
CEIL4(xcRB->reply_data_length));
|
||||
PDEBUG("Capping Reply CPRB length at %d\n",
|
||||
xcRB->reply_control_blk_length);
|
||||
}
|
||||
|
||||
/* prepare type6 header */
|
||||
msg->hdr = static_type6_hdrX;
|
||||
memcpy(msg->hdr.agent_id , &(xcRB->agent_ID), sizeof(xcRB->agent_ID));
|
||||
msg->hdr.ToCardLen1 = xcRB->request_control_blk_length;
|
||||
if (xcRB->request_data_length) {
|
||||
msg->hdr.offset2 = msg->hdr.offset1 + rcblen;
|
||||
msg->hdr.ToCardLen2 = xcRB->request_data_length;
|
||||
}
|
||||
msg->hdr.FromCardLen1 = xcRB->reply_control_blk_length;
|
||||
msg->hdr.FromCardLen2 = xcRB->reply_data_length;
|
||||
|
||||
/* prepare CPRB */
|
||||
if (copy_from_user(&(msg->cprbx), xcRB->request_control_blk_addr,
|
||||
xcRB->request_control_blk_length))
|
||||
return -EFAULT;
|
||||
if (msg->cprbx.cprb_len + sizeof(msg->hdr.function_code) >
|
||||
xcRB->request_control_blk_length) {
|
||||
PDEBUG("cprb_len too large (%d/%d)\n", msg->cprbx.cprb_len,
|
||||
xcRB->request_control_blk_length);
|
||||
return -EFAULT;
|
||||
}
|
||||
function_code = ((unsigned char *)&msg->cprbx) + msg->cprbx.cprb_len;
|
||||
memcpy(msg->hdr.function_code, function_code, sizeof(msg->hdr.function_code));
|
||||
|
||||
/* copy data block */
|
||||
if (xcRB->request_data_length &&
|
||||
copy_from_user(req_data, xcRB->request_data_address,
|
||||
xcRB->request_data_length))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy results from a type 86 ICA reply message back to user space.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @reply: reply AP message.
|
||||
* @data: pointer to user output data
|
||||
* @length: size of user output data
|
||||
*
|
||||
* Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
|
||||
*/
|
||||
struct type86x_reply {
|
||||
struct type86_hdr hdr;
|
||||
struct type86_fmt2_ext fmt2;
|
||||
struct CPRBX cprbx;
|
||||
unsigned char pad[4]; /* 4 byte function code/rules block ? */
|
||||
unsigned short length;
|
||||
char text[0];
|
||||
} __attribute__((packed));
|
||||
|
||||
static int convert_type86_ica(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
static unsigned char static_pad[] = {
|
||||
0x00,0x02,
|
||||
0x1B,0x7B,0x5D,0xB5,0x75,0x01,0x3D,0xFD,
|
||||
0x8D,0xD1,0xC7,0x03,0x2D,0x09,0x23,0x57,
|
||||
0x89,0x49,0xB9,0x3F,0xBB,0x99,0x41,0x5B,
|
||||
0x75,0x21,0x7B,0x9D,0x3B,0x6B,0x51,0x39,
|
||||
0xBB,0x0D,0x35,0xB9,0x89,0x0F,0x93,0xA5,
|
||||
0x0B,0x47,0xF1,0xD3,0xBB,0xCB,0xF1,0x9D,
|
||||
0x23,0x73,0x71,0xFF,0xF3,0xF5,0x45,0xFB,
|
||||
0x61,0x29,0x23,0xFD,0xF1,0x29,0x3F,0x7F,
|
||||
0x17,0xB7,0x1B,0xA9,0x19,0xBD,0x57,0xA9,
|
||||
0xD7,0x95,0xA3,0xCB,0xED,0x1D,0xDB,0x45,
|
||||
0x7D,0x11,0xD1,0x51,0x1B,0xED,0x71,0xE9,
|
||||
0xB1,0xD1,0xAB,0xAB,0x21,0x2B,0x1B,0x9F,
|
||||
0x3B,0x9F,0xF7,0xF7,0xBD,0x63,0xEB,0xAD,
|
||||
0xDF,0xB3,0x6F,0x5B,0xDB,0x8D,0xA9,0x5D,
|
||||
0xE3,0x7D,0x77,0x49,0x47,0xF5,0xA7,0xFD,
|
||||
0xAB,0x2F,0x27,0x35,0x77,0xD3,0x49,0xC9,
|
||||
0x09,0xEB,0xB1,0xF9,0xBF,0x4B,0xCB,0x2B,
|
||||
0xEB,0xEB,0x05,0xFF,0x7D,0xC7,0x91,0x8B,
|
||||
0x09,0x83,0xB9,0xB9,0x69,0x33,0x39,0x6B,
|
||||
0x79,0x75,0x19,0xBF,0xBB,0x07,0x1D,0xBD,
|
||||
0x29,0xBF,0x39,0x95,0x93,0x1D,0x35,0xC7,
|
||||
0xC9,0x4D,0xE5,0x97,0x0B,0x43,0x9B,0xF1,
|
||||
0x16,0x93,0x03,0x1F,0xA5,0xFB,0xDB,0xF3,
|
||||
0x27,0x4F,0x27,0x61,0x05,0x1F,0xB9,0x23,
|
||||
0x2F,0xC3,0x81,0xA9,0x23,0x71,0x55,0x55,
|
||||
0xEB,0xED,0x41,0xE5,0xF3,0x11,0xF1,0x43,
|
||||
0x69,0x03,0xBD,0x0B,0x37,0x0F,0x51,0x8F,
|
||||
0x0B,0xB5,0x89,0x5B,0x67,0xA9,0xD9,0x4F,
|
||||
0x01,0xF9,0x21,0x77,0x37,0x73,0x79,0xC5,
|
||||
0x7F,0x51,0xC1,0xCF,0x97,0xA1,0x75,0xAD,
|
||||
0x35,0x9D,0xD3,0xD3,0xA7,0x9D,0x5D,0x41,
|
||||
0x6F,0x65,0x1B,0xCF,0xA9,0x87,0x91,0x09
|
||||
};
|
||||
struct type86x_reply *msg = reply->message;
|
||||
unsigned short service_rc, service_rs;
|
||||
unsigned int reply_len, pad_len;
|
||||
char *data;
|
||||
|
||||
service_rc = msg->cprbx.ccp_rtcode;
|
||||
if (unlikely(service_rc != 0)) {
|
||||
service_rs = msg->cprbx.ccp_rscode;
|
||||
if (service_rc == 8 && service_rs == 66) {
|
||||
PDEBUG("Bad block format on PCIXCC/CEX2C\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 65) {
|
||||
PDEBUG("Probably an even modulus on PCIXCC/CEX2C\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 770) {
|
||||
PDEBUG("Invalid key length on PCIXCC/CEX2C\n");
|
||||
zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
|
||||
return -EAGAIN;
|
||||
}
|
||||
if (service_rc == 8 && service_rs == 783) {
|
||||
PDEBUG("Extended bitlengths not enabled on PCIXCC/CEX2C\n");
|
||||
zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
|
||||
return -EAGAIN;
|
||||
}
|
||||
PRINTK("Unknown service rc/rs (PCIXCC/CEX2C): %d/%d\n",
|
||||
service_rc, service_rs);
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
data = msg->text;
|
||||
reply_len = msg->length - 2;
|
||||
if (reply_len > outputdatalength)
|
||||
return -EINVAL;
|
||||
/**
|
||||
* For all encipher requests, the length of the ciphertext (reply_len)
|
||||
* will always equal the modulus length. For MEX decipher requests
|
||||
* the output needs to get padded. Minimum pad size is 10.
|
||||
*
|
||||
* Currently, the cases where padding will be added is for:
|
||||
* - PCIXCC_MCL2 using a CRT form token (since PKD didn't support
|
||||
* ZERO-PAD and CRT is only supported for PKD requests)
|
||||
* - PCICC, always
|
||||
*/
|
||||
pad_len = outputdatalength - reply_len;
|
||||
if (pad_len > 0) {
|
||||
if (pad_len < 10)
|
||||
return -EINVAL;
|
||||
/* 'restore' padding left in the PCICC/PCIXCC card. */
|
||||
if (copy_to_user(outputdata, static_pad, pad_len - 1))
|
||||
return -EFAULT;
|
||||
if (put_user(0, outputdata + pad_len - 1))
|
||||
return -EFAULT;
|
||||
}
|
||||
/* Copy the crypto response to user space. */
|
||||
if (copy_to_user(outputdata + pad_len, data, reply_len))
|
||||
return -EFAULT;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy results from a type 86 XCRB reply message back to user space.
|
||||
*
|
||||
* @zdev: crypto device pointer
|
||||
* @reply: reply AP message.
|
||||
* @xcRB: pointer to XCRB
|
||||
*
|
||||
* Returns 0 on success or -EINVAL, -EFAULT, -EAGAIN in case of an error.
|
||||
*/
|
||||
static int convert_type86_xcrb(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
struct ica_xcRB *xcRB)
|
||||
{
|
||||
struct type86_fmt2_msg *msg = reply->message;
|
||||
char *data = reply->message;
|
||||
|
||||
/* Copy CPRB to user */
|
||||
if (copy_to_user(xcRB->reply_control_blk_addr,
|
||||
data + msg->fmt2.offset1, msg->fmt2.count1))
|
||||
return -EFAULT;
|
||||
xcRB->reply_control_blk_length = msg->fmt2.count1;
|
||||
|
||||
/* Copy data buffer to user */
|
||||
if (msg->fmt2.count2)
|
||||
if (copy_to_user(xcRB->reply_data_addr,
|
||||
data + msg->fmt2.offset2, msg->fmt2.count2))
|
||||
return -EFAULT;
|
||||
xcRB->reply_data_length = msg->fmt2.count2;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int convert_response_ica(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
char __user *outputdata,
|
||||
unsigned int outputdatalength)
|
||||
{
|
||||
struct type86x_reply *msg = reply->message;
|
||||
|
||||
/* Response type byte is the second byte in the response. */
|
||||
switch (((unsigned char *) reply->message)[1]) {
|
||||
case TYPE82_RSP_CODE:
|
||||
case TYPE88_RSP_CODE:
|
||||
return convert_error(zdev, reply);
|
||||
case TYPE86_RSP_CODE:
|
||||
if (msg->hdr.reply_code)
|
||||
return convert_error(zdev, reply);
|
||||
if (msg->cprbx.cprb_ver_id == 0x02)
|
||||
return convert_type86_ica(zdev, reply,
|
||||
outputdata, outputdatalength);
|
||||
/* no break, incorrect cprb version is an unknown response */
|
||||
default: /* Unknown response type, this should NEVER EVER happen */
|
||||
PRINTK("Unrecognized Message Header: %08x%08x\n",
|
||||
*(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message+4));
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
static int convert_response_xcrb(struct zcrypt_device *zdev,
|
||||
struct ap_message *reply,
|
||||
struct ica_xcRB *xcRB)
|
||||
{
|
||||
struct type86x_reply *msg = reply->message;
|
||||
|
||||
/* Response type byte is the second byte in the response. */
|
||||
switch (((unsigned char *) reply->message)[1]) {
|
||||
case TYPE82_RSP_CODE:
|
||||
case TYPE88_RSP_CODE:
|
||||
xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
|
||||
return convert_error(zdev, reply);
|
||||
case TYPE86_RSP_CODE:
|
||||
if (msg->hdr.reply_code) {
|
||||
memcpy(&(xcRB->status), msg->fmt2.apfs, sizeof(u32));
|
||||
return convert_error(zdev, reply);
|
||||
}
|
||||
if (msg->cprbx.cprb_ver_id == 0x02)
|
||||
return convert_type86_xcrb(zdev, reply, xcRB);
|
||||
/* no break, incorrect cprb version is an unknown response */
|
||||
default: /* Unknown response type, this should NEVER EVER happen */
|
||||
PRINTK("Unrecognized Message Header: %08x%08x\n",
|
||||
*(unsigned int *) reply->message,
|
||||
*(unsigned int *) (reply->message+4));
|
||||
xcRB->status = 0x0008044DL; /* HDD_InvalidParm */
|
||||
zdev->online = 0;
|
||||
return -EAGAIN; /* repeat the request on a different device. */
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is called from the AP bus code after a crypto request
|
||||
* "msg" has finished with the reply message "reply".
|
||||
* It is called from tasklet context.
|
||||
* @ap_dev: pointer to the AP device
|
||||
* @msg: pointer to the AP message
|
||||
* @reply: pointer to the AP reply message
|
||||
*/
|
||||
static void zcrypt_pcixcc_receive(struct ap_device *ap_dev,
|
||||
struct ap_message *msg,
|
||||
struct ap_message *reply)
|
||||
{
|
||||
static struct error_hdr error_reply = {
|
||||
.type = TYPE82_RSP_CODE,
|
||||
.reply_code = REP82_ERROR_MACHINE_FAILURE,
|
||||
};
|
||||
struct response_type *resp_type =
|
||||
(struct response_type *) msg->private;
|
||||
struct type86x_reply *t86r = reply->message;
|
||||
int length;
|
||||
|
||||
/* Copy the reply message to the request message buffer. */
|
||||
if (IS_ERR(reply))
|
||||
memcpy(msg->message, &error_reply, sizeof(error_reply));
|
||||
else if (t86r->hdr.type == TYPE86_RSP_CODE &&
|
||||
t86r->cprbx.cprb_ver_id == 0x02) {
|
||||
switch (resp_type->type) {
|
||||
case PCIXCC_RESPONSE_TYPE_ICA:
|
||||
length = sizeof(struct type86x_reply)
|
||||
+ t86r->length - 2;
|
||||
length = min(PCIXCC_MAX_ICA_RESPONSE_SIZE, length);
|
||||
memcpy(msg->message, reply->message, length);
|
||||
break;
|
||||
case PCIXCC_RESPONSE_TYPE_XCRB:
|
||||
length = t86r->fmt2.offset2 + t86r->fmt2.count2;
|
||||
length = min(PCIXCC_MAX_XCRB_RESPONSE_SIZE, length);
|
||||
memcpy(msg->message, reply->message, length);
|
||||
break;
|
||||
default:
|
||||
PRINTK("Invalid internal response type: %i\n",
|
||||
resp_type->type);
|
||||
memcpy(msg->message, &error_reply,
|
||||
sizeof error_reply);
|
||||
}
|
||||
} else
|
||||
memcpy(msg->message, reply->message, sizeof error_reply);
|
||||
complete(&(resp_type->work));
|
||||
}
|
||||
|
||||
static atomic_t zcrypt_step = ATOMIC_INIT(0);
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCIXCC/CEX2C
|
||||
* device to handle a modexpo request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCIXCC/CEX2C device to the request distributor
|
||||
* @mex: pointer to the modexpo request buffer
|
||||
*/
|
||||
static long zcrypt_pcixcc_modexpo(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo *mex)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct response_type resp_type = {
|
||||
.type = PCIXCC_RESPONSE_TYPE_ICA,
|
||||
};
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &resp_type;
|
||||
rc = ICAMEX_msg_to_type6MEX_msgX(zdev, &ap_msg, mex);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&resp_type.work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&resp_type.work, PCIXCC_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response_ica(zdev, &ap_msg, mex->outputdata,
|
||||
mex->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
free_page((unsigned long) ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCIXCC/CEX2C
|
||||
* device to handle a modexpo_crt request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCIXCC/CEX2C device to the request distributor
|
||||
* @crt: pointer to the modexpoc_crt request buffer
|
||||
*/
|
||||
static long zcrypt_pcixcc_modexpo_crt(struct zcrypt_device *zdev,
|
||||
struct ica_rsa_modexpo_crt *crt)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct response_type resp_type = {
|
||||
.type = PCIXCC_RESPONSE_TYPE_ICA,
|
||||
};
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &resp_type;
|
||||
rc = ICACRT_msg_to_type6CRT_msgX(zdev, &ap_msg, crt);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&resp_type.work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&resp_type.work, PCIXCC_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response_ica(zdev, &ap_msg, crt->outputdata,
|
||||
crt->outputdatalength);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
free_page((unsigned long) ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The request distributor calls this function if it picked the PCIXCC/CEX2C
|
||||
* device to handle a send_cprb request.
|
||||
* @zdev: pointer to zcrypt_device structure that identifies the
|
||||
* PCIXCC/CEX2C device to the request distributor
|
||||
* @xcRB: pointer to the send_cprb request buffer
|
||||
*/
|
||||
long zcrypt_pcixcc_send_cprb(struct zcrypt_device *zdev, struct ica_xcRB *xcRB)
|
||||
{
|
||||
struct ap_message ap_msg;
|
||||
struct response_type resp_type = {
|
||||
.type = PCIXCC_RESPONSE_TYPE_XCRB,
|
||||
};
|
||||
int rc;
|
||||
|
||||
ap_msg.message = (void *) kmalloc(PCIXCC_MAX_XCRB_MESSAGE_SIZE, GFP_KERNEL);
|
||||
if (!ap_msg.message)
|
||||
return -ENOMEM;
|
||||
ap_msg.psmid = (((unsigned long long) current->pid) << 32) +
|
||||
atomic_inc_return(&zcrypt_step);
|
||||
ap_msg.private = &resp_type;
|
||||
rc = XCRB_msg_to_type6CPRB_msgX(zdev, &ap_msg, xcRB);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
init_completion(&resp_type.work);
|
||||
ap_queue_message(zdev->ap_dev, &ap_msg);
|
||||
rc = wait_for_completion_interruptible_timeout(
|
||||
&resp_type.work, PCIXCC_CLEANUP_TIME);
|
||||
if (rc > 0)
|
||||
rc = convert_response_xcrb(zdev, &ap_msg, xcRB);
|
||||
else {
|
||||
/* Signal pending or message timed out. */
|
||||
ap_cancel_message(zdev->ap_dev, &ap_msg);
|
||||
if (rc == 0)
|
||||
/* Message timed out. */
|
||||
rc = -ETIME;
|
||||
}
|
||||
out_free:
|
||||
memset(ap_msg.message, 0x0, ap_msg.length);
|
||||
kfree(ap_msg.message);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* The crypto operations for a PCIXCC/CEX2C card.
|
||||
*/
|
||||
static struct zcrypt_ops zcrypt_pcixcc_ops = {
|
||||
.rsa_modexpo = zcrypt_pcixcc_modexpo,
|
||||
.rsa_modexpo_crt = zcrypt_pcixcc_modexpo_crt,
|
||||
.send_cprb = zcrypt_pcixcc_send_cprb,
|
||||
};
|
||||
|
||||
/**
|
||||
* Micro-code detection function. Its sends a message to a pcixcc card
|
||||
* to find out the microcode level.
|
||||
* @ap_dev: pointer to the AP device.
|
||||
*/
|
||||
static int zcrypt_pcixcc_mcl(struct ap_device *ap_dev)
|
||||
{
|
||||
static unsigned char msg[] = {
|
||||
0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x43,0x41,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x50,0x4B,0x00,0x00,
|
||||
0x00,0x00,0x01,0xC4,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x07,0x24,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0xDC,0x02,0x00,0x00,0x00,0x54,0x32,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE8,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x24,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
||||
0x00,0x00,0x00,0x00,0x50,0x4B,0x00,0x0A,
|
||||
0x4D,0x52,0x50,0x20,0x20,0x20,0x20,0x20,
|
||||
0x00,0x42,0x00,0x01,0x02,0x03,0x04,0x05,
|
||||
0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
|
||||
0x0E,0x0F,0x00,0x11,0x22,0x33,0x44,0x55,
|
||||
0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,
|
||||
0xEE,0xFF,0xFF,0xEE,0xDD,0xCC,0xBB,0xAA,
|
||||
0x99,0x88,0x77,0x66,0x55,0x44,0x33,0x22,
|
||||
0x11,0x00,0x01,0x23,0x45,0x67,0x89,0xAB,
|
||||
0xCD,0xEF,0xFE,0xDC,0xBA,0x98,0x76,0x54,
|
||||
0x32,0x10,0x00,0x9A,0x00,0x98,0x00,0x00,
|
||||
0x1E,0x00,0x00,0x94,0x00,0x00,0x00,0x00,
|
||||
0x04,0x00,0x00,0x8C,0x00,0x00,0x00,0x40,
|
||||
0x02,0x00,0x00,0x40,0xBA,0xE8,0x23,0x3C,
|
||||
0x75,0xF3,0x91,0x61,0xD6,0x73,0x39,0xCF,
|
||||
0x7B,0x6D,0x8E,0x61,0x97,0x63,0x9E,0xD9,
|
||||
0x60,0x55,0xD6,0xC7,0xEF,0xF8,0x1E,0x63,
|
||||
0x95,0x17,0xCC,0x28,0x45,0x60,0x11,0xC5,
|
||||
0xC4,0x4E,0x66,0xC6,0xE6,0xC3,0xDE,0x8A,
|
||||
0x19,0x30,0xCF,0x0E,0xD7,0xAA,0xDB,0x01,
|
||||
0xD8,0x00,0xBB,0x8F,0x39,0x9F,0x64,0x28,
|
||||
0xF5,0x7A,0x77,0x49,0xCC,0x6B,0xA3,0x91,
|
||||
0x97,0x70,0xE7,0x60,0x1E,0x39,0xE1,0xE5,
|
||||
0x33,0xE1,0x15,0x63,0x69,0x08,0x80,0x4C,
|
||||
0x67,0xC4,0x41,0x8F,0x48,0xDF,0x26,0x98,
|
||||
0xF1,0xD5,0x8D,0x88,0xD9,0x6A,0xA4,0x96,
|
||||
0xC5,0x84,0xD9,0x30,0x49,0x67,0x7D,0x19,
|
||||
0xB1,0xB3,0x45,0x4D,0xB2,0x53,0x9A,0x47,
|
||||
0x3C,0x7C,0x55,0xBF,0xCC,0x85,0x00,0x36,
|
||||
0xF1,0x3D,0x93,0x53
|
||||
};
|
||||
unsigned long long psmid;
|
||||
struct CPRBX *cprbx;
|
||||
char *reply;
|
||||
int rc, i;
|
||||
|
||||
reply = (void *) get_zeroed_page(GFP_KERNEL);
|
||||
if (!reply)
|
||||
return -ENOMEM;
|
||||
|
||||
rc = ap_send(ap_dev->qid, 0x0102030405060708ULL, msg, sizeof(msg));
|
||||
if (rc)
|
||||
goto out_free;
|
||||
|
||||
/* Wait for the test message to complete. */
|
||||
for (i = 0; i < 6; i++) {
|
||||
mdelay(300);
|
||||
rc = ap_recv(ap_dev->qid, &psmid, reply, 4096);
|
||||
if (rc == 0 && psmid == 0x0102030405060708ULL)
|
||||
break;
|
||||
}
|
||||
|
||||
if (i >= 6) {
|
||||
/* Got no answer. */
|
||||
rc = -ENODEV;
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
cprbx = (struct CPRBX *) (reply + 48);
|
||||
if (cprbx->ccp_rtcode == 8 && cprbx->ccp_rscode == 33)
|
||||
rc = ZCRYPT_PCIXCC_MCL2;
|
||||
else
|
||||
rc = ZCRYPT_PCIXCC_MCL3;
|
||||
out_free:
|
||||
free_page((unsigned long) reply);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* Probe function for PCIXCC/CEX2C cards. It always accepts the AP device
|
||||
* since the bus_match already checked the hardware type. The PCIXCC
|
||||
* cards come in two flavours: micro code level 2 and micro code level 3.
|
||||
* This is checked by sending a test message to the device.
|
||||
* @ap_dev: pointer to the AP device.
|
||||
*/
|
||||
static int zcrypt_pcixcc_probe(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev;
|
||||
int rc;
|
||||
|
||||
zdev = zcrypt_device_alloc(PCIXCC_MAX_RESPONSE_SIZE);
|
||||
if (!zdev)
|
||||
return -ENOMEM;
|
||||
zdev->ap_dev = ap_dev;
|
||||
zdev->ops = &zcrypt_pcixcc_ops;
|
||||
zdev->online = 1;
|
||||
if (ap_dev->device_type == AP_DEVICE_TYPE_PCIXCC) {
|
||||
rc = zcrypt_pcixcc_mcl(ap_dev);
|
||||
if (rc < 0) {
|
||||
zcrypt_device_free(zdev);
|
||||
return rc;
|
||||
}
|
||||
zdev->user_space_type = rc;
|
||||
if (rc == ZCRYPT_PCIXCC_MCL2) {
|
||||
zdev->type_string = "PCIXCC_MCL2";
|
||||
zdev->speed_rating = PCIXCC_MCL2_SPEED_RATING;
|
||||
zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE_OLD;
|
||||
zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
|
||||
} else {
|
||||
zdev->type_string = "PCIXCC_MCL3";
|
||||
zdev->speed_rating = PCIXCC_MCL3_SPEED_RATING;
|
||||
zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
|
||||
zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
|
||||
}
|
||||
} else {
|
||||
zdev->user_space_type = ZCRYPT_CEX2C;
|
||||
zdev->type_string = "CEX2C";
|
||||
zdev->speed_rating = CEX2C_SPEED_RATING;
|
||||
zdev->min_mod_size = PCIXCC_MIN_MOD_SIZE;
|
||||
zdev->max_mod_size = PCIXCC_MAX_MOD_SIZE;
|
||||
}
|
||||
ap_dev->reply = &zdev->reply;
|
||||
ap_dev->private = zdev;
|
||||
rc = zcrypt_device_register(zdev);
|
||||
if (rc)
|
||||
goto out_free;
|
||||
return 0;
|
||||
|
||||
out_free:
|
||||
ap_dev->private = NULL;
|
||||
zcrypt_device_free(zdev);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is called to remove the extended PCIXCC/CEX2C driver information
|
||||
* if an AP device is removed.
|
||||
*/
|
||||
static void zcrypt_pcixcc_remove(struct ap_device *ap_dev)
|
||||
{
|
||||
struct zcrypt_device *zdev = ap_dev->private;
|
||||
|
||||
zcrypt_device_unregister(zdev);
|
||||
}
|
||||
|
||||
int __init zcrypt_pcixcc_init(void)
|
||||
{
|
||||
return ap_driver_register(&zcrypt_pcixcc_driver, THIS_MODULE, "pcixcc");
|
||||
}
|
||||
|
||||
void zcrypt_pcixcc_exit(void)
|
||||
{
|
||||
ap_driver_unregister(&zcrypt_pcixcc_driver);
|
||||
}
|
||||
|
||||
#ifndef CONFIG_ZCRYPT_MONOLITHIC
|
||||
module_init(zcrypt_pcixcc_init);
|
||||
module_exit(zcrypt_pcixcc_exit);
|
||||
#endif
|
79
drivers/s390/crypto/zcrypt_pcixcc.h
Normal file
79
drivers/s390/crypto/zcrypt_pcixcc.h
Normal file
@ -0,0 +1,79 @@
|
||||
/*
|
||||
* linux/drivers/s390/crypto/zcrypt_pcixcc.h
|
||||
*
|
||||
* zcrypt 2.1.0
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
* Major cleanup & driver split: Martin Schwidefsky <schwidefsky@de.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef _ZCRYPT_PCIXCC_H_
|
||||
#define _ZCRYPT_PCIXCC_H_
|
||||
|
||||
/**
|
||||
* CPRBX
|
||||
* Note that all shorts and ints are big-endian.
|
||||
* All pointer fields are 16 bytes long, and mean nothing.
|
||||
*
|
||||
* A request CPRB is followed by a request_parameter_block.
|
||||
*
|
||||
* The request (or reply) parameter block is organized thus:
|
||||
* function code
|
||||
* VUD block
|
||||
* key block
|
||||
*/
|
||||
struct CPRBX {
|
||||
unsigned short cprb_len; /* CPRB length 220 */
|
||||
unsigned char cprb_ver_id; /* CPRB version id. 0x02 */
|
||||
unsigned char pad_000[3]; /* Alignment pad bytes */
|
||||
unsigned char func_id[2]; /* function id 0x5432 */
|
||||
unsigned char cprb_flags[4]; /* Flags */
|
||||
unsigned int req_parml; /* request parameter buffer len */
|
||||
unsigned int req_datal; /* request data buffer */
|
||||
unsigned int rpl_msgbl; /* reply message block length */
|
||||
unsigned int rpld_parml; /* replied parameter block len */
|
||||
unsigned int rpl_datal; /* reply data block len */
|
||||
unsigned int rpld_datal; /* replied data block len */
|
||||
unsigned int req_extbl; /* request extension block len */
|
||||
unsigned char pad_001[4]; /* reserved */
|
||||
unsigned int rpld_extbl; /* replied extension block len */
|
||||
unsigned char req_parmb[16]; /* request parm block 'address' */
|
||||
unsigned char req_datab[16]; /* request data block 'address' */
|
||||
unsigned char rpl_parmb[16]; /* reply parm block 'address' */
|
||||
unsigned char rpl_datab[16]; /* reply data block 'address' */
|
||||
unsigned char req_extb[16]; /* request extension block 'addr'*/
|
||||
unsigned char rpl_extb[16]; /* reply extension block 'addres'*/
|
||||
unsigned short ccp_rtcode; /* server return code */
|
||||
unsigned short ccp_rscode; /* server reason code */
|
||||
unsigned int mac_data_len; /* Mac Data Length */
|
||||
unsigned char logon_id[8]; /* Logon Identifier */
|
||||
unsigned char mac_value[8]; /* Mac Value */
|
||||
unsigned char mac_content_flgs;/* Mac content flag byte */
|
||||
unsigned char pad_002; /* Alignment */
|
||||
unsigned short domain; /* Domain */
|
||||
unsigned char pad_003[12]; /* Domain masks */
|
||||
unsigned char pad_004[36]; /* reserved */
|
||||
} __attribute__((packed));
|
||||
|
||||
int zcrypt_pcixcc_init(void);
|
||||
void zcrypt_pcixcc_exit(void);
|
||||
|
||||
#endif /* _ZCRYPT_PCIXCC_H_ */
|
@ -19,9 +19,6 @@
|
||||
|
||||
#include "s390mach.h"
|
||||
|
||||
#define DBG printk
|
||||
// #define DBG(args,...) do {} while (0);
|
||||
|
||||
static struct semaphore m_sem;
|
||||
|
||||
extern int css_process_crw(int, int);
|
||||
@ -83,11 +80,11 @@ repeat:
|
||||
ccode = stcrw(&crw[chain]);
|
||||
if (ccode != 0)
|
||||
break;
|
||||
DBG(KERN_DEBUG "crw_info : CRW reports slct=%d, oflw=%d, "
|
||||
"chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
|
||||
crw[chain].slct, crw[chain].oflw, crw[chain].chn,
|
||||
crw[chain].rsc, crw[chain].anc, crw[chain].erc,
|
||||
crw[chain].rsid);
|
||||
printk(KERN_DEBUG "crw_info : CRW reports slct=%d, oflw=%d, "
|
||||
"chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
|
||||
crw[chain].slct, crw[chain].oflw, crw[chain].chn,
|
||||
crw[chain].rsc, crw[chain].anc, crw[chain].erc,
|
||||
crw[chain].rsid);
|
||||
/* Check for overflows. */
|
||||
if (crw[chain].oflw) {
|
||||
pr_debug("%s: crw overflow detected!\n", __FUNCTION__);
|
||||
@ -117,8 +114,8 @@ repeat:
|
||||
* reported to the common I/O layer.
|
||||
*/
|
||||
if (crw[chain].slct) {
|
||||
DBG(KERN_INFO"solicited machine check for "
|
||||
"channel path %02X\n", crw[0].rsid);
|
||||
pr_debug("solicited machine check for "
|
||||
"channel path %02X\n", crw[0].rsid);
|
||||
break;
|
||||
}
|
||||
switch (crw[0].erc) {
|
||||
|
@ -543,7 +543,7 @@ do { \
|
||||
} while (0)
|
||||
|
||||
#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_NORMAL
|
||||
# define ZFCP_LOG_NORMAL(fmt, args...)
|
||||
# define ZFCP_LOG_NORMAL(fmt, args...) do { } while (0)
|
||||
#else
|
||||
# define ZFCP_LOG_NORMAL(fmt, args...) \
|
||||
do { \
|
||||
@ -553,7 +553,7 @@ do { \
|
||||
#endif
|
||||
|
||||
#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_INFO
|
||||
# define ZFCP_LOG_INFO(fmt, args...)
|
||||
# define ZFCP_LOG_INFO(fmt, args...) do { } while (0)
|
||||
#else
|
||||
# define ZFCP_LOG_INFO(fmt, args...) \
|
||||
do { \
|
||||
@ -563,14 +563,14 @@ do { \
|
||||
#endif
|
||||
|
||||
#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_DEBUG
|
||||
# define ZFCP_LOG_DEBUG(fmt, args...)
|
||||
# define ZFCP_LOG_DEBUG(fmt, args...) do { } while (0)
|
||||
#else
|
||||
# define ZFCP_LOG_DEBUG(fmt, args...) \
|
||||
ZFCP_LOG(ZFCP_LOG_LEVEL_DEBUG, fmt , ##args)
|
||||
#endif
|
||||
|
||||
#if ZFCP_LOG_LEVEL_LIMIT < ZFCP_LOG_LEVEL_TRACE
|
||||
# define ZFCP_LOG_TRACE(fmt, args...)
|
||||
# define ZFCP_LOG_TRACE(fmt, args...) do { } while (0)
|
||||
#else
|
||||
# define ZFCP_LOG_TRACE(fmt, args...) \
|
||||
ZFCP_LOG(ZFCP_LOG_LEVEL_TRACE, fmt , ##args)
|
||||
|
@ -11,19 +11,18 @@
|
||||
#include <linux/init.h>
|
||||
#include <asm/ebcdic.h>
|
||||
|
||||
struct sysinfo_1_1_1
|
||||
{
|
||||
struct sysinfo_1_1_1 {
|
||||
char reserved_0[32];
|
||||
char manufacturer[16];
|
||||
char type[4];
|
||||
char reserved_1[12];
|
||||
char model[16];
|
||||
char model_capacity[16];
|
||||
char sequence[16];
|
||||
char plant[4];
|
||||
char model[16];
|
||||
};
|
||||
|
||||
struct sysinfo_1_2_1
|
||||
{
|
||||
struct sysinfo_1_2_1 {
|
||||
char reserved_0[80];
|
||||
char sequence[16];
|
||||
char plant[4];
|
||||
@ -31,9 +30,12 @@ struct sysinfo_1_2_1
|
||||
unsigned short cpu_address;
|
||||
};
|
||||
|
||||
struct sysinfo_1_2_2
|
||||
{
|
||||
char reserved_0[32];
|
||||
struct sysinfo_1_2_2 {
|
||||
char format;
|
||||
char reserved_0[1];
|
||||
unsigned short acc_offset;
|
||||
char reserved_1[24];
|
||||
unsigned int secondary_capability;
|
||||
unsigned int capability;
|
||||
unsigned short cpus_total;
|
||||
unsigned short cpus_configured;
|
||||
@ -42,8 +44,12 @@ struct sysinfo_1_2_2
|
||||
unsigned short adjustment[0];
|
||||
};
|
||||
|
||||
struct sysinfo_2_2_1
|
||||
{
|
||||
struct sysinfo_1_2_2_extension {
|
||||
unsigned int alt_capability;
|
||||
unsigned short alt_adjustment[0];
|
||||
};
|
||||
|
||||
struct sysinfo_2_2_1 {
|
||||
char reserved_0[80];
|
||||
char sequence[16];
|
||||
char plant[4];
|
||||
@ -51,15 +57,11 @@ struct sysinfo_2_2_1
|
||||
unsigned short cpu_address;
|
||||
};
|
||||
|
||||
struct sysinfo_2_2_2
|
||||
{
|
||||
struct sysinfo_2_2_2 {
|
||||
char reserved_0[32];
|
||||
unsigned short lpar_number;
|
||||
char reserved_1;
|
||||
unsigned char characteristics;
|
||||
#define LPAR_CHAR_DEDICATED (1 << 7)
|
||||
#define LPAR_CHAR_SHARED (1 << 6)
|
||||
#define LPAR_CHAR_LIMITED (1 << 5)
|
||||
unsigned short cpus_total;
|
||||
unsigned short cpus_configured;
|
||||
unsigned short cpus_standby;
|
||||
@ -71,12 +73,14 @@ struct sysinfo_2_2_2
|
||||
unsigned short cpus_shared;
|
||||
};
|
||||
|
||||
struct sysinfo_3_2_2
|
||||
{
|
||||
#define LPAR_CHAR_DEDICATED (1 << 7)
|
||||
#define LPAR_CHAR_SHARED (1 << 6)
|
||||
#define LPAR_CHAR_LIMITED (1 << 5)
|
||||
|
||||
struct sysinfo_3_2_2 {
|
||||
char reserved_0[31];
|
||||
unsigned char count;
|
||||
struct
|
||||
{
|
||||
struct {
|
||||
char reserved_0[4];
|
||||
unsigned short cpus_total;
|
||||
unsigned short cpus_configured;
|
||||
@ -90,136 +94,223 @@ struct sysinfo_3_2_2
|
||||
} vm[8];
|
||||
};
|
||||
|
||||
union s390_sysinfo
|
||||
static inline int stsi(void *sysinfo, int fc, int sel1, int sel2)
|
||||
{
|
||||
struct sysinfo_1_1_1 sysinfo_1_1_1;
|
||||
struct sysinfo_1_2_1 sysinfo_1_2_1;
|
||||
struct sysinfo_1_2_2 sysinfo_1_2_2;
|
||||
struct sysinfo_2_2_1 sysinfo_2_2_1;
|
||||
struct sysinfo_2_2_2 sysinfo_2_2_2;
|
||||
struct sysinfo_3_2_2 sysinfo_3_2_2;
|
||||
};
|
||||
register int r0 asm("0") = (fc << 28) | sel1;
|
||||
register int r1 asm("1") = sel2;
|
||||
|
||||
static inline int stsi (void *sysinfo,
|
||||
int fc, int sel1, int sel2)
|
||||
{
|
||||
int cc, retv;
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
__asm__ __volatile__ ( "lr\t0,%2\n"
|
||||
"\tlr\t1,%3\n"
|
||||
"\tstsi\t0(%4)\n"
|
||||
"0:\tipm\t%0\n"
|
||||
"\tsrl\t%0,28\n"
|
||||
"1:lr\t%1,0\n"
|
||||
".section .fixup,\"ax\"\n"
|
||||
"2:\tlhi\t%0,3\n"
|
||||
"\tbras\t1,3f\n"
|
||||
"\t.long 1b\n"
|
||||
"3:\tl\t1,0(1)\n"
|
||||
"\tbr\t1\n"
|
||||
".previous\n"
|
||||
".section __ex_table,\"a\"\n"
|
||||
"\t.align 4\n"
|
||||
"\t.long 0b,2b\n"
|
||||
".previous\n"
|
||||
: "=d" (cc), "=d" (retv)
|
||||
: "d" ((fc << 28) | sel1), "d" (sel2), "a" (sysinfo)
|
||||
: "cc", "memory", "0", "1" );
|
||||
#else
|
||||
__asm__ __volatile__ ( "lr\t0,%2\n"
|
||||
"lr\t1,%3\n"
|
||||
"\tstsi\t0(%4)\n"
|
||||
"0:\tipm\t%0\n"
|
||||
"\tsrl\t%0,28\n"
|
||||
"1:lr\t%1,0\n"
|
||||
".section .fixup,\"ax\"\n"
|
||||
"2:\tlhi\t%0,3\n"
|
||||
"\tjg\t1b\n"
|
||||
".previous\n"
|
||||
".section __ex_table,\"a\"\n"
|
||||
"\t.align 8\n"
|
||||
"\t.quad 0b,2b\n"
|
||||
".previous\n"
|
||||
: "=d" (cc), "=d" (retv)
|
||||
: "d" ((fc << 28) | sel1), "d" (sel2), "a" (sysinfo)
|
||||
: "cc", "memory", "0", "1" );
|
||||
#endif
|
||||
|
||||
return cc? -1 : retv;
|
||||
asm volatile(
|
||||
" stsi 0(%2)\n"
|
||||
"0: jz 2f\n"
|
||||
"1: lhi %0,%3\n"
|
||||
"2:\n"
|
||||
EX_TABLE(0b,1b)
|
||||
: "+d" (r0) : "d" (r1), "a" (sysinfo), "K" (-ENOSYS)
|
||||
: "cc", "memory" );
|
||||
return r0;
|
||||
}
|
||||
|
||||
static inline int stsi_0 (void)
|
||||
static inline int stsi_0(void)
|
||||
{
|
||||
int rc = stsi (NULL, 0, 0, 0);
|
||||
return rc == -1 ? rc : (((unsigned int)rc) >> 28);
|
||||
return rc == -ENOSYS ? rc : (((unsigned int) rc) >> 28);
|
||||
}
|
||||
|
||||
static inline int stsi_1_1_1 (struct sysinfo_1_1_1 *info)
|
||||
static int stsi_1_1_1(struct sysinfo_1_1_1 *info, char *page, int len)
|
||||
{
|
||||
int rc = stsi (info, 1, 1, 1);
|
||||
if (rc != -1)
|
||||
{
|
||||
EBCASC (info->manufacturer, sizeof(info->manufacturer));
|
||||
EBCASC (info->type, sizeof(info->type));
|
||||
EBCASC (info->model, sizeof(info->model));
|
||||
EBCASC (info->sequence, sizeof(info->sequence));
|
||||
EBCASC (info->plant, sizeof(info->plant));
|
||||
if (stsi(info, 1, 1, 1) == -ENOSYS)
|
||||
return len;
|
||||
|
||||
EBCASC(info->manufacturer, sizeof(info->manufacturer));
|
||||
EBCASC(info->type, sizeof(info->type));
|
||||
EBCASC(info->model, sizeof(info->model));
|
||||
EBCASC(info->sequence, sizeof(info->sequence));
|
||||
EBCASC(info->plant, sizeof(info->plant));
|
||||
EBCASC(info->model_capacity, sizeof(info->model_capacity));
|
||||
len += sprintf(page + len, "Manufacturer: %-16.16s\n",
|
||||
info->manufacturer);
|
||||
len += sprintf(page + len, "Type: %-4.4s\n",
|
||||
info->type);
|
||||
if (info->model[0] != '\0')
|
||||
/*
|
||||
* Sigh: the model field has been renamed with System z9
|
||||
* to model_capacity and a new model field has been added
|
||||
* after the plant field. To avoid confusing older programs
|
||||
* the "Model:" prints "model_capacity model" or just
|
||||
* "model_capacity" if the model string is empty .
|
||||
*/
|
||||
len += sprintf(page + len,
|
||||
"Model: %-16.16s %-16.16s\n",
|
||||
info->model_capacity, info->model);
|
||||
else
|
||||
len += sprintf(page + len, "Model: %-16.16s\n",
|
||||
info->model_capacity);
|
||||
len += sprintf(page + len, "Sequence Code: %-16.16s\n",
|
||||
info->sequence);
|
||||
len += sprintf(page + len, "Plant: %-4.4s\n",
|
||||
info->plant);
|
||||
len += sprintf(page + len, "Model Capacity: %-16.16s\n",
|
||||
info->model_capacity);
|
||||
return len;
|
||||
}
|
||||
|
||||
#if 0 /* Currently unused */
|
||||
static int stsi_1_2_1(struct sysinfo_1_2_1 *info, char *page, int len)
|
||||
{
|
||||
if (stsi(info, 1, 2, 1) == -ENOSYS)
|
||||
return len;
|
||||
|
||||
len += sprintf(page + len, "\n");
|
||||
EBCASC(info->sequence, sizeof(info->sequence));
|
||||
EBCASC(info->plant, sizeof(info->plant));
|
||||
len += sprintf(page + len, "Sequence Code of CPU: %-16.16s\n",
|
||||
info->sequence);
|
||||
len += sprintf(page + len, "Plant of CPU: %-16.16s\n",
|
||||
info->plant);
|
||||
return len;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int stsi_1_2_2(struct sysinfo_1_2_2 *info, char *page, int len)
|
||||
{
|
||||
struct sysinfo_1_2_2_extension *ext;
|
||||
int i;
|
||||
|
||||
if (stsi(info, 1, 2, 2) == -ENOSYS)
|
||||
return len;
|
||||
ext = (struct sysinfo_1_2_2_extension *)
|
||||
((unsigned long) info + info->acc_offset);
|
||||
|
||||
len += sprintf(page + len, "\n");
|
||||
len += sprintf(page + len, "CPUs Total: %d\n",
|
||||
info->cpus_total);
|
||||
len += sprintf(page + len, "CPUs Configured: %d\n",
|
||||
info->cpus_configured);
|
||||
len += sprintf(page + len, "CPUs Standby: %d\n",
|
||||
info->cpus_standby);
|
||||
len += sprintf(page + len, "CPUs Reserved: %d\n",
|
||||
info->cpus_reserved);
|
||||
|
||||
if (info->format == 1) {
|
||||
/*
|
||||
* Sigh 2. According to the specification the alternate
|
||||
* capability field is a 32 bit floating point number
|
||||
* if the higher order 8 bits are not zero. Printing
|
||||
* a floating point number in the kernel is a no-no,
|
||||
* always print the number as 32 bit unsigned integer.
|
||||
* The user-space needs to know about the stange
|
||||
* encoding of the alternate cpu capability.
|
||||
*/
|
||||
len += sprintf(page + len, "Capability: %u %u\n",
|
||||
info->capability, ext->alt_capability);
|
||||
for (i = 2; i <= info->cpus_total; i++)
|
||||
len += sprintf(page + len,
|
||||
"Adjustment %02d-way: %u %u\n",
|
||||
i, info->adjustment[i-2],
|
||||
ext->alt_adjustment[i-2]);
|
||||
|
||||
} else {
|
||||
len += sprintf(page + len, "Capability: %u\n",
|
||||
info->capability);
|
||||
for (i = 2; i <= info->cpus_total; i++)
|
||||
len += sprintf(page + len,
|
||||
"Adjustment %02d-way: %u\n",
|
||||
i, info->adjustment[i-2]);
|
||||
}
|
||||
return rc == -1 ? rc : 0;
|
||||
|
||||
if (info->secondary_capability != 0)
|
||||
len += sprintf(page + len, "Secondary Capability: %d\n",
|
||||
info->secondary_capability);
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static inline int stsi_1_2_1 (struct sysinfo_1_2_1 *info)
|
||||
#if 0 /* Currently unused */
|
||||
static int stsi_2_2_1(struct sysinfo_2_2_1 *info, char *page, int len)
|
||||
{
|
||||
int rc = stsi (info, 1, 2, 1);
|
||||
if (rc != -1)
|
||||
{
|
||||
EBCASC (info->sequence, sizeof(info->sequence));
|
||||
EBCASC (info->plant, sizeof(info->plant));
|
||||
if (stsi(info, 2, 2, 1) == -ENOSYS)
|
||||
return len;
|
||||
|
||||
len += sprintf(page + len, "\n");
|
||||
EBCASC (info->sequence, sizeof(info->sequence));
|
||||
EBCASC (info->plant, sizeof(info->plant));
|
||||
len += sprintf(page + len, "Sequence Code of logical CPU: %-16.16s\n",
|
||||
info->sequence);
|
||||
len += sprintf(page + len, "Plant of logical CPU: %-16.16s\n",
|
||||
info->plant);
|
||||
return len;
|
||||
}
|
||||
#endif
|
||||
|
||||
static int stsi_2_2_2(struct sysinfo_2_2_2 *info, char *page, int len)
|
||||
{
|
||||
if (stsi(info, 2, 2, 2) == -ENOSYS)
|
||||
return len;
|
||||
|
||||
EBCASC (info->name, sizeof(info->name));
|
||||
|
||||
len += sprintf(page + len, "\n");
|
||||
len += sprintf(page + len, "LPAR Number: %d\n",
|
||||
info->lpar_number);
|
||||
|
||||
len += sprintf(page + len, "LPAR Characteristics: ");
|
||||
if (info->characteristics & LPAR_CHAR_DEDICATED)
|
||||
len += sprintf(page + len, "Dedicated ");
|
||||
if (info->characteristics & LPAR_CHAR_SHARED)
|
||||
len += sprintf(page + len, "Shared ");
|
||||
if (info->characteristics & LPAR_CHAR_LIMITED)
|
||||
len += sprintf(page + len, "Limited ");
|
||||
len += sprintf(page + len, "\n");
|
||||
|
||||
len += sprintf(page + len, "LPAR Name: %-8.8s\n",
|
||||
info->name);
|
||||
|
||||
len += sprintf(page + len, "LPAR Adjustment: %d\n",
|
||||
info->caf);
|
||||
|
||||
len += sprintf(page + len, "LPAR CPUs Total: %d\n",
|
||||
info->cpus_total);
|
||||
len += sprintf(page + len, "LPAR CPUs Configured: %d\n",
|
||||
info->cpus_configured);
|
||||
len += sprintf(page + len, "LPAR CPUs Standby: %d\n",
|
||||
info->cpus_standby);
|
||||
len += sprintf(page + len, "LPAR CPUs Reserved: %d\n",
|
||||
info->cpus_reserved);
|
||||
len += sprintf(page + len, "LPAR CPUs Dedicated: %d\n",
|
||||
info->cpus_dedicated);
|
||||
len += sprintf(page + len, "LPAR CPUs Shared: %d\n",
|
||||
info->cpus_shared);
|
||||
return len;
|
||||
}
|
||||
|
||||
static int stsi_3_2_2(struct sysinfo_3_2_2 *info, char *page, int len)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (stsi(info, 3, 2, 2) == -ENOSYS)
|
||||
return len;
|
||||
for (i = 0; i < info->count; i++) {
|
||||
EBCASC (info->vm[i].name, sizeof(info->vm[i].name));
|
||||
EBCASC (info->vm[i].cpi, sizeof(info->vm[i].cpi));
|
||||
len += sprintf(page + len, "\n");
|
||||
len += sprintf(page + len, "VM%02d Name: %-8.8s\n",
|
||||
i, info->vm[i].name);
|
||||
len += sprintf(page + len, "VM%02d Control Program: %-16.16s\n",
|
||||
i, info->vm[i].cpi);
|
||||
|
||||
len += sprintf(page + len, "VM%02d Adjustment: %d\n",
|
||||
i, info->vm[i].caf);
|
||||
|
||||
len += sprintf(page + len, "VM%02d CPUs Total: %d\n",
|
||||
i, info->vm[i].cpus_total);
|
||||
len += sprintf(page + len, "VM%02d CPUs Configured: %d\n",
|
||||
i, info->vm[i].cpus_configured);
|
||||
len += sprintf(page + len, "VM%02d CPUs Standby: %d\n",
|
||||
i, info->vm[i].cpus_standby);
|
||||
len += sprintf(page + len, "VM%02d CPUs Reserved: %d\n",
|
||||
i, info->vm[i].cpus_reserved);
|
||||
}
|
||||
return rc == -1 ? rc : 0;
|
||||
}
|
||||
|
||||
static inline int stsi_1_2_2 (struct sysinfo_1_2_2 *info)
|
||||
{
|
||||
int rc = stsi (info, 1, 2, 2);
|
||||
return rc == -1 ? rc : 0;
|
||||
}
|
||||
|
||||
static inline int stsi_2_2_1 (struct sysinfo_2_2_1 *info)
|
||||
{
|
||||
int rc = stsi (info, 2, 2, 1);
|
||||
if (rc != -1)
|
||||
{
|
||||
EBCASC (info->sequence, sizeof(info->sequence));
|
||||
EBCASC (info->plant, sizeof(info->plant));
|
||||
}
|
||||
return rc == -1 ? rc : 0;
|
||||
}
|
||||
|
||||
static inline int stsi_2_2_2 (struct sysinfo_2_2_2 *info)
|
||||
{
|
||||
int rc = stsi (info, 2, 2, 2);
|
||||
if (rc != -1)
|
||||
{
|
||||
EBCASC (info->name, sizeof(info->name));
|
||||
}
|
||||
return rc == -1 ? rc : 0;
|
||||
}
|
||||
|
||||
static inline int stsi_3_2_2 (struct sysinfo_3_2_2 *info)
|
||||
{
|
||||
int rc = stsi (info, 3, 2, 2);
|
||||
if (rc != -1)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < info->count; i++)
|
||||
{
|
||||
EBCASC (info->vm[i].name, sizeof(info->vm[i].name));
|
||||
EBCASC (info->vm[i].cpi, sizeof(info->vm[i].cpi));
|
||||
}
|
||||
}
|
||||
return rc == -1 ? rc : 0;
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
@ -227,118 +318,34 @@ static int proc_read_sysinfo(char *page, char **start,
|
||||
off_t off, int count,
|
||||
int *eof, void *data)
|
||||
{
|
||||
unsigned long info_page = get_zeroed_page (GFP_KERNEL);
|
||||
union s390_sysinfo *info = (union s390_sysinfo *) info_page;
|
||||
int len = 0;
|
||||
int level;
|
||||
int i;
|
||||
unsigned long info = get_zeroed_page (GFP_KERNEL);
|
||||
int level, len;
|
||||
|
||||
if (!info)
|
||||
return 0;
|
||||
|
||||
level = stsi_0 ();
|
||||
len = 0;
|
||||
level = stsi_0();
|
||||
if (level >= 1)
|
||||
len = stsi_1_1_1((struct sysinfo_1_1_1 *) info, page, len);
|
||||
|
||||
if (level >= 1 && stsi_1_1_1 (&info->sysinfo_1_1_1) == 0)
|
||||
{
|
||||
len += sprintf (page+len, "Manufacturer: %-16.16s\n",
|
||||
info->sysinfo_1_1_1.manufacturer);
|
||||
len += sprintf (page+len, "Type: %-4.4s\n",
|
||||
info->sysinfo_1_1_1.type);
|
||||
len += sprintf (page+len, "Model: %-16.16s\n",
|
||||
info->sysinfo_1_1_1.model);
|
||||
len += sprintf (page+len, "Sequence Code: %-16.16s\n",
|
||||
info->sysinfo_1_1_1.sequence);
|
||||
len += sprintf (page+len, "Plant: %-4.4s\n",
|
||||
info->sysinfo_1_1_1.plant);
|
||||
}
|
||||
if (level >= 1)
|
||||
len = stsi_1_2_2((struct sysinfo_1_2_2 *) info, page, len);
|
||||
|
||||
if (level >= 1 && stsi_1_2_2 (&info->sysinfo_1_2_2) == 0)
|
||||
{
|
||||
len += sprintf (page+len, "\n");
|
||||
len += sprintf (page+len, "CPUs Total: %d\n",
|
||||
info->sysinfo_1_2_2.cpus_total);
|
||||
len += sprintf (page+len, "CPUs Configured: %d\n",
|
||||
info->sysinfo_1_2_2.cpus_configured);
|
||||
len += sprintf (page+len, "CPUs Standby: %d\n",
|
||||
info->sysinfo_1_2_2.cpus_standby);
|
||||
len += sprintf (page+len, "CPUs Reserved: %d\n",
|
||||
info->sysinfo_1_2_2.cpus_reserved);
|
||||
|
||||
len += sprintf (page+len, "Capability: %d\n",
|
||||
info->sysinfo_1_2_2.capability);
|
||||
if (level >= 2)
|
||||
len = stsi_2_2_2((struct sysinfo_2_2_2 *) info, page, len);
|
||||
|
||||
for (i = 2; i <= info->sysinfo_1_2_2.cpus_total; i++)
|
||||
len += sprintf (page+len, "Adjustment %02d-way: %d\n",
|
||||
i, info->sysinfo_1_2_2.adjustment[i-2]);
|
||||
}
|
||||
if (level >= 3)
|
||||
len = stsi_3_2_2((struct sysinfo_3_2_2 *) info, page, len);
|
||||
|
||||
if (level >= 2 && stsi_2_2_2 (&info->sysinfo_2_2_2) == 0)
|
||||
{
|
||||
len += sprintf (page+len, "\n");
|
||||
len += sprintf (page+len, "LPAR Number: %d\n",
|
||||
info->sysinfo_2_2_2.lpar_number);
|
||||
|
||||
len += sprintf (page+len, "LPAR Characteristics: ");
|
||||
if (info->sysinfo_2_2_2.characteristics & LPAR_CHAR_DEDICATED)
|
||||
len += sprintf (page+len, "Dedicated ");
|
||||
if (info->sysinfo_2_2_2.characteristics & LPAR_CHAR_SHARED)
|
||||
len += sprintf (page+len, "Shared ");
|
||||
if (info->sysinfo_2_2_2.characteristics & LPAR_CHAR_LIMITED)
|
||||
len += sprintf (page+len, "Limited ");
|
||||
len += sprintf (page+len, "\n");
|
||||
|
||||
len += sprintf (page+len, "LPAR Name: %-8.8s\n",
|
||||
info->sysinfo_2_2_2.name);
|
||||
|
||||
len += sprintf (page+len, "LPAR Adjustment: %d\n",
|
||||
info->sysinfo_2_2_2.caf);
|
||||
|
||||
len += sprintf (page+len, "LPAR CPUs Total: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_total);
|
||||
len += sprintf (page+len, "LPAR CPUs Configured: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_configured);
|
||||
len += sprintf (page+len, "LPAR CPUs Standby: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_standby);
|
||||
len += sprintf (page+len, "LPAR CPUs Reserved: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_reserved);
|
||||
len += sprintf (page+len, "LPAR CPUs Dedicated: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_dedicated);
|
||||
len += sprintf (page+len, "LPAR CPUs Shared: %d\n",
|
||||
info->sysinfo_2_2_2.cpus_shared);
|
||||
}
|
||||
|
||||
if (level >= 3 && stsi_3_2_2 (&info->sysinfo_3_2_2) == 0)
|
||||
{
|
||||
for (i = 0; i < info->sysinfo_3_2_2.count; i++)
|
||||
{
|
||||
len += sprintf (page+len, "\n");
|
||||
len += sprintf (page+len, "VM%02d Name: %-8.8s\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].name);
|
||||
len += sprintf (page+len, "VM%02d Control Program: %-16.16s\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].cpi);
|
||||
|
||||
len += sprintf (page+len, "VM%02d Adjustment: %d\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].caf);
|
||||
|
||||
len += sprintf (page+len, "VM%02d CPUs Total: %d\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].cpus_total);
|
||||
len += sprintf (page+len, "VM%02d CPUs Configured: %d\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].cpus_configured);
|
||||
len += sprintf (page+len, "VM%02d CPUs Standby: %d\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].cpus_standby);
|
||||
len += sprintf (page+len, "VM%02d CPUs Reserved: %d\n",
|
||||
i, info->sysinfo_3_2_2.vm[i].cpus_reserved);
|
||||
}
|
||||
}
|
||||
|
||||
free_page (info_page);
|
||||
free_page (info);
|
||||
return len;
|
||||
}
|
||||
|
||||
static __init int create_proc_sysinfo(void)
|
||||
{
|
||||
create_proc_read_entry ("sysinfo", 0444, NULL,
|
||||
proc_read_sysinfo, NULL);
|
||||
create_proc_read_entry("sysinfo", 0444, NULL,
|
||||
proc_read_sysinfo, NULL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -1,4 +1,4 @@
|
||||
include include/asm-generic/Kbuild.asm
|
||||
|
||||
unifdef-y += cmb.h debug.h
|
||||
header-y += dasd.h qeth.h tape390.h ucontext.h vtoc.h z90crypt.h
|
||||
header-y += dasd.h monwriter.h qeth.h tape390.h ucontext.h vtoc.h z90crypt.h
|
||||
|
90
include/asm-s390/appldata.h
Normal file
90
include/asm-s390/appldata.h
Normal file
@ -0,0 +1,90 @@
|
||||
/*
|
||||
* include/asm-s390/appldata.h
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
*
|
||||
* Author(s): Melissa Howland <melissah@us.ibm.com>
|
||||
*/
|
||||
|
||||
#ifndef _ASM_S390_APPLDATA_H
|
||||
#define _ASM_S390_APPLDATA_H
|
||||
|
||||
#include <asm/io.h>
|
||||
|
||||
#ifndef CONFIG_64BIT
|
||||
|
||||
#define APPLDATA_START_INTERVAL_REC 0x00 /* Function codes for */
|
||||
#define APPLDATA_STOP_REC 0x01 /* DIAG 0xDC */
|
||||
#define APPLDATA_GEN_EVENT_REC 0x02
|
||||
#define APPLDATA_START_CONFIG_REC 0x03
|
||||
|
||||
/*
|
||||
* Parameter list for DIAGNOSE X'DC'
|
||||
*/
|
||||
struct appldata_parameter_list {
|
||||
u16 diag; /* The DIAGNOSE code X'00DC' */
|
||||
u8 function; /* The function code for the DIAGNOSE */
|
||||
u8 parlist_length; /* Length of the parameter list */
|
||||
u32 product_id_addr; /* Address of the 16-byte product ID */
|
||||
u16 reserved;
|
||||
u16 buffer_length; /* Length of the application data buffer */
|
||||
u32 buffer_addr; /* Address of the application data buffer */
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#else /* CONFIG_64BIT */
|
||||
|
||||
#define APPLDATA_START_INTERVAL_REC 0x80
|
||||
#define APPLDATA_STOP_REC 0x81
|
||||
#define APPLDATA_GEN_EVENT_REC 0x82
|
||||
#define APPLDATA_START_CONFIG_REC 0x83
|
||||
|
||||
/*
|
||||
* Parameter list for DIAGNOSE X'DC'
|
||||
*/
|
||||
struct appldata_parameter_list {
|
||||
u16 diag;
|
||||
u8 function;
|
||||
u8 parlist_length;
|
||||
u32 unused01;
|
||||
u16 reserved;
|
||||
u16 buffer_length;
|
||||
u32 unused02;
|
||||
u64 product_id_addr;
|
||||
u64 buffer_addr;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#endif /* CONFIG_64BIT */
|
||||
|
||||
struct appldata_product_id {
|
||||
char prod_nr[7]; /* product number */
|
||||
u16 prod_fn; /* product function */
|
||||
u8 record_nr; /* record number */
|
||||
u16 version_nr; /* version */
|
||||
u16 release_nr; /* release */
|
||||
u16 mod_lvl; /* modification level */
|
||||
} __attribute__ ((packed));
|
||||
|
||||
static inline int appldata_asm(struct appldata_product_id *id,
|
||||
unsigned short fn, void *buffer,
|
||||
unsigned short length)
|
||||
{
|
||||
struct appldata_parameter_list parm_list;
|
||||
int ry;
|
||||
|
||||
if (!MACHINE_IS_VM)
|
||||
return -ENOSYS;
|
||||
parm_list.diag = 0xdc;
|
||||
parm_list.function = fn;
|
||||
parm_list.parlist_length = sizeof(parm_list);
|
||||
parm_list.buffer_length = length;
|
||||
parm_list.product_id_addr = (unsigned long) id;
|
||||
parm_list.buffer_addr = virt_to_phys(buffer);
|
||||
asm volatile(
|
||||
"diag %1,%0,0xdc"
|
||||
: "=d" (ry)
|
||||
: "d" (&parm_list), "m" (parm_list), "m" (*id)
|
||||
: "cc");
|
||||
return ry;
|
||||
}
|
||||
|
||||
#endif /* _ASM_S390_APPLDATA_H */
|
@ -270,6 +270,11 @@ struct diag210 {
|
||||
__u32 vrdccrft : 8; /* real device feature (output) */
|
||||
} __attribute__ ((packed,aligned(4)));
|
||||
|
||||
struct ccw_dev_id {
|
||||
u8 ssid;
|
||||
u16 devno;
|
||||
};
|
||||
|
||||
extern int diag210(struct diag210 *addr);
|
||||
|
||||
extern void wait_cons_dev(void);
|
||||
@ -280,6 +285,8 @@ extern void cio_reset_channel_paths(void);
|
||||
|
||||
extern void css_schedule_reprobe(void);
|
||||
|
||||
extern void reipl_ccw_dev(struct ccw_dev_id *id);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -11,6 +11,6 @@
|
||||
|
||||
#define MAX_DMA_ADDRESS 0x80000000
|
||||
|
||||
#define free_dma(x)
|
||||
#define free_dma(x) do { } while (0)
|
||||
|
||||
#endif /* _ASM_DMA_H */
|
||||
|
@ -7,75 +7,21 @@
|
||||
#include <asm/errno.h>
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
#ifndef __s390x__
|
||||
#define __futex_atomic_fixup \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 4\n" \
|
||||
" .long 0b,4b,2b,4b,3b,4b\n" \
|
||||
".previous"
|
||||
#else /* __s390x__ */
|
||||
#define __futex_atomic_fixup \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 8\n" \
|
||||
" .quad 0b,4b,2b,4b,3b,4b\n" \
|
||||
".previous"
|
||||
#endif /* __s390x__ */
|
||||
|
||||
#define __futex_atomic_op(insn, ret, oldval, newval, uaddr, oparg) \
|
||||
asm volatile(" sacf 256\n" \
|
||||
"0: l %1,0(%6)\n" \
|
||||
"1: " insn \
|
||||
"2: cs %1,%2,0(%6)\n" \
|
||||
"3: jl 1b\n" \
|
||||
" lhi %0,0\n" \
|
||||
"4: sacf 0\n" \
|
||||
__futex_atomic_fixup \
|
||||
: "=d" (ret), "=&d" (oldval), "=&d" (newval), \
|
||||
"=m" (*uaddr) \
|
||||
: "0" (-EFAULT), "d" (oparg), "a" (uaddr), \
|
||||
"m" (*uaddr) : "cc" );
|
||||
|
||||
static inline int futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
|
||||
{
|
||||
int op = (encoded_op >> 28) & 7;
|
||||
int cmp = (encoded_op >> 24) & 15;
|
||||
int oparg = (encoded_op << 8) >> 20;
|
||||
int cmparg = (encoded_op << 20) >> 20;
|
||||
int oldval = 0, newval, ret;
|
||||
int oldval, ret;
|
||||
|
||||
if (encoded_op & (FUTEX_OP_OPARG_SHIFT << 28))
|
||||
oparg = 1 << oparg;
|
||||
|
||||
if (! access_ok (VERIFY_WRITE, uaddr, sizeof(int)))
|
||||
return -EFAULT;
|
||||
|
||||
inc_preempt_count();
|
||||
|
||||
switch (op) {
|
||||
case FUTEX_OP_SET:
|
||||
__futex_atomic_op("lr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_ADD:
|
||||
__futex_atomic_op("lr %2,%1\nar %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_OR:
|
||||
__futex_atomic_op("lr %2,%1\nor %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_ANDN:
|
||||
__futex_atomic_op("lr %2,%1\nnr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
case FUTEX_OP_XOR:
|
||||
__futex_atomic_op("lr %2,%1\nxr %2,%5\n",
|
||||
ret, oldval, newval, uaddr, oparg);
|
||||
break;
|
||||
default:
|
||||
ret = -ENOSYS;
|
||||
}
|
||||
|
||||
dec_preempt_count();
|
||||
ret = uaccess.futex_atomic_op(op, uaddr, oparg, &oldval);
|
||||
|
||||
if (!ret) {
|
||||
switch (cmp) {
|
||||
@ -91,32 +37,13 @@ static inline int futex_atomic_op_inuser (int encoded_op, int __user *uaddr)
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline int
|
||||
futex_atomic_cmpxchg_inatomic(int __user *uaddr, int oldval, int newval)
|
||||
static inline int futex_atomic_cmpxchg_inatomic(int __user *uaddr,
|
||||
int oldval, int newval)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (! access_ok (VERIFY_WRITE, uaddr, sizeof(int)))
|
||||
return -EFAULT;
|
||||
asm volatile(" sacf 256\n"
|
||||
" cs %1,%4,0(%5)\n"
|
||||
"0: lr %0,%1\n"
|
||||
"1: sacf 0\n"
|
||||
#ifndef __s390x__
|
||||
".section __ex_table,\"a\"\n"
|
||||
" .align 4\n"
|
||||
" .long 0b,1b\n"
|
||||
".previous"
|
||||
#else /* __s390x__ */
|
||||
".section __ex_table,\"a\"\n"
|
||||
" .align 8\n"
|
||||
" .quad 0b,1b\n"
|
||||
".previous"
|
||||
#endif /* __s390x__ */
|
||||
: "=d" (ret), "+d" (oldval), "=m" (*uaddr)
|
||||
: "0" (-EFAULT), "d" (newval), "a" (uaddr), "m" (*uaddr)
|
||||
: "cc", "memory" );
|
||||
return oldval;
|
||||
|
||||
return uaccess.futex_atomic_cmpxchg(uaddr, oldval, newval);
|
||||
}
|
||||
|
||||
#endif /* __KERNEL__ */
|
||||
|
@ -116,7 +116,7 @@ extern void iounmap(void *addr);
|
||||
#define outb(x,addr) ((void) writeb(x,addr))
|
||||
#define outb_p(x,addr) outb(x,addr)
|
||||
|
||||
#define mmiowb()
|
||||
#define mmiowb() do { } while (0)
|
||||
|
||||
/*
|
||||
* Convert a physical pointer to a virtual kernel pointer for /dev/mem
|
||||
|
59
include/asm-s390/kdebug.h
Normal file
59
include/asm-s390/kdebug.h
Normal file
@ -0,0 +1,59 @@
|
||||
#ifndef _S390_KDEBUG_H
|
||||
#define _S390_KDEBUG_H
|
||||
|
||||
/*
|
||||
* Feb 2006 Ported to s390 <grundym@us.ibm.com>
|
||||
*/
|
||||
#include <linux/notifier.h>
|
||||
|
||||
struct pt_regs;
|
||||
|
||||
struct die_args {
|
||||
struct pt_regs *regs;
|
||||
const char *str;
|
||||
long err;
|
||||
int trapnr;
|
||||
int signr;
|
||||
};
|
||||
|
||||
/* Note - you should never unregister because that can race with NMIs.
|
||||
* If you really want to do it first unregister - then synchronize_sched
|
||||
* - then free.
|
||||
*/
|
||||
extern int register_die_notifier(struct notifier_block *);
|
||||
extern int unregister_die_notifier(struct notifier_block *);
|
||||
extern int register_page_fault_notifier(struct notifier_block *);
|
||||
extern int unregister_page_fault_notifier(struct notifier_block *);
|
||||
extern struct atomic_notifier_head s390die_chain;
|
||||
|
||||
|
||||
enum die_val {
|
||||
DIE_OOPS = 1,
|
||||
DIE_BPT,
|
||||
DIE_SSTEP,
|
||||
DIE_PANIC,
|
||||
DIE_NMI,
|
||||
DIE_DIE,
|
||||
DIE_NMIWATCHDOG,
|
||||
DIE_KERNELDEBUG,
|
||||
DIE_TRAP,
|
||||
DIE_GPF,
|
||||
DIE_CALL,
|
||||
DIE_NMI_IPI,
|
||||
DIE_PAGE_FAULT,
|
||||
};
|
||||
|
||||
static inline int notify_die(enum die_val val, const char *str,
|
||||
struct pt_regs *regs, long err, int trap, int sig)
|
||||
{
|
||||
struct die_args args = {
|
||||
.regs = regs,
|
||||
.str = str,
|
||||
.err = err,
|
||||
.trapnr = trap,
|
||||
.signr = sig
|
||||
};
|
||||
return atomic_notifier_call_chain(&s390die_chain, val, &args);
|
||||
}
|
||||
|
||||
#endif
|
114
include/asm-s390/kprobes.h
Normal file
114
include/asm-s390/kprobes.h
Normal file
@ -0,0 +1,114 @@
|
||||
#ifndef _ASM_S390_KPROBES_H
|
||||
#define _ASM_S390_KPROBES_H
|
||||
/*
|
||||
* Kernel Probes (KProbes)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* Copyright (C) IBM Corporation, 2002, 2006
|
||||
*
|
||||
* 2002-Oct Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
|
||||
* Probes initial implementation ( includes suggestions from
|
||||
* Rusty Russell).
|
||||
* 2004-Nov Modified for PPC64 by Ananth N Mavinakayanahalli
|
||||
* <ananth@in.ibm.com>
|
||||
* 2005-Dec Used as a template for s390 by Mike Grundy
|
||||
* <grundym@us.ibm.com>
|
||||
*/
|
||||
#include <linux/types.h>
|
||||
#include <linux/ptrace.h>
|
||||
#include <linux/percpu.h>
|
||||
|
||||
#define __ARCH_WANT_KPROBES_INSN_SLOT
|
||||
struct pt_regs;
|
||||
struct kprobe;
|
||||
|
||||
typedef u16 kprobe_opcode_t;
|
||||
#define BREAKPOINT_INSTRUCTION 0x0002
|
||||
|
||||
/* Maximum instruction size is 3 (16bit) halfwords: */
|
||||
#define MAX_INSN_SIZE 0x0003
|
||||
#define MAX_STACK_SIZE 64
|
||||
#define MIN_STACK_SIZE(ADDR) (((MAX_STACK_SIZE) < \
|
||||
(((unsigned long)current_thread_info()) + THREAD_SIZE - (ADDR))) \
|
||||
? (MAX_STACK_SIZE) \
|
||||
: (((unsigned long)current_thread_info()) + THREAD_SIZE - (ADDR)))
|
||||
|
||||
#define JPROBE_ENTRY(pentry) (kprobe_opcode_t *)(pentry)
|
||||
|
||||
#define ARCH_SUPPORTS_KRETPROBES
|
||||
#define ARCH_INACTIVE_KPROBE_COUNT 0
|
||||
|
||||
#define KPROBE_SWAP_INST 0x10
|
||||
|
||||
#define FIXUP_PSW_NORMAL 0x08
|
||||
#define FIXUP_BRANCH_NOT_TAKEN 0x04
|
||||
#define FIXUP_RETURN_REGISTER 0x02
|
||||
#define FIXUP_NOT_REQUIRED 0x01
|
||||
|
||||
/* Architecture specific copy of original instruction */
|
||||
struct arch_specific_insn {
|
||||
/* copy of original instruction */
|
||||
kprobe_opcode_t *insn;
|
||||
int fixup;
|
||||
int ilen;
|
||||
int reg;
|
||||
};
|
||||
|
||||
struct ins_replace_args {
|
||||
kprobe_opcode_t *ptr;
|
||||
kprobe_opcode_t old;
|
||||
kprobe_opcode_t new;
|
||||
};
|
||||
struct prev_kprobe {
|
||||
struct kprobe *kp;
|
||||
unsigned long status;
|
||||
unsigned long saved_psw;
|
||||
unsigned long kprobe_saved_imask;
|
||||
unsigned long kprobe_saved_ctl[3];
|
||||
};
|
||||
|
||||
/* per-cpu kprobe control block */
|
||||
struct kprobe_ctlblk {
|
||||
unsigned long kprobe_status;
|
||||
unsigned long kprobe_saved_imask;
|
||||
unsigned long kprobe_saved_ctl[3];
|
||||
struct pt_regs jprobe_saved_regs;
|
||||
unsigned long jprobe_saved_r14;
|
||||
unsigned long jprobe_saved_r15;
|
||||
struct prev_kprobe prev_kprobe;
|
||||
kprobe_opcode_t jprobes_stack[MAX_STACK_SIZE];
|
||||
};
|
||||
|
||||
void arch_remove_kprobe(struct kprobe *p);
|
||||
void kretprobe_trampoline(void);
|
||||
int is_prohibited_opcode(kprobe_opcode_t *instruction);
|
||||
void get_instruction_type(struct arch_specific_insn *ainsn);
|
||||
|
||||
#define flush_insn_slot(p) do { } while (0)
|
||||
|
||||
#endif /* _ASM_S390_KPROBES_H */
|
||||
|
||||
#ifdef CONFIG_KPROBES
|
||||
|
||||
extern int kprobe_exceptions_notify(struct notifier_block *self,
|
||||
unsigned long val, void *data);
|
||||
#else /* !CONFIG_KPROBES */
|
||||
static inline int kprobe_exceptions_notify(struct notifier_block *self,
|
||||
unsigned long val, void *data)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
@ -35,6 +35,7 @@
|
||||
#define __LC_IO_NEW_PSW 0x01f0
|
||||
#endif /* !__s390x__ */
|
||||
|
||||
#define __LC_IPL_PARMBLOCK_PTR 0x014
|
||||
#define __LC_EXT_PARAMS 0x080
|
||||
#define __LC_CPU_ADDRESS 0x084
|
||||
#define __LC_EXT_INT_CODE 0x086
|
||||
@ -47,6 +48,7 @@
|
||||
#define __LC_PER_ATMID 0x096
|
||||
#define __LC_PER_ADDRESS 0x098
|
||||
#define __LC_PER_ACCESS_ID 0x0A1
|
||||
#define __LC_AR_MODE_ID 0x0A3
|
||||
|
||||
#define __LC_SUBCHANNEL_ID 0x0B8
|
||||
#define __LC_SUBCHANNEL_NR 0x0BA
|
||||
@ -106,18 +108,28 @@
|
||||
#define __LC_INT_CLOCK 0xDE8
|
||||
#endif /* __s390x__ */
|
||||
|
||||
#define __LC_PANIC_MAGIC 0xE00
|
||||
|
||||
#define __LC_PANIC_MAGIC 0xE00
|
||||
#ifndef __s390x__
|
||||
#define __LC_PFAULT_INTPARM 0x080
|
||||
#define __LC_CPU_TIMER_SAVE_AREA 0x0D8
|
||||
#define __LC_CLOCK_COMP_SAVE_AREA 0x0E0
|
||||
#define __LC_PSW_SAVE_AREA 0x100
|
||||
#define __LC_PREFIX_SAVE_AREA 0x108
|
||||
#define __LC_AREGS_SAVE_AREA 0x120
|
||||
#define __LC_FPREGS_SAVE_AREA 0x160
|
||||
#define __LC_GPREGS_SAVE_AREA 0x180
|
||||
#define __LC_CREGS_SAVE_AREA 0x1C0
|
||||
#else /* __s390x__ */
|
||||
#define __LC_PFAULT_INTPARM 0x11B8
|
||||
#define __LC_FPREGS_SAVE_AREA 0x1200
|
||||
#define __LC_GPREGS_SAVE_AREA 0x1280
|
||||
#define __LC_PSW_SAVE_AREA 0x1300
|
||||
#define __LC_PREFIX_SAVE_AREA 0x1318
|
||||
#define __LC_FP_CREG_SAVE_AREA 0x131C
|
||||
#define __LC_TODREG_SAVE_AREA 0x1324
|
||||
#define __LC_CPU_TIMER_SAVE_AREA 0x1328
|
||||
#define __LC_CLOCK_COMP_SAVE_AREA 0x1331
|
||||
#define __LC_AREGS_SAVE_AREA 0x1340
|
||||
#define __LC_CREGS_SAVE_AREA 0x1380
|
||||
#endif /* __s390x__ */
|
||||
|
33
include/asm-s390/monwriter.h
Normal file
33
include/asm-s390/monwriter.h
Normal file
@ -0,0 +1,33 @@
|
||||
/*
|
||||
* include/asm-s390/monwriter.h
|
||||
*
|
||||
* Copyright (C) IBM Corp. 2006
|
||||
* Character device driver for writing z/VM APPLDATA monitor records
|
||||
* Version 1.0
|
||||
* Author(s): Melissa Howland <melissah@us.ibm.com>
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _ASM_390_MONWRITER_H
|
||||
#define _ASM_390_MONWRITER_H
|
||||
|
||||
/* mon_function values */
|
||||
#define MONWRITE_START_INTERVAL 0x00 /* start interval recording */
|
||||
#define MONWRITE_STOP_INTERVAL 0x01 /* stop interval or config recording */
|
||||
#define MONWRITE_GEN_EVENT 0x02 /* generate event record */
|
||||
#define MONWRITE_START_CONFIG 0x03 /* start configuration recording */
|
||||
|
||||
/* the header the app uses in its write() data */
|
||||
struct monwrite_hdr {
|
||||
unsigned char mon_function;
|
||||
unsigned short applid;
|
||||
unsigned char record_num;
|
||||
unsigned short version;
|
||||
unsigned short release;
|
||||
unsigned short mod_level;
|
||||
unsigned short datalen;
|
||||
unsigned char hdrlen;
|
||||
|
||||
} __attribute__((packed));
|
||||
|
||||
#endif /* _ASM_390_MONWRITER_H */
|
@ -21,6 +21,16 @@
|
||||
|
||||
extern void diag10(unsigned long addr);
|
||||
|
||||
/*
|
||||
* Page allocation orders.
|
||||
*/
|
||||
#ifndef __s390x__
|
||||
# define PGD_ALLOC_ORDER 1
|
||||
#else /* __s390x__ */
|
||||
# define PMD_ALLOC_ORDER 2
|
||||
# define PGD_ALLOC_ORDER 2
|
||||
#endif /* __s390x__ */
|
||||
|
||||
/*
|
||||
* Allocate and free page tables. The xxx_kernel() versions are
|
||||
* used to allocate a kernel page table - this turns on ASN bits
|
||||
@ -29,30 +39,23 @@ extern void diag10(unsigned long addr);
|
||||
|
||||
static inline pgd_t *pgd_alloc(struct mm_struct *mm)
|
||||
{
|
||||
pgd_t *pgd;
|
||||
pgd_t *pgd = (pgd_t *) __get_free_pages(GFP_KERNEL, PGD_ALLOC_ORDER);
|
||||
int i;
|
||||
|
||||
if (!pgd)
|
||||
return NULL;
|
||||
for (i = 0; i < PTRS_PER_PGD; i++)
|
||||
#ifndef __s390x__
|
||||
pgd = (pgd_t *) __get_free_pages(GFP_KERNEL,1);
|
||||
if (pgd != NULL)
|
||||
for (i = 0; i < USER_PTRS_PER_PGD; i++)
|
||||
pmd_clear(pmd_offset(pgd + i, i*PGDIR_SIZE));
|
||||
#else /* __s390x__ */
|
||||
pgd = (pgd_t *) __get_free_pages(GFP_KERNEL,2);
|
||||
if (pgd != NULL)
|
||||
for (i = 0; i < PTRS_PER_PGD; i++)
|
||||
pgd_clear(pgd + i);
|
||||
#endif /* __s390x__ */
|
||||
pmd_clear(pmd_offset(pgd + i, i*PGDIR_SIZE));
|
||||
#else
|
||||
pgd_clear(pgd + i);
|
||||
#endif
|
||||
return pgd;
|
||||
}
|
||||
|
||||
static inline void pgd_free(pgd_t *pgd)
|
||||
{
|
||||
#ifndef __s390x__
|
||||
free_pages((unsigned long) pgd, 1);
|
||||
#else /* __s390x__ */
|
||||
free_pages((unsigned long) pgd, 2);
|
||||
#endif /* __s390x__ */
|
||||
free_pages((unsigned long) pgd, PGD_ALLOC_ORDER);
|
||||
}
|
||||
|
||||
#ifndef __s390x__
|
||||
@ -68,20 +71,19 @@ static inline void pgd_free(pgd_t *pgd)
|
||||
#else /* __s390x__ */
|
||||
static inline pmd_t * pmd_alloc_one(struct mm_struct *mm, unsigned long vmaddr)
|
||||
{
|
||||
pmd_t *pmd;
|
||||
int i;
|
||||
pmd_t *pmd = (pmd_t *) __get_free_pages(GFP_KERNEL, PMD_ALLOC_ORDER);
|
||||
int i;
|
||||
|
||||
pmd = (pmd_t *) __get_free_pages(GFP_KERNEL, 2);
|
||||
if (pmd != NULL) {
|
||||
for (i=0; i < PTRS_PER_PMD; i++)
|
||||
pmd_clear(pmd+i);
|
||||
}
|
||||
if (!pmd)
|
||||
return NULL;
|
||||
for (i=0; i < PTRS_PER_PMD; i++)
|
||||
pmd_clear(pmd + i);
|
||||
return pmd;
|
||||
}
|
||||
|
||||
static inline void pmd_free (pmd_t *pmd)
|
||||
{
|
||||
free_pages((unsigned long) pmd, 2);
|
||||
free_pages((unsigned long) pmd, PMD_ALLOC_ORDER);
|
||||
}
|
||||
|
||||
#define __pmd_free_tlb(tlb,pmd) \
|
||||
@ -123,15 +125,14 @@ pmd_populate(struct mm_struct *mm, pmd_t *pmd, struct page *page)
|
||||
static inline pte_t *
|
||||
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long vmaddr)
|
||||
{
|
||||
pte_t *pte;
|
||||
int i;
|
||||
pte_t *pte = (pte_t *) __get_free_page(GFP_KERNEL|__GFP_REPEAT);
|
||||
int i;
|
||||
|
||||
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
|
||||
if (pte != NULL) {
|
||||
for (i=0; i < PTRS_PER_PTE; i++) {
|
||||
pte_clear(mm, vmaddr, pte+i);
|
||||
vmaddr += PAGE_SIZE;
|
||||
}
|
||||
if (!pte)
|
||||
return NULL;
|
||||
for (i=0; i < PTRS_PER_PTE; i++) {
|
||||
pte_clear(mm, vmaddr, pte + i);
|
||||
vmaddr += PAGE_SIZE;
|
||||
}
|
||||
return pte;
|
||||
}
|
||||
|
@ -89,19 +89,6 @@ extern char empty_zero_page[PAGE_SIZE];
|
||||
# define PTRS_PER_PGD 2048
|
||||
#endif /* __s390x__ */
|
||||
|
||||
/*
|
||||
* pgd entries used up by user/kernel:
|
||||
*/
|
||||
#ifndef __s390x__
|
||||
# define USER_PTRS_PER_PGD 512
|
||||
# define USER_PGD_PTRS 512
|
||||
# define KERNEL_PGD_PTRS 512
|
||||
#else /* __s390x__ */
|
||||
# define USER_PTRS_PER_PGD 2048
|
||||
# define USER_PGD_PTRS 2048
|
||||
# define KERNEL_PGD_PTRS 2048
|
||||
#endif /* __s390x__ */
|
||||
|
||||
#define FIRST_USER_ADDRESS 0
|
||||
|
||||
#define pte_ERROR(e) \
|
||||
@ -216,12 +203,14 @@ extern char empty_zero_page[PAGE_SIZE];
|
||||
#define _PAGE_RO 0x200 /* HW read-only */
|
||||
#define _PAGE_INVALID 0x400 /* HW invalid */
|
||||
|
||||
/* Mask and four different kinds of invalid pages. */
|
||||
#define _PAGE_INVALID_MASK 0x601
|
||||
#define _PAGE_INVALID_EMPTY 0x400
|
||||
#define _PAGE_INVALID_NONE 0x401
|
||||
#define _PAGE_INVALID_SWAP 0x600
|
||||
#define _PAGE_INVALID_FILE 0x601
|
||||
/* Mask and six different types of pages. */
|
||||
#define _PAGE_TYPE_MASK 0x601
|
||||
#define _PAGE_TYPE_EMPTY 0x400
|
||||
#define _PAGE_TYPE_NONE 0x401
|
||||
#define _PAGE_TYPE_SWAP 0x600
|
||||
#define _PAGE_TYPE_FILE 0x601
|
||||
#define _PAGE_TYPE_RO 0x200
|
||||
#define _PAGE_TYPE_RW 0x000
|
||||
|
||||
#ifndef __s390x__
|
||||
|
||||
@ -280,15 +269,14 @@ extern char empty_zero_page[PAGE_SIZE];
|
||||
#endif /* __s390x__ */
|
||||
|
||||
/*
|
||||
* No mapping available
|
||||
* Page protection definitions.
|
||||
*/
|
||||
#define PAGE_NONE_SHARED __pgprot(_PAGE_INVALID_NONE)
|
||||
#define PAGE_NONE_PRIVATE __pgprot(_PAGE_INVALID_NONE)
|
||||
#define PAGE_RO_SHARED __pgprot(_PAGE_RO)
|
||||
#define PAGE_RO_PRIVATE __pgprot(_PAGE_RO)
|
||||
#define PAGE_COPY __pgprot(_PAGE_RO)
|
||||
#define PAGE_SHARED __pgprot(0)
|
||||
#define PAGE_KERNEL __pgprot(0)
|
||||
#define PAGE_NONE __pgprot(_PAGE_TYPE_NONE)
|
||||
#define PAGE_RO __pgprot(_PAGE_TYPE_RO)
|
||||
#define PAGE_RW __pgprot(_PAGE_TYPE_RW)
|
||||
|
||||
#define PAGE_KERNEL PAGE_RW
|
||||
#define PAGE_COPY PAGE_RO
|
||||
|
||||
/*
|
||||
* The S390 can't do page protection for execute, and considers that the
|
||||
@ -296,23 +284,23 @@ extern char empty_zero_page[PAGE_SIZE];
|
||||
* the closest we can get..
|
||||
*/
|
||||
/*xwr*/
|
||||
#define __P000 PAGE_NONE_PRIVATE
|
||||
#define __P001 PAGE_RO_PRIVATE
|
||||
#define __P010 PAGE_COPY
|
||||
#define __P011 PAGE_COPY
|
||||
#define __P100 PAGE_RO_PRIVATE
|
||||
#define __P101 PAGE_RO_PRIVATE
|
||||
#define __P110 PAGE_COPY
|
||||
#define __P111 PAGE_COPY
|
||||
#define __P000 PAGE_NONE
|
||||
#define __P001 PAGE_RO
|
||||
#define __P010 PAGE_RO
|
||||
#define __P011 PAGE_RO
|
||||
#define __P100 PAGE_RO
|
||||
#define __P101 PAGE_RO
|
||||
#define __P110 PAGE_RO
|
||||
#define __P111 PAGE_RO
|
||||
|
||||
#define __S000 PAGE_NONE_SHARED
|
||||
#define __S001 PAGE_RO_SHARED
|
||||
#define __S010 PAGE_SHARED
|
||||
#define __S011 PAGE_SHARED
|
||||
#define __S100 PAGE_RO_SHARED
|
||||
#define __S101 PAGE_RO_SHARED
|
||||
#define __S110 PAGE_SHARED
|
||||
#define __S111 PAGE_SHARED
|
||||
#define __S000 PAGE_NONE
|
||||
#define __S001 PAGE_RO
|
||||
#define __S010 PAGE_RW
|
||||
#define __S011 PAGE_RW
|
||||
#define __S100 PAGE_RO
|
||||
#define __S101 PAGE_RO
|
||||
#define __S110 PAGE_RW
|
||||
#define __S111 PAGE_RW
|
||||
|
||||
/*
|
||||
* Certain architectures need to do special things when PTEs
|
||||
@ -377,18 +365,18 @@ static inline int pmd_bad(pmd_t pmd)
|
||||
|
||||
static inline int pte_none(pte_t pte)
|
||||
{
|
||||
return (pte_val(pte) & _PAGE_INVALID_MASK) == _PAGE_INVALID_EMPTY;
|
||||
return (pte_val(pte) & _PAGE_TYPE_MASK) == _PAGE_TYPE_EMPTY;
|
||||
}
|
||||
|
||||
static inline int pte_present(pte_t pte)
|
||||
{
|
||||
return !(pte_val(pte) & _PAGE_INVALID) ||
|
||||
(pte_val(pte) & _PAGE_INVALID_MASK) == _PAGE_INVALID_NONE;
|
||||
(pte_val(pte) & _PAGE_TYPE_MASK) == _PAGE_TYPE_NONE;
|
||||
}
|
||||
|
||||
static inline int pte_file(pte_t pte)
|
||||
{
|
||||
return (pte_val(pte) & _PAGE_INVALID_MASK) == _PAGE_INVALID_FILE;
|
||||
return (pte_val(pte) & _PAGE_TYPE_MASK) == _PAGE_TYPE_FILE;
|
||||
}
|
||||
|
||||
#define pte_same(a,b) (pte_val(a) == pte_val(b))
|
||||
@ -461,7 +449,7 @@ static inline void pmd_clear(pmd_t * pmdp)
|
||||
|
||||
static inline void pte_clear(struct mm_struct *mm, unsigned long addr, pte_t *ptep)
|
||||
{
|
||||
pte_val(*ptep) = _PAGE_INVALID_EMPTY;
|
||||
pte_val(*ptep) = _PAGE_TYPE_EMPTY;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -477,7 +465,7 @@ static inline pte_t pte_modify(pte_t pte, pgprot_t newprot)
|
||||
|
||||
static inline pte_t pte_wrprotect(pte_t pte)
|
||||
{
|
||||
/* Do not clobber _PAGE_INVALID_NONE pages! */
|
||||
/* Do not clobber _PAGE_TYPE_NONE pages! */
|
||||
if (!(pte_val(pte) & _PAGE_INVALID))
|
||||
pte_val(pte) |= _PAGE_RO;
|
||||
return pte;
|
||||
@ -556,26 +544,30 @@ static inline pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
|
||||
return pte;
|
||||
}
|
||||
|
||||
static inline void __ptep_ipte(unsigned long address, pte_t *ptep)
|
||||
{
|
||||
if (!(pte_val(*ptep) & _PAGE_INVALID)) {
|
||||
#ifndef __s390x__
|
||||
/* S390 has 1mb segments, we are emulating 4MB segments */
|
||||
pte_t *pto = (pte_t *) (((unsigned long) ptep) & 0x7ffffc00);
|
||||
#else
|
||||
/* ipte in zarch mode can do the math */
|
||||
pte_t *pto = ptep;
|
||||
#endif
|
||||
asm volatile ("ipte %2,%3"
|
||||
: "=m" (*ptep) : "m" (*ptep),
|
||||
"a" (pto), "a" (address) );
|
||||
}
|
||||
pte_val(*ptep) = _PAGE_TYPE_EMPTY;
|
||||
}
|
||||
|
||||
static inline pte_t
|
||||
ptep_clear_flush(struct vm_area_struct *vma,
|
||||
unsigned long address, pte_t *ptep)
|
||||
{
|
||||
pte_t pte = *ptep;
|
||||
#ifndef __s390x__
|
||||
if (!(pte_val(pte) & _PAGE_INVALID)) {
|
||||
/* S390 has 1mb segments, we are emulating 4MB segments */
|
||||
pte_t *pto = (pte_t *) (((unsigned long) ptep) & 0x7ffffc00);
|
||||
__asm__ __volatile__ ("ipte %2,%3"
|
||||
: "=m" (*ptep) : "m" (*ptep),
|
||||
"a" (pto), "a" (address) );
|
||||
}
|
||||
#else /* __s390x__ */
|
||||
if (!(pte_val(pte) & _PAGE_INVALID))
|
||||
__asm__ __volatile__ ("ipte %2,%3"
|
||||
: "=m" (*ptep) : "m" (*ptep),
|
||||
"a" (ptep), "a" (address) );
|
||||
#endif /* __s390x__ */
|
||||
pte_val(*ptep) = _PAGE_INVALID_EMPTY;
|
||||
|
||||
__ptep_ipte(address, ptep);
|
||||
return pte;
|
||||
}
|
||||
|
||||
@ -755,7 +747,7 @@ static inline pte_t mk_swap_pte(unsigned long type, unsigned long offset)
|
||||
{
|
||||
pte_t pte;
|
||||
offset &= __SWP_OFFSET_MASK;
|
||||
pte_val(pte) = _PAGE_INVALID_SWAP | ((type & 0x1f) << 2) |
|
||||
pte_val(pte) = _PAGE_TYPE_SWAP | ((type & 0x1f) << 2) |
|
||||
((offset & 1UL) << 7) | ((offset & ~1UL) << 11);
|
||||
return pte;
|
||||
}
|
||||
@ -778,7 +770,7 @@ static inline pte_t mk_swap_pte(unsigned long type, unsigned long offset)
|
||||
|
||||
#define pgoff_to_pte(__off) \
|
||||
((pte_t) { ((((__off) & 0x7f) << 1) + (((__off) >> 7) << 12)) \
|
||||
| _PAGE_INVALID_FILE })
|
||||
| _PAGE_TYPE_FILE })
|
||||
|
||||
#endif /* !__ASSEMBLY__ */
|
||||
|
||||
|
@ -339,4 +339,21 @@ int unregister_idle_notifier(struct notifier_block *nb);
|
||||
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Helper macro for exception table entries
|
||||
*/
|
||||
#ifndef __s390x__
|
||||
#define EX_TABLE(_fault,_target) \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 4\n" \
|
||||
" .long " #_fault "," #_target "\n" \
|
||||
".previous\n"
|
||||
#else
|
||||
#define EX_TABLE(_fault,_target) \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 8\n" \
|
||||
" .quad " #_fault "," #_target "\n" \
|
||||
".previous\n"
|
||||
#endif
|
||||
|
||||
#endif /* __ASM_S390_PROCESSOR_H */
|
||||
|
@ -14,8 +14,6 @@
|
||||
|
||||
#define PARMAREA 0x10400
|
||||
#define COMMAND_LINE_SIZE 896
|
||||
#define RAMDISK_ORIGIN 0x800000
|
||||
#define RAMDISK_SIZE 0x800000
|
||||
#define MEMORY_CHUNKS 16 /* max 0x7fff */
|
||||
#define IPL_PARMBLOCK_ORIGIN 0x2000
|
||||
|
||||
@ -46,10 +44,12 @@ extern unsigned long machine_flags;
|
||||
#define MACHINE_HAS_IEEE (machine_flags & 2)
|
||||
#define MACHINE_HAS_CSP (machine_flags & 8)
|
||||
#define MACHINE_HAS_DIAG44 (1)
|
||||
#define MACHINE_HAS_MVCOS (0)
|
||||
#else /* __s390x__ */
|
||||
#define MACHINE_HAS_IEEE (1)
|
||||
#define MACHINE_HAS_CSP (1)
|
||||
#define MACHINE_HAS_DIAG44 (machine_flags & 32)
|
||||
#define MACHINE_HAS_MVCOS (machine_flags & 512)
|
||||
#endif /* __s390x__ */
|
||||
|
||||
|
||||
@ -70,52 +70,76 @@ extern unsigned int console_irq;
|
||||
#define SET_CONSOLE_3215 do { console_mode = 2; } while (0)
|
||||
#define SET_CONSOLE_3270 do { console_mode = 3; } while (0)
|
||||
|
||||
struct ipl_list_header {
|
||||
u32 length;
|
||||
u8 reserved[3];
|
||||
|
||||
struct ipl_list_hdr {
|
||||
u32 len;
|
||||
u8 reserved1[3];
|
||||
u8 version;
|
||||
u32 blk0_len;
|
||||
u8 pbt;
|
||||
u8 flags;
|
||||
u16 reserved2;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct ipl_block_fcp {
|
||||
u32 length;
|
||||
u8 pbt;
|
||||
u8 reserved1[322-1];
|
||||
u8 reserved1[313-1];
|
||||
u8 opt;
|
||||
u8 reserved2[3];
|
||||
u16 reserved3;
|
||||
u16 devno;
|
||||
u8 reserved2[4];
|
||||
u8 reserved4[4];
|
||||
u64 wwpn;
|
||||
u64 lun;
|
||||
u32 bootprog;
|
||||
u8 reserved3[12];
|
||||
u8 reserved5[12];
|
||||
u64 br_lba;
|
||||
u32 scp_data_len;
|
||||
u8 reserved4[260];
|
||||
u8 reserved6[260];
|
||||
u8 scp_data[];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct ipl_parameter_block {
|
||||
union {
|
||||
u32 length;
|
||||
struct ipl_list_header header;
|
||||
} hdr;
|
||||
struct ipl_block_fcp fcp;
|
||||
struct ipl_block_ccw {
|
||||
u8 load_param[8];
|
||||
u8 reserved1[84];
|
||||
u8 reserved2[2];
|
||||
u16 devno;
|
||||
u8 vm_flags;
|
||||
u8 reserved3[3];
|
||||
u32 vm_parm_len;
|
||||
} __attribute__((packed));
|
||||
|
||||
#define IPL_MAX_SUPPORTED_VERSION (0)
|
||||
struct ipl_parameter_block {
|
||||
struct ipl_list_hdr hdr;
|
||||
union {
|
||||
struct ipl_block_fcp fcp;
|
||||
struct ipl_block_ccw ccw;
|
||||
} ipl_info;
|
||||
} __attribute__((packed));
|
||||
|
||||
#define IPL_TYPE_FCP (0)
|
||||
#define IPL_PARM_BLK_FCP_LEN (sizeof(struct ipl_list_hdr) + \
|
||||
sizeof(struct ipl_block_fcp))
|
||||
|
||||
#define IPL_PARM_BLK_CCW_LEN (sizeof(struct ipl_list_hdr) + \
|
||||
sizeof(struct ipl_block_ccw))
|
||||
|
||||
#define IPL_MAX_SUPPORTED_VERSION (0)
|
||||
|
||||
/*
|
||||
* IPL validity flags and parameters as detected in head.S
|
||||
*/
|
||||
extern u32 ipl_parameter_flags;
|
||||
extern u32 ipl_flags;
|
||||
extern u16 ipl_devno;
|
||||
|
||||
#define IPL_DEVNO_VALID (ipl_parameter_flags & 1)
|
||||
#define IPL_PARMBLOCK_VALID (ipl_parameter_flags & 2)
|
||||
void do_reipl(void);
|
||||
|
||||
enum {
|
||||
IPL_DEVNO_VALID = 1,
|
||||
IPL_PARMBLOCK_VALID = 2,
|
||||
};
|
||||
|
||||
#define IPL_PARMBLOCK_START ((struct ipl_parameter_block *) \
|
||||
IPL_PARMBLOCK_ORIGIN)
|
||||
#define IPL_PARMBLOCK_SIZE (IPL_PARMBLOCK_START->hdr.length)
|
||||
#define IPL_PARMBLOCK_SIZE (IPL_PARMBLOCK_START->hdr.len)
|
||||
|
||||
#else /* __ASSEMBLY__ */
|
||||
|
||||
|
@ -104,7 +104,7 @@ smp_call_function_on(void (*func) (void *info), void *info,
|
||||
#define smp_cpu_not_running(cpu) 1
|
||||
#define smp_get_cpu(cpu) ({ 0; })
|
||||
#define smp_put_cpu(cpu) ({ 0; })
|
||||
#define smp_setup_cpu_possible_map()
|
||||
#define smp_setup_cpu_possible_map() do { } while (0)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -47,7 +47,7 @@
|
||||
S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
|
||||
asm volatile ("lctlg 7,7,%0" : : "m" (__pto) ); \
|
||||
})
|
||||
#else
|
||||
#else /* __s390x__ */
|
||||
#define set_fs(x) \
|
||||
({ \
|
||||
unsigned long __pto; \
|
||||
@ -56,7 +56,7 @@
|
||||
S390_lowcore.user_asce : S390_lowcore.kernel_asce; \
|
||||
asm volatile ("lctl 7,7,%0" : : "m" (__pto) ); \
|
||||
})
|
||||
#endif
|
||||
#endif /* __s390x__ */
|
||||
|
||||
#define segment_eq(a,b) ((a).ar4 == (b).ar4)
|
||||
|
||||
@ -85,76 +85,51 @@ struct exception_table_entry
|
||||
unsigned long insn, fixup;
|
||||
};
|
||||
|
||||
#ifndef __s390x__
|
||||
#define __uaccess_fixup \
|
||||
".section .fixup,\"ax\"\n" \
|
||||
"2: lhi %0,%4\n" \
|
||||
" bras 1,3f\n" \
|
||||
" .long 1b\n" \
|
||||
"3: l 1,0(1)\n" \
|
||||
" br 1\n" \
|
||||
".previous\n" \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 4\n" \
|
||||
" .long 0b,2b\n" \
|
||||
".previous"
|
||||
#define __uaccess_clobber "cc", "1"
|
||||
#else /* __s390x__ */
|
||||
#define __uaccess_fixup \
|
||||
".section .fixup,\"ax\"\n" \
|
||||
"2: lghi %0,%4\n" \
|
||||
" jg 1b\n" \
|
||||
".previous\n" \
|
||||
".section __ex_table,\"a\"\n" \
|
||||
" .align 8\n" \
|
||||
" .quad 0b,2b\n" \
|
||||
".previous"
|
||||
#define __uaccess_clobber "cc"
|
||||
#endif /* __s390x__ */
|
||||
struct uaccess_ops {
|
||||
size_t (*copy_from_user)(size_t, const void __user *, void *);
|
||||
size_t (*copy_from_user_small)(size_t, const void __user *, void *);
|
||||
size_t (*copy_to_user)(size_t, void __user *, const void *);
|
||||
size_t (*copy_to_user_small)(size_t, void __user *, const void *);
|
||||
size_t (*copy_in_user)(size_t, void __user *, const void __user *);
|
||||
size_t (*clear_user)(size_t, void __user *);
|
||||
size_t (*strnlen_user)(size_t, const char __user *);
|
||||
size_t (*strncpy_from_user)(size_t, const char __user *, char *);
|
||||
int (*futex_atomic_op)(int op, int __user *, int oparg, int *old);
|
||||
int (*futex_atomic_cmpxchg)(int __user *, int old, int new);
|
||||
};
|
||||
|
||||
extern struct uaccess_ops uaccess;
|
||||
extern struct uaccess_ops uaccess_std;
|
||||
extern struct uaccess_ops uaccess_mvcos;
|
||||
|
||||
static inline int __put_user_fn(size_t size, void __user *ptr, void *x)
|
||||
{
|
||||
size = uaccess.copy_to_user_small(size, ptr, x);
|
||||
return size ? -EFAULT : size;
|
||||
}
|
||||
|
||||
static inline int __get_user_fn(size_t size, const void __user *ptr, void *x)
|
||||
{
|
||||
size = uaccess.copy_from_user_small(size, ptr, x);
|
||||
return size ? -EFAULT : size;
|
||||
}
|
||||
|
||||
/*
|
||||
* These are the main single-value transfer routines. They automatically
|
||||
* use the right size if we just have the right pointer type.
|
||||
*/
|
||||
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
|
||||
#define __put_user_asm(x, ptr, err) \
|
||||
({ \
|
||||
err = 0; \
|
||||
asm volatile( \
|
||||
"0: mvcs 0(%1,%2),%3,%0\n" \
|
||||
"1:\n" \
|
||||
__uaccess_fixup \
|
||||
: "+&d" (err) \
|
||||
: "d" (sizeof(*(ptr))), "a" (ptr), "Q" (x), \
|
||||
"K" (-EFAULT) \
|
||||
: __uaccess_clobber ); \
|
||||
})
|
||||
#else
|
||||
#define __put_user_asm(x, ptr, err) \
|
||||
({ \
|
||||
err = 0; \
|
||||
asm volatile( \
|
||||
"0: mvcs 0(%1,%2),0(%3),%0\n" \
|
||||
"1:\n" \
|
||||
__uaccess_fixup \
|
||||
: "+&d" (err) \
|
||||
: "d" (sizeof(*(ptr))), "a" (ptr), "a" (&(x)), \
|
||||
"K" (-EFAULT), "m" (x) \
|
||||
: __uaccess_clobber ); \
|
||||
})
|
||||
#endif
|
||||
|
||||
#define __put_user(x, ptr) \
|
||||
({ \
|
||||
__typeof__(*(ptr)) __x = (x); \
|
||||
int __pu_err; \
|
||||
int __pu_err = -EFAULT; \
|
||||
__chk_user_ptr(ptr); \
|
||||
switch (sizeof (*(ptr))) { \
|
||||
case 1: \
|
||||
case 2: \
|
||||
case 4: \
|
||||
case 8: \
|
||||
__put_user_asm(__x, ptr, __pu_err); \
|
||||
__pu_err = __put_user_fn(sizeof (*(ptr)), \
|
||||
ptr, &__x); \
|
||||
break; \
|
||||
default: \
|
||||
__put_user_bad(); \
|
||||
@ -172,60 +147,36 @@ struct exception_table_entry
|
||||
|
||||
extern int __put_user_bad(void) __attribute__((noreturn));
|
||||
|
||||
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 2)
|
||||
#define __get_user_asm(x, ptr, err) \
|
||||
({ \
|
||||
err = 0; \
|
||||
asm volatile ( \
|
||||
"0: mvcp %O1(%2,%R1),0(%3),%0\n" \
|
||||
"1:\n" \
|
||||
__uaccess_fixup \
|
||||
: "+&d" (err), "=Q" (x) \
|
||||
: "d" (sizeof(*(ptr))), "a" (ptr), \
|
||||
"K" (-EFAULT) \
|
||||
: __uaccess_clobber ); \
|
||||
})
|
||||
#else
|
||||
#define __get_user_asm(x, ptr, err) \
|
||||
({ \
|
||||
err = 0; \
|
||||
asm volatile ( \
|
||||
"0: mvcp 0(%2,%5),0(%3),%0\n" \
|
||||
"1:\n" \
|
||||
__uaccess_fixup \
|
||||
: "+&d" (err), "=m" (x) \
|
||||
: "d" (sizeof(*(ptr))), "a" (ptr), \
|
||||
"K" (-EFAULT), "a" (&(x)) \
|
||||
: __uaccess_clobber ); \
|
||||
})
|
||||
#endif
|
||||
|
||||
#define __get_user(x, ptr) \
|
||||
({ \
|
||||
int __gu_err; \
|
||||
__chk_user_ptr(ptr); \
|
||||
int __gu_err = -EFAULT; \
|
||||
__chk_user_ptr(ptr); \
|
||||
switch (sizeof(*(ptr))) { \
|
||||
case 1: { \
|
||||
unsigned char __x; \
|
||||
__get_user_asm(__x, ptr, __gu_err); \
|
||||
__gu_err = __get_user_fn(sizeof (*(ptr)), \
|
||||
ptr, &__x); \
|
||||
(x) = *(__force __typeof__(*(ptr)) *) &__x; \
|
||||
break; \
|
||||
}; \
|
||||
case 2: { \
|
||||
unsigned short __x; \
|
||||
__get_user_asm(__x, ptr, __gu_err); \
|
||||
__gu_err = __get_user_fn(sizeof (*(ptr)), \
|
||||
ptr, &__x); \
|
||||
(x) = *(__force __typeof__(*(ptr)) *) &__x; \
|
||||
break; \
|
||||
}; \
|
||||
case 4: { \
|
||||
unsigned int __x; \
|
||||
__get_user_asm(__x, ptr, __gu_err); \
|
||||
__gu_err = __get_user_fn(sizeof (*(ptr)), \
|
||||
ptr, &__x); \
|
||||
(x) = *(__force __typeof__(*(ptr)) *) &__x; \
|
||||
break; \
|
||||
}; \
|
||||
case 8: { \
|
||||
unsigned long long __x; \
|
||||
__get_user_asm(__x, ptr, __gu_err); \
|
||||
__gu_err = __get_user_fn(sizeof (*(ptr)), \
|
||||
ptr, &__x); \
|
||||
(x) = *(__force __typeof__(*(ptr)) *) &__x; \
|
||||
break; \
|
||||
}; \
|
||||
@ -247,8 +198,6 @@ extern int __get_user_bad(void) __attribute__((noreturn));
|
||||
#define __put_user_unaligned __put_user
|
||||
#define __get_user_unaligned __get_user
|
||||
|
||||
extern long __copy_to_user_asm(const void *from, long n, void __user *to);
|
||||
|
||||
/**
|
||||
* __copy_to_user: - Copy a block of data into user space, with less checking.
|
||||
* @to: Destination address, in user space.
|
||||
@ -266,7 +215,10 @@ extern long __copy_to_user_asm(const void *from, long n, void __user *to);
|
||||
static inline unsigned long
|
||||
__copy_to_user(void __user *to, const void *from, unsigned long n)
|
||||
{
|
||||
return __copy_to_user_asm(from, n, to);
|
||||
if (__builtin_constant_p(n) && (n <= 256))
|
||||
return uaccess.copy_to_user_small(n, to, from);
|
||||
else
|
||||
return uaccess.copy_to_user(n, to, from);
|
||||
}
|
||||
|
||||
#define __copy_to_user_inatomic __copy_to_user
|
||||
@ -294,8 +246,6 @@ copy_to_user(void __user *to, const void *from, unsigned long n)
|
||||
return n;
|
||||
}
|
||||
|
||||
extern long __copy_from_user_asm(void *to, long n, const void __user *from);
|
||||
|
||||
/**
|
||||
* __copy_from_user: - Copy a block of data from user space, with less checking.
|
||||
* @to: Destination address, in kernel space.
|
||||
@ -316,7 +266,10 @@ extern long __copy_from_user_asm(void *to, long n, const void __user *from);
|
||||
static inline unsigned long
|
||||
__copy_from_user(void *to, const void __user *from, unsigned long n)
|
||||
{
|
||||
return __copy_from_user_asm(to, n, from);
|
||||
if (__builtin_constant_p(n) && (n <= 256))
|
||||
return uaccess.copy_from_user_small(n, from, to);
|
||||
else
|
||||
return uaccess.copy_from_user(n, from, to);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -346,13 +299,10 @@ copy_from_user(void *to, const void __user *from, unsigned long n)
|
||||
return n;
|
||||
}
|
||||
|
||||
extern unsigned long __copy_in_user_asm(const void __user *from, long n,
|
||||
void __user *to);
|
||||
|
||||
static inline unsigned long
|
||||
__copy_in_user(void __user *to, const void __user *from, unsigned long n)
|
||||
{
|
||||
return __copy_in_user_asm(from, n, to);
|
||||
return uaccess.copy_in_user(n, to, from);
|
||||
}
|
||||
|
||||
static inline unsigned long
|
||||
@ -360,34 +310,28 @@ copy_in_user(void __user *to, const void __user *from, unsigned long n)
|
||||
{
|
||||
might_sleep();
|
||||
if (__access_ok(from,n) && __access_ok(to,n))
|
||||
n = __copy_in_user_asm(from, n, to);
|
||||
n = __copy_in_user(to, from, n);
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
* Copy a null terminated string from userspace.
|
||||
*/
|
||||
extern long __strncpy_from_user_asm(long count, char *dst,
|
||||
const char __user *src);
|
||||
|
||||
static inline long
|
||||
strncpy_from_user(char *dst, const char __user *src, long count)
|
||||
{
|
||||
long res = -EFAULT;
|
||||
might_sleep();
|
||||
if (access_ok(VERIFY_READ, src, 1))
|
||||
res = __strncpy_from_user_asm(count, dst, src);
|
||||
res = uaccess.strncpy_from_user(count, src, dst);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
extern long __strnlen_user_asm(long count, const char __user *src);
|
||||
|
||||
static inline unsigned long
|
||||
strnlen_user(const char __user * src, unsigned long n)
|
||||
{
|
||||
might_sleep();
|
||||
return __strnlen_user_asm(n, src);
|
||||
return uaccess.strnlen_user(n, src);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -410,12 +354,10 @@ strnlen_user(const char __user * src, unsigned long n)
|
||||
* Zero Userspace
|
||||
*/
|
||||
|
||||
extern long __clear_user_asm(void __user *to, long n);
|
||||
|
||||
static inline unsigned long
|
||||
__clear_user(void __user *to, unsigned long n)
|
||||
{
|
||||
return __clear_user_asm(to, n);
|
||||
return uaccess.clear_user(n, to);
|
||||
}
|
||||
|
||||
static inline unsigned long
|
||||
@ -423,7 +365,7 @@ clear_user(void __user *to, unsigned long n)
|
||||
{
|
||||
might_sleep();
|
||||
if (access_ok(VERIFY_WRITE, to, n))
|
||||
n = __clear_user_asm(to, n);
|
||||
n = uaccess.clear_user(n, to);
|
||||
return n;
|
||||
}
|
||||
|
||||
|
@ -25,17 +25,12 @@
|
||||
#define __NR_unlink 10
|
||||
#define __NR_execve 11
|
||||
#define __NR_chdir 12
|
||||
#define __NR_time 13
|
||||
#define __NR_mknod 14
|
||||
#define __NR_chmod 15
|
||||
#define __NR_lchown 16
|
||||
#define __NR_lseek 19
|
||||
#define __NR_getpid 20
|
||||
#define __NR_mount 21
|
||||
#define __NR_umount 22
|
||||
#define __NR_setuid 23
|
||||
#define __NR_getuid 24
|
||||
#define __NR_stime 25
|
||||
#define __NR_ptrace 26
|
||||
#define __NR_alarm 27
|
||||
#define __NR_pause 29
|
||||
@ -51,11 +46,7 @@
|
||||
#define __NR_pipe 42
|
||||
#define __NR_times 43
|
||||
#define __NR_brk 45
|
||||
#define __NR_setgid 46
|
||||
#define __NR_getgid 47
|
||||
#define __NR_signal 48
|
||||
#define __NR_geteuid 49
|
||||
#define __NR_getegid 50
|
||||
#define __NR_acct 51
|
||||
#define __NR_umount2 52
|
||||
#define __NR_ioctl 54
|
||||
@ -69,18 +60,13 @@
|
||||
#define __NR_getpgrp 65
|
||||
#define __NR_setsid 66
|
||||
#define __NR_sigaction 67
|
||||
#define __NR_setreuid 70
|
||||
#define __NR_setregid 71
|
||||
#define __NR_sigsuspend 72
|
||||
#define __NR_sigpending 73
|
||||
#define __NR_sethostname 74
|
||||
#define __NR_setrlimit 75
|
||||
#define __NR_getrlimit 76
|
||||
#define __NR_getrusage 77
|
||||
#define __NR_gettimeofday 78
|
||||
#define __NR_settimeofday 79
|
||||
#define __NR_getgroups 80
|
||||
#define __NR_setgroups 81
|
||||
#define __NR_symlink 83
|
||||
#define __NR_readlink 85
|
||||
#define __NR_uselib 86
|
||||
@ -92,12 +78,10 @@
|
||||
#define __NR_truncate 92
|
||||
#define __NR_ftruncate 93
|
||||
#define __NR_fchmod 94
|
||||
#define __NR_fchown 95
|
||||
#define __NR_getpriority 96
|
||||
#define __NR_setpriority 97
|
||||
#define __NR_statfs 99
|
||||
#define __NR_fstatfs 100
|
||||
#define __NR_ioperm 101
|
||||
#define __NR_socketcall 102
|
||||
#define __NR_syslog 103
|
||||
#define __NR_setitimer 104
|
||||
@ -131,11 +115,7 @@
|
||||
#define __NR_sysfs 135
|
||||
#define __NR_personality 136
|
||||
#define __NR_afs_syscall 137 /* Syscall for Andrew File System */
|
||||
#define __NR_setfsuid 138
|
||||
#define __NR_setfsgid 139
|
||||
#define __NR__llseek 140
|
||||
#define __NR_getdents 141
|
||||
#define __NR__newselect 142
|
||||
#define __NR_flock 143
|
||||
#define __NR_msync 144
|
||||
#define __NR_readv 145
|
||||
@ -157,13 +137,9 @@
|
||||
#define __NR_sched_rr_get_interval 161
|
||||
#define __NR_nanosleep 162
|
||||
#define __NR_mremap 163
|
||||
#define __NR_setresuid 164
|
||||
#define __NR_getresuid 165
|
||||
#define __NR_query_module 167
|
||||
#define __NR_poll 168
|
||||
#define __NR_nfsservctl 169
|
||||
#define __NR_setresgid 170
|
||||
#define __NR_getresgid 171
|
||||
#define __NR_prctl 172
|
||||
#define __NR_rt_sigreturn 173
|
||||
#define __NR_rt_sigaction 174
|
||||
@ -174,7 +150,6 @@
|
||||
#define __NR_rt_sigsuspend 179
|
||||
#define __NR_pread64 180
|
||||
#define __NR_pwrite64 181
|
||||
#define __NR_chown 182
|
||||
#define __NR_getcwd 183
|
||||
#define __NR_capget 184
|
||||
#define __NR_capset 185
|
||||
@ -183,39 +158,11 @@
|
||||
#define __NR_getpmsg 188
|
||||
#define __NR_putpmsg 189
|
||||
#define __NR_vfork 190
|
||||
#define __NR_ugetrlimit 191 /* SuS compliant getrlimit */
|
||||
#define __NR_mmap2 192
|
||||
#define __NR_truncate64 193
|
||||
#define __NR_ftruncate64 194
|
||||
#define __NR_stat64 195
|
||||
#define __NR_lstat64 196
|
||||
#define __NR_fstat64 197
|
||||
#define __NR_lchown32 198
|
||||
#define __NR_getuid32 199
|
||||
#define __NR_getgid32 200
|
||||
#define __NR_geteuid32 201
|
||||
#define __NR_getegid32 202
|
||||
#define __NR_setreuid32 203
|
||||
#define __NR_setregid32 204
|
||||
#define __NR_getgroups32 205
|
||||
#define __NR_setgroups32 206
|
||||
#define __NR_fchown32 207
|
||||
#define __NR_setresuid32 208
|
||||
#define __NR_getresuid32 209
|
||||
#define __NR_setresgid32 210
|
||||
#define __NR_getresgid32 211
|
||||
#define __NR_chown32 212
|
||||
#define __NR_setuid32 213
|
||||
#define __NR_setgid32 214
|
||||
#define __NR_setfsuid32 215
|
||||
#define __NR_setfsgid32 216
|
||||
#define __NR_pivot_root 217
|
||||
#define __NR_mincore 218
|
||||
#define __NR_madvise 219
|
||||
#define __NR_getdents64 220
|
||||
#define __NR_fcntl64 221
|
||||
#define __NR_readahead 222
|
||||
#define __NR_sendfile64 223
|
||||
#define __NR_setxattr 224
|
||||
#define __NR_lsetxattr 225
|
||||
#define __NR_fsetxattr 226
|
||||
@ -256,7 +203,6 @@
|
||||
#define __NR_clock_getres (__NR_timer_create+7)
|
||||
#define __NR_clock_nanosleep (__NR_timer_create+8)
|
||||
/* Number 263 is reserved for vserver */
|
||||
#define __NR_fadvise64_64 264
|
||||
#define __NR_statfs64 265
|
||||
#define __NR_fstatfs64 266
|
||||
#define __NR_remap_file_pages 267
|
||||
@ -285,7 +231,6 @@
|
||||
#define __NR_mknodat 290
|
||||
#define __NR_fchownat 291
|
||||
#define __NR_futimesat 292
|
||||
#define __NR_fstatat64 293
|
||||
#define __NR_unlinkat 294
|
||||
#define __NR_renameat 295
|
||||
#define __NR_linkat 296
|
||||
@ -310,62 +255,65 @@
|
||||
* have a different name although they do the same (e.g. __NR_chown32
|
||||
* is __NR_chown on 64 bit).
|
||||
*/
|
||||
#ifdef __s390x__
|
||||
#undef __NR_time
|
||||
#undef __NR_lchown
|
||||
#undef __NR_setuid
|
||||
#undef __NR_getuid
|
||||
#undef __NR_stime
|
||||
#undef __NR_setgid
|
||||
#undef __NR_getgid
|
||||
#undef __NR_geteuid
|
||||
#undef __NR_getegid
|
||||
#undef __NR_setreuid
|
||||
#undef __NR_setregid
|
||||
#undef __NR_getrlimit
|
||||
#undef __NR_getgroups
|
||||
#undef __NR_setgroups
|
||||
#undef __NR_fchown
|
||||
#undef __NR_ioperm
|
||||
#undef __NR_setfsuid
|
||||
#undef __NR_setfsgid
|
||||
#undef __NR__llseek
|
||||
#undef __NR__newselect
|
||||
#undef __NR_setresuid
|
||||
#undef __NR_getresuid
|
||||
#undef __NR_setresgid
|
||||
#undef __NR_getresgid
|
||||
#undef __NR_chown
|
||||
#undef __NR_ugetrlimit
|
||||
#undef __NR_mmap2
|
||||
#undef __NR_truncate64
|
||||
#undef __NR_ftruncate64
|
||||
#undef __NR_stat64
|
||||
#undef __NR_lstat64
|
||||
#undef __NR_fstat64
|
||||
#undef __NR_lchown32
|
||||
#undef __NR_getuid32
|
||||
#undef __NR_getgid32
|
||||
#undef __NR_geteuid32
|
||||
#undef __NR_getegid32
|
||||
#undef __NR_setreuid32
|
||||
#undef __NR_setregid32
|
||||
#undef __NR_getgroups32
|
||||
#undef __NR_setgroups32
|
||||
#undef __NR_fchown32
|
||||
#undef __NR_setresuid32
|
||||
#undef __NR_getresuid32
|
||||
#undef __NR_setresgid32
|
||||
#undef __NR_getresgid32
|
||||
#undef __NR_chown32
|
||||
#undef __NR_setuid32
|
||||
#undef __NR_setgid32
|
||||
#undef __NR_setfsuid32
|
||||
#undef __NR_setfsgid32
|
||||
#undef __NR_fcntl64
|
||||
#undef __NR_sendfile64
|
||||
#undef __NR_fadvise64_64
|
||||
#undef __NR_fstatat64
|
||||
#ifndef __s390x__
|
||||
|
||||
#define __NR_time 13
|
||||
#define __NR_lchown 16
|
||||
#define __NR_setuid 23
|
||||
#define __NR_getuid 24
|
||||
#define __NR_stime 25
|
||||
#define __NR_setgid 46
|
||||
#define __NR_getgid 47
|
||||
#define __NR_geteuid 49
|
||||
#define __NR_getegid 50
|
||||
#define __NR_setreuid 70
|
||||
#define __NR_setregid 71
|
||||
#define __NR_getrlimit 76
|
||||
#define __NR_getgroups 80
|
||||
#define __NR_setgroups 81
|
||||
#define __NR_fchown 95
|
||||
#define __NR_ioperm 101
|
||||
#define __NR_setfsuid 138
|
||||
#define __NR_setfsgid 139
|
||||
#define __NR__llseek 140
|
||||
#define __NR__newselect 142
|
||||
#define __NR_setresuid 164
|
||||
#define __NR_getresuid 165
|
||||
#define __NR_setresgid 170
|
||||
#define __NR_getresgid 171
|
||||
#define __NR_chown 182
|
||||
#define __NR_ugetrlimit 191 /* SuS compliant getrlimit */
|
||||
#define __NR_mmap2 192
|
||||
#define __NR_truncate64 193
|
||||
#define __NR_ftruncate64 194
|
||||
#define __NR_stat64 195
|
||||
#define __NR_lstat64 196
|
||||
#define __NR_fstat64 197
|
||||
#define __NR_lchown32 198
|
||||
#define __NR_getuid32 199
|
||||
#define __NR_getgid32 200
|
||||
#define __NR_geteuid32 201
|
||||
#define __NR_getegid32 202
|
||||
#define __NR_setreuid32 203
|
||||
#define __NR_setregid32 204
|
||||
#define __NR_getgroups32 205
|
||||
#define __NR_setgroups32 206
|
||||
#define __NR_fchown32 207
|
||||
#define __NR_setresuid32 208
|
||||
#define __NR_getresuid32 209
|
||||
#define __NR_setresgid32 210
|
||||
#define __NR_getresgid32 211
|
||||
#define __NR_chown32 212
|
||||
#define __NR_setuid32 213
|
||||
#define __NR_setgid32 214
|
||||
#define __NR_setfsuid32 215
|
||||
#define __NR_setfsgid32 216
|
||||
#define __NR_fcntl64 221
|
||||
#define __NR_sendfile64 223
|
||||
#define __NR_fadvise64_64 264
|
||||
#define __NR_fstatat64 293
|
||||
|
||||
#else
|
||||
|
||||
#define __NR_select 142
|
||||
#define __NR_getrlimit 191 /* SuS compliant getrlimit */
|
||||
|
@ -1,212 +0,0 @@
|
||||
/*
|
||||
* include/asm-s390/z90crypt.h
|
||||
*
|
||||
* z90crypt 1.3.3 (user-visible header)
|
||||
*
|
||||
* Copyright (C) 2001, 2005 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef __ASM_S390_Z90CRYPT_H
|
||||
#define __ASM_S390_Z90CRYPT_H
|
||||
#include <linux/ioctl.h>
|
||||
|
||||
#define z90crypt_VERSION 1
|
||||
#define z90crypt_RELEASE 3 // 2 = PCIXCC, 3 = rewrite for coding standards
|
||||
#define z90crypt_VARIANT 3 // 3 = CEX2A support
|
||||
|
||||
/**
|
||||
* struct ica_rsa_modexpo
|
||||
*
|
||||
* Requirements:
|
||||
* - outputdatalength is at least as large as inputdatalength.
|
||||
* - All key parts are right justified in their fields, padded on
|
||||
* the left with zeroes.
|
||||
* - length(b_key) = inputdatalength
|
||||
* - length(n_modulus) = inputdatalength
|
||||
*/
|
||||
struct ica_rsa_modexpo {
|
||||
char __user * inputdata;
|
||||
unsigned int inputdatalength;
|
||||
char __user * outputdata;
|
||||
unsigned int outputdatalength;
|
||||
char __user * b_key;
|
||||
char __user * n_modulus;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ica_rsa_modexpo_crt
|
||||
*
|
||||
* Requirements:
|
||||
* - inputdatalength is even.
|
||||
* - outputdatalength is at least as large as inputdatalength.
|
||||
* - All key parts are right justified in their fields, padded on
|
||||
* the left with zeroes.
|
||||
* - length(bp_key) = inputdatalength/2 + 8
|
||||
* - length(bq_key) = inputdatalength/2
|
||||
* - length(np_key) = inputdatalength/2 + 8
|
||||
* - length(nq_key) = inputdatalength/2
|
||||
* - length(u_mult_inv) = inputdatalength/2 + 8
|
||||
*/
|
||||
struct ica_rsa_modexpo_crt {
|
||||
char __user * inputdata;
|
||||
unsigned int inputdatalength;
|
||||
char __user * outputdata;
|
||||
unsigned int outputdatalength;
|
||||
char __user * bp_key;
|
||||
char __user * bq_key;
|
||||
char __user * np_prime;
|
||||
char __user * nq_prime;
|
||||
char __user * u_mult_inv;
|
||||
};
|
||||
|
||||
#define Z90_IOCTL_MAGIC 'z' // NOTE: Need to allocate from linux folks
|
||||
|
||||
/**
|
||||
* Interface notes:
|
||||
*
|
||||
* The ioctl()s which are implemented (along with relevant details)
|
||||
* are:
|
||||
*
|
||||
* ICARSAMODEXPO
|
||||
* Perform an RSA operation using a Modulus-Exponent pair
|
||||
* This takes an ica_rsa_modexpo struct as its arg.
|
||||
*
|
||||
* NOTE: please refer to the comments preceding this structure
|
||||
* for the implementation details for the contents of the
|
||||
* block
|
||||
*
|
||||
* ICARSACRT
|
||||
* Perform an RSA operation using a Chinese-Remainder Theorem key
|
||||
* This takes an ica_rsa_modexpo_crt struct as its arg.
|
||||
*
|
||||
* NOTE: please refer to the comments preceding this structure
|
||||
* for the implementation details for the contents of the
|
||||
* block
|
||||
*
|
||||
* Z90STAT_TOTALCOUNT
|
||||
* Return an integer count of all device types together.
|
||||
*
|
||||
* Z90STAT_PCICACOUNT
|
||||
* Return an integer count of all PCICAs.
|
||||
*
|
||||
* Z90STAT_PCICCCOUNT
|
||||
* Return an integer count of all PCICCs.
|
||||
*
|
||||
* Z90STAT_PCIXCCMCL2COUNT
|
||||
* Return an integer count of all MCL2 PCIXCCs.
|
||||
*
|
||||
* Z90STAT_PCIXCCMCL3COUNT
|
||||
* Return an integer count of all MCL3 PCIXCCs.
|
||||
*
|
||||
* Z90STAT_CEX2CCOUNT
|
||||
* Return an integer count of all CEX2Cs.
|
||||
*
|
||||
* Z90STAT_CEX2ACOUNT
|
||||
* Return an integer count of all CEX2As.
|
||||
*
|
||||
* Z90STAT_REQUESTQ_COUNT
|
||||
* Return an integer count of the number of entries waiting to be
|
||||
* sent to a device.
|
||||
*
|
||||
* Z90STAT_PENDINGQ_COUNT
|
||||
* Return an integer count of the number of entries sent to a
|
||||
* device awaiting the reply.
|
||||
*
|
||||
* Z90STAT_TOTALOPEN_COUNT
|
||||
* Return an integer count of the number of open file handles.
|
||||
*
|
||||
* Z90STAT_DOMAIN_INDEX
|
||||
* Return the integer value of the Cryptographic Domain.
|
||||
*
|
||||
* Z90STAT_STATUS_MASK
|
||||
* Return an 64 element array of unsigned chars for the status of
|
||||
* all devices.
|
||||
* 0x01: PCICA
|
||||
* 0x02: PCICC
|
||||
* 0x03: PCIXCC_MCL2
|
||||
* 0x04: PCIXCC_MCL3
|
||||
* 0x05: CEX2C
|
||||
* 0x06: CEX2A
|
||||
* 0x0d: device is disabled via the proc filesystem
|
||||
*
|
||||
* Z90STAT_QDEPTH_MASK
|
||||
* Return an 64 element array of unsigned chars for the queue
|
||||
* depth of all devices.
|
||||
*
|
||||
* Z90STAT_PERDEV_REQCNT
|
||||
* Return an 64 element array of unsigned integers for the number
|
||||
* of successfully completed requests per device since the device
|
||||
* was detected and made available.
|
||||
*
|
||||
* ICAZ90STATUS (deprecated)
|
||||
* Return some device driver status in a ica_z90_status struct
|
||||
* This takes an ica_z90_status struct as its arg.
|
||||
*
|
||||
* NOTE: this ioctl() is deprecated, and has been replaced with
|
||||
* single ioctl()s for each type of status being requested
|
||||
*
|
||||
* Z90STAT_PCIXCCCOUNT (deprecated)
|
||||
* Return an integer count of all PCIXCCs (MCL2 + MCL3).
|
||||
* This is DEPRECATED now that MCL3 PCIXCCs are treated differently from
|
||||
* MCL2 PCIXCCs.
|
||||
*
|
||||
* Z90QUIESCE (not recommended)
|
||||
* Quiesce the driver. This is intended to stop all new
|
||||
* requests from being processed. Its use is NOT recommended,
|
||||
* except in circumstances where there is no other way to stop
|
||||
* callers from accessing the driver. Its original use was to
|
||||
* allow the driver to be "drained" of work in preparation for
|
||||
* a system shutdown.
|
||||
*
|
||||
* NOTE: once issued, this ban on new work cannot be undone
|
||||
* except by unloading and reloading the driver.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Supported ioctl calls
|
||||
*/
|
||||
#define ICARSAMODEXPO _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x05, 0)
|
||||
#define ICARSACRT _IOC(_IOC_READ|_IOC_WRITE, Z90_IOCTL_MAGIC, 0x06, 0)
|
||||
|
||||
/* DEPRECATED status calls (bound for removal at some point) */
|
||||
#define ICAZ90STATUS _IOR(Z90_IOCTL_MAGIC, 0x10, struct ica_z90_status)
|
||||
#define Z90STAT_PCIXCCCOUNT _IOR(Z90_IOCTL_MAGIC, 0x43, int)
|
||||
|
||||
/* unrelated to ICA callers */
|
||||
#define Z90QUIESCE _IO(Z90_IOCTL_MAGIC, 0x11)
|
||||
|
||||
/* New status calls */
|
||||
#define Z90STAT_TOTALCOUNT _IOR(Z90_IOCTL_MAGIC, 0x40, int)
|
||||
#define Z90STAT_PCICACOUNT _IOR(Z90_IOCTL_MAGIC, 0x41, int)
|
||||
#define Z90STAT_PCICCCOUNT _IOR(Z90_IOCTL_MAGIC, 0x42, int)
|
||||
#define Z90STAT_PCIXCCMCL2COUNT _IOR(Z90_IOCTL_MAGIC, 0x4b, int)
|
||||
#define Z90STAT_PCIXCCMCL3COUNT _IOR(Z90_IOCTL_MAGIC, 0x4c, int)
|
||||
#define Z90STAT_CEX2CCOUNT _IOR(Z90_IOCTL_MAGIC, 0x4d, int)
|
||||
#define Z90STAT_CEX2ACOUNT _IOR(Z90_IOCTL_MAGIC, 0x4e, int)
|
||||
#define Z90STAT_REQUESTQ_COUNT _IOR(Z90_IOCTL_MAGIC, 0x44, int)
|
||||
#define Z90STAT_PENDINGQ_COUNT _IOR(Z90_IOCTL_MAGIC, 0x45, int)
|
||||
#define Z90STAT_TOTALOPEN_COUNT _IOR(Z90_IOCTL_MAGIC, 0x46, int)
|
||||
#define Z90STAT_DOMAIN_INDEX _IOR(Z90_IOCTL_MAGIC, 0x47, int)
|
||||
#define Z90STAT_STATUS_MASK _IOR(Z90_IOCTL_MAGIC, 0x48, char[64])
|
||||
#define Z90STAT_QDEPTH_MASK _IOR(Z90_IOCTL_MAGIC, 0x49, char[64])
|
||||
#define Z90STAT_PERDEV_REQCNT _IOR(Z90_IOCTL_MAGIC, 0x4a, int[64])
|
||||
|
||||
#endif /* __ASM_S390_Z90CRYPT_H */
|
285
include/asm-s390/zcrypt.h
Normal file
285
include/asm-s390/zcrypt.h
Normal file
@ -0,0 +1,285 @@
|
||||
/*
|
||||
* include/asm-s390/zcrypt.h
|
||||
*
|
||||
* zcrypt 2.1.0 (user-visible header)
|
||||
*
|
||||
* Copyright (C) 2001, 2006 IBM Corporation
|
||||
* Author(s): Robert Burroughs
|
||||
* Eric Rossman (edrossma@us.ibm.com)
|
||||
*
|
||||
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
*/
|
||||
|
||||
#ifndef __ASM_S390_ZCRYPT_H
|
||||
#define __ASM_S390_ZCRYPT_H
|
||||
|
||||
#define ZCRYPT_VERSION 2
|
||||
#define ZCRYPT_RELEASE 1
|
||||
#define ZCRYPT_VARIANT 0
|
||||
|
||||
#include <linux/ioctl.h>
|
||||
#include <linux/compiler.h>
|
||||
|
||||
/**
|
||||
* struct ica_rsa_modexpo
|
||||
*
|
||||
* Requirements:
|
||||
* - outputdatalength is at least as large as inputdatalength.
|
||||
* - All key parts are right justified in their fields, padded on
|
||||
* the left with zeroes.
|
||||
* - length(b_key) = inputdatalength
|
||||
* - length(n_modulus) = inputdatalength
|
||||
*/
|
||||
struct ica_rsa_modexpo {
|
||||
char __user * inputdata;
|
||||
unsigned int inputdatalength;
|
||||
char __user * outputdata;
|
||||
unsigned int outputdatalength;
|
||||
char __user * b_key;
|
||||
char __user * n_modulus;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ica_rsa_modexpo_crt
|
||||
*
|
||||
* Requirements:
|
||||
* - inputdatalength is even.
|
||||
* - outputdatalength is at least as large as inputdatalength.
|
||||
* - All key parts are right justified in their fields, padded on
|
||||
* the left with zeroes.
|
||||
* - length(bp_key) = inputdatalength/2 + 8
|
||||
* - length(bq_key) = inputdatalength/2
|
||||
* - length(np_key) = inputdatalength/2 + 8
|
||||
* - length(nq_key) = inputdatalength/2
|
||||
* - length(u_mult_inv) = inputdatalength/2 + 8
|
||||
*/
|
||||
struct ica_rsa_modexpo_crt {
|
||||
char __user * inputdata;
|
||||
unsigned int inputdatalength;
|
||||
char __user * outputdata;
|
||||
unsigned int outputdatalength;
|
||||
char __user * bp_key;
|
||||
char __user * bq_key;
|
||||
char __user * np_prime;
|
||||
char __user * nq_prime;
|
||||
char __user * u_mult_inv;
|
||||
};
|
||||
|
||||
/**
|
||||
* CPRBX
|
||||
* Note that all shorts and ints are big-endian.
|
||||
* All pointer fields are 16 bytes long, and mean nothing.
|
||||
*
|
||||
* A request CPRB is followed by a request_parameter_block.
|
||||
*
|
||||
* The request (or reply) parameter block is organized thus:
|
||||
* function code
|
||||
* VUD block
|
||||
* key block
|
||||
*/
|
||||
struct ica_CPRBX {
|
||||
unsigned short cprb_len; /* CPRB length 220 */
|
||||
unsigned char cprb_ver_id; /* CPRB version id. 0x02 */
|
||||
unsigned char pad_000[3]; /* Alignment pad bytes */
|
||||
unsigned char func_id[2]; /* function id 0x5432 */
|
||||
unsigned char cprb_flags[4]; /* Flags */
|
||||
unsigned int req_parml; /* request parameter buffer len */
|
||||
unsigned int req_datal; /* request data buffer */
|
||||
unsigned int rpl_msgbl; /* reply message block length */
|
||||
unsigned int rpld_parml; /* replied parameter block len */
|
||||
unsigned int rpl_datal; /* reply data block len */
|
||||
unsigned int rpld_datal; /* replied data block len */
|
||||
unsigned int req_extbl; /* request extension block len */
|
||||
unsigned char pad_001[4]; /* reserved */
|
||||
unsigned int rpld_extbl; /* replied extension block len */
|
||||
unsigned char padx000[16 - sizeof (char *)];
|
||||
unsigned char * req_parmb; /* request parm block 'address' */
|
||||
unsigned char padx001[16 - sizeof (char *)];
|
||||
unsigned char * req_datab; /* request data block 'address' */
|
||||
unsigned char padx002[16 - sizeof (char *)];
|
||||
unsigned char * rpl_parmb; /* reply parm block 'address' */
|
||||
unsigned char padx003[16 - sizeof (char *)];
|
||||
unsigned char * rpl_datab; /* reply data block 'address' */
|
||||
unsigned char padx004[16 - sizeof (char *)];
|
||||
unsigned char * req_extb; /* request extension block 'addr'*/
|
||||
unsigned char padx005[16 - sizeof (char *)];
|
||||
unsigned char * rpl_extb; /* reply extension block 'addres'*/
|
||||
unsigned short ccp_rtcode; /* server return code */
|
||||
unsigned short ccp_rscode; /* server reason code */
|
||||
unsigned int mac_data_len; /* Mac Data Length */
|
||||
unsigned char logon_id[8]; /* Logon Identifier */
|
||||
unsigned char mac_value[8]; /* Mac Value */
|
||||
unsigned char mac_content_flgs;/* Mac content flag byte */
|
||||
unsigned char pad_002; /* Alignment */
|
||||
unsigned short domain; /* Domain */
|
||||
unsigned char usage_domain[4];/* Usage domain */
|
||||
unsigned char cntrl_domain[4];/* Control domain */
|
||||
unsigned char S390enf_mask[4];/* S/390 enforcement mask */
|
||||
unsigned char pad_004[36]; /* reserved */
|
||||
};
|
||||
|
||||
/**
|
||||
* xcRB
|
||||
*/
|
||||
struct ica_xcRB {
|
||||
unsigned short agent_ID;
|
||||
unsigned int user_defined;
|
||||
unsigned short request_ID;
|
||||
unsigned int request_control_blk_length;
|
||||
unsigned char padding1[16 - sizeof (char *)];
|
||||
char __user * request_control_blk_addr;
|
||||
unsigned int request_data_length;
|
||||
char padding2[16 - sizeof (char *)];
|
||||
char __user * request_data_address;
|
||||
unsigned int reply_control_blk_length;
|
||||
char padding3[16 - sizeof (char *)];
|
||||
char __user * reply_control_blk_addr;
|
||||
unsigned int reply_data_length;
|
||||
char padding4[16 - sizeof (char *)];
|
||||
char __user * reply_data_addr;
|
||||
unsigned short priority_window;
|
||||
unsigned int status;
|
||||
} __attribute__((packed));
|
||||
#define AUTOSELECT ((unsigned int)0xFFFFFFFF)
|
||||
|
||||
#define ZCRYPT_IOCTL_MAGIC 'z'
|
||||
|
||||
/**
|
||||
* Interface notes:
|
||||
*
|
||||
* The ioctl()s which are implemented (along with relevant details)
|
||||
* are:
|
||||
*
|
||||
* ICARSAMODEXPO
|
||||
* Perform an RSA operation using a Modulus-Exponent pair
|
||||
* This takes an ica_rsa_modexpo struct as its arg.
|
||||
*
|
||||
* NOTE: please refer to the comments preceding this structure
|
||||
* for the implementation details for the contents of the
|
||||
* block
|
||||
*
|
||||
* ICARSACRT
|
||||
* Perform an RSA operation using a Chinese-Remainder Theorem key
|
||||
* This takes an ica_rsa_modexpo_crt struct as its arg.
|
||||
*
|
||||
* NOTE: please refer to the comments preceding this structure
|
||||
* for the implementation details for the contents of the
|
||||
* block
|
||||
*
|
||||
* Z90STAT_TOTALCOUNT
|
||||
* Return an integer count of all device types together.
|
||||
*
|
||||
* Z90STAT_PCICACOUNT
|
||||
* Return an integer count of all PCICAs.
|
||||
*
|
||||
* Z90STAT_PCICCCOUNT
|
||||
* Return an integer count of all PCICCs.
|
||||
*
|
||||
* Z90STAT_PCIXCCMCL2COUNT
|
||||
* Return an integer count of all MCL2 PCIXCCs.
|
||||
*
|
||||
* Z90STAT_PCIXCCMCL3COUNT
|
||||
* Return an integer count of all MCL3 PCIXCCs.
|
||||
*
|
||||
* Z90STAT_CEX2CCOUNT
|
||||
* Return an integer count of all CEX2Cs.
|
||||
*
|
||||
* Z90STAT_CEX2ACOUNT
|
||||
* Return an integer count of all CEX2As.
|
||||
*
|
||||
* Z90STAT_REQUESTQ_COUNT
|
||||
* Return an integer count of the number of entries waiting to be
|
||||
* sent to a device.
|
||||
*
|
||||
* Z90STAT_PENDINGQ_COUNT
|
||||
* Return an integer count of the number of entries sent to a
|
||||
* device awaiting the reply.
|
||||
*
|
||||
* Z90STAT_TOTALOPEN_COUNT
|
||||
* Return an integer count of the number of open file handles.
|
||||
*
|
||||
* Z90STAT_DOMAIN_INDEX
|
||||
* Return the integer value of the Cryptographic Domain.
|
||||
*
|
||||
* Z90STAT_STATUS_MASK
|
||||
* Return an 64 element array of unsigned chars for the status of
|
||||
* all devices.
|
||||
* 0x01: PCICA
|
||||
* 0x02: PCICC
|
||||
* 0x03: PCIXCC_MCL2
|
||||
* 0x04: PCIXCC_MCL3
|
||||
* 0x05: CEX2C
|
||||
* 0x06: CEX2A
|
||||
* 0x0d: device is disabled via the proc filesystem
|
||||
*
|
||||
* Z90STAT_QDEPTH_MASK
|
||||
* Return an 64 element array of unsigned chars for the queue
|
||||
* depth of all devices.
|
||||
*
|
||||
* Z90STAT_PERDEV_REQCNT
|
||||
* Return an 64 element array of unsigned integers for the number
|
||||
* of successfully completed requests per device since the device
|
||||
* was detected and made available.
|
||||
*
|
||||
* ICAZ90STATUS (deprecated)
|
||||
* Return some device driver status in a ica_z90_status struct
|
||||
* This takes an ica_z90_status struct as its arg.
|
||||
*
|
||||
* NOTE: this ioctl() is deprecated, and has been replaced with
|
||||
* single ioctl()s for each type of status being requested
|
||||
*
|
||||
* Z90STAT_PCIXCCCOUNT (deprecated)
|
||||
* Return an integer count of all PCIXCCs (MCL2 + MCL3).
|
||||
* This is DEPRECATED now that MCL3 PCIXCCs are treated differently from
|
||||
* MCL2 PCIXCCs.
|
||||
*
|
||||
* Z90QUIESCE (not recommended)
|
||||
* Quiesce the driver. This is intended to stop all new
|
||||
* requests from being processed. Its use is NOT recommended,
|
||||
* except in circumstances where there is no other way to stop
|
||||
* callers from accessing the driver. Its original use was to
|
||||
* allow the driver to be "drained" of work in preparation for
|
||||
* a system shutdown.
|
||||
*
|
||||
* NOTE: once issued, this ban on new work cannot be undone
|
||||
* except by unloading and reloading the driver.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Supported ioctl calls
|
||||
*/
|
||||
#define ICARSAMODEXPO _IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x05, 0)
|
||||
#define ICARSACRT _IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x06, 0)
|
||||
#define ZSECSENDCPRB _IOC(_IOC_READ|_IOC_WRITE, ZCRYPT_IOCTL_MAGIC, 0x81, 0)
|
||||
|
||||
/* New status calls */
|
||||
#define Z90STAT_TOTALCOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x40, int)
|
||||
#define Z90STAT_PCICACOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x41, int)
|
||||
#define Z90STAT_PCICCCOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x42, int)
|
||||
#define Z90STAT_PCIXCCMCL2COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4b, int)
|
||||
#define Z90STAT_PCIXCCMCL3COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4c, int)
|
||||
#define Z90STAT_CEX2CCOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4d, int)
|
||||
#define Z90STAT_CEX2ACOUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4e, int)
|
||||
#define Z90STAT_REQUESTQ_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x44, int)
|
||||
#define Z90STAT_PENDINGQ_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x45, int)
|
||||
#define Z90STAT_TOTALOPEN_COUNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x46, int)
|
||||
#define Z90STAT_DOMAIN_INDEX _IOR(ZCRYPT_IOCTL_MAGIC, 0x47, int)
|
||||
#define Z90STAT_STATUS_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x48, char[64])
|
||||
#define Z90STAT_QDEPTH_MASK _IOR(ZCRYPT_IOCTL_MAGIC, 0x49, char[64])
|
||||
#define Z90STAT_PERDEV_REQCNT _IOR(ZCRYPT_IOCTL_MAGIC, 0x4a, int[64])
|
||||
|
||||
#endif /* __ASM_S390_ZCRYPT_H */
|
@ -148,6 +148,17 @@ struct ccw_device_id {
|
||||
#define CCW_DEVICE_ID_MATCH_DEVICE_TYPE 0x04
|
||||
#define CCW_DEVICE_ID_MATCH_DEVICE_MODEL 0x08
|
||||
|
||||
/* s390 AP bus devices */
|
||||
struct ap_device_id {
|
||||
__u16 match_flags; /* which fields to match against */
|
||||
__u8 dev_type; /* device type */
|
||||
__u8 pad1;
|
||||
__u32 pad2;
|
||||
kernel_ulong_t driver_info;
|
||||
};
|
||||
|
||||
#define AP_DEVICE_ID_MATCH_DEVICE_TYPE 0x01
|
||||
|
||||
|
||||
#define PNP_ID_LEN 8
|
||||
#define PNP_MAX_DEVICES 8
|
||||
|
@ -265,6 +265,14 @@ static int do_ccw_entry(const char *filename,
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* looks like: "ap:tN" */
|
||||
static int do_ap_entry(const char *filename,
|
||||
struct ap_device_id *id, char *alias)
|
||||
{
|
||||
sprintf(alias, "ap:t%02X", id->dev_type);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Looks like: "serio:tyNprNidNexN" */
|
||||
static int do_serio_entry(const char *filename,
|
||||
struct serio_device_id *id, char *alias)
|
||||
@ -503,6 +511,10 @@ void handle_moddevtable(struct module *mod, struct elf_info *info,
|
||||
do_table(symval, sym->st_size,
|
||||
sizeof(struct ccw_device_id), "ccw",
|
||||
do_ccw_entry, mod);
|
||||
else if (sym_is(symname, "__mod_ap_device_table"))
|
||||
do_table(symval, sym->st_size,
|
||||
sizeof(struct ap_device_id), "ap",
|
||||
do_ap_entry, mod);
|
||||
else if (sym_is(symname, "__mod_serio_device_table"))
|
||||
do_table(symval, sym->st_size,
|
||||
sizeof(struct serio_device_id), "serio",
|
||||
|
Loading…
Reference in New Issue
Block a user