Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit fe45736f4134b9656c656ac5e15b915192f2704a

Authored by Linus Torvalds 2014-05-30 09:31:09 +0800

Exists in ti-lsk-linux-4.1.y and in 12 other branches

Merge branch 'fixes' of git://ftp.arm.linux.org.uk/~rmk/linux-arm

Pull ARM fixes from Russell King:
 "The usual random collection of relatively small ARM fixes"

* 'fixes' of git://ftp.arm.linux.org.uk/~rmk/linux-arm:
  ARM: 8063/1: bL_switcher: fix individual online status reporting of removed CPUs
  ARM: 8064/1: fix v7-M signal return
  ARM: 8057/1: amba: Add Qualcomm vendor ID.
  ARM: 8052/1: unwind: Fix handling of "Pop r4-r[4+nnn],r14" opcode
  ARM: 8051/1: put_user: fix possible data corruption in put_user
  ARM: 8048/1: fix v7-M setup stack location

Showing 6 changed files Inline Diff

arch/arm/common/bL_switcher.c
arch/arm/include/asm/uaccess.h
arch/arm/kernel/entry-header.S
arch/arm/kernel/unwind.c
arch/arm/mm/proc-v7m.S
include/linux/amba/bus.h

arch/arm/common/bL_switcher.c

Diff comments View file @ fe45736

 /*
  * arch/arm/common/bL_switcher.c -- big.LITTLE cluster switcher core driver
  *
  * Created by:	Nicolas Pitre, March 2012
  * Copyright:	(C) 2012-2013  Linaro Limited
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #include <linux/atomic.h>
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/interrupt.h>
 #include <linux/cpu_pm.h>
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
 #include <linux/kthread.h>
 #include <linux/wait.h>
 #include <linux/time.h>
 #include <linux/clockchips.h>
 #include <linux/hrtimer.h>
 #include <linux/tick.h>
 #include <linux/notifier.h>
 #include <linux/mm.h>
 #include <linux/mutex.h>
 #include <linux/smp.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/sysfs.h>
 #include <linux/irqchip/arm-gic.h>
 #include <linux/moduleparam.h>
 #include <asm/smp_plat.h>
 #include <asm/cputype.h>
 #include <asm/suspend.h>
 #include <asm/mcpm.h>
 #include <asm/bL_switcher.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/power_cpu_migrate.h>
 /*
  * Use our own MPIDR accessors as the generic ones in asm/cputype.h have
  * __attribute_const__ and we don't want the compiler to assume any
  * constness here as the value _does_ change along some code paths.
  */
 static int read_mpidr(void)
 {
 	unsigned int id;
 	asm volatile ("mrc p15, 0, %0, c0, c0, 5" : "=r" (id));
 	return id & MPIDR_HWID_BITMASK;
 }
 /*
  * Get a global nanosecond time stamp for tracing.
  */
 static s64 get_ns(void)
 {
 	struct timespec ts;
 	getnstimeofday(&ts);
 	return timespec_to_ns(&ts);
 }
 /*
  * bL switcher core code.
  */
 static void bL_do_switch(void *_arg)
 {
 	unsigned ib_mpidr, ib_cpu, ib_cluster;
 	long volatile handshake, **handshake_ptr = _arg;
 	pr_debug("%s\n", __func__);
 	ib_mpidr = cpu_logical_map(smp_processor_id());
 	ib_cpu = MPIDR_AFFINITY_LEVEL(ib_mpidr, 0);
 	ib_cluster = MPIDR_AFFINITY_LEVEL(ib_mpidr, 1);
 	/* Advertise our handshake location */
 	if (handshake_ptr) {
 		handshake = 0;
 		*handshake_ptr = &handshake;
 	} else
 		handshake = -1;
 	/*
 	 * Our state has been saved at this point.  Let's release our
 	 * inbound CPU.
 	 */
 	mcpm_set_entry_vector(ib_cpu, ib_cluster, cpu_resume);
 	sev();
 	/*
 	 * From this point, we must assume that our counterpart CPU might
 	 * have taken over in its parallel world already, as if execution
 	 * just returned from cpu_suspend().  It is therefore important to
 	 * be very careful not to make any change the other guy is not
 	 * expecting.  This is why we need stack isolation.
 	 *
 	 * Fancy under cover tasks could be performed here.  For now
 	 * we have none.
 	 */
 	/*
 	 * Let's wait until our inbound is alive.
 	 */
 	while (!handshake) {
 		wfe();
 		smp_mb();
 	}
 	/* Let's put ourself down. */
 	mcpm_cpu_power_down();
 	/* should never get here */
 	BUG();
 }
 /*
  * Stack isolation.  To ensure 'current' remains valid, we just use another
  * piece of our thread's stack space which should be fairly lightly used.
  * The selected area starts just above the thread_info structure located
  * at the very bottom of the stack, aligned to a cache line, and indexed
  * with the cluster number.
  */
 #define STACK_SIZE 512
 extern void call_with_stack(void (*fn)(void *), void *arg, void *sp);
 static int bL_switchpoint(unsigned long _arg)
 {
 	unsigned int mpidr = read_mpidr();
 	unsigned int clusterid = MPIDR_AFFINITY_LEVEL(mpidr, 1);
 	void *stack = current_thread_info() + 1;
 	stack = PTR_ALIGN(stack, L1_CACHE_BYTES);
 	stack += clusterid * STACK_SIZE + STACK_SIZE;
 	call_with_stack(bL_do_switch, (void *)_arg, stack);
 	BUG();
 }
 /*
  * Generic switcher interface
  */
 static unsigned int bL_gic_id[MAX_CPUS_PER_CLUSTER][MAX_NR_CLUSTERS];
 static int bL_switcher_cpu_pairing[NR_CPUS];
 /*
  * bL_switch_to - Switch to a specific cluster for the current CPU
  * @new_cluster_id: the ID of the cluster to switch to.
  *
  * This function must be called on the CPU to be switched.
  * Returns 0 on success, else a negative status code.
  */
 static int bL_switch_to(unsigned int new_cluster_id)
 {
 	unsigned int mpidr, this_cpu, that_cpu;
 	unsigned int ob_mpidr, ob_cpu, ob_cluster, ib_mpidr, ib_cpu, ib_cluster;
 	struct completion inbound_alive;
 	struct tick_device *tdev;
 	enum clock_event_mode tdev_mode;
 	long volatile *handshake_ptr;
 	int ipi_nr, ret;
 	this_cpu = smp_processor_id();
 	ob_mpidr = read_mpidr();
 	ob_cpu = MPIDR_AFFINITY_LEVEL(ob_mpidr, 0);
 	ob_cluster = MPIDR_AFFINITY_LEVEL(ob_mpidr, 1);
 	BUG_ON(cpu_logical_map(this_cpu) != ob_mpidr);
 	if (new_cluster_id == ob_cluster)
 		return 0;
 	that_cpu = bL_switcher_cpu_pairing[this_cpu];
 	ib_mpidr = cpu_logical_map(that_cpu);
 	ib_cpu = MPIDR_AFFINITY_LEVEL(ib_mpidr, 0);
 	ib_cluster = MPIDR_AFFINITY_LEVEL(ib_mpidr, 1);
 	pr_debug("before switch: CPU %d MPIDR %#x -> %#x\n",
 		 this_cpu, ob_mpidr, ib_mpidr);
 	this_cpu = smp_processor_id();
 	/* Close the gate for our entry vectors */
 	mcpm_set_entry_vector(ob_cpu, ob_cluster, NULL);
 	mcpm_set_entry_vector(ib_cpu, ib_cluster, NULL);
 	/* Install our "inbound alive" notifier. */
 	init_completion(&inbound_alive);
 	ipi_nr = register_ipi_completion(&inbound_alive, this_cpu);
 	ipi_nr |= ((1 << 16) << bL_gic_id[ob_cpu][ob_cluster]);
 	mcpm_set_early_poke(ib_cpu, ib_cluster, gic_get_sgir_physaddr(), ipi_nr);
 	/*
 	 * Let's wake up the inbound CPU now in case it requires some delay
 	 * to come online, but leave it gated in our entry vector code.
 	 */
 	ret = mcpm_cpu_power_up(ib_cpu, ib_cluster);
 	if (ret) {
 		pr_err("%s: mcpm_cpu_power_up() returned %d\n", __func__, ret);
 		return ret;
 	}
 	/*
 	 * Raise a SGI on the inbound CPU to make sure it doesn't stall
 	 * in a possible WFI, such as in bL_power_down().
 	 */
 	gic_send_sgi(bL_gic_id[ib_cpu][ib_cluster], 0);
 	/*
 	 * Wait for the inbound to come up.  This allows for other
 	 * tasks to be scheduled in the mean time.
 	 */
 	wait_for_completion(&inbound_alive);
 	mcpm_set_early_poke(ib_cpu, ib_cluster, 0, 0);
 	/*
 	 * From this point we are entering the switch critical zone
 	 * and can't take any interrupts anymore.
 	 */
 	local_irq_disable();
 	local_fiq_disable();
 	trace_cpu_migrate_begin(get_ns(), ob_mpidr);
 	/* redirect GIC's SGIs to our counterpart */
 	gic_migrate_target(bL_gic_id[ib_cpu][ib_cluster]);
 	tdev = tick_get_device(this_cpu);
 	if (tdev && !cpumask_equal(tdev->evtdev->cpumask, cpumask_of(this_cpu)))
 		tdev = NULL;
 	if (tdev) {
 		tdev_mode = tdev->evtdev->mode;
 		clockevents_set_mode(tdev->evtdev, CLOCK_EVT_MODE_SHUTDOWN);
 	}
 	ret = cpu_pm_enter();
 	/* we can not tolerate errors at this point */
 	if (ret)
 		panic("%s: cpu_pm_enter() returned %d\n", __func__, ret);
 	/* Swap the physical CPUs in the logical map for this logical CPU. */
 	cpu_logical_map(this_cpu) = ib_mpidr;
 	cpu_logical_map(that_cpu) = ob_mpidr;
 	/* Let's do the actual CPU switch. */
 	ret = cpu_suspend((unsigned long)&handshake_ptr, bL_switchpoint);
 	if (ret > 0)
 		panic("%s: cpu_suspend() returned %d\n", __func__, ret);
 	/* We are executing on the inbound CPU at this point */
 	mpidr = read_mpidr();
 	pr_debug("after switch: CPU %d MPIDR %#x\n", this_cpu, mpidr);
 	BUG_ON(mpidr != ib_mpidr);
 	mcpm_cpu_powered_up();
 	ret = cpu_pm_exit();
 	if (tdev) {
 		clockevents_set_mode(tdev->evtdev, tdev_mode);
 		clockevents_program_event(tdev->evtdev,
 					  tdev->evtdev->next_event, 1);
 	}
 	trace_cpu_migrate_finish(get_ns(), ib_mpidr);
 	local_fiq_enable();
 	local_irq_enable();
 	*handshake_ptr = 1;
 	dsb_sev();
 	if (ret)
 		pr_err("%s exiting with error %d\n", __func__, ret);
 	return ret;
 }
 struct bL_thread {
 	spinlock_t lock;
 	struct task_struct *task;
 	wait_queue_head_t wq;
 	int wanted_cluster;
 	struct completion started;
 	bL_switch_completion_handler completer;
 	void *completer_cookie;
 };
 static struct bL_thread bL_threads[NR_CPUS];
 static int bL_switcher_thread(void *arg)
 {
 	struct bL_thread *t = arg;
 	struct sched_param param = { .sched_priority = 1 };
 	int cluster;
 	bL_switch_completion_handler completer;
 	void *completer_cookie;
 	sched_setscheduler_nocheck(current, SCHED_FIFO, &param);
 	complete(&t->started);
 	do {
 		if (signal_pending(current))
 			flush_signals(current);
 		wait_event_interruptible(t->wq,
 				t->wanted_cluster != -1 ||
 				kthread_should_stop());
 		spin_lock(&t->lock);
 		cluster = t->wanted_cluster;
 		completer = t->completer;
 		completer_cookie = t->completer_cookie;
 		t->wanted_cluster = -1;
 		t->completer = NULL;
 		spin_unlock(&t->lock);
 		if (cluster != -1) {
 			bL_switch_to(cluster);
 			if (completer)
 				completer(completer_cookie);
 		}
 	} while (!kthread_should_stop());
 	return 0;
 }
 static struct task_struct *bL_switcher_thread_create(int cpu, void *arg)
 {
 	struct task_struct *task;
 	task = kthread_create_on_node(bL_switcher_thread, arg,
 				      cpu_to_node(cpu), "kswitcher_%d", cpu);
 	if (!IS_ERR(task)) {
 		kthread_bind(task, cpu);
 		wake_up_process(task);
 	} else
 		pr_err("%s failed for CPU %d\n", __func__, cpu);
 	return task;
 }
 /*
  * bL_switch_request_cb - Switch to a specific cluster for the given CPU,
  *      with completion notification via a callback
  *
  * @cpu: the CPU to switch
  * @new_cluster_id: the ID of the cluster to switch to.
  * @completer: switch completion callback.  if non-NULL,
  *	@completer(@completer_cookie) will be called on completion of
  *	the switch, in non-atomic context.
  * @completer_cookie: opaque context argument for @completer.
  *
  * This function causes a cluster switch on the given CPU by waking up
  * the appropriate switcher thread.  This function may or may not return
  * before the switch has occurred.
  *
  * If a @completer callback function is supplied, it will be called when
  * the switch is complete.  This can be used to determine asynchronously
  * when the switch is complete, regardless of when bL_switch_request()
  * returns.  When @completer is supplied, no new switch request is permitted
  * for the affected CPU until after the switch is complete, and @completer
  * has returned.
  */
 int bL_switch_request_cb(unsigned int cpu, unsigned int new_cluster_id,
 			 bL_switch_completion_handler completer,
 			 void *completer_cookie)
 {
 	struct bL_thread *t;
 	if (cpu >= ARRAY_SIZE(bL_threads)) {
 		pr_err("%s: cpu %d out of bounds\n", __func__, cpu);
 		return -EINVAL;
 	}
 	t = &bL_threads[cpu];
 	if (IS_ERR(t->task))
 		return PTR_ERR(t->task);
 	if (!t->task)
 		return -ESRCH;
 	spin_lock(&t->lock);
 	if (t->completer) {
 		spin_unlock(&t->lock);
 		return -EBUSY;
 	}
 	t->completer = completer;
 	t->completer_cookie = completer_cookie;
 	t->wanted_cluster = new_cluster_id;
 	spin_unlock(&t->lock);
 	wake_up(&t->wq);
 	return 0;
 }
 EXPORT_SYMBOL_GPL(bL_switch_request_cb);
 /*
  * Activation and configuration code.
  */
 static DEFINE_MUTEX(bL_switcher_activation_lock);
 static BLOCKING_NOTIFIER_HEAD(bL_activation_notifier);
 static unsigned int bL_switcher_active;
 static unsigned int bL_switcher_cpu_original_cluster[NR_CPUS];
 static cpumask_t bL_switcher_removed_logical_cpus;
 int bL_switcher_register_notifier(struct notifier_block *nb)
 {
 	return blocking_notifier_chain_register(&bL_activation_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(bL_switcher_register_notifier);
 int bL_switcher_unregister_notifier(struct notifier_block *nb)
 {
 	return blocking_notifier_chain_unregister(&bL_activation_notifier, nb);
 }
 EXPORT_SYMBOL_GPL(bL_switcher_unregister_notifier);
 static int bL_activation_notify(unsigned long val)
 {
 	int ret;
 	ret = blocking_notifier_call_chain(&bL_activation_notifier, val, NULL);
 	if (ret & NOTIFY_STOP_MASK)
 		pr_err("%s: notifier chain failed with status 0x%x\n",
 			__func__, ret);
 	return notifier_to_errno(ret);
 }
 static void bL_switcher_restore_cpus(void)
 {
 	int i;
-	for_each_cpu(i, &bL_switcher_removed_logical_cpus)
+	for_each_cpu(i, &bL_switcher_removed_logical_cpus) {
-		cpu_up(i);
+		struct device *cpu_dev = get_cpu_device(i);
+		int ret = device_online(cpu_dev);
+		if (ret)
+			dev_err(cpu_dev, "switcher: unable to restore CPU\n");
+	}
 }
 static int bL_switcher_halve_cpus(void)
 {
 	int i, j, cluster_0, gic_id, ret;
 	unsigned int cpu, cluster, mask;
 	cpumask_t available_cpus;
 	/* First pass to validate what we have */
 	mask = 0;
 	for_each_online_cpu(i) {
 		cpu = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0);
 		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
 		if (cluster >= 2) {
 			pr_err("%s: only dual cluster systems are supported\n", __func__);
 			return -EINVAL;
 		}
 		if (WARN_ON(cpu >= MAX_CPUS_PER_CLUSTER))
 			return -EINVAL;
 		mask |= (1 << cluster);
 	}
 	if (mask != 3) {
 		pr_err("%s: no CPU pairing possible\n", __func__);
 		return -EINVAL;
 	}
 	/*
 	 * Now let's do the pairing.  We match each CPU with another CPU
 	 * from a different cluster.  To get a uniform scheduling behavior
 	 * without fiddling with CPU topology and compute capacity data,
 	 * we'll use logical CPUs initially belonging to the same cluster.
 	 */
 	memset(bL_switcher_cpu_pairing, -1, sizeof(bL_switcher_cpu_pairing));
 	cpumask_copy(&available_cpus, cpu_online_mask);
 	cluster_0 = -1;
 	for_each_cpu(i, &available_cpus) {
 		int match = -1;
 		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
 		if (cluster_0 == -1)
 			cluster_0 = cluster;
 		if (cluster != cluster_0)
 			continue;
 		cpumask_clear_cpu(i, &available_cpus);
 		for_each_cpu(j, &available_cpus) {
 			cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(j), 1);
 			/*
 			 * Let's remember the last match to create "odd"
 			 * pairings on purpose in order for other code not
 			 * to assume any relation between physical and
 			 * logical CPU numbers.
 			 */
 			if (cluster != cluster_0)
 				match = j;
 		}
 		if (match != -1) {
 			bL_switcher_cpu_pairing[i] = match;
 			cpumask_clear_cpu(match, &available_cpus);
 			pr_info("CPU%d paired with CPU%d\n", i, match);
 		}
 	}
 	/*
 	 * Now we disable the unwanted CPUs i.e. everything that has no
 	 * pairing information (that includes the pairing counterparts).
 	 */
 	cpumask_clear(&bL_switcher_removed_logical_cpus);
 	for_each_online_cpu(i) {
 		cpu = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0);
 		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
 		/* Let's take note of the GIC ID for this CPU */
 		gic_id = gic_get_cpu_id(i);
 		if (gic_id < 0) {
 			pr_err("%s: bad GIC ID for CPU %d\n", __func__, i);
 			bL_switcher_restore_cpus();
 			return -EINVAL;
 		}
 		bL_gic_id[cpu][cluster] = gic_id;
 		pr_info("GIC ID for CPU %u cluster %u is %u\n",
 			cpu, cluster, gic_id);
 		if (bL_switcher_cpu_pairing[i] != -1) {
 			bL_switcher_cpu_original_cluster[i] = cluster;
 			continue;
 		}
-		ret = cpu_down(i);
+		ret = device_offline(get_cpu_device(i));
 		if (ret) {
 			bL_switcher_restore_cpus();
 			return ret;
 		}
 		cpumask_set_cpu(i, &bL_switcher_removed_logical_cpus);
 	}
 	return 0;
 }
 /* Determine the logical CPU a given physical CPU is grouped on. */
 int bL_switcher_get_logical_index(u32 mpidr)
 {
 	int cpu;
 	if (!bL_switcher_active)
 		return -EUNATCH;
 	mpidr &= MPIDR_HWID_BITMASK;
 	for_each_online_cpu(cpu) {
 		int pairing = bL_switcher_cpu_pairing[cpu];
 		if (pairing == -1)
 			continue;
 		if ((mpidr == cpu_logical_map(cpu)) ||
 		    (mpidr == cpu_logical_map(pairing)))
 			return cpu;
 	}
 	return -EINVAL;
 }
 static void bL_switcher_trace_trigger_cpu(void *__always_unused info)
 {
 	trace_cpu_migrate_current(get_ns(), read_mpidr());
 }
 int bL_switcher_trace_trigger(void)
 {
 	int ret;
 	preempt_disable();
 	bL_switcher_trace_trigger_cpu(NULL);
 	ret = smp_call_function(bL_switcher_trace_trigger_cpu, NULL, true);
 	preempt_enable();
 	return ret;
 }
 EXPORT_SYMBOL_GPL(bL_switcher_trace_trigger);
 static int bL_switcher_enable(void)
 {
 	int cpu, ret;
 	mutex_lock(&bL_switcher_activation_lock);
 	lock_device_hotplug();
 	if (bL_switcher_active) {
 		unlock_device_hotplug();
 		mutex_unlock(&bL_switcher_activation_lock);
 		return 0;
 	}
 	pr_info("big.LITTLE switcher initializing\n");
 	ret = bL_activation_notify(BL_NOTIFY_PRE_ENABLE);
 	if (ret)
 		goto error;
 	ret = bL_switcher_halve_cpus();
 	if (ret)
 		goto error;
 	bL_switcher_trace_trigger();
 	for_each_online_cpu(cpu) {
 		struct bL_thread *t = &bL_threads[cpu];
 		spin_lock_init(&t->lock);
 		init_waitqueue_head(&t->wq);
 		init_completion(&t->started);
 		t->wanted_cluster = -1;
 		t->task = bL_switcher_thread_create(cpu, t);
 	}
 	bL_switcher_active = 1;
 	bL_activation_notify(BL_NOTIFY_POST_ENABLE);
 	pr_info("big.LITTLE switcher initialized\n");
 	goto out;
 error:
 	pr_warn("big.LITTLE switcher initialization failed\n");
 	bL_activation_notify(BL_NOTIFY_POST_DISABLE);
 out:
 	unlock_device_hotplug();
 	mutex_unlock(&bL_switcher_activation_lock);
 	return ret;
 }
 #ifdef CONFIG_SYSFS
 static void bL_switcher_disable(void)
 {
 	unsigned int cpu, cluster;
 	struct bL_thread *t;
 	struct task_struct *task;
 	mutex_lock(&bL_switcher_activation_lock);
 	lock_device_hotplug();
 	if (!bL_switcher_active)
 		goto out;
 	if (bL_activation_notify(BL_NOTIFY_PRE_DISABLE) != 0) {
 		bL_activation_notify(BL_NOTIFY_POST_ENABLE);
 		goto out;
 	}
 	bL_switcher_active = 0;
 	/*
 	 * To deactivate the switcher, we must shut down the switcher
 	 * threads to prevent any other requests from being accepted.
 	 * Then, if the final cluster for given logical CPU is not the
 	 * same as the original one, we'll recreate a switcher thread
 	 * just for the purpose of switching the CPU back without any
 	 * possibility for interference from external requests.
 	 */
 	for_each_online_cpu(cpu) {
 		t = &bL_threads[cpu];
 		task = t->task;
 		t->task = NULL;
 		if (!task || IS_ERR(task))
 			continue;
 		kthread_stop(task);
 		/* no more switch may happen on this CPU at this point */
 		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
 		if (cluster == bL_switcher_cpu_original_cluster[cpu])
 			continue;
 		init_completion(&t->started);
 		t->wanted_cluster = bL_switcher_cpu_original_cluster[cpu];
 		task = bL_switcher_thread_create(cpu, t);
 		if (!IS_ERR(task)) {
 			wait_for_completion(&t->started);
 			kthread_stop(task);
 			cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
 			if (cluster == bL_switcher_cpu_original_cluster[cpu])
 				continue;
 		}
 		/* If execution gets here, we're in trouble. */
 		pr_crit("%s: unable to restore original cluster for CPU %d\n",
 			__func__, cpu);
 		pr_crit("%s: CPU %d can't be restored\n",
 			__func__, bL_switcher_cpu_pairing[cpu]);
 		cpumask_clear_cpu(bL_switcher_cpu_pairing[cpu],
 				  &bL_switcher_removed_logical_cpus);
 	}
 	bL_switcher_restore_cpus();
 	bL_switcher_trace_trigger();
 	bL_activation_notify(BL_NOTIFY_POST_DISABLE);
 out:
 	unlock_device_hotplug();
 	mutex_unlock(&bL_switcher_activation_lock);
 }
 static ssize_t bL_switcher_active_show(struct kobject *kobj,
 		struct kobj_attribute *attr, char *buf)
 {
 	return sprintf(buf, "%u\n", bL_switcher_active);
 }
 static ssize_t bL_switcher_active_store(struct kobject *kobj,
 		struct kobj_attribute *attr, const char *buf, size_t count)
 {
 	int ret;
 	switch (buf[0]) {
 	case '0':
 		bL_switcher_disable();
 		ret = 0;
 		break;
 	case '1':
 		ret = bL_switcher_enable();
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	return (ret >= 0) ? count : ret;
 }
 static ssize_t bL_switcher_trace_trigger_store(struct kobject *kobj,
 		struct kobj_attribute *attr, const char *buf, size_t count)
 {
 	int ret = bL_switcher_trace_trigger();
 	return ret ? ret : count;
 }
 static struct kobj_attribute bL_switcher_active_attr =
 	__ATTR(active, 0644, bL_switcher_active_show, bL_switcher_active_store);
 static struct kobj_attribute bL_switcher_trace_trigger_attr =
 	__ATTR(trace_trigger, 0200, NULL, bL_switcher_trace_trigger_store);
 static struct attribute *bL_switcher_attrs[] = {
 	&bL_switcher_active_attr.attr,
 	&bL_switcher_trace_trigger_attr.attr,
 	NULL,
 };
 static struct attribute_group bL_switcher_attr_group = {
 	.attrs = bL_switcher_attrs,
 };
 static struct kobject *bL_switcher_kobj;
 static int __init bL_switcher_sysfs_init(void)
 {
 	int ret;
 	bL_switcher_kobj = kobject_create_and_add("bL_switcher", kernel_kobj);
 	if (!bL_switcher_kobj)
 		return -ENOMEM;
 	ret = sysfs_create_group(bL_switcher_kobj, &bL_switcher_attr_group);
 	if (ret)
 		kobject_put(bL_switcher_kobj);
 	return ret;
 }
 #endif  /* CONFIG_SYSFS */
 bool bL_switcher_get_enabled(void)
 {
 	mutex_lock(&bL_switcher_activation_lock);
 	return bL_switcher_active;
 }
 EXPORT_SYMBOL_GPL(bL_switcher_get_enabled);
 void bL_switcher_put_enabled(void)
 {
 	mutex_unlock(&bL_switcher_activation_lock);
 }
 EXPORT_SYMBOL_GPL(bL_switcher_put_enabled);
 /*
  * Veto any CPU hotplug operation on those CPUs we've removed
  * while the switcher is active.
  * We're just not ready to deal with that given the trickery involved.
  */
 static int bL_switcher_hotplug_callback(struct notifier_block *nfb,
 					unsigned long action, void *hcpu)
 {
 	if (bL_switcher_active) {
 		int pairing = bL_switcher_cpu_pairing[(unsigned long)hcpu];
 		switch (action & 0xf) {
 		case CPU_UP_PREPARE:
 		case CPU_DOWN_PREPARE:
 			if (pairing == -1)
 				return NOTIFY_BAD;
 		}
 	}
 	return NOTIFY_DONE;
 }
 static bool no_bL_switcher;
 core_param(no_bL_switcher, no_bL_switcher, bool, 0644);
 static int __init bL_switcher_init(void)
 {
 	int ret;
 	if (!mcpm_is_available())
 		return -ENODEV;
 	cpu_notifier(bL_switcher_hotplug_callback, 0);
 	if (!no_bL_switcher) {
 		ret = bL_switcher_enable();
 		if (ret)
 			return ret;
 	}
 #ifdef CONFIG_SYSFS
 	ret = bL_switcher_sysfs_init();
 	if (ret)
 		pr_err("%s: unable to create sysfs entry\n", __func__);
 #endif
 	return 0;
 }
 late_initcall(bL_switcher_init);

arch/arm/include/asm/uaccess.h

Diff comments View file @ fe45736

 /*
  *  arch/arm/include/asm/uaccess.h
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #ifndef _ASMARM_UACCESS_H
 #define _ASMARM_UACCESS_H
 /*
  * User space memory access functions
  */
 #include <linux/string.h>
 #include <linux/thread_info.h>
 #include <asm/errno.h>
 #include <asm/memory.h>
 #include <asm/domain.h>
 #include <asm/unified.h>
 #include <asm/compiler.h>
 #ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 #include <asm-generic/uaccess-unaligned.h>
 #else
 #define __get_user_unaligned __get_user
 #define __put_user_unaligned __put_user
 #endif
 #define VERIFY_READ 0
 #define VERIFY_WRITE 1
 /*
  * The exception table consists of pairs of addresses: the first is the
  * address of an instruction that is allowed to fault, and the second is
  * the address at which the program should continue.  No registers are
  * modified, so it is entirely up to the continuation code to figure out
  * what to do.
  *
  * All the routines below use bits of fixup code that are out of line
  * with the main instruction path.  This means when everything is well,
  * we don't even have to jump over them.  Further, they do not intrude
  * on our cache or tlb entries.
  */
 struct exception_table_entry
 {
 	unsigned long insn, fixup;
 };
 extern int fixup_exception(struct pt_regs *regs);
 /*
  * These two are intentionally not defined anywhere - if the kernel
  * code generates any references to them, that's a bug.
  */
 extern int __get_user_bad(void);
 extern int __put_user_bad(void);
 /*
  * Note that this is actually 0x1,0000,0000
  */
 #define KERNEL_DS	0x00000000
 #define get_ds()	(KERNEL_DS)
 #ifdef CONFIG_MMU
 #define USER_DS		TASK_SIZE
 #define get_fs()	(current_thread_info()->addr_limit)
 static inline void set_fs(mm_segment_t fs)
 {
 	current_thread_info()->addr_limit = fs;
 	modify_domain(DOMAIN_KERNEL, fs ? DOMAIN_CLIENT : DOMAIN_MANAGER);
 }
 #define segment_eq(a,b)	((a) == (b))
 #define __addr_ok(addr) ({ \
 	unsigned long flag; \
 	__asm__("cmp %2, %0; movlo %0, #0" \
 		: "=&r" (flag) \
 		: "0" (current_thread_info()->addr_limit), "r" (addr) \
 		: "cc"); \
 	(flag == 0); })
 /* We use 33-bit arithmetic here... */
 #define __range_ok(addr,size) ({ \
 	unsigned long flag, roksum; \
 	__chk_user_ptr(addr);	\
 	__asm__("adds %1, %2, %3; sbcccs %1, %1, %0; movcc %0, #0" \
 		: "=&r" (flag), "=&r" (roksum) \
 		: "r" (addr), "Ir" (size), "0" (current_thread_info()->addr_limit) \
 		: "cc"); \
 	flag; })
 /*
  * Single-value transfer routines.  They automatically use the right
  * size if we just have the right pointer type.  Note that the functions
  * which read from user space (*get_*) need to take care not to leak
  * kernel data even if the calling code is buggy and fails to check
  * the return value.  This means zeroing out the destination variable
  * or buffer on error.  Normally this is done out of line by the
  * fixup code, but there are a few places where it intrudes on the
  * main code path.  When we only write to user space, there is no
  * problem.
  */
 extern int __get_user_1(void *);
 extern int __get_user_2(void *);
 extern int __get_user_4(void *);
 #define __GUP_CLOBBER_1	"lr", "cc"
 #ifdef CONFIG_CPU_USE_DOMAINS
 #define __GUP_CLOBBER_2	"ip", "lr", "cc"
 #else
 #define __GUP_CLOBBER_2 "lr", "cc"
 #endif
 #define __GUP_CLOBBER_4	"lr", "cc"
 #define __get_user_x(__r2,__p,__e,__l,__s)				\
 	   __asm__ __volatile__ (					\
 		__asmeq("%0", "r0") __asmeq("%1", "r2")			\
 		__asmeq("%3", "r1")					\
 		"bl	__get_user_" #__s				\
 		: "=&r" (__e), "=r" (__r2)				\
 		: "0" (__p), "r" (__l)					\
 		: __GUP_CLOBBER_##__s)
 #define __get_user_check(x,p)							\
 	({								\
 		unsigned long __limit = current_thread_info()->addr_limit - 1; \
 		register const typeof(*(p)) __user *__p asm("r0") = (p);\
 		register unsigned long __r2 asm("r2");			\
 		register unsigned long __l asm("r1") = __limit;		\
 		register int __e asm("r0");				\
 		switch (sizeof(*(__p))) {				\
 		case 1:							\
 			__get_user_x(__r2, __p, __e, __l, 1);		\
 			break;						\
 		case 2:							\
 			__get_user_x(__r2, __p, __e, __l, 2);		\
 			break;						\
 		case 4:							\
 			__get_user_x(__r2, __p, __e, __l, 4);		\
 			break;						\
 		default: __e = __get_user_bad(); break;			\
 		}							\
 		x = (typeof(*(p))) __r2;				\
 		__e;							\
 	})
 #define get_user(x,p)							\
 	({								\
 		might_fault();						\
 		__get_user_check(x,p);					\
 	 })
 extern int __put_user_1(void *, unsigned int);
 extern int __put_user_2(void *, unsigned int);
 extern int __put_user_4(void *, unsigned int);
 extern int __put_user_8(void *, unsigned long long);
 #define __put_user_x(__r2,__p,__e,__l,__s)				\
 	   __asm__ __volatile__ (					\
 		__asmeq("%0", "r0") __asmeq("%2", "r2")			\
 		__asmeq("%3", "r1")					\
 		"bl	__put_user_" #__s				\
 		: "=&r" (__e)						\
 		: "0" (__p), "r" (__r2), "r" (__l)			\
 		: "ip", "lr", "cc")
 #define __put_user_check(x,p)							\
 	({								\
 		unsigned long __limit = current_thread_info()->addr_limit - 1; \
+		const typeof(*(p)) __user *__tmp_p = (p);		\
 		register const typeof(*(p)) __r2 asm("r2") = (x);	\
-		register const typeof(*(p)) __user *__p asm("r0") = (p);\
+		register const typeof(*(p)) __user *__p asm("r0") = __tmp_p; \
 		register unsigned long __l asm("r1") = __limit;		\
 		register int __e asm("r0");				\
 		switch (sizeof(*(__p))) {				\
 		case 1:							\
 			__put_user_x(__r2, __p, __e, __l, 1);		\
 			break;						\
 		case 2:							\
 			__put_user_x(__r2, __p, __e, __l, 2);		\
 			break;						\
 		case 4:							\
 			__put_user_x(__r2, __p, __e, __l, 4);		\
 			break;						\
 		case 8:							\
 			__put_user_x(__r2, __p, __e, __l, 8);		\
 			break;						\
 		default: __e = __put_user_bad(); break;			\
 		}							\
 		__e;							\
 	})
 #define put_user(x,p)							\
 	({								\
 		might_fault();						\
 		__put_user_check(x,p);					\
 	 })
 #else /* CONFIG_MMU */
 /*
  * uClinux has only one addr space, so has simplified address limits.
  */
 #define USER_DS			KERNEL_DS
 #define segment_eq(a,b)		(1)
 #define __addr_ok(addr)		((void)(addr),1)
 #define __range_ok(addr,size)	((void)(addr),0)
 #define get_fs()		(KERNEL_DS)
 static inline void set_fs(mm_segment_t fs)
 {
 }
 #define get_user(x,p)	__get_user(x,p)
 #define put_user(x,p)	__put_user(x,p)
 #endif /* CONFIG_MMU */
 #define access_ok(type,addr,size)	(__range_ok(addr,size) == 0)
 #define user_addr_max() \
 	(segment_eq(get_fs(), USER_DS) ? TASK_SIZE : ~0UL)
 /*
  * The "__xxx" versions of the user access functions do not verify the
  * address space - it must have been done previously with a separate
  * "access_ok()" call.
  *
  * The "xxx_error" versions set the third argument to EFAULT if an
  * error occurs, and leave it unchanged on success.  Note that these
  * versions are void (ie, don't return a value as such).
  */
 #define __get_user(x,ptr)						\
 ({									\
 	long __gu_err = 0;						\
 	__get_user_err((x),(ptr),__gu_err);				\
 	__gu_err;							\
 })
 #define __get_user_error(x,ptr,err)					\
 ({									\
 	__get_user_err((x),(ptr),err);					\
 	(void) 0;							\
 })
 #define __get_user_err(x,ptr,err)					\
 do {									\
 	unsigned long __gu_addr = (unsigned long)(ptr);			\
 	unsigned long __gu_val;						\
 	__chk_user_ptr(ptr);						\
 	might_fault();							\
 	switch (sizeof(*(ptr))) {					\
 	case 1:	__get_user_asm_byte(__gu_val,__gu_addr,err);	break;	\
 	case 2:	__get_user_asm_half(__gu_val,__gu_addr,err);	break;	\
 	case 4:	__get_user_asm_word(__gu_val,__gu_addr,err);	break;	\
 	default: (__gu_val) = __get_user_bad();				\
 	}								\
 	(x) = (__typeof__(*(ptr)))__gu_val;				\
 } while (0)
 #define __get_user_asm_byte(x,addr,err)				\
 	__asm__ __volatile__(					\
 	"1:	" TUSER(ldrb) "	%1,[%2],#0\n"			\
 	"2:\n"							\
 	"	.pushsection .fixup,\"ax\"\n"			\
 	"	.align	2\n"					\
 	"3:	mov	%0, %3\n"				\
 	"	mov	%1, #0\n"				\
 	"	b	2b\n"					\
 	"	.popsection\n"					\
 	"	.pushsection __ex_table,\"a\"\n"		\
 	"	.align	3\n"					\
 	"	.long	1b, 3b\n"				\
 	"	.popsection"					\
 	: "+r" (err), "=&r" (x)					\
 	: "r" (addr), "i" (-EFAULT)				\
 	: "cc")
 #ifndef __ARMEB__
 #define __get_user_asm_half(x,__gu_addr,err)			\
 ({								\
 	unsigned long __b1, __b2;				\
 	__get_user_asm_byte(__b1, __gu_addr, err);		\
 	__get_user_asm_byte(__b2, __gu_addr + 1, err);		\
 	(x) = __b1 | (__b2 << 8);				\
 })
 #else
 #define __get_user_asm_half(x,__gu_addr,err)			\
 ({								\
 	unsigned long __b1, __b2;				\
 	__get_user_asm_byte(__b1, __gu_addr, err);		\
 	__get_user_asm_byte(__b2, __gu_addr + 1, err);		\
 	(x) = (__b1 << 8) | __b2;				\
 })
 #endif
 #define __get_user_asm_word(x,addr,err)				\
 	__asm__ __volatile__(					\
 	"1:	" TUSER(ldr) "	%1,[%2],#0\n"			\
 	"2:\n"							\
 	"	.pushsection .fixup,\"ax\"\n"			\
 	"	.align	2\n"					\
 	"3:	mov	%0, %3\n"				\
 	"	mov	%1, #0\n"				\
 	"	b	2b\n"					\
 	"	.popsection\n"					\
 	"	.pushsection __ex_table,\"a\"\n"		\
 	"	.align	3\n"					\
 	"	.long	1b, 3b\n"				\
 	"	.popsection"					\
 	: "+r" (err), "=&r" (x)					\
 	: "r" (addr), "i" (-EFAULT)				\
 	: "cc")
 #define __put_user(x,ptr)						\
 ({									\
 	long __pu_err = 0;						\
 	__put_user_err((x),(ptr),__pu_err);				\
 	__pu_err;							\
 })
 #define __put_user_error(x,ptr,err)					\
 ({									\
 	__put_user_err((x),(ptr),err);					\
 	(void) 0;							\
 })
 #define __put_user_err(x,ptr,err)					\
 do {									\
 	unsigned long __pu_addr = (unsigned long)(ptr);			\
 	__typeof__(*(ptr)) __pu_val = (x);				\
 	__chk_user_ptr(ptr);						\
 	might_fault();							\
 	switch (sizeof(*(ptr))) {					\
 	case 1: __put_user_asm_byte(__pu_val,__pu_addr,err);	break;	\
 	case 2: __put_user_asm_half(__pu_val,__pu_addr,err);	break;	\
 	case 4: __put_user_asm_word(__pu_val,__pu_addr,err);	break;	\
 	case 8:	__put_user_asm_dword(__pu_val,__pu_addr,err);	break;	\
 	default: __put_user_bad();					\
 	}								\
 } while (0)
 #define __put_user_asm_byte(x,__pu_addr,err)			\
 	__asm__ __volatile__(					\
 	"1:	" TUSER(strb) "	%1,[%2],#0\n"			\
 	"2:\n"							\
 	"	.pushsection .fixup,\"ax\"\n"			\
 	"	.align	2\n"					\
 	"3:	mov	%0, %3\n"				\
 	"	b	2b\n"					\
 	"	.popsection\n"					\
 	"	.pushsection __ex_table,\"a\"\n"		\
 	"	.align	3\n"					\
 	"	.long	1b, 3b\n"				\
 	"	.popsection"					\
 	: "+r" (err)						\
 	: "r" (x), "r" (__pu_addr), "i" (-EFAULT)		\
 	: "cc")
 #ifndef __ARMEB__
 #define __put_user_asm_half(x,__pu_addr,err)			\
 ({								\
 	unsigned long __temp = (unsigned long)(x);		\
 	__put_user_asm_byte(__temp, __pu_addr, err);		\
 	__put_user_asm_byte(__temp >> 8, __pu_addr + 1, err);	\
 })
 #else
 #define __put_user_asm_half(x,__pu_addr,err)			\
 ({								\
 	unsigned long __temp = (unsigned long)(x);		\
 	__put_user_asm_byte(__temp >> 8, __pu_addr, err);	\
 	__put_user_asm_byte(__temp, __pu_addr + 1, err);	\
 })
 #endif
 #define __put_user_asm_word(x,__pu_addr,err)			\
 	__asm__ __volatile__(					\
 	"1:	" TUSER(str) "	%1,[%2],#0\n"			\
 	"2:\n"							\
 	"	.pushsection .fixup,\"ax\"\n"			\
 	"	.align	2\n"					\
 	"3:	mov	%0, %3\n"				\
 	"	b	2b\n"					\
 	"	.popsection\n"					\
 	"	.pushsection __ex_table,\"a\"\n"		\
 	"	.align	3\n"					\
 	"	.long	1b, 3b\n"				\
 	"	.popsection"					\
 	: "+r" (err)						\
 	: "r" (x), "r" (__pu_addr), "i" (-EFAULT)		\
 	: "cc")
 #ifndef __ARMEB__
 #define	__reg_oper0	"%R2"
 #define	__reg_oper1	"%Q2"
 #else
 #define	__reg_oper0	"%Q2"
 #define	__reg_oper1	"%R2"
 #endif
 #define __put_user_asm_dword(x,__pu_addr,err)			\
 	__asm__ __volatile__(					\
  ARM(	"1:	" TUSER(str) "	" __reg_oper1 ", [%1], #4\n"	) \
  ARM(	"2:	" TUSER(str) "	" __reg_oper0 ", [%1]\n"	) \
  THUMB(	"1:	" TUSER(str) "	" __reg_oper1 ", [%1]\n"	) \
  THUMB(	"2:	" TUSER(str) "	" __reg_oper0 ", [%1, #4]\n"	) \
 	"3:\n"							\
 	"	.pushsection .fixup,\"ax\"\n"			\
 	"	.align	2\n"					\
 	"4:	mov	%0, %3\n"				\
 	"	b	3b\n"					\
 	"	.popsection\n"					\
 	"	.pushsection __ex_table,\"a\"\n"		\
 	"	.align	3\n"					\
 	"	.long	1b, 4b\n"				\
 	"	.long	2b, 4b\n"				\
 	"	.popsection"					\
 	: "+r" (err), "+r" (__pu_addr)				\
 	: "r" (x), "i" (-EFAULT)				\
 	: "cc")
 #ifdef CONFIG_MMU
 extern unsigned long __must_check __copy_from_user(void *to, const void __user *from, unsigned long n);
 extern unsigned long __must_check __copy_to_user(void __user *to, const void *from, unsigned long n);
 extern unsigned long __must_check __copy_to_user_std(void __user *to, const void *from, unsigned long n);
 extern unsigned long __must_check __clear_user(void __user *addr, unsigned long n);
 extern unsigned long __must_check __clear_user_std(void __user *addr, unsigned long n);
 #else
 #define __copy_from_user(to,from,n)	(memcpy(to, (void __force *)from, n), 0)
 #define __copy_to_user(to,from,n)	(memcpy((void __force *)to, from, n), 0)
 #define __clear_user(addr,n)		(memset((void __force *)addr, 0, n), 0)
 #endif
 static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)
 {
 	if (access_ok(VERIFY_READ, from, n))
 		n = __copy_from_user(to, from, n);
 	else /* security hole - plug it */
 		memset(to, 0, n);
 	return n;
 }
 static inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
 {
 	if (access_ok(VERIFY_WRITE, to, n))
 		n = __copy_to_user(to, from, n);
 	return n;
 }
 #define __copy_to_user_inatomic __copy_to_user
 #define __copy_from_user_inatomic __copy_from_user
 static inline unsigned long __must_check clear_user(void __user *to, unsigned long n)
 {
 	if (access_ok(VERIFY_WRITE, to, n))
 		n = __clear_user(to, n);
 	return n;
 }
 extern long strncpy_from_user(char *dest, const char __user *src, long count);
 extern __must_check long strlen_user(const char __user *str);
 extern __must_check long strnlen_user(const char __user *str, long n);
 #endif /* _ASMARM_UACCESS_H */

