Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 08dc2ca6 authored by James Bottomley's avatar James Bottomley Committed by Kyle McMartin
Browse files

[PARISC] Fix our spinlock implementation 



We actually have two separate bad bugs

1. The read_lock implementation spins with disabled interrupts.  This is
completely wrong
2. Our spin_lock_irqsave should check to see if interrupts were enabled
before the call and re-enable interrupts around the inner spin loop.

The problem is that if we spin with interrupts off, we can't receive
IPIs. This has resulted in a bug where SMP machines suddenly spit
smp_call_function timeout messages and hang.

The scenario I've caught is

CPU0 does a flush_tlb_all holding the vmlist_lock for write.
CPU1 tries a cat of /proc/meminfo which tries to acquire vmlist_lock for
     read
CPU1 is now spinning with interrupts disabled
CPU0 tries to execute a smp_call_function to flush the local tlb caches

This is now a deadlock because CPU1 is spinning with interrupts disabled
and can never receive the IPI

Signed-off-by: default avatarJames Bottomley <jejb@parisc-linux.org>
Signed-off-by: default avatarKyle McMartin <kyle@parisc-linux.org>
parent 4269b0d3

include/asm-parisc/spinlock.h

+10 −9
Original line number Diff line number Diff line
@@ -11,18 +11,25 @@ static inline int __raw_spin_is_locked(raw_spinlock_t *x) 
	return *a == 0;

}



#define __raw_spin_lock_flags(lock, flags) __raw_spin_lock(lock)

#define __raw_spin_lock(lock) __raw_spin_lock_flags(lock, 0)

#define __raw_spin_unlock_wait(x) \

		do { cpu_relax(); } while (__raw_spin_is_locked(x))



static inline void __raw_spin_lock(raw_spinlock_t *x)

static inline void __raw_spin_lock_flags(raw_spinlock_t *x,

					 unsigned long flags)

{

	volatile unsigned int *a;



	mb();

	a = __ldcw_align(x);

	while (__ldcw(a) == 0)

		while (*a == 0);

		while (*a == 0)

			if (flags & PSW_SM_I) {

				local_irq_enable();

				cpu_relax();

				local_irq_disable();

			} else

				cpu_relax();

	mb();

}
@@ -60,26 +67,20 @@ static inline int __raw_spin_trylock(raw_spinlock_t *x) 


static  __inline__ void __raw_read_lock(raw_rwlock_t *rw)

{

	unsigned long flags;

	local_irq_save(flags);

	__raw_spin_lock(&rw->lock);



	rw->counter++;



	__raw_spin_unlock(&rw->lock);

	local_irq_restore(flags);

}



static  __inline__ void __raw_read_unlock(raw_rwlock_t *rw)

{

	unsigned long flags;

	local_irq_save(flags);

	__raw_spin_lock(&rw->lock);



	rw->counter--;



	__raw_spin_unlock(&rw->lock);

	local_irq_restore(flags);

}



/* write_lock is less trivial.  We optimistically grab the lock and check