Merge branch 'semaphore' of git://git.kernel.org/pub/scm/linux/kernel/git/willy/misc (d7bb545d) · Commits · e / devices / android_kernel_teracube_mt6765

arch/alpha/kernel/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -7,7 +7,7 @@ EXTRA_AFLAGS := $(KBUILD_CFLAGS)
	EXTRA_CFLAGS := -Werror -Wno-sign-compare		EXTRA_CFLAGS := -Werror -Wno-sign-compare

	obj-y := entry.o traps.o process.o init_task.o osf_sys.o irq.o \		obj-y := entry.o traps.o process.o init_task.o osf_sys.o irq.o \
	irq_alpha.o signal.o setup.o ptrace.o time.o semaphore.o \		irq_alpha.o signal.o setup.o ptrace.o time.o \
	alpha_ksyms.o systbls.o err_common.o io.o		alpha_ksyms.o systbls.o err_common.o io.o

	obj-$(CONFIG_VGA_HOSE) += console.o		obj-$(CONFIG_VGA_HOSE) += console.o

arch/alpha/kernel/alpha_ksyms.c

+0 −9

Original line number	Original line	Diff line number	Diff line
	@@ -77,15 +77,6 @@ EXPORT_SYMBOL(__do_clear_user);
	EXPORT_SYMBOL(__strncpy_from_user);		EXPORT_SYMBOL(__strncpy_from_user);
	EXPORT_SYMBOL(__strnlen_user);		EXPORT_SYMBOL(__strnlen_user);

	/* Semaphore helper functions. */
	EXPORT_SYMBOL(__down_failed);
	EXPORT_SYMBOL(__down_failed_interruptible);
	EXPORT_SYMBOL(__up_wakeup);
	EXPORT_SYMBOL(down);
	EXPORT_SYMBOL(down_interruptible);
	EXPORT_SYMBOL(down_trylock);
	EXPORT_SYMBOL(up);

	/*		/*
	* SMP-specific symbols.		* SMP-specific symbols.
	*/		*/

arch/alpha/kernel/semaphore.c

deleted100644 → 0

+0 −224

