Skip to content
Snippets Groups Projects
Select Git revision
  • bd4c86eaa6ff10abc4e00d0f45d2a28b10b09df4
  • vme-testing default
  • ci-test
  • master
  • remoteproc
  • am625-sk-ov5640
  • pcal6534-upstreaming
  • lps22df-upstreaming
  • msc-upstreaming
  • imx8mp
  • iio/noa1305
  • vme-next
  • vme-next-4.14-rc4
  • v4.14-rc4
  • v4.14-rc3
  • v4.14-rc2
  • v4.14-rc1
  • v4.13
  • vme-next-4.13-rc7
  • v4.13-rc7
  • v4.13-rc6
  • v4.13-rc5
  • v4.13-rc4
  • v4.13-rc3
  • v4.13-rc2
  • v4.13-rc1
  • v4.12
  • v4.12-rc7
  • v4.12-rc6
  • v4.12-rc5
  • v4.12-rc4
  • v4.12-rc3
32 results

mmu.c

Blame
  • crash.c 9.64 KiB
    /*
     * Architecture specific (PPC64) functions for kexec based crash dumps.
     *
     * Copyright (C) 2005, IBM Corp.
     *
     * Created by: Haren Myneni
     *
     * This source code is licensed under the GNU General Public License,
     * Version 2.  See the file COPYING for more details.
     *
     */
    
    #undef DEBUG
    
    #include <linux/kernel.h>
    #include <linux/smp.h>
    #include <linux/reboot.h>
    #include <linux/kexec.h>
    #include <linux/bootmem.h>
    #include <linux/crash_dump.h>
    #include <linux/delay.h>
    #include <linux/elf.h>
    #include <linux/elfcore.h>
    #include <linux/init.h>
    #include <linux/irq.h>
    #include <linux/types.h>
    
    #include <asm/processor.h>
    #include <asm/machdep.h>
    #include <asm/kexec.h>
    #include <asm/kdump.h>
    #include <asm/lmb.h>
    #include <asm/firmware.h>
    #include <asm/smp.h>
    #include <asm/system.h>
    #include <asm/setjmp.h>
    
    #ifdef DEBUG
    #include <asm/udbg.h>
    #define DBG(fmt...) udbg_printf(fmt)
    #else
    #define DBG(fmt...)
    #endif
    
    /* This keeps a track of which one is crashing cpu. */
    int crashing_cpu = -1;
    static cpumask_t cpus_in_crash = CPU_MASK_NONE;
    cpumask_t cpus_in_sr = CPU_MASK_NONE;
    
    #define CRASH_HANDLER_MAX 1
    /* NULL terminated list of shutdown handles */
    static crash_shutdown_t crash_shutdown_handles[CRASH_HANDLER_MAX+1];
    static DEFINE_SPINLOCK(crash_handlers_lock);
    
    #ifdef CONFIG_SMP
    static atomic_t enter_on_soft_reset = ATOMIC_INIT(0);
    
    void crash_ipi_callback(struct pt_regs *regs)
    {
    	int cpu = smp_processor_id();
    
    	if (!cpu_online(cpu))
    		return;
    
    	hard_irq_disable();
    	if (!cpu_isset(cpu, cpus_in_crash))
    		crash_save_cpu(regs, cpu);
    	cpu_set(cpu, cpus_in_crash);
    
    	/*
    	 * Entered via soft-reset - could be the kdump
    	 * process is invoked using soft-reset or user activated
    	 * it if some CPU did not respond to an IPI.
    	 * For soft-reset, the secondary CPU can enter this func
    	 * twice. 1 - using IPI, and 2. soft-reset.
    	 * Tell the kexec CPU that entered via soft-reset and ready
    	 * to go down.
    	 */
    	if (cpu_isset(cpu, cpus_in_sr)) {
    		cpu_clear(cpu, cpus_in_sr);
    		atomic_inc(&enter_on_soft_reset);
    	}
    
    	/*
    	 * Starting the kdump boot.
    	 * This barrier is needed to make sure that all CPUs are stopped.
    	 * If not, soft-reset will be invoked to bring other CPUs.
    	 */
    	while (!cpu_isset(crashing_cpu, cpus_in_crash))
    		cpu_relax();
    
    	if (ppc_md.kexec_cpu_down)
    		ppc_md.kexec_cpu_down(1, 1);
    
    #ifdef CONFIG_PPC64
    	kexec_smp_wait();
    #else
    	for (;;);	/* FIXME */
    #endif
    
    	/* NOTREACHED */
    }
    
    /*
     * Wait until all CPUs are entered via soft-reset.
     */
    static void crash_soft_reset_check(int cpu)
    {
    	unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
    
    	cpu_clear(cpu, cpus_in_sr);
    	while (atomic_read(&enter_on_soft_reset) != ncpus)
    		cpu_relax();
    }
    
    
    static void crash_kexec_prepare_cpus(int cpu)
    {
    	unsigned int msecs;
    
    	unsigned int ncpus = num_online_cpus() - 1;/* Excluding the panic cpu */
    
    	crash_send_ipi(crash_ipi_callback);
    	smp_wmb();
    
    	/*
    	 * FIXME: Until we will have the way to stop other CPUSs reliabally,
    	 * the crash CPU will send an IPI and wait for other CPUs to
    	 * respond.
    	 * Delay of at least 10 seconds.
    	 */
    	printk(KERN_EMERG "Sending IPI to other cpus...\n");
    	msecs = 10000;
    	while ((cpus_weight(cpus_in_crash) < ncpus) && (--msecs > 0)) {
    		cpu_relax();
    		mdelay(1);
    	}
    
    	/* Would it be better to replace the trap vector here? */
    
    	/*
    	 * FIXME: In case if we do not get all CPUs, one possibility: ask the
    	 * user to do soft reset such that we get all.
    	 * Soft-reset will be used until better mechanism is implemented.
    	 */
    	if (cpus_weight(cpus_in_crash) < ncpus) {
    		printk(KERN_EMERG "done waiting: %d cpu(s) not responding\n",
    			ncpus - cpus_weight(cpus_in_crash));
    		printk(KERN_EMERG "Activate soft-reset to stop other cpu(s)\n");
    		cpus_in_sr = CPU_MASK_NONE;
    		atomic_set(&enter_on_soft_reset, 0);
    		while (cpus_weight(cpus_in_crash) < ncpus)
    			cpu_relax();
    	}
    	/*
    	 * Make sure all CPUs are entered via soft-reset if the kdump is
    	 * invoked using soft-reset.
    	 */
    	if (cpu_isset(cpu, cpus_in_sr))
    		crash_soft_reset_check(cpu);
    	/* Leave the IPI callback set */
    }
    
    /*
     * This function will be called by secondary cpus or by kexec cpu
     * if soft-reset is activated to stop some CPUs.
     */
    void crash_kexec_secondary(struct pt_regs *regs)
    {
    	int cpu = smp_processor_id();
    	unsigned long flags;
    	int msecs = 5;
    
    	local_irq_save(flags);
    	/* Wait 5ms if the kexec CPU is not entered yet. */
    	while (crashing_cpu < 0) {
    		if (--msecs < 0) {
    			/*
    			 * Either kdump image is not loaded or
    			 * kdump process is not started - Probably xmon
    			 * exited using 'x'(exit and recover) or
    			 * kexec_should_crash() failed for all running tasks.
    			 */
    			cpu_clear(cpu, cpus_in_sr);
    			local_irq_restore(flags);
    			return;
    		}
    		mdelay(1);
    		cpu_relax();
    	}
    	if (cpu == crashing_cpu) {
    		/*
    		 * Panic CPU will enter this func only via soft-reset.
    		 * Wait until all secondary CPUs entered and
    		 * then start kexec boot.
    		 */
    		crash_soft_reset_check(cpu);
    		cpu_set(crashing_cpu, cpus_in_crash);
    		if (ppc_md.kexec_cpu_down)
    			ppc_md.kexec_cpu_down(1, 0);
    		machine_kexec(kexec_crash_image);
    		/* NOTREACHED */
    	}
    	crash_ipi_callback(regs);
    }
    
    #else
    static void crash_kexec_prepare_cpus(int cpu)
    {
    	/*
    	 * move the secondarys to us so that we can copy
    	 * the new kernel 0-0x100 safely
    	 *
    	 * do this if kexec in setup.c ?
    	 */
    #ifdef CONFIG_PPC64
    	smp_release_cpus();
    #else
    	/* FIXME */
    #endif
    }
    
    void crash_kexec_secondary(struct pt_regs *regs)
    {
    	cpus_in_sr = CPU_MASK_NONE;
    }
    #endif
    #ifdef CONFIG_SPU_BASE
    
    #include <asm/spu.h>
    #include <asm/spu_priv1.h>
    
    struct crash_spu_info {
    	struct spu *spu;
    	u32 saved_spu_runcntl_RW;
    	u32 saved_spu_status_R;
    	u32 saved_spu_npc_RW;
    	u64 saved_mfc_sr1_RW;
    	u64 saved_mfc_dar;
    	u64 saved_mfc_dsisr;
    };
    
    #define CRASH_NUM_SPUS	16	/* Enough for current hardware */
    static struct crash_spu_info crash_spu_info[CRASH_NUM_SPUS];
    
    static void crash_kexec_stop_spus(void)
    {
    	struct spu *spu;
    	int i;
    	u64 tmp;
    
    	for (i = 0; i < CRASH_NUM_SPUS; i++) {
    		if (!crash_spu_info[i].spu)
    			continue;
    
    		spu = crash_spu_info[i].spu;
    
    		crash_spu_info[i].saved_spu_runcntl_RW =
    			in_be32(&spu->problem->spu_runcntl_RW);
    		crash_spu_info[i].saved_spu_status_R =
    			in_be32(&spu->problem->spu_status_R);
    		crash_spu_info[i].saved_spu_npc_RW =
    			in_be32(&spu->problem->spu_npc_RW);
    
    		crash_spu_info[i].saved_mfc_dar    = spu_mfc_dar_get(spu);
    		crash_spu_info[i].saved_mfc_dsisr  = spu_mfc_dsisr_get(spu);
    		tmp = spu_mfc_sr1_get(spu);
    		crash_spu_info[i].saved_mfc_sr1_RW = tmp;
    
    		tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
    		spu_mfc_sr1_set(spu, tmp);
    
    		__delay(200);
    	}
    }
    
    void crash_register_spus(struct list_head *list)
    {
    	struct spu *spu;
    
    	list_for_each_entry(spu, list, full_list) {
    		if (WARN_ON(spu->number >= CRASH_NUM_SPUS))
    			continue;
    
    		crash_spu_info[spu->number].spu = spu;
    	}
    }
    
    #else
    static inline void crash_kexec_stop_spus(void)
    {
    }
    #endif /* CONFIG_SPU_BASE */
    
    /*
     * Register a function to be called on shutdown.  Only use this if you
     * can't reset your device in the second kernel.
     */
    int crash_shutdown_register(crash_shutdown_t handler)
    {
    	unsigned int i, rc;
    
    	spin_lock(&crash_handlers_lock);
    	for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
    		if (!crash_shutdown_handles[i]) {
    			/* Insert handle at first empty entry */
    			crash_shutdown_handles[i] = handler;
    			rc = 0;
    			break;
    		}
    
    	if (i == CRASH_HANDLER_MAX) {
    		printk(KERN_ERR "Crash shutdown handles full, "
    		       "not registered.\n");
    		rc = 1;
    	}
    
    	spin_unlock(&crash_handlers_lock);
    	return rc;
    }
    EXPORT_SYMBOL(crash_shutdown_register);
    
    int crash_shutdown_unregister(crash_shutdown_t handler)
    {
    	unsigned int i, rc;
    
    	spin_lock(&crash_handlers_lock);
    	for (i = 0 ; i < CRASH_HANDLER_MAX; i++)
    		if (crash_shutdown_handles[i] == handler)
    			break;
    
    	if (i == CRASH_HANDLER_MAX) {
    		printk(KERN_ERR "Crash shutdown handle not found\n");
    		rc = 1;
    	} else {
    		/* Shift handles down */
    		for (; crash_shutdown_handles[i]; i++)
    			crash_shutdown_handles[i] =
    				crash_shutdown_handles[i+1];
    		rc = 0;
    	}
    
    	spin_unlock(&crash_handlers_lock);
    	return rc;
    }
    EXPORT_SYMBOL(crash_shutdown_unregister);
    
    static unsigned long crash_shutdown_buf[JMP_BUF_LEN];
    
    static int handle_fault(struct pt_regs *regs)
    {
    	longjmp(crash_shutdown_buf, 1);
    	return 0;
    }
    
    void default_machine_crash_shutdown(struct pt_regs *regs)
    {
    	unsigned int i;
    	int (*old_handler)(struct pt_regs *regs);
    
    
    	/*
    	 * This function is only called after the system
    	 * has panicked or is otherwise in a critical state.
    	 * The minimum amount of code to allow a kexec'd kernel
    	 * to run successfully needs to happen here.
    	 *
    	 * In practice this means stopping other cpus in
    	 * an SMP system.
    	 * The kernel is broken so disable interrupts.
    	 */
    	hard_irq_disable();
    
    	for_each_irq(i) {
    		struct irq_desc *desc = irq_desc + i;
    
    		if (desc->status & IRQ_INPROGRESS)
    			desc->chip->eoi(i);
    
    		if (!(desc->status & IRQ_DISABLED))
    			desc->chip->disable(i);
    	}
    
    	/*
    	 * Call registered shutdown routines savely.  Swap out
    	 * __debugger_fault_handler, and replace on exit.
    	 */
    	old_handler = __debugger_fault_handler;
    	__debugger_fault_handler = handle_fault;
    	for (i = 0; crash_shutdown_handles[i]; i++) {
    		if (setjmp(crash_shutdown_buf) == 0) {
    			/*
    			 * Insert syncs and delay to ensure
    			 * instructions in the dangerous region don't
    			 * leak away from this protected region.
    			 */
    			asm volatile("sync; isync");
    			/* dangerous region */
    			crash_shutdown_handles[i]();
    			asm volatile("sync; isync");
    		}
    	}
    	__debugger_fault_handler = old_handler;
    
    	/*
    	 * Make a note of crashing cpu. Will be used in machine_kexec
    	 * such that another IPI will not be sent.
    	 */
    	crashing_cpu = smp_processor_id();
    	crash_save_cpu(regs, crashing_cpu);
    	crash_kexec_prepare_cpus(crashing_cpu);
    	cpu_set(crashing_cpu, cpus_in_crash);
    	crash_kexec_stop_spus();
    	if (ppc_md.kexec_cpu_down)
    		ppc_md.kexec_cpu_down(1, 0);
    }