git.oblomov.eu Git - linux-2.6/blob - drivers/s390/s390mach.c

   1 /*
   2  *  drivers/s390/s390mach.c
   3  *   S/390 machine check handler
   4  *
   5  *  S390 version
   6  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   7  *    Author(s): Ingo Adlung (adlung@de.ibm.com)
   8  *               Martin Schwidefsky (schwidefsky@de.ibm.com)
   9  */
  10
  11 #include <linux/config.h>
  12 #include <linux/init.h>
  13 #include <linux/sched.h>
  14 #include <linux/errno.h>
  15 #include <linux/workqueue.h>
  16
  17 #include <asm/lowcore.h>
  18
  19 #include "s390mach.h"
  20
  21 #define DBG printk
  22 // #define DBG(args,...) do {} while (0);
  23
  24 static struct semaphore m_sem;
  25
  26 extern int css_process_crw(int);
  27 extern int chsc_process_crw(void);
  28 extern int chp_process_crw(int, int);
  29 extern void css_reiterate_subchannels(void);
  30
  31 extern struct workqueue_struct *slow_path_wq;
  32 extern struct work_struct slow_path_work;
  33
  34 static NORET_TYPE void
  35 s390_handle_damage(char *msg)
  36 {
  37 #ifdef CONFIG_SMP
  38         smp_send_stop();
  39 #endif
  40         disabled_wait((unsigned long) __builtin_return_address(0));
  41         for(;;);
  42 }
  43
  44 /*
  45  * Retrieve CRWs and call function to handle event.
  46  *
  47  * Note : we currently process CRWs for io and chsc subchannels only
  48  */
  49 static int
  50 s390_collect_crw_info(void *param)
  51 {
  52         struct crw crw;
  53         int ccode, ret, slow;
  54         struct semaphore *sem;
  55
  56         sem = (struct semaphore *)param;
  57         /* Set a nice name. */
  58         daemonize("kmcheck");
  59 repeat:
  60         down_interruptible(sem);
  61         slow = 0;
  62         while (1) {
  63                 ccode = stcrw(&crw);
  64                 if (ccode != 0)
  65                         break;
  66                 DBG(KERN_DEBUG "crw_info : CRW reports slct=%d, oflw=%d, "
  67                     "chn=%d, rsc=%X, anc=%d, erc=%X, rsid=%X\n",
  68                     crw.slct, crw.oflw, crw.chn, crw.rsc, crw.anc,
  69                     crw.erc, crw.rsid);
  70                 /* Check for overflows. */
  71                 if (crw.oflw) {
  72                         pr_debug("%s: crw overflow detected!\n", __FUNCTION__);
  73                         css_reiterate_subchannels();
  74                         slow = 1;
  75                         continue;
  76                 }
  77                 switch (crw.rsc) {
  78                 case CRW_RSC_SCH:
  79                         pr_debug("source is subchannel %04X\n", crw.rsid);
  80                         ret = css_process_crw (crw.rsid);
  81                         if (ret == -EAGAIN)
  82                                 slow = 1;
  83                         break;
  84                 case CRW_RSC_MONITOR:
  85                         pr_debug("source is monitoring facility\n");
  86                         break;
  87                 case CRW_RSC_CPATH:
  88                         pr_debug("source is channel path %02X\n", crw.rsid);
  89                         switch (crw.erc) {
  90                         case CRW_ERC_IPARM: /* Path has come. */
  91                                 ret = chp_process_crw(crw.rsid, 1);
  92                                 break;
  93                         case CRW_ERC_PERRI: /* Path has gone. */
  94                         case CRW_ERC_PERRN:
  95                                 ret = chp_process_crw(crw.rsid, 0);
  96                                 break;
  97                         default:
  98                                 pr_debug("Don't know how to handle erc=%x\n",
  99                                          crw.erc);
 100                                 ret = 0;
 101                         }
 102                         if (ret == -EAGAIN)
 103                                 slow = 1;
 104                         break;
 105                 case CRW_RSC_CONFIG:
 106                         pr_debug("source is configuration-alert facility\n");
 107                         break;
 108                 case CRW_RSC_CSS:
 109                         pr_debug("source is channel subsystem\n");
 110                         ret = chsc_process_crw();
 111                         if (ret == -EAGAIN)
 112                                 slow = 1;
 113                         break;
 114                 default:
 115                         pr_debug("unknown source\n");
 116                         break;
 117                 }
 118         }
 119         if (slow)
 120                 queue_work(slow_path_wq, &slow_path_work);
 121         goto repeat;
 122         return 0;
 123 }
 124
 125 struct mcck_struct {
 126         int kill_task;
 127         int channel_report;
 128         int warning;
 129         unsigned long long mcck_code;
 130 };
 131
 132 static DEFINE_PER_CPU(struct mcck_struct, cpu_mcck);
 133
 134 /*
 135  * Main machine check handler function. Will be called with interrupts enabled
 136  * or disabled and machine checks enabled or disabled.
 137  */
 138 void
 139 s390_handle_mcck(void)
 140 {
 141         unsigned long flags;
 142         struct mcck_struct mcck;
 143
 144         /*
 145          * Disable machine checks and get the current state of accumulated
 146          * machine checks. Afterwards delete the old state and enable machine
 147          * checks again.
 148          */
 149         local_irq_save(flags);
 150         local_mcck_disable();
 151         mcck = __get_cpu_var(cpu_mcck);
 152         memset(&__get_cpu_var(cpu_mcck), 0, sizeof(struct mcck_struct));
 153         clear_thread_flag(TIF_MCCK_PENDING);
 154         local_mcck_enable();
 155         local_irq_restore(flags);
 156
 157         if (mcck.channel_report)
 158                 up(&m_sem);
 159
 160 #ifdef CONFIG_MACHCHK_WARNING
 161 /*
 162  * The warning may remain for a prolonged period on the bare iron.
 163  * (actually till the machine is powered off, or until the problem is gone)
 164  * So we just stop listening for the WARNING MCH and prevent continuously
 165  * being interrupted.  One caveat is however, that we must do this per
 166  * processor and cannot use the smp version of ctl_clear_bit().
 167  * On VM we only get one interrupt per virtally presented machinecheck.
 168  * Though one suffices, we may get one interrupt per (virtual) processor.
 169  */
 170         if (mcck.warning) {     /* WARNING pending ? */
 171                 static int mchchk_wng_posted = 0;
 172                 /*
 173                  * Use single machine clear, as we cannot handle smp right now
 174                  */
 175                 __ctl_clear_bit(14, 24);        /* Disable WARNING MCH */
 176                 if (xchg(&mchchk_wng_posted, 1) == 0)
 177                         kill_proc(1, SIGPWR, 1);
 178         }
 179 #endif
 180
 181         if (mcck.kill_task) {
 182                 local_irq_enable();
 183                 printk(KERN_EMERG "mcck: Terminating task because of machine "
 184                        "malfunction (code 0x%016llx).\n", mcck.mcck_code);
 185                 printk(KERN_EMERG "mcck: task: %s, pid: %d.\n",
 186                        current->comm, current->pid);
 187                 do_exit(SIGSEGV);
 188         }
 189 }
 190
 191 /*
 192  * returns 0 if all registers could be validated
 193  * returns 1 otherwise
 194  */
 195 static int
 196 s390_revalidate_registers(struct mci *mci)
 197 {
 198         int kill_task;
 199         u64 tmpclock;
 200         u64 zero;
 201         void *fpt_save_area, *fpt_creg_save_area;
 202
 203         kill_task = 0;
 204         zero = 0;
 205         /* General purpose registers */
 206         if (!mci->gr)
 207                 /*
 208                  * General purpose registers couldn't be restored and have
 209                  * unknown contents. Process needs to be terminated.
 210                  */
 211                 kill_task = 1;
 212
 213         /* Revalidate floating point registers */
 214         if (!mci->fp)
 215                 /*
 216                  * Floating point registers can't be restored and
 217                  * therefore the process needs to be terminated.
 218                  */
 219                 kill_task = 1;
 220
 221 #ifndef __s390x__
 222         asm volatile("ld 0,0(%0)\n"
 223                      "ld 2,8(%0)\n"
 224                      "ld 4,16(%0)\n"
 225                      "ld 6,24(%0)"
 226                      : : "a" (&S390_lowcore.floating_pt_save_area));
 227 #endif
 228
 229         if (MACHINE_HAS_IEEE) {
 230 #ifdef __s390x__
 231                 fpt_save_area = &S390_lowcore.floating_pt_save_area;
 232                 fpt_creg_save_area = &S390_lowcore.fpt_creg_save_area;
 233 #else
 234                 fpt_save_area = (void *) S390_lowcore.extended_save_area_addr;
 235                 fpt_creg_save_area = fpt_save_area+128;
 236 #endif
 237                 /* Floating point control register */
 238                 if (!mci->fc) {
 239                         /*
 240                          * Floating point control register can't be restored.
 241                          * Task will be terminated.
 242                          */
 243                         asm volatile ("lfpc 0(%0)" : : "a" (&zero));
 244                         kill_task = 1;
 245
 246                 }
 247                 else
 248                         asm volatile (
 249                                 "lfpc 0(%0)"
 250                                 : : "a" (fpt_creg_save_area));
 251
 252                 asm volatile("ld  0,0(%0)\n"
 253                              "ld  1,8(%0)\n"
 254                              "ld  2,16(%0)\n"
 255                              "ld  3,24(%0)\n"
 256                              "ld  4,32(%0)\n"
 257                              "ld  5,40(%0)\n"
 258                              "ld  6,48(%0)\n"
 259                              "ld  7,56(%0)\n"
 260                              "ld  8,64(%0)\n"
 261                              "ld  9,72(%0)\n"
 262                              "ld 10,80(%0)\n"
 263                              "ld 11,88(%0)\n"
 264                              "ld 12,96(%0)\n"
 265                              "ld 13,104(%0)\n"
 266                              "ld 14,112(%0)\n"
 267                              "ld 15,120(%0)\n"
 268                              : : "a" (fpt_save_area));
 269         }
 270
 271         /* Revalidate access registers */
 272         asm volatile("lam 0,15,0(%0)"
 273                      : : "a" (&S390_lowcore.access_regs_save_area));
 274         if (!mci->ar)
 275                 /*
 276                  * Access registers have unknown contents.
 277                  * Terminating task.
 278                  */
 279                 kill_task = 1;
 280
 281         /* Revalidate control registers */
 282         if (!mci->cr)
 283                 /*
 284                  * Control registers have unknown contents.
 285                  * Can't recover and therefore stopping machine.
 286                  */
 287                 s390_handle_damage("invalid control registers.");
 288         else
 289 #ifdef __s390x__
 290                 asm volatile("lctlg 0,15,0(%0)"
 291                              : : "a" (&S390_lowcore.cregs_save_area));
 292 #else
 293                 asm volatile("lctl 0,15,0(%0)"
 294                              : : "a" (&S390_lowcore.cregs_save_area));
 295 #endif
 296
 297         /*
 298          * We don't even try to revalidate the TOD register, since we simply
 299          * can't write something sensible into that register.
 300          */
 301
 302 #ifdef __s390x__
 303         /*
 304          * See if we can revalidate the TOD programmable register with its
 305          * old contents (should be zero) otherwise set it to zero.
 306          */
 307         if (!mci->pr)
 308                 asm volatile("sr 0,0\n"
 309                              "sckpf"
 310                              : : : "0", "cc");
 311         else
 312                 asm volatile(
 313                         "l 0,0(%0)\n"
 314                         "sckpf"
 315                         : : "a" (&S390_lowcore.tod_progreg_save_area) : "0", "cc");
 316 #endif
 317
 318         /* Revalidate clock comparator register */
 319         asm volatile ("stck 0(%1)\n"
 320                       "sckc 0(%1)"
 321                       : "=m" (tmpclock) : "a" (&(tmpclock)) : "cc", "memory");
 322
 323         /* Check if old PSW is valid */
 324         if (!mci->wp)
 325                 /*
 326                  * Can't tell if we come from user or kernel mode
 327                  * -> stopping machine.
 328                  */
 329                 s390_handle_damage("old psw invalid.");
 330
 331         if (!mci->ms || !mci->pm || !mci->ia)
 332                 kill_task = 1;
 333
 334         return kill_task;
 335 }
 336
 337 /*
 338  * machine check handler.
 339  */
 340 void
 341 s390_do_machine_check(struct pt_regs *regs)
 342 {
 343         struct mci *mci;
 344         struct mcck_struct *mcck;
 345         int umode;
 346
 347         mci = (struct mci *) &S390_lowcore.mcck_interruption_code;
 348         mcck = &__get_cpu_var(cpu_mcck);
 349         umode = user_mode(regs);
 350
 351         if (mci->sd)
 352                 /* System damage -> stopping machine */
 353                 s390_handle_damage("received system damage machine check.");
 354
 355         if (mci->pd) {
 356                 if (mci->b) {
 357                         /* Processing backup -> verify if we can survive this */
 358                         u64 z_mcic, o_mcic, t_mcic;
 359 #ifdef __s390x__
 360                         z_mcic = (1ULL<<63 | 1ULL<<59 | 1ULL<<29);
 361                         o_mcic = (1ULL<<43 | 1ULL<<42 | 1ULL<<41 | 1ULL<<40 |
 362                                   1ULL<<36 | 1ULL<<35 | 1ULL<<34 | 1ULL<<32 |
 363                                   1ULL<<30 | 1ULL<<21 | 1ULL<<20 | 1ULL<<17 |
 364                                   1ULL<<16);
 365 #else
 366                         z_mcic = (1ULL<<63 | 1ULL<<59 | 1ULL<<57 | 1ULL<<50 |
 367                                   1ULL<<29);
 368                         o_mcic = (1ULL<<43 | 1ULL<<42 | 1ULL<<41 | 1ULL<<40 |
 369                                   1ULL<<36 | 1ULL<<35 | 1ULL<<34 | 1ULL<<32 |
 370                                   1ULL<<30 | 1ULL<<20 | 1ULL<<17 | 1ULL<<16);
 371 #endif
 372                         t_mcic = *(u64 *)mci;
 373
 374                         if (((t_mcic & z_mcic) != 0) ||
 375                             ((t_mcic & o_mcic) != o_mcic)) {
 376                                 s390_handle_damage("processing backup machine "
 377                                                    "check with damage.");
 378                         }
 379                         if (!umode)
 380                                 s390_handle_damage("processing backup machine "
 381                                                    "check in kernel mode.");
 382                         mcck->kill_task = 1;
 383                         mcck->mcck_code = *(unsigned long long *) mci;
 384                 }
 385                 else {
 386                         /* Processing damage -> stopping machine */
 387                         s390_handle_damage("received instruction processing "
 388                                            "damage machine check.");
 389                 }
 390         }
 391         if (s390_revalidate_registers(mci)) {
 392                 if (umode) {
 393                         /*
 394                          * Couldn't restore all register contents while in
 395                          * user mode -> mark task for termination.
 396                          */
 397                         mcck->kill_task = 1;
 398                         mcck->mcck_code = *(unsigned long long *) mci;
 399                         set_thread_flag(TIF_MCCK_PENDING);
 400                 }
 401                 else
 402                         /*
 403                          * Couldn't restore all register contents while in
 404                          * kernel mode -> stopping machine.
 405                          */
 406                         s390_handle_damage("unable to revalidate registers.");
 407         }
 408
 409         if (mci->se)
 410                 /* Storage error uncorrected */
 411                 s390_handle_damage("received storage error uncorrected "
 412                                    "machine check.");
 413
 414         if (mci->ke)
 415                 /* Storage key-error uncorrected */
 416                 s390_handle_damage("received storage key-error uncorrected "
 417                                    "machine check.");
 418
 419         if (mci->ds && mci->fa)
 420                 /* Storage degradation */
 421                 s390_handle_damage("received storage degradation machine "
 422                                    "check.");
 423
 424         if (mci->cp) {
 425                 /* Channel report word pending */
 426                 mcck->channel_report = 1;
 427                 set_thread_flag(TIF_MCCK_PENDING);
 428         }
 429
 430         if (mci->w) {
 431                 /* Warning pending */
 432                 mcck->warning = 1;
 433                 set_thread_flag(TIF_MCCK_PENDING);
 434         }
 435 }
 436
 437 /*
 438  * s390_init_machine_check
 439  *
 440  * initialize machine check handling
 441  */
 442 static int
 443 machine_check_init(void)
 444 {
 445         init_MUTEX_LOCKED(&m_sem);
 446         ctl_clear_bit(14, 25);  /* disable external damage MCH */
 447         ctl_set_bit(14, 27);    /* enable system recovery MCH */
 448 #ifdef CONFIG_MACHCHK_WARNING
 449         ctl_set_bit(14, 24);    /* enable warning MCH */
 450 #endif
 451         return 0;
 452 }
 453
 454 /*
 455  * Initialize the machine check handler really early to be able to
 456  * catch all machine checks that happen during boot
 457  */
 458 arch_initcall(machine_check_init);
 459
 460 /*
 461  * Machine checks for the channel subsystem must be enabled
 462  * after the channel subsystem is initialized
 463  */
 464 static int __init
 465 machine_check_crw_init (void)
 466 {
 467         kernel_thread(s390_collect_crw_info, &m_sem, CLONE_FS|CLONE_FILES);
 468         ctl_set_bit(14, 28);    /* enable channel report MCH */
 469         return 0;
 470 }
 471
 472 device_initcall (machine_check_crw_init);