Original line number	Original line	Diff line number	Diff line
	/*
	* Alpha semaphore implementation.
	*
	* (C) Copyright 1996 Linus Torvalds
	* (C) Copyright 1999, 2000 Richard Henderson
	*/

	#include <linux/errno.h>
	#include <linux/sched.h>
	#include <linux/init.h>

	/*
	* This is basically the PPC semaphore scheme ported to use
	* the Alpha ll/sc sequences, so see the PPC code for
	* credits.
	*/

	/*
	* Atomically update sem->count.
	* This does the equivalent of the following:
	*
	* old_count = sem->count;
	* tmp = MAX(old_count, 0) + incr;
	* sem->count = tmp;
	* return old_count;
	*/
	static inline int __sem_update_count(struct semaphore *sem, int incr)
	{
	long old_count, tmp = 0;

	__asm__ __volatile__(
	"1: ldl_l %0,%2\n"
	" cmovgt %0,%0,%1\n"
	" addl %1,%3,%1\n"
	" stl_c %1,%2\n"
	" beq %1,2f\n"
	" mb\n"
	".subsection 2\n"
	"2: br 1b\n"
	".previous"
	: "=&r" (old_count), "=&r" (tmp), "=m" (sem->count)
	: "Ir" (incr), "1" (tmp), "m" (sem->count));

	return old_count;
	}

	/*
	* Perform the "down" function. Return zero for semaphore acquired,
	* return negative for signalled out of the function.
	*
	* If called from down, the return is ignored and the wait loop is
	* not interruptible. This means that a task waiting on a semaphore
	* using "down()" cannot be killed until someone does an "up()" on
	* the semaphore.
	*
	* If called from down_interruptible, the return value gets checked
	* upon return. If the return value is negative then the task continues
	* with the negative value in the return register (it can be tested by
	* the caller).
	*
	* Either form may be used in conjunction with "up()".
	*/

	void __sched
	__down_failed(struct semaphore *sem)
	{
	struct task_struct *tsk = current;
	DECLARE_WAITQUEUE(wait, tsk);

	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down failed(%p)\n",
	tsk->comm, task_pid_nr(tsk), sem);
	#endif

	tsk->state = TASK_UNINTERRUPTIBLE;
	wmb();
	add_wait_queue_exclusive(&sem->wait, &wait);

	/*
	* Try to get the semaphore. If the count is > 0, then we've
	* got the semaphore; we decrement count and exit the loop.
	* If the count is 0 or negative, we set it to -1, indicating
	* that we are asleep, and then sleep.
	*/
	while (__sem_update_count(sem, -1) <= 0) {
	schedule();
	set_task_state(tsk, TASK_UNINTERRUPTIBLE);
	}
	remove_wait_queue(&sem->wait, &wait);
	tsk->state = TASK_RUNNING;

	/*
	* If there are any more sleepers, wake one of them up so
	* that it can either get the semaphore, or set count to -1
	* indicating that there are still processes sleeping.
	*/
	wake_up(&sem->wait);

	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down acquired(%p)\n",
	tsk->comm, task_pid_nr(tsk), sem);
	#endif
	}

	int __sched
	__down_failed_interruptible(struct semaphore *sem)
	{
	struct task_struct *tsk = current;
	DECLARE_WAITQUEUE(wait, tsk);
	long ret = 0;

	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down failed(%p)\n",
	tsk->comm, task_pid_nr(tsk), sem);
	#endif

	tsk->state = TASK_INTERRUPTIBLE;
	wmb();
	add_wait_queue_exclusive(&sem->wait, &wait);

	while (__sem_update_count(sem, -1) <= 0) {
	if (signal_pending(current)) {
	/*
	* A signal is pending - give up trying.
	* Set sem->count to 0 if it is negative,
	* since we are no longer sleeping.
	*/
	__sem_update_count(sem, 0);
	ret = -EINTR;
	break;
	}
	schedule();
	set_task_state(tsk, TASK_INTERRUPTIBLE);
	}

	remove_wait_queue(&sem->wait, &wait);
	tsk->state = TASK_RUNNING;
	wake_up(&sem->wait);

	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down %s(%p)\n",
	current->comm, task_pid_nr(current),
	(ret < 0 ? "interrupted" : "acquired"), sem);
	#endif
	return ret;
	}

	void
	__up_wakeup(struct semaphore *sem)
	{
	/*
	* Note that we incremented count in up() before we came here,
	* but that was ineffective since the result was <= 0, and
	* any negative value of count is equivalent to 0.
	* This ends up setting count to 1, unless count is now > 0
	* (i.e. because some other cpu has called up() in the meantime),
	* in which case we just increment count.
	*/
	__sem_update_count(sem, 1);
	wake_up(&sem->wait);
	}

	void __sched
	down(struct semaphore *sem)
	{
	#ifdef WAITQUEUE_DEBUG
	CHECK_MAGIC(sem->__magic);
	#endif
	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down(%p) <count=%d> from %p\n",
	current->comm, task_pid_nr(current), sem,
	atomic_read(&sem->count), __builtin_return_address(0));
	#endif
	__down(sem);
	}

	int __sched
	down_interruptible(struct semaphore *sem)
	{
	#ifdef WAITQUEUE_DEBUG
	CHECK_MAGIC(sem->__magic);
	#endif
	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down(%p) <count=%d> from %p\n",
	current->comm, task_pid_nr(current), sem,
	atomic_read(&sem->count), __builtin_return_address(0));
	#endif
	return __down_interruptible(sem);
	}

	int
	down_trylock(struct semaphore *sem)
	{
	int ret;

	#ifdef WAITQUEUE_DEBUG
	CHECK_MAGIC(sem->__magic);
	#endif

	ret = __down_trylock(sem);

	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): down_trylock %s from %p\n",
	current->comm, task_pid_nr(current),
	ret ? "failed" : "acquired",
	__builtin_return_address(0));
	#endif

	return ret;
	}

	void
	up(struct semaphore *sem)
	{
	#ifdef WAITQUEUE_DEBUG
	CHECK_MAGIC(sem->__magic);
	#endif
	#ifdef CONFIG_DEBUG_SEMAPHORE
	printk("%s(%d): up(%p) <count=%d> from %p\n",
	current->comm, task_pid_nr(current), sem,
	atomic_read(&sem->count), __builtin_return_address(0));
	#endif
	__up(sem);
	}

