1 /* 2 * Copyright IBM Corp. 2012 3 * Author(s): Jan Glauber <jang@linux.vnet.ibm.com> 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/syscalls.h> 8 #include <linux/signal.h> 9 #include <linux/mm.h> 10 #include <linux/slab.h> 11 #include <linux/init.h> 12 #include <linux/errno.h> 13 #include <linux/kernel_stat.h> 14 #include <asm/runtime_instr.h> 15 #include <asm/cpu_mf.h> 16 #include <asm/irq.h> 17 18 /* empty control block to disable RI by loading it */ 19 struct runtime_instr_cb runtime_instr_empty_cb; 20 21 static int runtime_instr_avail(void) 22 { 23 return test_facility(64); 24 } 25 26 static void disable_runtime_instr(void) 27 { 28 struct pt_regs *regs = task_pt_regs(current); 29 30 load_runtime_instr_cb(&runtime_instr_empty_cb); 31 32 /* 33 * Make sure the RI bit is deleted from the PSW. If the user did not 34 * switch off RI before the system call the process will get a 35 * specification exception otherwise. 36 */ 37 regs->psw.mask &= ~PSW_MASK_RI; 38 } 39 40 static void init_runtime_instr_cb(struct runtime_instr_cb *cb) 41 { 42 cb->buf_limit = 0xfff; 43 if (s390_user_mode == HOME_SPACE_MODE) 44 cb->home_space = 1; 45 cb->int_requested = 1; 46 cb->pstate = 1; 47 cb->pstate_set_buf = 1; 48 cb->pstate_sample = 1; 49 cb->pstate_collect = 1; 50 cb->key = PAGE_DEFAULT_KEY; 51 cb->valid = 1; 52 } 53 54 void exit_thread_runtime_instr(void) 55 { 56 struct task_struct *task = current; 57 58 if (!task->thread.ri_cb) 59 return; 60 disable_runtime_instr(); 61 kfree(task->thread.ri_cb); 62 task->thread.ri_signum = 0; 63 task->thread.ri_cb = NULL; 64 } 65 66 static void runtime_instr_int_handler(struct ext_code ext_code, 67 unsigned int param32, unsigned long param64) 68 { 69 struct siginfo info; 70 71 if (!(param32 & CPU_MF_INT_RI_MASK)) 72 return; 73 74 inc_irq_stat(IRQEXT_CMR); 75 76 if (!current->thread.ri_cb) 77 return; 78 if (current->thread.ri_signum < SIGRTMIN || 79 current->thread.ri_signum > SIGRTMAX) { 80 WARN_ON_ONCE(1); 81 return; 82 } 83 84 memset(&info, 0, sizeof(info)); 85 info.si_signo = current->thread.ri_signum; 86 info.si_code = SI_QUEUE; 87 if (param32 & CPU_MF_INT_RI_BUF_FULL) 88 info.si_int = ENOBUFS; 89 else if (param32 & CPU_MF_INT_RI_HALTED) 90 info.si_int = ECANCELED; 91 else 92 return; /* unknown reason */ 93 94 send_sig_info(current->thread.ri_signum, &info, current); 95 } 96 97 SYSCALL_DEFINE2(s390_runtime_instr, int, command, int, signum) 98 { 99 struct runtime_instr_cb *cb; 100 101 if (!runtime_instr_avail()) 102 return -EOPNOTSUPP; 103 104 if (command == S390_RUNTIME_INSTR_STOP) { 105 preempt_disable(); 106 exit_thread_runtime_instr(); 107 preempt_enable(); 108 return 0; 109 } 110 111 if (command != S390_RUNTIME_INSTR_START || 112 (signum < SIGRTMIN || signum > SIGRTMAX)) 113 return -EINVAL; 114 115 if (!current->thread.ri_cb) { 116 cb = kzalloc(sizeof(*cb), GFP_KERNEL); 117 if (!cb) 118 return -ENOMEM; 119 } else { 120 cb = current->thread.ri_cb; 121 memset(cb, 0, sizeof(*cb)); 122 } 123 124 init_runtime_instr_cb(cb); 125 current->thread.ri_signum = signum; 126 127 /* now load the control block to make it available */ 128 preempt_disable(); 129 current->thread.ri_cb = cb; 130 load_runtime_instr_cb(cb); 131 preempt_enable(); 132 return 0; 133 } 134 135 static int __init runtime_instr_init(void) 136 { 137 int rc; 138 139 if (!runtime_instr_avail()) 140 return 0; 141 142 irq_subclass_register(IRQ_SUBCLASS_MEASUREMENT_ALERT); 143 rc = register_external_interrupt(0x1407, runtime_instr_int_handler); 144 if (rc) 145 irq_subclass_unregister(IRQ_SUBCLASS_MEASUREMENT_ALERT); 146 else 147 pr_info("Runtime instrumentation facility initialized\n"); 148 return rc; 149 } 150 device_initcall(runtime_instr_init); 151