arch/arm/kernel/entry-header.S

Diff comments View file @ fe45736

 #include <linux/init.h>
 #include <linux/linkage.h>
 #include <asm/assembler.h>
 #include <asm/asm-offsets.h>
 #include <asm/errno.h>
 #include <asm/thread_info.h>
 #include <asm/v7m.h>
 @ Bad Abort numbers
 @ -----------------
 @
 #define BAD_PREFETCH	0
 #define BAD_DATA	1
 #define BAD_ADDREXCPTN	2
 #define BAD_IRQ		3
 #define BAD_UNDEFINSTR	4
 @
 @ Most of the stack format comes from struct pt_regs, but with
 @ the addition of 8 bytes for storing syscall args 5 and 6.
 @ This _must_ remain a multiple of 8 for EABI.
 @
 #define S_OFF		8
 /*
  * The SWI code relies on the fact that R0 is at the bottom of the stack
  * (due to slow/fast restore user regs).
  */
 #if S_R0 != 0
 #error "Please fix"
 #endif
 	.macro	zero_fp
 #ifdef CONFIG_FRAME_POINTER
 	mov	fp, #0
 #endif
 	.endm
 	.macro	alignment_trap, rtemp
 #ifdef CONFIG_ALIGNMENT_TRAP
 	ldr	\rtemp, .LCcralign
 	ldr	\rtemp, [\rtemp]
 	mcr	p15, 0, \rtemp, c1, c0
 #endif
 	.endm
 #ifdef CONFIG_CPU_V7M
 /*
  * ARMv7-M exception entry/exit macros.
  *
  * xPSR, ReturnAddress(), LR (R14), R12, R3, R2, R1, and R0 are
  * automatically saved on the current stack (32 words) before
  * switching to the exception stack (SP_main).
  *
  * If exception is taken while in user mode, SP_main is
  * empty. Otherwise, SP_main is aligned to 64 bit automatically
  * (CCR.STKALIGN set).
  *
  * Linux assumes that the interrupts are disabled when entering an
  * exception handler and it may BUG if this is not the case. Interrupts
  * are disabled during entry and reenabled in the exit macro.
  *
  * v7m_exception_slow_exit is used when returning from SVC or PendSV.
  * When returning to kernel mode, we don't return from exception.
  */
 	.macro	v7m_exception_entry
 	@ determine the location of the registers saved by the core during
 	@ exception entry. Depending on the mode the cpu was in when the
 	@ exception happend that is either on the main or the process stack.
 	@ Bit 2 of EXC_RETURN stored in the lr register specifies which stack
 	@ was used.
 	tst	lr, #EXC_RET_STACK_MASK
 	mrsne	r12, psp
 	moveq	r12, sp
 	@ we cannot rely on r0-r3 and r12 matching the value saved in the
 	@ exception frame because of tail-chaining. So these have to be
 	@ reloaded.
 	ldmia	r12!, {r0-r3}
 	@ Linux expects to have irqs off. Do it here before taking stack space
 	cpsid	i
 	sub	sp, #S_FRAME_SIZE-S_IP
 	stmdb	sp!, {r0-r11}
 	@ load saved r12, lr, return address and xPSR.
 	@ r0-r7 are used for signals and never touched from now on. Clobbering
 	@ r8-r12 is OK.
 	mov	r9, r12
 	ldmia	r9!, {r8, r10-r12}
 	@ calculate the original stack pointer value.
 	@ r9 currently points to the memory location just above the auto saved
 	@ xPSR.
 	@ The cpu might automatically 8-byte align the stack. Bit 9
 	@ of the saved xPSR specifies if stack aligning took place. In this case
 	@ another 32-bit value is included in the stack.
 	tst	r12, V7M_xPSR_FRAMEPTRALIGN
 	addne	r9, r9, #4
 	@ store saved r12 using str to have a register to hold the base for stm
 	str	r8, [sp, #S_IP]
 	add	r8, sp, #S_SP
 	@ store r13-r15, xPSR
 	stmia	r8!, {r9-r12}
 	@ store old_r0
 	str	r0, [r8]
 	.endm
         /*
 	 * PENDSV and SVCALL are configured to have the same exception
 	 * priorities. As a kernel thread runs at SVCALL execution priority it
 	 * can never be preempted and so we will never have to return to a
 	 * kernel thread here.
          */
 	.macro	v7m_exception_slow_exit ret_r0
 	cpsid	i
 	ldr	lr, =EXC_RET_THREADMODE_PROCESSSTACK
 	@ read original r12, sp, lr, pc and xPSR
 	add	r12, sp, #S_IP
 	ldmia	r12, {r1-r5}
 	@ an exception frame is always 8-byte aligned. To tell the hardware if
 	@ the sp to be restored is aligned or not set bit 9 of the saved xPSR
 	@ accordingly.
 	tst	r2, #4
 	subne	r2, r2, #4
 	orrne	r5, V7M_xPSR_FRAMEPTRALIGN
 	biceq	r5, V7M_xPSR_FRAMEPTRALIGN
+	@ ensure bit 0 is cleared in the PC, otherwise behaviour is
+	@ unpredictable
+	bic	r4, #1
 	@ write basic exception frame
 	stmdb	r2!, {r1, r3-r5}
 	ldmia	sp, {r1, r3-r5}
 	.if	\ret_r0
 	stmdb	r2!, {r0, r3-r5}
 	.else
 	stmdb	r2!, {r1, r3-r5}
 	.endif
 	@ restore process sp
 	msr	psp, r2
 	@ restore original r4-r11
 	ldmia	sp!, {r0-r11}
 	@ restore main sp
 	add	sp, sp, #S_FRAME_SIZE-S_IP
 	cpsie	i
 	bx	lr
 	.endm
 #endif	/* CONFIG_CPU_V7M */
 	@
 	@ Store/load the USER SP and LR registers by switching to the SYS
 	@ mode. Useful in Thumb-2 mode where "stm/ldm rd, {sp, lr}^" is not
 	@ available. Should only be called from SVC mode
 	@
 	.macro	store_user_sp_lr, rd, rtemp, offset = 0
 	mrs	\rtemp, cpsr
 	eor	\rtemp, \rtemp, #(SVC_MODE ^ SYSTEM_MODE)
 	msr	cpsr_c, \rtemp			@ switch to the SYS mode
 	str	sp, [\rd, #\offset]		@ save sp_usr
 	str	lr, [\rd, #\offset + 4]		@ save lr_usr
 	eor	\rtemp, \rtemp, #(SVC_MODE ^ SYSTEM_MODE)
 	msr	cpsr_c, \rtemp			@ switch back to the SVC mode
 	.endm
 	.macro	load_user_sp_lr, rd, rtemp, offset = 0
 	mrs	\rtemp, cpsr
 	eor	\rtemp, \rtemp, #(SVC_MODE ^ SYSTEM_MODE)
 	msr	cpsr_c, \rtemp			@ switch to the SYS mode
 	ldr	sp, [\rd, #\offset]		@ load sp_usr
 	ldr	lr, [\rd, #\offset + 4]		@ load lr_usr
 	eor	\rtemp, \rtemp, #(SVC_MODE ^ SYSTEM_MODE)
 	msr	cpsr_c, \rtemp			@ switch back to the SVC mode
 	.endm
 #ifndef CONFIG_THUMB2_KERNEL
 	.macro	svc_exit, rpsr, irq = 0
 	.if	\irq != 0
 	@ IRQs already off
 #ifdef CONFIG_TRACE_IRQFLAGS
 	@ The parent context IRQs must have been enabled to get here in
 	@ the first place, so there's no point checking the PSR I bit.
 	bl	trace_hardirqs_on
 #endif
 	.else
 	@ IRQs off again before pulling preserved data off the stack
 	disable_irq_notrace
 #ifdef CONFIG_TRACE_IRQFLAGS
 	tst	\rpsr, #PSR_I_BIT
 	bleq	trace_hardirqs_on
 	tst	\rpsr, #PSR_I_BIT
 	blne	trace_hardirqs_off
 #endif
 	.endif
 	msr	spsr_cxsf, \rpsr
 #if defined(CONFIG_CPU_V6)
 	ldr	r0, [sp]
 	strex	r1, r2, [sp]			@ clear the exclusive monitor
 	ldmib	sp, {r1 - pc}^			@ load r1 - pc, cpsr
 #elif defined(CONFIG_CPU_32v6K)
 	clrex					@ clear the exclusive monitor
 	ldmia	sp, {r0 - pc}^			@ load r0 - pc, cpsr
 #else
 	ldmia	sp, {r0 - pc}^			@ load r0 - pc, cpsr
 #endif
 	.endm
 	.macro	restore_user_regs, fast = 0, offset = 0
 	ldr	r1, [sp, #\offset + S_PSR]	@ get calling cpsr
 	ldr	lr, [sp, #\offset + S_PC]!	@ get pc
 	msr	spsr_cxsf, r1			@ save in spsr_svc
 #if defined(CONFIG_CPU_V6)
 	strex	r1, r2, [sp]			@ clear the exclusive monitor
 #elif defined(CONFIG_CPU_32v6K)
 	clrex					@ clear the exclusive monitor
 #endif
 	.if	\fast
 	ldmdb	sp, {r1 - lr}^			@ get calling r1 - lr
 	.else
 	ldmdb	sp, {r0 - lr}^			@ get calling r0 - lr
 	.endif
 	mov	r0, r0				@ ARMv5T and earlier require a nop
 						@ after ldm {}^
 	add	sp, sp, #S_FRAME_SIZE - S_PC
 	movs	pc, lr				@ return & move spsr_svc into cpsr
 	.endm
 	@
 	@ 32-bit wide "mov pc, reg"
 	@
 	.macro	movw_pc, reg
 	mov	pc, \reg
 	.endm
 #else	/* CONFIG_THUMB2_KERNEL */
 	.macro	svc_exit, rpsr, irq = 0
 	.if	\irq != 0
 	@ IRQs already off
 #ifdef CONFIG_TRACE_IRQFLAGS
 	@ The parent context IRQs must have been enabled to get here in
 	@ the first place, so there's no point checking the PSR I bit.
 	bl	trace_hardirqs_on
 #endif
 	.else
 	@ IRQs off again before pulling preserved data off the stack
 	disable_irq_notrace
 #ifdef CONFIG_TRACE_IRQFLAGS
 	tst	\rpsr, #PSR_I_BIT
 	bleq	trace_hardirqs_on
 	tst	\rpsr, #PSR_I_BIT
 	blne	trace_hardirqs_off
 #endif
 	.endif
 	ldr	lr, [sp, #S_SP]			@ top of the stack
 	ldrd	r0, r1, [sp, #S_LR]		@ calling lr and pc
 	clrex					@ clear the exclusive monitor
 	stmdb	lr!, {r0, r1, \rpsr}		@ calling lr and rfe context
 	ldmia	sp, {r0 - r12}
 	mov	sp, lr
 	ldr	lr, [sp], #4
 	rfeia	sp!
 	.endm
 #ifdef CONFIG_CPU_V7M
 	/*
 	 * Note we don't need to do clrex here as clearing the local monitor is
 	 * part of each exception entry and exit sequence.
 	 */
 	.macro	restore_user_regs, fast = 0, offset = 0
 	.if	\offset
 	add	sp, #\offset
 	.endif
 	v7m_exception_slow_exit ret_r0 = \fast
 	.endm
 #else	/* ifdef CONFIG_CPU_V7M */
 	.macro	restore_user_regs, fast = 0, offset = 0
 	clrex					@ clear the exclusive monitor
 	mov	r2, sp
 	load_user_sp_lr r2, r3, \offset + S_SP	@ calling sp, lr
 	ldr	r1, [sp, #\offset + S_PSR]	@ get calling cpsr
 	ldr	lr, [sp, #\offset + S_PC]	@ get pc
 	add	sp, sp, #\offset + S_SP
 	msr	spsr_cxsf, r1			@ save in spsr_svc
 	.if	\fast
 	ldmdb	sp, {r1 - r12}			@ get calling r1 - r12
 	.else
 	ldmdb	sp, {r0 - r12}			@ get calling r0 - r12
 	.endif
 	add	sp, sp, #S_FRAME_SIZE - S_SP
 	movs	pc, lr				@ return & move spsr_svc into cpsr
 	.endm
 #endif	/* ifdef CONFIG_CPU_V7M / else */
 	@
 	@ 32-bit wide "mov pc, reg"
 	@
 	.macro	movw_pc, reg
 	mov	pc, \reg
 	nop
 	.endm
 #endif	/* !CONFIG_THUMB2_KERNEL */
 /*
  * Context tracking subsystem.  Used to instrument transitions
  * between user and kernel mode.
  */
 	.macro ct_user_exit, save = 1
 #ifdef CONFIG_CONTEXT_TRACKING
 	.if	\save
 	stmdb   sp!, {r0-r3, ip, lr}
 	bl	context_tracking_user_exit
 	ldmia	sp!, {r0-r3, ip, lr}
 	.else
 	bl	context_tracking_user_exit
 	.endif
 #endif
 	.endm
 	.macro ct_user_enter, save = 1
 #ifdef CONFIG_CONTEXT_TRACKING
 	.if	\save
 	stmdb   sp!, {r0-r3, ip, lr}
 	bl	context_tracking_user_enter
 	ldmia	sp!, {r0-r3, ip, lr}
 	.else
 	bl	context_tracking_user_enter
 	.endif
 #endif
 	.endm
 /*
  * These are the registers used in the syscall handler, and allow us to
  * have in theory up to 7 arguments to a function - r0 to r6.
  *
  * r7 is reserved for the system call number for thumb mode.
  *
  * Note that tbl == why is intentional.
  *
  * We must set at least "tsk" and "why" when calling ret_with_reschedule.
  */
 scno	.req	r7		@ syscall number
 tbl	.req	r8		@ syscall table pointer
 why	.req	r8		@ Linux syscall (!= 0)
 tsk	.req	r9		@ current thread_info

arch/arm/kernel/unwind.c

Diff comments View file @ fe45736

1	/*	1	/*
2	* arch/arm/kernel/unwind.c	2	* arch/arm/kernel/unwind.c
3	*	3	*
4	* Copyright (C) 2008 ARM Limited	4	* Copyright (C) 2008 ARM Limited
5	*	5	*
6	* This program is free software; you can redistribute it and/or modify	6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License version 2 as	7	* it under the terms of the GNU General Public License version 2 as
8	* published by the Free Software Foundation.	8	* published by the Free Software Foundation.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*	18	*
19	*	19	*
20	* Stack unwinding support for ARM	20	* Stack unwinding support for ARM
21	*	21	*
22	* An ARM EABI version of gcc is required to generate the unwind	22	* An ARM EABI version of gcc is required to generate the unwind
23	* tables. For information about the structure of the unwind tables,	23	* tables. For information about the structure of the unwind tables,
24	* see "Exception Handling ABI for the ARM Architecture" at:	24	* see "Exception Handling ABI for the ARM Architecture" at:
25	*	25	*
26	* http://infocenter.arm.com/help/topic/com.arm.doc.subset.swdev.abi/index.html	26	* http://infocenter.arm.com/help/topic/com.arm.doc.subset.swdev.abi/index.html
27	*/	27	*/
28		28
29	#ifndef __CHECKER__	29	#ifndef __CHECKER__
30	#if !defined (__ARM_EABI__)	30	#if !defined (__ARM_EABI__)
31	#warning Your compiler does not have EABI support.	31	#warning Your compiler does not have EABI support.
32	#warning ARM unwind is known to compile only with EABI compilers.	32	#warning ARM unwind is known to compile only with EABI compilers.
33	#warning Change compiler or disable ARM_UNWIND option.	33	#warning Change compiler or disable ARM_UNWIND option.
34	#elif (__GNUC__ == 4 && __GNUC_MINOR__ <= 2)	34	#elif (__GNUC__ == 4 && __GNUC_MINOR__ <= 2)
35	#warning Your compiler is too buggy; it is known to not compile ARM unwind support.	35	#warning Your compiler is too buggy; it is known to not compile ARM unwind support.
36	#warning Change compiler or disable ARM_UNWIND option.	36	#warning Change compiler or disable ARM_UNWIND option.
37	#endif	37	#endif
38	#endif /* __CHECKER__ */	38	#endif /* __CHECKER__ */
39		39
40	#include <linux/kernel.h>	40	#include <linux/kernel.h>
41	#include <linux/init.h>	41	#include <linux/init.h>
42	#include <linux/export.h>	42	#include <linux/export.h>
43	#include <linux/sched.h>	43	#include <linux/sched.h>
44	#include <linux/slab.h>	44	#include <linux/slab.h>
45	#include <linux/spinlock.h>	45	#include <linux/spinlock.h>
46	#include <linux/list.h>	46	#include <linux/list.h>
47		47
48	#include <asm/stacktrace.h>	48	#include <asm/stacktrace.h>
49	#include <asm/traps.h>	49	#include <asm/traps.h>
50	#include <asm/unwind.h>	50	#include <asm/unwind.h>
51		51
52	/* Dummy functions to avoid linker complaints */	52	/* Dummy functions to avoid linker complaints */
53	void __aeabi_unwind_cpp_pr0(void)	53	void __aeabi_unwind_cpp_pr0(void)
54	{	54	{
55	};	55	};
56	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr0);	56	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr0);
57		57
58	void __aeabi_unwind_cpp_pr1(void)	58	void __aeabi_unwind_cpp_pr1(void)
59	{	59	{
60	};	60	};
61	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr1);	61	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr1);
62		62
63	void __aeabi_unwind_cpp_pr2(void)	63	void __aeabi_unwind_cpp_pr2(void)
64	{	64	{
65	};	65	};
66	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr2);	66	EXPORT_SYMBOL(__aeabi_unwind_cpp_pr2);
67		67
68	struct unwind_ctrl_block {	68	struct unwind_ctrl_block {
69	unsigned long vrs[16]; /* virtual register set */	69	unsigned long vrs[16]; /* virtual register set */
70	const unsigned long insn; / pointer to the current instructions word */	70	const unsigned long insn; / pointer to the current instructions word */
71	unsigned long sp_high; /* highest value of sp allowed */	71	unsigned long sp_high; /* highest value of sp allowed */
72	/*	72	/*
73	* 1 : check for stack overflow for each register pop.	73	* 1 : check for stack overflow for each register pop.
74	* 0 : save overhead if there is plenty of stack remaining.	74	* 0 : save overhead if there is plenty of stack remaining.
75	*/	75	*/
76	int check_each_pop;	76	int check_each_pop;
77	int entries; /* number of entries left to interpret */	77	int entries; /* number of entries left to interpret */
78	int byte; /* current byte number in the instructions word */	78	int byte; /* current byte number in the instructions word */
79	};	79	};
80		80
81	enum regs {	81	enum regs {
82	#ifdef CONFIG_THUMB2_KERNEL	82	#ifdef CONFIG_THUMB2_KERNEL
83	FP = 7,	83	FP = 7,
84	#else	84	#else
85	FP = 11,	85	FP = 11,
86	#endif	86	#endif
87	SP = 13,	87	SP = 13,
88	LR = 14,	88	LR = 14,
89	PC = 15	89	PC = 15
90	};	90	};
91		91
92	extern const struct unwind_idx __start_unwind_idx[];	92	extern const struct unwind_idx __start_unwind_idx[];
93	static const struct unwind_idx *__origin_unwind_idx;	93	static const struct unwind_idx *__origin_unwind_idx;
94	extern const struct unwind_idx __stop_unwind_idx[];	94	extern const struct unwind_idx __stop_unwind_idx[];
95		95
96	static DEFINE_SPINLOCK(unwind_lock);	96	static DEFINE_SPINLOCK(unwind_lock);
97	static LIST_HEAD(unwind_tables);	97	static LIST_HEAD(unwind_tables);
98		98
99	/* Convert a prel31 symbol to an absolute address */	99	/* Convert a prel31 symbol to an absolute address */
100	#define prel31_to_addr(ptr) \	100	#define prel31_to_addr(ptr) \
101	({ \	101	({ \
102	/* sign-extend to 32 bits */ \	102	/* sign-extend to 32 bits */ \
103	long offset = (((long)*(ptr)) << 1) >> 1; \	103	long offset = (((long)*(ptr)) << 1) >> 1; \
104	(unsigned long)(ptr) + offset; \	104	(unsigned long)(ptr) + offset; \
105	})	105	})
106		106
107	/*	107	/*
108	* Binary search in the unwind index. The entries are	108	* Binary search in the unwind index. The entries are
109	* guaranteed to be sorted in ascending order by the linker.	109	* guaranteed to be sorted in ascending order by the linker.
110	*	110	*
111	* start = first entry	111	* start = first entry
112	* origin = first entry with positive offset (or stop if there is no such entry)	112	* origin = first entry with positive offset (or stop if there is no such entry)
113	* stop - 1 = last entry	113	* stop - 1 = last entry
114	*/	114	*/
115	static const struct unwind_idx *search_index(unsigned long addr,	115	static const struct unwind_idx *search_index(unsigned long addr,
116	const struct unwind_idx *start,	116	const struct unwind_idx *start,
117	const struct unwind_idx *origin,	117	const struct unwind_idx *origin,
118	const struct unwind_idx *stop)	118	const struct unwind_idx *stop)
119	{	119	{
120	unsigned long addr_prel31;	120	unsigned long addr_prel31;
121		121
122	pr_debug("%s(%08lx, %p, %p, %p)\n",	122	pr_debug("%s(%08lx, %p, %p, %p)\n",
123	__func__, addr, start, origin, stop);	123	__func__, addr, start, origin, stop);
124		124
125	/*	125	/*
126	* only search in the section with the matching sign. This way the	126	* only search in the section with the matching sign. This way the
127	* prel31 numbers can be compared as unsigned longs.	127	* prel31 numbers can be compared as unsigned longs.
128	*/	128	*/
129	if (addr < (unsigned long)start)	129	if (addr < (unsigned long)start)
130	/* negative offsets: [start; origin) */	130	/* negative offsets: [start; origin) */
131	stop = origin;	131	stop = origin;
132	else	132	else
133	/* positive offsets: [origin; stop) */	133	/* positive offsets: [origin; stop) */
134	start = origin;	134	start = origin;
135		135
136	/* prel31 for address relavive to start */	136	/* prel31 for address relavive to start */
137	addr_prel31 = (addr - (unsigned long)start) & 0x7fffffff;	137	addr_prel31 = (addr - (unsigned long)start) & 0x7fffffff;
138		138
139	while (start < stop - 1) {	139	while (start < stop - 1) {
140	const struct unwind_idx *mid = start + ((stop - start) >> 1);	140	const struct unwind_idx *mid = start + ((stop - start) >> 1);
141		141
142	/*	142	/*
143	* As addr_prel31 is relative to start an offset is needed to	143	* As addr_prel31 is relative to start an offset is needed to
144	* make it relative to mid.	144	* make it relative to mid.
145	*/	145	*/
146	if (addr_prel31 - ((unsigned long)mid - (unsigned long)start) <	146	if (addr_prel31 - ((unsigned long)mid - (unsigned long)start) <
147	mid->addr_offset)	147	mid->addr_offset)
148	stop = mid;	148	stop = mid;
149	else {	149	else {
150	/* keep addr_prel31 relative to start */	150	/* keep addr_prel31 relative to start */
151	addr_prel31 -= ((unsigned long)mid -	151	addr_prel31 -= ((unsigned long)mid -
152	(unsigned long)start);	152	(unsigned long)start);
153	start = mid;	153	start = mid;
154	}	154	}
155	}	155	}
156		156
157	if (likely(start->addr_offset <= addr_prel31))	157	if (likely(start->addr_offset <= addr_prel31))
158	return start;	158	return start;
159	else {	159	else {
160	pr_warning("unwind: Unknown symbol address %08lx\n", addr);	160	pr_warning("unwind: Unknown symbol address %08lx\n", addr);
161	return NULL;	161	return NULL;
162	}	162	}
163	}	163	}
164		164
165	static const struct unwind_idx *unwind_find_origin(	165	static const struct unwind_idx *unwind_find_origin(
166	const struct unwind_idx start, const struct unwind_idx stop)	166	const struct unwind_idx start, const struct unwind_idx stop)
167	{	167	{
168	pr_debug("%s(%p, %p)\n", __func__, start, stop);	168	pr_debug("%s(%p, %p)\n", __func__, start, stop);
169	while (start < stop) {	169	while (start < stop) {
170	const struct unwind_idx *mid = start + ((stop - start) >> 1);	170	const struct unwind_idx *mid = start + ((stop - start) >> 1);
171		171
172	if (mid->addr_offset >= 0x40000000)	172	if (mid->addr_offset >= 0x40000000)
173	/* negative offset */	173	/* negative offset */
174	start = mid + 1;	174	start = mid + 1;
175	else	175	else
176	/* positive offset */	176	/* positive offset */
177	stop = mid;	177	stop = mid;
178	}	178	}
179	pr_debug("%s -> %p\n", __func__, stop);	179	pr_debug("%s -> %p\n", __func__, stop);
180	return stop;	180	return stop;
181	}	181	}
182		182
183	static const struct unwind_idx *unwind_find_idx(unsigned long addr)	183	static const struct unwind_idx *unwind_find_idx(unsigned long addr)
184	{	184	{
185	const struct unwind_idx *idx = NULL;	185	const struct unwind_idx *idx = NULL;
186	unsigned long flags;	186	unsigned long flags;
187		187
188	pr_debug("%s(%08lx)\n", __func__, addr);	188	pr_debug("%s(%08lx)\n", __func__, addr);
189		189
190	if (core_kernel_text(addr)) {	190	if (core_kernel_text(addr)) {
191	if (unlikely(!__origin_unwind_idx))	191	if (unlikely(!__origin_unwind_idx))
192	__origin_unwind_idx =	192	__origin_unwind_idx =
193	unwind_find_origin(__start_unwind_idx,	193	unwind_find_origin(__start_unwind_idx,
194	__stop_unwind_idx);	194	__stop_unwind_idx);
195		195
196	/* main unwind table */	196	/* main unwind table */
197	idx = search_index(addr, __start_unwind_idx,	197	idx = search_index(addr, __start_unwind_idx,
198	__origin_unwind_idx,	198	__origin_unwind_idx,
199	__stop_unwind_idx);	199	__stop_unwind_idx);
200	} else {	200	} else {
201	/* module unwind tables */	201	/* module unwind tables */
202	struct unwind_table *table;	202	struct unwind_table *table;
203		203
204	spin_lock_irqsave(&unwind_lock, flags);	204	spin_lock_irqsave(&unwind_lock, flags);
205	list_for_each_entry(table, &unwind_tables, list) {	205	list_for_each_entry(table, &unwind_tables, list) {
206	if (addr >= table->begin_addr &&	206	if (addr >= table->begin_addr &&
207	addr < table->end_addr) {	207	addr < table->end_addr) {
208	idx = search_index(addr, table->start,	208	idx = search_index(addr, table->start,
209	table->origin,	209	table->origin,
210	table->stop);	210	table->stop);
211	/* Move-to-front to exploit common traces */	211	/* Move-to-front to exploit common traces */
212	list_move(&table->list, &unwind_tables);	212	list_move(&table->list, &unwind_tables);
213	break;	213	break;
214	}	214	}
215	}	215	}
216	spin_unlock_irqrestore(&unwind_lock, flags);	216	spin_unlock_irqrestore(&unwind_lock, flags);
217	}	217	}
218		218
219	pr_debug("%s: idx = %p\n", __func__, idx);	219	pr_debug("%s: idx = %p\n", __func__, idx);
220	return idx;	220	return idx;
221	}	221	}
222		222
223	static unsigned long unwind_get_byte(struct unwind_ctrl_block *ctrl)	223	static unsigned long unwind_get_byte(struct unwind_ctrl_block *ctrl)
224	{	224	{
225	unsigned long ret;	225	unsigned long ret;
226		226
227	if (ctrl->entries <= 0) {	227	if (ctrl->entries <= 0) {
228	pr_warning("unwind: Corrupt unwind table\n");	228	pr_warning("unwind: Corrupt unwind table\n");
229	return 0;	229	return 0;
230	}	230	}
231		231
232	ret = (ctrl->insn >> (ctrl->byte 8)) & 0xff;	232	ret = (ctrl->insn >> (ctrl->byte 8)) & 0xff;
233		233
234	if (ctrl->byte == 0) {	234	if (ctrl->byte == 0) {
235	ctrl->insn++;	235	ctrl->insn++;
236	ctrl->entries--;	236	ctrl->entries--;
237	ctrl->byte = 3;	237	ctrl->byte = 3;
238	} else	238	} else
239	ctrl->byte--;	239	ctrl->byte--;
240		240
241	return ret;	241	return ret;
242	}	242	}
243		243
244	/* Before poping a register check whether it is feasible or not */	244	/* Before poping a register check whether it is feasible or not */
245	static int unwind_pop_register(struct unwind_ctrl_block *ctrl,	245	static int unwind_pop_register(struct unwind_ctrl_block *ctrl,
246	unsigned long **vsp, unsigned int reg)	246	unsigned long **vsp, unsigned int reg)
247	{	247	{
248	if (unlikely(ctrl->check_each_pop))	248	if (unlikely(ctrl->check_each_pop))
249	if (vsp >= (unsigned long )ctrl->sp_high)	249	if (vsp >= (unsigned long )ctrl->sp_high)
250	return -URC_FAILURE;	250	return -URC_FAILURE;
251		251
252	ctrl->vrs[reg] = (vsp)++;	252	ctrl->vrs[reg] = (vsp)++;
253	return URC_OK;	253	return URC_OK;
254	}	254	}
255		255
256	/* Helper functions to execute the instructions */	256	/* Helper functions to execute the instructions */
257	static int unwind_exec_pop_subset_r4_to_r13(struct unwind_ctrl_block *ctrl,	257	static int unwind_exec_pop_subset_r4_to_r13(struct unwind_ctrl_block *ctrl,
258	unsigned long mask)	258	unsigned long mask)
259	{	259	{
260	unsigned long vsp = (unsigned long )ctrl->vrs[SP];	260	unsigned long vsp = (unsigned long )ctrl->vrs[SP];
261	int load_sp, reg = 4;	261	int load_sp, reg = 4;
262		262
263	load_sp = mask & (1 << (13 - 4));	263	load_sp = mask & (1 << (13 - 4));
264	while (mask) {	264	while (mask) {
265	if (mask & 1)	265	if (mask & 1)
266	if (unwind_pop_register(ctrl, &vsp, reg))	266	if (unwind_pop_register(ctrl, &vsp, reg))
267	return -URC_FAILURE;	267	return -URC_FAILURE;
268	mask >>= 1;	268	mask >>= 1;
269	reg++;	269	reg++;
270	}	270	}
271	if (!load_sp)	271	if (!load_sp)
272	ctrl->vrs[SP] = (unsigned long)vsp;	272	ctrl->vrs[SP] = (unsigned long)vsp;
273		273
274	return URC_OK;	274	return URC_OK;
275	}	275	}
276		276
277	static int unwind_exec_pop_r4_to_rN(struct unwind_ctrl_block *ctrl,	277	static int unwind_exec_pop_r4_to_rN(struct unwind_ctrl_block *ctrl,
278	unsigned long insn)	278	unsigned long insn)
279	{	279	{
280	unsigned long vsp = (unsigned long )ctrl->vrs[SP];	280	unsigned long vsp = (unsigned long )ctrl->vrs[SP];
281	int reg;	281	int reg;
282		282
283	/* pop R4-R[4+bbb] */	283	/* pop R4-R[4+bbb] */
284	for (reg = 4; reg <= 4 + (insn & 7); reg++)	284	for (reg = 4; reg <= 4 + (insn & 7); reg++)
285	if (unwind_pop_register(ctrl, &vsp, reg))	285	if (unwind_pop_register(ctrl, &vsp, reg))
286	return -URC_FAILURE;	286	return -URC_FAILURE;
287		287
288	if (insn & 0x80)	288	if (insn & 0x8)
289	if (unwind_pop_register(ctrl, &vsp, 14))	289	if (unwind_pop_register(ctrl, &vsp, 14))
290	return -URC_FAILURE;	290	return -URC_FAILURE;
291		291
292	ctrl->vrs[SP] = (unsigned long)vsp;	292	ctrl->vrs[SP] = (unsigned long)vsp;
293		293
294	return URC_OK;	294	return URC_OK;
295	}	295	}
296		296
297	static int unwind_exec_pop_subset_r0_to_r3(struct unwind_ctrl_block *ctrl,	297	static int unwind_exec_pop_subset_r0_to_r3(struct unwind_ctrl_block *ctrl,
298	unsigned long mask)	298	unsigned long mask)
299	{	299	{
300	unsigned long vsp = (unsigned long )ctrl->vrs[SP];	300	unsigned long vsp = (unsigned long )ctrl->vrs[SP];
301	int reg = 0;	301	int reg = 0;
302		302
303	/* pop R0-R3 according to mask */	303	/* pop R0-R3 according to mask */
304	while (mask) {	304	while (mask) {
305	if (mask & 1)	305	if (mask & 1)
306	if (unwind_pop_register(ctrl, &vsp, reg))	306	if (unwind_pop_register(ctrl, &vsp, reg))
307	return -URC_FAILURE;	307	return -URC_FAILURE;
308	mask >>= 1;	308	mask >>= 1;
309	reg++;	309	reg++;
310	}	310	}
311	ctrl->vrs[SP] = (unsigned long)vsp;	311	ctrl->vrs[SP] = (unsigned long)vsp;
312		312
313	return URC_OK;	313	return URC_OK;
314	}	314	}
315		315
316	/*	316	/*
317	* Execute the current unwind instruction.	317	* Execute the current unwind instruction.
318	*/	318	*/
319	static int unwind_exec_insn(struct unwind_ctrl_block *ctrl)	319	static int unwind_exec_insn(struct unwind_ctrl_block *ctrl)
320	{	320	{
321	unsigned long insn = unwind_get_byte(ctrl);	321	unsigned long insn = unwind_get_byte(ctrl);
322	int ret = URC_OK;	322	int ret = URC_OK;
323		323
324	pr_debug("%s: insn = %08lx\n", __func__, insn);	324	pr_debug("%s: insn = %08lx\n", __func__, insn);
325		325
326	if ((insn & 0xc0) == 0x00)	326	if ((insn & 0xc0) == 0x00)
327	ctrl->vrs[SP] += ((insn & 0x3f) << 2) + 4;	327	ctrl->vrs[SP] += ((insn & 0x3f) << 2) + 4;
328	else if ((insn & 0xc0) == 0x40)	328	else if ((insn & 0xc0) == 0x40)
329	ctrl->vrs[SP] -= ((insn & 0x3f) << 2) + 4;	329	ctrl->vrs[SP] -= ((insn & 0x3f) << 2) + 4;
330	else if ((insn & 0xf0) == 0x80) {	330	else if ((insn & 0xf0) == 0x80) {
331	unsigned long mask;	331	unsigned long mask;
332		332
333	insn = (insn << 8) \| unwind_get_byte(ctrl);	333	insn = (insn << 8) \| unwind_get_byte(ctrl);
334	mask = insn & 0x0fff;	334	mask = insn & 0x0fff;
335	if (mask == 0) {	335	if (mask == 0) {
336	pr_warning("unwind: 'Refuse to unwind' instruction %04lx\n",	336	pr_warning("unwind: 'Refuse to unwind' instruction %04lx\n",
337	insn);	337	insn);
338	return -URC_FAILURE;	338	return -URC_FAILURE;
339	}	339	}
340		340
341	ret = unwind_exec_pop_subset_r4_to_r13(ctrl, mask);	341	ret = unwind_exec_pop_subset_r4_to_r13(ctrl, mask);
342	if (ret)	342	if (ret)
343	goto error;	343	goto error;
344	} else if ((insn & 0xf0) == 0x90 &&	344	} else if ((insn & 0xf0) == 0x90 &&
345	(insn & 0x0d) != 0x0d)	345	(insn & 0x0d) != 0x0d)
346	ctrl->vrs[SP] = ctrl->vrs[insn & 0x0f];	346	ctrl->vrs[SP] = ctrl->vrs[insn & 0x0f];
347	else if ((insn & 0xf0) == 0xa0) {	347	else if ((insn & 0xf0) == 0xa0) {
348	ret = unwind_exec_pop_r4_to_rN(ctrl, insn);	348	ret = unwind_exec_pop_r4_to_rN(ctrl, insn);
349	if (ret)	349	if (ret)
350	goto error;	350	goto error;
351	} else if (insn == 0xb0) {	351	} else if (insn == 0xb0) {
352	if (ctrl->vrs[PC] == 0)	352	if (ctrl->vrs[PC] == 0)
353	ctrl->vrs[PC] = ctrl->vrs[LR];	353	ctrl->vrs[PC] = ctrl->vrs[LR];
354	/* no further processing */	354	/* no further processing */
355	ctrl->entries = 0;	355	ctrl->entries = 0;
356	} else if (insn == 0xb1) {	356	} else if (insn == 0xb1) {
357	unsigned long mask = unwind_get_byte(ctrl);	357	unsigned long mask = unwind_get_byte(ctrl);
358		358
359	if (mask == 0 \|\| mask & 0xf0) {	359	if (mask == 0 \|\| mask & 0xf0) {
360	pr_warning("unwind: Spare encoding %04lx\n",	360	pr_warning("unwind: Spare encoding %04lx\n",
361	(insn << 8) \| mask);	361	(insn << 8) \| mask);
362	return -URC_FAILURE;	362	return -URC_FAILURE;
363	}	363	}
364		364
365	ret = unwind_exec_pop_subset_r0_to_r3(ctrl, mask);	365	ret = unwind_exec_pop_subset_r0_to_r3(ctrl, mask);
366	if (ret)	366	if (ret)
367	goto error;	367	goto error;
368	} else if (insn == 0xb2) {	368	} else if (insn == 0xb2) {
369	unsigned long uleb128 = unwind_get_byte(ctrl);	369	unsigned long uleb128 = unwind_get_byte(ctrl);
370		370
371	ctrl->vrs[SP] += 0x204 + (uleb128 << 2);	371	ctrl->vrs[SP] += 0x204 + (uleb128 << 2);
372	} else {	372	} else {
373	pr_warning("unwind: Unhandled instruction %02lx\n", insn);	373	pr_warning("unwind: Unhandled instruction %02lx\n", insn);
374	return -URC_FAILURE;	374	return -URC_FAILURE;
375	}	375	}
376		376
377	pr_debug("%s: fp = %08lx sp = %08lx lr = %08lx pc = %08lx\n", __func__,	377	pr_debug("%s: fp = %08lx sp = %08lx lr = %08lx pc = %08lx\n", __func__,
378	ctrl->vrs[FP], ctrl->vrs[SP], ctrl->vrs[LR], ctrl->vrs[PC]);	378	ctrl->vrs[FP], ctrl->vrs[SP], ctrl->vrs[LR], ctrl->vrs[PC]);
379		379
380	error:	380	error:
381	return ret;	381	return ret;
382	}	382	}
383		383
384	/*	384	/*
385	* Unwind a single frame starting with sp for the symbol at pc. It	385	* Unwind a single frame starting with sp for the symbol at pc. It
386	* updates the pc and sp with the new values.	386	* updates the pc and sp with the new values.
387	*/	387	*/
388	int unwind_frame(struct stackframe *frame)	388	int unwind_frame(struct stackframe *frame)
389	{	389	{
390	unsigned long low;	390	unsigned long low;
391	const struct unwind_idx *idx;	391	const struct unwind_idx *idx;
392	struct unwind_ctrl_block ctrl;	392	struct unwind_ctrl_block ctrl;
393		393
394	/* store the highest address on the stack to avoid crossing it*/	394	/* store the highest address on the stack to avoid crossing it*/
395	low = frame->sp;	395	low = frame->sp;
396	ctrl.sp_high = ALIGN(low, THREAD_SIZE);	396	ctrl.sp_high = ALIGN(low, THREAD_SIZE);
397		397
398	pr_debug("%s(pc = %08lx lr = %08lx sp = %08lx)\n", __func__,	398	pr_debug("%s(pc = %08lx lr = %08lx sp = %08lx)\n", __func__,
399	frame->pc, frame->lr, frame->sp);	399	frame->pc, frame->lr, frame->sp);
400		400
401	if (!kernel_text_address(frame->pc))	401	if (!kernel_text_address(frame->pc))
402	return -URC_FAILURE;	402	return -URC_FAILURE;
403		403
404	idx = unwind_find_idx(frame->pc);	404	idx = unwind_find_idx(frame->pc);
405	if (!idx) {	405	if (!idx) {
406	pr_warning("unwind: Index not found %08lx\n", frame->pc);	406	pr_warning("unwind: Index not found %08lx\n", frame->pc);
407	return -URC_FAILURE;	407	return -URC_FAILURE;
408	}	408	}
409		409
410	ctrl.vrs[FP] = frame->fp;	410	ctrl.vrs[FP] = frame->fp;
411	ctrl.vrs[SP] = frame->sp;	411	ctrl.vrs[SP] = frame->sp;
412	ctrl.vrs[LR] = frame->lr;	412	ctrl.vrs[LR] = frame->lr;
413	ctrl.vrs[PC] = 0;	413	ctrl.vrs[PC] = 0;
414		414
415	if (idx->insn == 1)	415	if (idx->insn == 1)
416	/* can't unwind */	416	/* can't unwind */
417	return -URC_FAILURE;	417	return -URC_FAILURE;
418	else if ((idx->insn & 0x80000000) == 0)	418	else if ((idx->insn & 0x80000000) == 0)
419	/* prel31 to the unwind table */	419	/* prel31 to the unwind table */
420	ctrl.insn = (unsigned long *)prel31_to_addr(&idx->insn);	420	ctrl.insn = (unsigned long *)prel31_to_addr(&idx->insn);
421	else if ((idx->insn & 0xff000000) == 0x80000000)	421	else if ((idx->insn & 0xff000000) == 0x80000000)
422	/* only personality routine 0 supported in the index */	422	/* only personality routine 0 supported in the index */
423	ctrl.insn = &idx->insn;	423	ctrl.insn = &idx->insn;
424	else {	424	else {
425	pr_warning("unwind: Unsupported personality routine %08lx in the index at %p\n",	425	pr_warning("unwind: Unsupported personality routine %08lx in the index at %p\n",
426	idx->insn, idx);	426	idx->insn, idx);
427	return -URC_FAILURE;	427	return -URC_FAILURE;
428	}	428	}
429		429
430	/* check the personality routine */	430	/* check the personality routine */
431	if ((*ctrl.insn & 0xff000000) == 0x80000000) {	431	if ((*ctrl.insn & 0xff000000) == 0x80000000) {
432	ctrl.byte = 2;	432	ctrl.byte = 2;
433	ctrl.entries = 1;	433	ctrl.entries = 1;
434	} else if ((*ctrl.insn & 0xff000000) == 0x81000000) {	434	} else if ((*ctrl.insn & 0xff000000) == 0x81000000) {
435	ctrl.byte = 1;	435	ctrl.byte = 1;
436	ctrl.entries = 1 + ((*ctrl.insn & 0x00ff0000) >> 16);	436	ctrl.entries = 1 + ((*ctrl.insn & 0x00ff0000) >> 16);
437	} else {	437	} else {
438	pr_warning("unwind: Unsupported personality routine %08lx at %p\n",	438	pr_warning("unwind: Unsupported personality routine %08lx at %p\n",
439	*ctrl.insn, ctrl.insn);	439	*ctrl.insn, ctrl.insn);
440	return -URC_FAILURE;	440	return -URC_FAILURE;
441	}	441	}
442		442
443	ctrl.check_each_pop = 0;	443	ctrl.check_each_pop = 0;
444		444
445	while (ctrl.entries > 0) {	445	while (ctrl.entries > 0) {
446	int urc;	446	int urc;
447	if ((ctrl.sp_high - ctrl.vrs[SP]) < sizeof(ctrl.vrs))	447	if ((ctrl.sp_high - ctrl.vrs[SP]) < sizeof(ctrl.vrs))
448	ctrl.check_each_pop = 1;	448	ctrl.check_each_pop = 1;
449	urc = unwind_exec_insn(&ctrl);	449	urc = unwind_exec_insn(&ctrl);
450	if (urc < 0)	450	if (urc < 0)
451	return urc;	451	return urc;
452	if (ctrl.vrs[SP] < low \|\| ctrl.vrs[SP] >= ctrl.sp_high)	452	if (ctrl.vrs[SP] < low \|\| ctrl.vrs[SP] >= ctrl.sp_high)
453	return -URC_FAILURE;	453	return -URC_FAILURE;
454	}	454	}
455		455
456	if (ctrl.vrs[PC] == 0)	456	if (ctrl.vrs[PC] == 0)
457	ctrl.vrs[PC] = ctrl.vrs[LR];	457	ctrl.vrs[PC] = ctrl.vrs[LR];
458		458
459	/* check for infinite loop */	459	/* check for infinite loop */
460	if (frame->pc == ctrl.vrs[PC])	460	if (frame->pc == ctrl.vrs[PC])
461	return -URC_FAILURE;	461	return -URC_FAILURE;
462		462
463	frame->fp = ctrl.vrs[FP];	463	frame->fp = ctrl.vrs[FP];
464	frame->sp = ctrl.vrs[SP];	464	frame->sp = ctrl.vrs[SP];
465	frame->lr = ctrl.vrs[LR];	465	frame->lr = ctrl.vrs[LR];
466	frame->pc = ctrl.vrs[PC];	466	frame->pc = ctrl.vrs[PC];
467		467
468	return URC_OK;	468	return URC_OK;
469	}	469	}
470		470
471	void unwind_backtrace(struct pt_regs regs, struct task_struct tsk)	471	void unwind_backtrace(struct pt_regs regs, struct task_struct tsk)
472	{	472	{
473	struct stackframe frame;	473	struct stackframe frame;
474	register unsigned long current_sp asm ("sp");	474	register unsigned long current_sp asm ("sp");
475		475
476	pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk);	476	pr_debug("%s(regs = %p tsk = %p)\n", __func__, regs, tsk);
477		477
478	if (!tsk)	478	if (!tsk)
479	tsk = current;	479	tsk = current;
480		480
481	if (regs) {	481	if (regs) {
482	frame.fp = regs->ARM_fp;	482	frame.fp = regs->ARM_fp;
483	frame.sp = regs->ARM_sp;	483	frame.sp = regs->ARM_sp;
484	frame.lr = regs->ARM_lr;	484	frame.lr = regs->ARM_lr;
485	/* PC might be corrupted, use LR in that case. */	485	/* PC might be corrupted, use LR in that case. */
486	frame.pc = kernel_text_address(regs->ARM_pc)	486	frame.pc = kernel_text_address(regs->ARM_pc)
487	? regs->ARM_pc : regs->ARM_lr;	487	? regs->ARM_pc : regs->ARM_lr;
488	} else if (tsk == current) {	488	} else if (tsk == current) {
489	frame.fp = (unsigned long)__builtin_frame_address(0);	489	frame.fp = (unsigned long)__builtin_frame_address(0);
490	frame.sp = current_sp;	490	frame.sp = current_sp;
491	frame.lr = (unsigned long)__builtin_return_address(0);	491	frame.lr = (unsigned long)__builtin_return_address(0);
492	frame.pc = (unsigned long)unwind_backtrace;	492	frame.pc = (unsigned long)unwind_backtrace;
493	} else {	493	} else {
494	/* task blocked in __switch_to */	494	/* task blocked in __switch_to */
495	frame.fp = thread_saved_fp(tsk);	495	frame.fp = thread_saved_fp(tsk);
496	frame.sp = thread_saved_sp(tsk);	496	frame.sp = thread_saved_sp(tsk);
497	/*	497	/*
498	* The function calling __switch_to cannot be a leaf function	498	* The function calling __switch_to cannot be a leaf function
499	* so LR is recovered from the stack.	499	* so LR is recovered from the stack.
500	*/	500	*/
501	frame.lr = 0;	501	frame.lr = 0;
502	frame.pc = thread_saved_pc(tsk);	502	frame.pc = thread_saved_pc(tsk);
503	}	503	}
504		504
505	while (1) {	505	while (1) {
506	int urc;	506	int urc;
507	unsigned long where = frame.pc;	507	unsigned long where = frame.pc;
508		508
509	urc = unwind_frame(&frame);	509	urc = unwind_frame(&frame);
510	if (urc < 0)	510	if (urc < 0)
511	break;	511	break;
512	dump_backtrace_entry(where, frame.pc, frame.sp - 4);	512	dump_backtrace_entry(where, frame.pc, frame.sp - 4);
513	}	513	}
514	}	514	}
515		515
516	struct unwind_table *unwind_table_add(unsigned long start, unsigned long size,	516	struct unwind_table *unwind_table_add(unsigned long start, unsigned long size,
517	unsigned long text_addr,	517	unsigned long text_addr,
518	unsigned long text_size)	518	unsigned long text_size)
519	{	519	{
520	unsigned long flags;	520	unsigned long flags;
521	struct unwind_table tab = kmalloc(sizeof(tab), GFP_KERNEL);	521	struct unwind_table tab = kmalloc(sizeof(tab), GFP_KERNEL);
522		522
523	pr_debug("%s(%08lx, %08lx, %08lx, %08lx)\n", __func__, start, size,	523	pr_debug("%s(%08lx, %08lx, %08lx, %08lx)\n", __func__, start, size,
524	text_addr, text_size);	524	text_addr, text_size);
525		525
526	if (!tab)	526	if (!tab)
527	return tab;	527	return tab;
528		528
529	tab->start = (const struct unwind_idx *)start;	529	tab->start = (const struct unwind_idx *)start;
530	tab->stop = (const struct unwind_idx *)(start + size);	530	tab->stop = (const struct unwind_idx *)(start + size);
531	tab->origin = unwind_find_origin(tab->start, tab->stop);	531	tab->origin = unwind_find_origin(tab->start, tab->stop);
532	tab->begin_addr = text_addr;	532	tab->begin_addr = text_addr;
533	tab->end_addr = text_addr + text_size;	533	tab->end_addr = text_addr + text_size;
534		534
535	spin_lock_irqsave(&unwind_lock, flags);	535	spin_lock_irqsave(&unwind_lock, flags);
536	list_add_tail(&tab->list, &unwind_tables);	536	list_add_tail(&tab->list, &unwind_tables);
537	spin_unlock_irqrestore(&unwind_lock, flags);	537	spin_unlock_irqrestore(&unwind_lock, flags);
538		538
539	return tab;	539	return tab;
540	}	540	}
541		541
542	void unwind_table_del(struct unwind_table *tab)	542	void unwind_table_del(struct unwind_table *tab)
543	{	543	{
544	unsigned long flags;	544	unsigned long flags;
545		545
546	if (!tab)	546	if (!tab)
547	return;	547	return;
548		548
549	spin_lock_irqsave(&unwind_lock, flags);	549	spin_lock_irqsave(&unwind_lock, flags);
550	list_del(&tab->list);	550	list_del(&tab->list);
551	spin_unlock_irqrestore(&unwind_lock, flags);	551	spin_unlock_irqrestore(&unwind_lock, flags);
552		552
553	kfree(tab);	553	kfree(tab);
554	}	554	}
555		555

arch/arm/mm/proc-v7m.S

Diff comments View file @ fe45736

 /*
  *  linux/arch/arm/mm/proc-v7m.S
  *
  *  Copyright (C) 2008 ARM Ltd.
  *  Copyright (C) 2001 Deep Blue Solutions Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  *  This is the "shell" of the ARMv7-M processor support.
  */
 #include <linux/linkage.h>
 #include <asm/assembler.h>
 #include <asm/v7m.h>
 #include "proc-macros.S"
 ENTRY(cpu_v7m_proc_init)
 	mov	pc, lr
 ENDPROC(cpu_v7m_proc_init)
 ENTRY(cpu_v7m_proc_fin)
 	mov	pc, lr
 ENDPROC(cpu_v7m_proc_fin)
 /*
  *	cpu_v7m_reset(loc)
  *
  *	Perform a soft reset of the system.  Put the CPU into the
  *	same state as it would be if it had been reset, and branch
  *	to what would be the reset vector.
  *
  *	- loc   - location to jump to for soft reset
  */
 	.align	5
 ENTRY(cpu_v7m_reset)
 	mov	pc, r0
 ENDPROC(cpu_v7m_reset)
 /*
  *	cpu_v7m_do_idle()
  *
  *	Idle the processor (eg, wait for interrupt).
  *
  *	IRQs are already disabled.
  */
 ENTRY(cpu_v7m_do_idle)
 	wfi
 	mov	pc, lr
 ENDPROC(cpu_v7m_do_idle)
 ENTRY(cpu_v7m_dcache_clean_area)
 	mov	pc, lr
 ENDPROC(cpu_v7m_dcache_clean_area)
 /*
  * There is no MMU, so here is nothing to do.
  */
 ENTRY(cpu_v7m_switch_mm)
 	mov	pc, lr
 ENDPROC(cpu_v7m_switch_mm)
 .globl	cpu_v7m_suspend_size
 .equ	cpu_v7m_suspend_size, 0
 #ifdef CONFIG_ARM_CPU_SUSPEND
 ENTRY(cpu_v7m_do_suspend)
 	mov	pc, lr
 ENDPROC(cpu_v7m_do_suspend)
 ENTRY(cpu_v7m_do_resume)
 	mov	pc, lr
 ENDPROC(cpu_v7m_do_resume)
 #endif
 	.section ".text.init", #alloc, #execinstr
 /*
  *	__v7m_setup
  *
  *	This should be able to cover all ARMv7-M cores.
  */
 __v7m_setup:
 	@ Configure the vector table base address
 	ldr	r0, =BASEADDR_V7M_SCB
 	ldr	r12, =vector_table
 	str	r12, [r0, V7M_SCB_VTOR]
 	@ enable UsageFault, BusFault and MemManage fault.
 	ldr	r5, [r0, #V7M_SCB_SHCSR]
 	orr	r5, #(V7M_SCB_SHCSR_USGFAULTENA | V7M_SCB_SHCSR_BUSFAULTENA | V7M_SCB_SHCSR_MEMFAULTENA)
 	str	r5, [r0, #V7M_SCB_SHCSR]
 	@ Lower the priority of the SVC and PendSV exceptions
 	mov	r5, #0x80000000
 	str	r5, [r0, V7M_SCB_SHPR2]	@ set SVC priority
 	mov	r5, #0x00800000
 	str	r5, [r0, V7M_SCB_SHPR3]	@ set PendSV priority
 	@ SVC to run the kernel in this mode
 	adr	r1, BSYM(1f)
 	ldr	r5, [r12, #11 * 4]	@ read the SVC vector entry
 	str	r1, [r12, #11 * 4]	@ write the temporary SVC vector entry
 	mov	r6, lr			@ save LR
 	mov	r7, sp			@ save SP
 	ldr	sp, =__v7m_setup_stack_top
 	cpsie	i
 	svc	#0
 1:	cpsid	i
 	str	r5, [r12, #11 * 4]	@ restore the original SVC vector entry
 	mov	lr, r6			@ restore LR
 	mov	sp, r7			@ restore SP
 	@ Special-purpose control register
 	mov	r1, #1
 	msr	control, r1		@ Thread mode has unpriviledged access
 	@ Configure the System Control Register to ensure 8-byte stack alignment
 	@ Note the STKALIGN bit is either RW or RAO.
 	ldr	r12, [r0, V7M_SCB_CCR]	@ system control register
 	orr	r12, #V7M_SCB_CCR_STKALIGN
 	str	r12, [r0, V7M_SCB_CCR]
 	mov	pc, lr
 ENDPROC(__v7m_setup)
+	.align 2
+__v7m_setup_stack:
+	.space	4 * 8				@ 8 registers
+__v7m_setup_stack_top:
 	define_processor_functions v7m, dabort=nommu_early_abort, pabort=legacy_pabort, nommu=1
 	.section ".rodata"
 	string cpu_arch_name, "armv7m"
 	string cpu_elf_name "v7m"
 	string cpu_v7m_name "ARMv7-M"
 	.section ".proc.info.init", #alloc, #execinstr
 	/*
 	 * Match any ARMv7-M processor core.
 	 */
 	.type	__v7m_proc_info, #object
 __v7m_proc_info:
 	.long	0x000f0000		@ Required ID value
 	.long	0x000f0000		@ Mask for ID
 	.long   0			@ proc_info_list.__cpu_mm_mmu_flags
 	.long   0			@ proc_info_list.__cpu_io_mmu_flags
 	b	__v7m_setup		@ proc_info_list.__cpu_flush
 	.long	cpu_arch_name
 	.long	cpu_elf_name
 	.long	HWCAP_HALF|HWCAP_THUMB|HWCAP_FAST_MULT
 	.long	cpu_v7m_name
 	.long	v7m_processor_functions	@ proc_info_list.proc
 	.long	0			@ proc_info_list.tlb
 	.long	0			@ proc_info_list.user
 	.long	nop_cache_fns		@ proc_info_list.cache
 	.size	__v7m_proc_info, . - __v7m_proc_info
-__v7m_setup_stack:

include/linux/amba/bus.h

Diff comments View file @ fe45736

 /*
  *  linux/include/amba/bus.h
  *
  *  This device type deals with ARM PrimeCells and anything else that
  *  presents a proper CID (0xB105F00D) at the end of the I/O register
  *  region or that is derived from a PrimeCell.
  *
  *  Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 #ifndef ASMARM_AMBA_H
 #define ASMARM_AMBA_H
 #include <linux/clk.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/err.h>
 #include <linux/resource.h>
 #include <linux/regulator/consumer.h>
 #define AMBA_NR_IRQS	9
 #define AMBA_CID	0xb105f00d
 struct clk;
 struct amba_device {
 	struct device		dev;
 	struct resource		res;
 	struct clk		*pclk;
 	unsigned int		periphid;
 	unsigned int		irq[AMBA_NR_IRQS];
 };
 struct amba_driver {
 	struct device_driver	drv;
 	int			(*probe)(struct amba_device *, const struct amba_id *);
 	int			(*remove)(struct amba_device *);
 	void			(*shutdown)(struct amba_device *);
 	int			(*suspend)(struct amba_device *, pm_message_t);
 	int			(*resume)(struct amba_device *);
 	const struct amba_id	*id_table;
 };
 enum amba_vendor {
 	AMBA_VENDOR_ARM = 0x41,
 	AMBA_VENDOR_ST = 0x80,
+	AMBA_VENDOR_QCOM = 0x51,
 };
 extern struct bus_type amba_bustype;
 #define to_amba_device(d)	container_of(d, struct amba_device, dev)
 #define amba_get_drvdata(d)	dev_get_drvdata(&d->dev)
 #define amba_set_drvdata(d,p)	dev_set_drvdata(&d->dev, p)
 int amba_driver_register(struct amba_driver *);
 void amba_driver_unregister(struct amba_driver *);
 struct amba_device *amba_device_alloc(const char *, resource_size_t, size_t);
 void amba_device_put(struct amba_device *);
 int amba_device_add(struct amba_device *, struct resource *);
 int amba_device_register(struct amba_device *, struct resource *);
 struct amba_device *amba_apb_device_add(struct device *parent, const char *name,
 					resource_size_t base, size_t size,
 					int irq1, int irq2, void *pdata,
 					unsigned int periphid);
 struct amba_device *amba_ahb_device_add(struct device *parent, const char *name,
 					resource_size_t base, size_t size,
 					int irq1, int irq2, void *pdata,
 					unsigned int periphid);
 struct amba_device *
 amba_apb_device_add_res(struct device *parent, const char *name,
 			resource_size_t base, size_t size, int irq1,
 			int irq2, void *pdata, unsigned int periphid,
 			struct resource *resbase);
 struct amba_device *
 amba_ahb_device_add_res(struct device *parent, const char *name,
 			resource_size_t base, size_t size, int irq1,
 			int irq2, void *pdata, unsigned int periphid,
 			struct resource *resbase);
 void amba_device_unregister(struct amba_device *);
 struct amba_device *amba_find_device(const char *, struct device *, unsigned int, unsigned int);
 int amba_request_regions(struct amba_device *, const char *);
 void amba_release_regions(struct amba_device *);
 #define amba_pclk_enable(d)	\
 	(IS_ERR((d)->pclk) ? 0 : clk_enable((d)->pclk))
 #define amba_pclk_disable(d)	\
 	do { if (!IS_ERR((d)->pclk)) clk_disable((d)->pclk); } while (0)
 /* Some drivers don't use the struct amba_device */
 #define AMBA_CONFIG_BITS(a) (((a) >> 24) & 0xff)
 #define AMBA_REV_BITS(a) (((a) >> 20) & 0x0f)
 #define AMBA_MANF_BITS(a) (((a) >> 12) & 0xff)
 #define AMBA_PART_BITS(a) ((a) & 0xfff)
 #define amba_config(d)	AMBA_CONFIG_BITS((d)->periphid)
 #define amba_rev(d)	AMBA_REV_BITS((d)->periphid)
 #define amba_manf(d)	AMBA_MANF_BITS((d)->periphid)
 #define amba_part(d)	AMBA_PART_BITS((d)->periphid)
 #define __AMBA_DEV(busid, data, mask)				\
 	{							\
 		.coherent_dma_mask = mask,			\
 		.init_name = busid,				\
 		.platform_data = data,				\
 	}
 /*
  * APB devices do not themselves have the ability to address memory,
  * so DMA masks should be zero (much like USB peripheral devices.)
  * The DMA controller DMA masks should be used instead (much like
  * USB host controllers in conventional PCs.)
  */
 #define AMBA_APB_DEVICE(name, busid, id, base, irqs, data)	\
 struct amba_device name##_device = {				\
 	.dev = __AMBA_DEV(busid, data, 0),			\
 	.res = DEFINE_RES_MEM(base, SZ_4K),			\
 	.irq = irqs,						\
 	.periphid = id,						\
 }
 /*
  * AHB devices are DMA capable, so set their DMA masks
  */
 #define AMBA_AHB_DEVICE(name, busid, id, base, irqs, data)	\
 struct amba_device name##_device = {				\
 	.dev = __AMBA_DEV(busid, data, ~0ULL),			\
 	.res = DEFINE_RES_MEM(base, SZ_4K),			\
 	.irq = irqs,						\
 	.periphid = id,						\
 }
 /*
  * module_amba_driver() - Helper macro for drivers that don't do anything
  * special in module init/exit.  This eliminates a lot of boilerplate.  Each
  * module may only use this macro once, and calling it replaces module_init()
  * and module_exit()
  */
 #define module_amba_driver(__amba_drv) \
 	module_driver(__amba_drv, amba_driver_register, amba_driver_unregister)
 #endif

Link here
Eric Lee 2015-10-21 05:00:58 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:58 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:58 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:59 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:59 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:59 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:59 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2015-10-21 05:00:59 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-07 07:12:20 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-07 07:12:20 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-07 07:12:20 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-07 07:12:20 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-18 12:35:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-18 12:35:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-18 12:35:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-18 12:35:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 17:38:41 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 17:38:41 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 17:38:41 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 17:38:41 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 18:18:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 18:18:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 18:18:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-20 18:18:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-21 10:48:30 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-21 10:48:30 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-21 10:48:30 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-01-21 10:48:30 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-02-04 11:31:24 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-02-04 11:31:24 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-02-04 11:31:24 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-02-04 11:31:24 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-17 08:35:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-17 08:35:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-17 08:35:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-17 08:35:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-24 02:39:36 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-24 02:39:37 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-24 02:39:37 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2016-08-24 02:39:37 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-03-31 15:58:52 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-03-31 15:58:52 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-03-31 15:58:52 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2017-03-31 15:58:52 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 10:59:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 10:59:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 10:59:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 10:59:08 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:13:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:13:35 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:13:36 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel
Link here
Eric Lee 2018-09-03 11:13:36 UTC

mentioned in commit 1cec24

_mentioned in commit 1cec24_

Choose File ... File name...
Cancel