arch/s390/kernel/runtime_instr.c

   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         measurement_alert_subclass_register();
 143         rc = register_external_interrupt(0x1407, runtime_instr_int_handler);
 144         if (rc)
 145                 measurement_alert_subclass_unregister();
 146         else
 147                 pr_info("Runtime instrumentation facility initialized\n");
 148         return rc;
 149 }
 150 device_initcall(runtime_instr_init);