arch/arm/kernel/Makefile

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -7,7 +7,7 @@ AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
	# Object file lists.		# Object file lists.

	obj-y := compat.o entry-armv.o entry-common.o irq.o \		obj-y := compat.o entry-armv.o entry-common.o irq.o \
	process.o ptrace.o semaphore.o setup.o signal.o \		process.o ptrace.o setup.o signal.o \
	sys_arm.o stacktrace.o time.o traps.o		sys_arm.o stacktrace.o time.o traps.o

	obj-$(CONFIG_ISA_DMA_API) += dma.o		obj-$(CONFIG_ISA_DMA_API) += dma.o

arch/arm/kernel/semaphore.c

deleted100644 → 0

+0 −221

Original line number	Original line	Diff line number	Diff line
	/*
	* ARM semaphore implementation, taken from
	*
	* i386 semaphore implementation.
	*
	* (C) Copyright 1999 Linus Torvalds
	*
	* Modified for ARM by Russell King
	*
	* 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/module.h>
	#include <linux/sched.h>
	#include <linux/errno.h>
	#include <linux/init.h>

	#include <asm/semaphore.h>

	/*
	* Semaphores are implemented using a two-way counter:
	* The "count" variable is decremented for each process
	* that tries to acquire the semaphore, while the "sleeping"
	* variable is a count of such acquires.
	*
	* Notably, the inline "up()" and "down()" functions can
	* efficiently test if they need to do any extra work (up
	* needs to do something only if count was negative before
	* the increment operation.
	*
	* "sleeping" and the contention routine ordering is
	* protected by the semaphore spinlock.
	*
	* Note that these functions are only called when there is
	* contention on the lock, and as such all this is the
	* "non-critical" part of the whole semaphore business. The
	* critical part is the inline stuff in <asm/semaphore.h>
	* where we want to avoid any extra jumps and calls.
	*/

	/*
	* Logic:
	* - only on a boundary condition do we need to care. When we go
	* from a negative count to a non-negative, we wake people up.
	* - when we go from a non-negative count to a negative do we
	* (a) synchronize with the "sleeper" count and (b) make sure
	* that we're on the wakeup list before we synchronize so that
	* we cannot lose wakeup events.
	*/

	void __up(struct semaphore *sem)
	{
	wake_up(&sem->wait);
	}

	static DEFINE_SPINLOCK(semaphore_lock);

	void __sched __down(struct semaphore * sem)
	{
	struct task_struct *tsk = current;
	DECLARE_WAITQUEUE(wait, tsk);
	tsk->state = TASK_UNINTERRUPTIBLE;
	add_wait_queue_exclusive(&sem->wait, &wait);

	spin_lock_irq(&semaphore_lock);
	sem->sleepers++;
	for (;;) {
	int sleepers = sem->sleepers;

	/*
	* Add "everybody else" into it. They aren't
	* playing, because we own the spinlock.
	*/
	if (!atomic_add_negative(sleepers - 1, &sem->count)) {
	sem->sleepers = 0;
	break;
	}
	sem->sleepers = 1; /* us - see -1 above */
	spin_unlock_irq(&semaphore_lock);

	schedule();
	tsk->state = TASK_UNINTERRUPTIBLE;
	spin_lock_irq(&semaphore_lock);
	}
	spin_unlock_irq(&semaphore_lock);
	remove_wait_queue(&sem->wait, &wait);
	tsk->state = TASK_RUNNING;
	wake_up(&sem->wait);
	}

	int __sched __down_interruptible(struct semaphore * sem)
	{
	int retval = 0;
	struct task_struct *tsk = current;
	DECLARE_WAITQUEUE(wait, tsk);
	tsk->state = TASK_INTERRUPTIBLE;
	add_wait_queue_exclusive(&sem->wait, &wait);

	spin_lock_irq(&semaphore_lock);
	sem->sleepers ++;
	for (;;) {
	int sleepers = sem->sleepers;

	/*
	* With signals pending, this turns into
	* the trylock failure case - we won't be
	* sleeping, and we* can't get the lock as
	* it has contention. Just correct the count
	* and exit.
	*/
	if (signal_pending(current)) {
	retval = -EINTR;
	sem->sleepers = 0;
	atomic_add(sleepers, &sem->count);
	break;
	}

	/*
	* Add "everybody else" into it. They aren't
	* playing, because we own the spinlock. The
	* "-1" is because we're still hoping to get
	* the lock.
	*/
	if (!atomic_add_negative(sleepers - 1, &sem->count)) {
	sem->sleepers = 0;
	break;
	}
	sem->sleepers = 1; /* us - see -1 above */
	spin_unlock_irq(&semaphore_lock);

	schedule();
	tsk->state = TASK_INTERRUPTIBLE;
	spin_lock_irq(&semaphore_lock);
	}
	spin_unlock_irq(&semaphore_lock);
	tsk->state = TASK_RUNNING;
	remove_wait_queue(&sem->wait, &wait);
	wake_up(&sem->wait);
	return retval;
	}

	/*
	* Trylock failed - make sure we correct for
	* having decremented the count.
	*
	* We could have done the trylock with a
	* single "cmpxchg" without failure cases,
	* but then it wouldn't work on a 386.
	*/
	int __down_trylock(struct semaphore * sem)
	{
	int sleepers;
	unsigned long flags;

	spin_lock_irqsave(&semaphore_lock, flags);
	sleepers = sem->sleepers + 1;
	sem->sleepers = 0;

	/*
	* Add "everybody else" and us into it. They aren't
	* playing, because we own the spinlock.
	*/
	if (!atomic_add_negative(sleepers, &sem->count))
	wake_up(&sem->wait);

	spin_unlock_irqrestore(&semaphore_lock, flags);
	return 1;
	}

	/*
	* The semaphore operations have a special calling sequence that
	* allow us to do a simpler in-line version of them. These routines
	* need to convert that sequence back into the C sequence when
	* there is contention on the semaphore.
	*
	* ip contains the semaphore pointer on entry. Save the C-clobbered
	* registers (r0 to r3 and lr), but not ip, as we use it as a return
	* value in some cases..
	* To remain AAPCS compliant (64-bit stack align) we save r4 as well.
	*/
	asm(" .section .sched.text,\"ax\",%progbits \n\
	.align 5 \n\
	.globl __down_failed \n\
	__down_failed: \n\
	stmfd sp!, {r0 - r4, lr} \n\
	mov r0, ip \n\
	bl __down \n\
	ldmfd sp!, {r0 - r4, pc} \n\
	\n\
	.align 5 \n\
	.globl __down_interruptible_failed \n\
	__down_interruptible_failed: \n\
	stmfd sp!, {r0 - r4, lr} \n\
	mov r0, ip \n\
	bl __down_interruptible \n\
	mov ip, r0 \n\
	ldmfd sp!, {r0 - r4, pc} \n\
	\n\
	.align 5 \n\
	.globl __down_trylock_failed \n\
	__down_trylock_failed: \n\
	stmfd sp!, {r0 - r4, lr} \n\
	mov r0, ip \n\
	bl __down_trylock \n\
	mov ip, r0 \n\
	ldmfd sp!, {r0 - r4, pc} \n\
	\n\
	.align 5 \n\
	.globl __up_wakeup \n\
	__up_wakeup: \n\
	stmfd sp!, {r0 - r4, lr} \n\
	mov r0, ip \n\
	bl __up \n\
	ldmfd sp!, {r0 - r4, pc} \n\
	");

	EXPORT_SYMBOL(__down_failed);
	EXPORT_SYMBOL(__down_interruptible_failed);
	EXPORT_SYMBOL(__down_trylock_failed);
	EXPORT_SYMBOL(__up_wakeup);