mirror of
https://github.com/edk2-porting/linux-next.git
synced 2024-12-28 15:13:55 +08:00
94c12cc7d1
Major cleanup of all s390 inline assemblies. They now have a common coding style. Quite a few have been shortened, mainly by using register asm variables. Use of the EX_TABLE macro helps as well. The atomic ops, bit ops and locking inlines new use the Q-constraint if a newer gcc is used. That results in slightly better code. Thanks to Christian Borntraeger for proof reading the changes. Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
109 lines
2.7 KiB
C
109 lines
2.7 KiB
C
/*
|
|
* linux/arch/s390/kernel/semaphore.c
|
|
*
|
|
* S390 version
|
|
* Copyright (C) 1998-2000 IBM Corporation
|
|
* Author(s): Martin Schwidefsky
|
|
*
|
|
* Derived from "linux/arch/i386/kernel/semaphore.c
|
|
* Copyright (C) 1999, Linus Torvalds
|
|
*
|
|
*/
|
|
#include <linux/sched.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/init.h>
|
|
|
|
#include <asm/semaphore.h>
|
|
|
|
/*
|
|
* Atomically update sem->count. Equivalent to:
|
|
* old_val = sem->count.counter;
|
|
* new_val = ((old_val >= 0) ? old_val : 0) + incr;
|
|
* sem->count.counter = new_val;
|
|
* return old_val;
|
|
*/
|
|
static inline int __sem_update_count(struct semaphore *sem, int incr)
|
|
{
|
|
int old_val, new_val;
|
|
|
|
asm volatile(
|
|
" l %0,0(%3)\n"
|
|
"0: ltr %1,%0\n"
|
|
" jhe 1f\n"
|
|
" lhi %1,0\n"
|
|
"1: ar %1,%4\n"
|
|
" cs %0,%1,0(%3)\n"
|
|
" jl 0b\n"
|
|
: "=&d" (old_val), "=&d" (new_val), "=m" (sem->count)
|
|
: "a" (&sem->count), "d" (incr), "m" (sem->count)
|
|
: "cc");
|
|
return old_val;
|
|
}
|
|
|
|
/*
|
|
* The inline function up() incremented count but the result
|
|
* was <= 0. This indicates that some process is waiting on
|
|
* the semaphore. The semaphore is free and we'll wake the
|
|
* first sleeping process, so we set count to 1 unless some
|
|
* other cpu has called up in the meantime in which case
|
|
* we just increment count by 1.
|
|
*/
|
|
void __up(struct semaphore *sem)
|
|
{
|
|
__sem_update_count(sem, 1);
|
|
wake_up(&sem->wait);
|
|
}
|
|
|
|
/*
|
|
* The inline function down() decremented count and the result
|
|
* was < 0. The wait loop will atomically test and update the
|
|
* semaphore counter following the rules:
|
|
* count > 0: decrement count, wake up queue and exit.
|
|
* count <= 0: set count to -1, go to sleep.
|
|
*/
|
|
void __sched __down(struct semaphore * sem)
|
|
{
|
|
struct task_struct *tsk = current;
|
|
DECLARE_WAITQUEUE(wait, tsk);
|
|
|
|
__set_task_state(tsk, TASK_UNINTERRUPTIBLE);
|
|
add_wait_queue_exclusive(&sem->wait, &wait);
|
|
while (__sem_update_count(sem, -1) <= 0) {
|
|
schedule();
|
|
set_task_state(tsk, TASK_UNINTERRUPTIBLE);
|
|
}
|
|
remove_wait_queue(&sem->wait, &wait);
|
|
__set_task_state(tsk, TASK_RUNNING);
|
|
wake_up(&sem->wait);
|
|
}
|
|
|
|
/*
|
|
* Same as __down() with an additional test for signals.
|
|
* If a signal is pending the count is updated as follows:
|
|
* count > 0: wake up queue and exit.
|
|
* count <= 0: set count to 0, wake up queue and exit.
|
|
*/
|
|
int __sched __down_interruptible(struct semaphore * sem)
|
|
{
|
|
int retval = 0;
|
|
struct task_struct *tsk = current;
|
|
DECLARE_WAITQUEUE(wait, tsk);
|
|
|
|
__set_task_state(tsk, TASK_INTERRUPTIBLE);
|
|
add_wait_queue_exclusive(&sem->wait, &wait);
|
|
while (__sem_update_count(sem, -1) <= 0) {
|
|
if (signal_pending(current)) {
|
|
__sem_update_count(sem, 0);
|
|
retval = -EINTR;
|
|
break;
|
|
}
|
|
schedule();
|
|
set_task_state(tsk, TASK_INTERRUPTIBLE);
|
|
}
|
|
remove_wait_queue(&sem->wait, &wait);
|
|
__set_task_state(tsk, TASK_RUNNING);
|
|
wake_up(&sem->wait);
|
|
return retval;
|
|
}
|
|
|