arch/ia64/kernel/crash.c

   1 /*
   2  * arch/ia64/kernel/crash.c
   3  *
   4  * Architecture specific (ia64) functions for kexec based crash dumps.
   5  *
   6  * Created by: Khalid Aziz <khalid.aziz@hp.com>
   7  * Copyright (C) 2005 Hewlett-Packard Development Company, L.P.
   8  * Copyright (C) 2005 Intel Corp        Zou Nan hai <nanhai.zou@intel.com>
   9  *
  10  */
  11 #include <linux/smp.h>
  12 #include <linux/delay.h>
  13 #include <linux/crash_dump.h>
  14 #include <linux/bootmem.h>
  15 #include <linux/kexec.h>
  16 #include <linux/elfcore.h>
  17 #include <linux/sysctl.h>
  18 #include <linux/init.h>
  19 #include <linux/kdebug.h>
  20
  21 #include <asm/mca.h>
  22
  23 int kdump_status[NR_CPUS];
  24 static atomic_t kdump_cpu_frozen;
  25 atomic_t kdump_in_progress;
  26 static int kdump_on_init = 1;
  27 static int kdump_on_fatal_mca = 1;
  28
  29 static inline Elf64_Word
  30 *append_elf_note(Elf64_Word *buf, char *name, unsigned type, void *data,
  31                 size_t data_len)
  32 {
  33         struct elf_note *note = (struct elf_note *)buf;
  34         note->n_namesz = strlen(name) + 1;
  35         note->n_descsz = data_len;
  36         note->n_type   = type;
  37         buf += (sizeof(*note) + 3)/4;
  38         memcpy(buf, name, note->n_namesz);
  39         buf += (note->n_namesz + 3)/4;
  40         memcpy(buf, data, data_len);
  41         buf += (data_len + 3)/4;
  42         return buf;
  43 }
  44
  45 static void
  46 final_note(void *buf)
  47 {
  48         memset(buf, 0, sizeof(struct elf_note));
  49 }
  50
  51 extern void ia64_dump_cpu_regs(void *);
  52
  53 static DEFINE_PER_CPU(struct elf_prstatus, elf_prstatus);
  54
  55 void
  56 crash_save_this_cpu(void)
  57 {
  58         void *buf;
  59         unsigned long cfm, sof, sol;
  60
  61         int cpu = smp_processor_id();
  62         struct elf_prstatus *prstatus = &per_cpu(elf_prstatus, cpu);
  63
  64         elf_greg_t *dst = (elf_greg_t *)&(prstatus->pr_reg);
  65         memset(prstatus, 0, sizeof(*prstatus));
  66         prstatus->pr_pid = current->pid;
  67
  68         ia64_dump_cpu_regs(dst);
  69         cfm = dst[43];
  70         sol = (cfm >> 7) & 0x7f;
  71         sof = cfm & 0x7f;
  72         dst[46] = (unsigned long)ia64_rse_skip_regs((unsigned long *)dst[46],
  73                         sof - sol);
  74
  75         buf = (u64 *) per_cpu_ptr(crash_notes, cpu);
  76         if (!buf)
  77                 return;
  78         buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS, prstatus,
  79                         sizeof(*prstatus));
  80         final_note(buf);
  81 }
  82
  83 #ifdef CONFIG_SMP
  84 static int
  85 kdump_wait_cpu_freeze(void)
  86 {
  87         int cpu_num = num_online_cpus() - 1;
  88         int timeout = 1000;
  89         while(timeout-- > 0) {
  90                 if (atomic_read(&kdump_cpu_frozen) == cpu_num)
  91                         return 0;
  92                 udelay(1000);
  93         }
  94         return 1;
  95 }
  96 #endif
  97
  98 void
  99 machine_crash_shutdown(struct pt_regs *pt)
 100 {
 101         /* This function is only called after the system
 102          * has paniced or is otherwise in a critical state.
 103          * The minimum amount of code to allow a kexec'd kernel
 104          * to run successfully needs to happen here.
 105          *
 106          * In practice this means shooting down the other cpus in
 107          * an SMP system.
 108          */
 109         kexec_disable_iosapic();
 110 #ifdef CONFIG_SMP
 111         kdump_smp_send_stop();
 112         /* not all cpu response to IPI, send INIT to freeze them */
 113         if (kdump_wait_cpu_freeze() && kdump_on_init)   {
 114                 kdump_smp_send_init();
 115         }
 116 #endif
 117 }
 118
 119 static void
 120 machine_kdump_on_init(void)
 121 {
 122         crash_save_vmcoreinfo();
 123         local_irq_disable();
 124         kexec_disable_iosapic();
 125         machine_kexec(ia64_kimage);
 126 }
 127
 128 void
 129 kdump_cpu_freeze(struct unw_frame_info *info, void *arg)
 130 {
 131         int cpuid;
 132
 133         local_irq_disable();
 134         cpuid = smp_processor_id();
 135         crash_save_this_cpu();
 136         current->thread.ksp = (__u64)info->sw - 16;
 137
 138         ia64_set_psr_mc();      /* mask MCA/INIT and stop reentrance */
 139
 140         atomic_inc(&kdump_cpu_frozen);
 141         kdump_status[cpuid] = 1;
 142         mb();
 143 #ifdef CONFIG_HOTPLUG_CPU
 144         if (cpuid != 0)
 145                 ia64_jump_to_sal(&sal_boot_rendez_state[cpuid]);
 146 #endif
 147         for (;;)
 148                 cpu_relax();
 149 }
 150
 151 static int
 152 kdump_init_notifier(struct notifier_block *self, unsigned long val, void *data)
 153 {
 154         struct ia64_mca_notify_die *nd;
 155         struct die_args *args = data;
 156
 157         if (!kdump_on_init && !kdump_on_fatal_mca)
 158                 return NOTIFY_DONE;
 159
 160         if (!ia64_kimage) {
 161                 if (val == DIE_INIT_MONARCH_LEAVE)
 162                         ia64_mca_printk(KERN_NOTICE
 163                                         "%s: kdump not configured\n",
 164                                         __func__);
 165                 return NOTIFY_DONE;
 166         }
 167
 168         if (val != DIE_INIT_MONARCH_LEAVE &&
 169             val != DIE_INIT_SLAVE_LEAVE &&
 170             val != DIE_INIT_MONARCH_PROCESS &&
 171             val != DIE_MCA_RENDZVOUS_LEAVE &&
 172             val != DIE_MCA_MONARCH_LEAVE)
 173                 return NOTIFY_DONE;
 174
 175         nd = (struct ia64_mca_notify_die *)args->err;
 176         /* Reason code 1 means machine check rendezvous*/
 177         if ((val == DIE_INIT_MONARCH_LEAVE || val == DIE_INIT_SLAVE_LEAVE
 178             || val == DIE_INIT_MONARCH_PROCESS) && nd->sos->rv_rc == 1)
 179                 return NOTIFY_DONE;
 180
 181         switch (val) {
 182         case DIE_INIT_MONARCH_PROCESS:
 183                 if (kdump_on_init) {
 184                         atomic_set(&kdump_in_progress, 1);
 185                         *(nd->monarch_cpu) = -1;
 186                 }
 187                 break;
 188         case DIE_INIT_MONARCH_LEAVE:
 189                 if (kdump_on_init)
 190                         machine_kdump_on_init();
 191                 break;
 192         case DIE_INIT_SLAVE_LEAVE:
 193                 if (atomic_read(&kdump_in_progress))
 194                         unw_init_running(kdump_cpu_freeze, NULL);
 195                 break;
 196         case DIE_MCA_RENDZVOUS_LEAVE:
 197                 if (atomic_read(&kdump_in_progress))
 198                         unw_init_running(kdump_cpu_freeze, NULL);
 199                 break;
 200         case DIE_MCA_MONARCH_LEAVE:
 201                 /* *(nd->data) indicate if MCA is recoverable */
 202                 if (kdump_on_fatal_mca && !(*(nd->data))) {
 203                         atomic_set(&kdump_in_progress, 1);
 204                         *(nd->monarch_cpu) = -1;
 205                         machine_kdump_on_init();
 206                 }
 207                 break;
 208         }
 209         return NOTIFY_DONE;
 210 }
 211
 212 #ifdef CONFIG_SYSCTL
 213 static ctl_table kdump_ctl_table[] = {
 214         {
 215                 .ctl_name = CTL_UNNUMBERED,
 216                 .procname = "kdump_on_init",
 217                 .data = &kdump_on_init,
 218                 .maxlen = sizeof(int),
 219                 .mode = 0644,
 220                 .proc_handler = &proc_dointvec,
 221         },
 222         {
 223                 .ctl_name = CTL_UNNUMBERED,
 224                 .procname = "kdump_on_fatal_mca",
 225                 .data = &kdump_on_fatal_mca,
 226                 .maxlen = sizeof(int),
 227                 .mode = 0644,
 228                 .proc_handler = &proc_dointvec,
 229         },
 230         { .ctl_name = 0 }
 231 };
 232
 233 static ctl_table sys_table[] = {
 234         {
 235           .ctl_name = CTL_KERN,
 236           .procname = "kernel",
 237           .mode = 0555,
 238           .child = kdump_ctl_table,
 239         },
 240         { .ctl_name = 0 }
 241 };
 242 #endif
 243
 244 static int
 245 machine_crash_setup(void)
 246 {
 247         /* be notified before default_monarch_init_process */
 248         static struct notifier_block kdump_init_notifier_nb = {
 249                 .notifier_call = kdump_init_notifier,
 250                 .priority = 1,
 251         };
 252         int ret;
 253         if((ret = register_die_notifier(&kdump_init_notifier_nb)) != 0)
 254                 return ret;
 255 #ifdef CONFIG_SYSCTL
 256         register_sysctl_table(sys_table);
 257 #endif
 258         return 0;
 259 }
 260
 261 __initcall(machine_crash_setup);
 262