Generic semaphore implementation (64ac24e7) · Commits · e / devices / android_kernel_teracube_mt6765

arch/alpha/kernel/Makefile

+1 −1

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

		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

		obj-$(CONFIG_VGA_HOSE) += console.o

arch/alpha/kernel/alpha_ksyms.c

+0 −9

Original line number	Diff line number	Diff line
		@@ -77,15 +77,6 @@ EXPORT_SYMBOL(__do_clear_user);
		EXPORT_SYMBOL(__strncpy_from_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.
		*/

arch/alpha/kernel/semaphore.c

deleted100644 → 0

+0 −224

Original line number	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	Diff line number	Diff line
		@@ -7,7 +7,7 @@ AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET)
		# Object file lists.

		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

		obj-$(CONFIG_ISA_DMA_API) += dma.o

arch/arm/kernel/semaphore.c

deleted100644 → 0

+0 −221

Original line number	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);