1 /* 2 * Machine check handler 3 * 4 * Copyright IBM Corp. 2000, 2009 5 * Author(s): Ingo Adlung <adlung@de.ibm.com>, 6 * Martin Schwidefsky <schwidefsky@de.ibm.com>, 7 * Cornelia Huck <cornelia.huck@de.ibm.com>, 8 * Heiko Carstens <heiko.carstens@de.ibm.com>, 9 */ 10 11 #include <linux/kernel_stat.h> 12 #include <linux/init.h> 13 #include <linux/errno.h> 14 #include <linux/hardirq.h> 15 #include <linux/time.h> 16 #include <linux/module.h> 17 #include <asm/lowcore.h> 18 #include <asm/smp.h> 19 #include <asm/stp.h> 20 #include <asm/cputime.h> 21 #include <asm/nmi.h> 22 #include <asm/crw.h> 23 #include <asm/switch_to.h> 24 #include <asm/ctl_reg.h> 25 26 struct mcck_struct { 27 unsigned int kill_task : 1; 28 unsigned int channel_report : 1; 29 unsigned int warning : 1; 30 unsigned int stp_queue : 1; 31 unsigned long mcck_code; 32 }; 33 34 static DEFINE_PER_CPU(struct mcck_struct, cpu_mcck); 35 36 static void s390_handle_damage(void) 37 { 38 smp_send_stop(); 39 disabled_wait((unsigned long) __builtin_return_address(0)); 40 while (1); 41 } 42 43 /* 44 * Main machine check handler function. Will be called with interrupts enabled 45 * or disabled and machine checks enabled or disabled. 46 */ 47 void s390_handle_mcck(void) 48 { 49 unsigned long flags; 50 struct mcck_struct mcck; 51 52 /* 53 * Disable machine checks and get the current state of accumulated 54 * machine checks. Afterwards delete the old state and enable machine 55 * checks again. 56 */ 57 local_irq_save(flags); 58 local_mcck_disable(); 59 mcck = *this_cpu_ptr(&cpu_mcck); 60 memset(this_cpu_ptr(&cpu_mcck), 0, sizeof(mcck)); 61 clear_cpu_flag(CIF_MCCK_PENDING); 62 local_mcck_enable(); 63 local_irq_restore(flags); 64 65 if (mcck.channel_report) 66 crw_handle_channel_report(); 67 /* 68 * A warning may remain for a prolonged period on the bare iron. 69 * (actually until the machine is powered off, or the problem is gone) 70 * So we just stop listening for the WARNING MCH and avoid continuously 71 * being interrupted. One caveat is however, that we must do this per 72 * processor and cannot use the smp version of ctl_clear_bit(). 73 * On VM we only get one interrupt per virtally presented machinecheck. 74 * Though one suffices, we may get one interrupt per (virtual) cpu. 75 */ 76 if (mcck.warning) { /* WARNING pending ? */ 77 static int mchchk_wng_posted = 0; 78 79 /* Use single cpu clear, as we cannot handle smp here. */ 80 __ctl_clear_bit(14, 24); /* Disable WARNING MCH */ 81 if (xchg(&mchchk_wng_posted, 1) == 0) 82 kill_cad_pid(SIGPWR, 1); 83 } 84 if (mcck.stp_queue) 85 stp_queue_work(); 86 if (mcck.kill_task) { 87 local_irq_enable(); 88 printk(KERN_EMERG "mcck: Terminating task because of machine " 89 "malfunction (code 0x%016lx).\n", mcck.mcck_code); 90 printk(KERN_EMERG "mcck: task: %s, pid: %d.\n", 91 current->comm, current->pid); 92 do_exit(SIGSEGV); 93 } 94 } 95 EXPORT_SYMBOL_GPL(s390_handle_mcck); 96 97 /* 98 * returns 0 if all registers could be validated 99 * returns 1 otherwise 100 */ 101 static int notrace s390_validate_registers(union mci mci, int umode) 102 { 103 int kill_task; 104 u64 zero; 105 void *fpt_save_area, *fpt_creg_save_area; 106 107 kill_task = 0; 108 zero = 0; 109 110 if (!mci.gr) { 111 /* 112 * General purpose registers couldn't be restored and have 113 * unknown contents. Stop system or terminate process. 114 */ 115 if (!umode) 116 s390_handle_damage(); 117 kill_task = 1; 118 } 119 if (!mci.fp) { 120 /* 121 * Floating point registers can't be restored. If the 122 * kernel currently uses floating point registers the 123 * system is stopped. If the process has its floating 124 * pointer registers loaded it is terminated. 125 * Otherwise just revalidate the registers. 126 */ 127 if (S390_lowcore.fpu_flags & KERNEL_VXR_V0V7) 128 s390_handle_damage(); 129 if (!test_cpu_flag(CIF_FPU)) 130 kill_task = 1; 131 } 132 fpt_save_area = &S390_lowcore.floating_pt_save_area; 133 fpt_creg_save_area = &S390_lowcore.fpt_creg_save_area; 134 if (!mci.fc) { 135 /* 136 * Floating point control register can't be restored. 137 * If the kernel currently uses the floating pointer 138 * registers and needs the FPC register the system is 139 * stopped. If the process has its floating pointer 140 * registers loaded it is terminated. Otherwiese the 141 * FPC is just revalidated. 142 */ 143 if (S390_lowcore.fpu_flags & KERNEL_FPC) 144 s390_handle_damage(); 145 asm volatile("lfpc 0(%0)" : : "a" (&zero), "m" (zero)); 146 if (!test_cpu_flag(CIF_FPU)) 147 kill_task = 1; 148 } else 149 asm volatile("lfpc 0(%0)" : : "a" (fpt_creg_save_area)); 150 151 if (!MACHINE_HAS_VX) { 152 /* Validate floating point registers */ 153 asm volatile( 154 " ld 0,0(%0)\n" 155 " ld 1,8(%0)\n" 156 " ld 2,16(%0)\n" 157 " ld 3,24(%0)\n" 158 " ld 4,32(%0)\n" 159 " ld 5,40(%0)\n" 160 " ld 6,48(%0)\n" 161 " ld 7,56(%0)\n" 162 " ld 8,64(%0)\n" 163 " ld 9,72(%0)\n" 164 " ld 10,80(%0)\n" 165 " ld 11,88(%0)\n" 166 " ld 12,96(%0)\n" 167 " ld 13,104(%0)\n" 168 " ld 14,112(%0)\n" 169 " ld 15,120(%0)\n" 170 : : "a" (fpt_save_area)); 171 } else { 172 /* Validate vector registers */ 173 union ctlreg0 cr0; 174 175 if (!mci.vr) { 176 /* 177 * Vector registers can't be restored. If the kernel 178 * currently uses vector registers the system is 179 * stopped. If the process has its vector registers 180 * loaded it is terminated. Otherwise just revalidate 181 * the registers. 182 */ 183 if (S390_lowcore.fpu_flags & KERNEL_VXR) 184 s390_handle_damage(); 185 if (!test_cpu_flag(CIF_FPU)) 186 kill_task = 1; 187 } 188 cr0.val = S390_lowcore.cregs_save_area[0]; 189 cr0.afp = cr0.vx = 1; 190 __ctl_load(cr0.val, 0, 0); 191 asm volatile( 192 " la 1,%0\n" 193 " .word 0xe70f,0x1000,0x0036\n" /* vlm 0,15,0(1) */ 194 " .word 0xe70f,0x1100,0x0c36\n" /* vlm 16,31,256(1) */ 195 : : "Q" (*(struct vx_array *) 196 &S390_lowcore.vector_save_area) : "1"); 197 __ctl_load(S390_lowcore.cregs_save_area[0], 0, 0); 198 } 199 /* Validate access registers */ 200 asm volatile( 201 " lam 0,15,0(%0)" 202 : : "a" (&S390_lowcore.access_regs_save_area)); 203 if (!mci.ar) { 204 /* 205 * Access registers have unknown contents. 206 * Terminating task. 207 */ 208 kill_task = 1; 209 } 210 /* Validate control registers */ 211 if (!mci.cr) { 212 /* 213 * Control registers have unknown contents. 214 * Can't recover and therefore stopping machine. 215 */ 216 s390_handle_damage(); 217 } else { 218 asm volatile( 219 " lctlg 0,15,0(%0)" 220 : : "a" (&S390_lowcore.cregs_save_area)); 221 } 222 /* 223 * We don't even try to validate the TOD register, since we simply 224 * can't write something sensible into that register. 225 */ 226 /* 227 * See if we can validate the TOD programmable register with its 228 * old contents (should be zero) otherwise set it to zero. 229 */ 230 if (!mci.pr) 231 asm volatile( 232 " sr 0,0\n" 233 " sckpf" 234 : : : "0", "cc"); 235 else 236 asm volatile( 237 " l 0,0(%0)\n" 238 " sckpf" 239 : : "a" (&S390_lowcore.tod_progreg_save_area) 240 : "0", "cc"); 241 /* Validate clock comparator register */ 242 set_clock_comparator(S390_lowcore.clock_comparator); 243 /* Check if old PSW is valid */ 244 if (!mci.wp) 245 /* 246 * Can't tell if we come from user or kernel mode 247 * -> stopping machine. 248 */ 249 s390_handle_damage(); 250 251 if (!mci.ms || !mci.pm || !mci.ia) 252 kill_task = 1; 253 254 return kill_task; 255 } 256 257 #define MAX_IPD_COUNT 29 258 #define MAX_IPD_TIME (5 * 60 * USEC_PER_SEC) /* 5 minutes */ 259 260 #define ED_STP_ISLAND 6 /* External damage STP island check */ 261 #define ED_STP_SYNC 7 /* External damage STP sync check */ 262 263 /* 264 * machine check handler. 265 */ 266 void notrace s390_do_machine_check(struct pt_regs *regs) 267 { 268 static int ipd_count; 269 static DEFINE_SPINLOCK(ipd_lock); 270 static unsigned long long last_ipd; 271 struct mcck_struct *mcck; 272 unsigned long long tmp; 273 union mci mci; 274 275 nmi_enter(); 276 inc_irq_stat(NMI_NMI); 277 mci.val = S390_lowcore.mcck_interruption_code; 278 mcck = this_cpu_ptr(&cpu_mcck); 279 280 if (mci.sd) { 281 /* System damage -> stopping machine */ 282 s390_handle_damage(); 283 } 284 if (mci.pd) { 285 if (mci.b) { 286 /* Processing backup -> verify if we can survive this */ 287 u64 z_mcic, o_mcic, t_mcic; 288 z_mcic = (1ULL<<63 | 1ULL<<59 | 1ULL<<29); 289 o_mcic = (1ULL<<43 | 1ULL<<42 | 1ULL<<41 | 1ULL<<40 | 290 1ULL<<36 | 1ULL<<35 | 1ULL<<34 | 1ULL<<32 | 291 1ULL<<30 | 1ULL<<21 | 1ULL<<20 | 1ULL<<17 | 292 1ULL<<16); 293 t_mcic = mci.val; 294 295 if (((t_mcic & z_mcic) != 0) || 296 ((t_mcic & o_mcic) != o_mcic)) { 297 s390_handle_damage(); 298 } 299 300 /* 301 * Nullifying exigent condition, therefore we might 302 * retry this instruction. 303 */ 304 spin_lock(&ipd_lock); 305 tmp = get_tod_clock(); 306 if (((tmp - last_ipd) >> 12) < MAX_IPD_TIME) 307 ipd_count++; 308 else 309 ipd_count = 1; 310 last_ipd = tmp; 311 if (ipd_count == MAX_IPD_COUNT) 312 s390_handle_damage(); 313 spin_unlock(&ipd_lock); 314 } else { 315 /* Processing damage -> stopping machine */ 316 s390_handle_damage(); 317 } 318 } 319 if (s390_validate_registers(mci, user_mode(regs))) { 320 /* 321 * Couldn't restore all register contents for the 322 * user space process -> mark task for termination. 323 */ 324 mcck->kill_task = 1; 325 mcck->mcck_code = mci.val; 326 set_cpu_flag(CIF_MCCK_PENDING); 327 } 328 if (mci.cd) { 329 /* Timing facility damage */ 330 s390_handle_damage(); 331 } 332 if (mci.ed && mci.ec) { 333 /* External damage */ 334 if (S390_lowcore.external_damage_code & (1U << ED_STP_SYNC)) 335 mcck->stp_queue |= stp_sync_check(); 336 if (S390_lowcore.external_damage_code & (1U << ED_STP_ISLAND)) 337 mcck->stp_queue |= stp_island_check(); 338 if (mcck->stp_queue) 339 set_cpu_flag(CIF_MCCK_PENDING); 340 } 341 if (mci.se) 342 /* Storage error uncorrected */ 343 s390_handle_damage(); 344 if (mci.ke) 345 /* Storage key-error uncorrected */ 346 s390_handle_damage(); 347 if (mci.ds && mci.fa) 348 /* Storage degradation */ 349 s390_handle_damage(); 350 if (mci.cp) { 351 /* Channel report word pending */ 352 mcck->channel_report = 1; 353 set_cpu_flag(CIF_MCCK_PENDING); 354 } 355 if (mci.w) { 356 /* Warning pending */ 357 mcck->warning = 1; 358 set_cpu_flag(CIF_MCCK_PENDING); 359 } 360 nmi_exit(); 361 } 362 363 static int __init machine_check_init(void) 364 { 365 ctl_set_bit(14, 25); /* enable external damage MCH */ 366 ctl_set_bit(14, 27); /* enable system recovery MCH */ 367 ctl_set_bit(14, 24); /* enable warning MCH */ 368 return 0; 369 } 370 early_initcall(machine_check_init); 371