tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * Locks for smp ppc
3 *
4 * Written by Cort Dougan (cort@cs.nmt.edu)
5 */
6
7#include <linux/config.h>
8#include <linux/sched.h>
9#include <linux/spinlock.h>
10#include <linux/module.h>
11#include <asm/ppc_asm.h>
12#include <asm/smp.h>
13
14#ifdef CONFIG_DEBUG_SPINLOCK
15
16#undef INIT_STUCK
17#define INIT_STUCK 200000000 /*0xffffffff*/
18
19/*
20 * Try to acquire a spinlock.
21 * Only does the stwcx. if the load returned 0 - the Programming
22 * Environments Manual suggests not doing unnecessary stcwx.'s
23 * since they may inhibit forward progress by other CPUs in getting
24 * a lock.
25 */
26static inline unsigned long __spin_trylock(volatile unsigned long *lock)
27{
28 unsigned long ret;
29
30 __asm__ __volatile__ ("\n\
311: lwarx %0,0,%1\n\
32 cmpwi 0,%0,0\n\
33 bne 2f\n"
34 PPC405_ERR77(0,%1)
35" stwcx. %2,0,%1\n\
36 bne- 1b\n\
37 isync\n\
382:"
39 : "=&r"(ret)
40 : "r"(lock), "r"(1)
41 : "cr0", "memory");
42
43 return ret;
44}
45
46void _raw_spin_lock(spinlock_t *lock)
47{
48 int cpu = smp_processor_id();
49 unsigned int stuck = INIT_STUCK;
50 while (__spin_trylock(&lock->lock)) {
51 while ((unsigned volatile long)lock->lock != 0) {
52 if (!--stuck) {
53 printk("_spin_lock(%p) CPU#%d NIP %p"
54 " holder: cpu %ld pc %08lX\n",
55 lock, cpu, __builtin_return_address(0),
56 lock->owner_cpu,lock->owner_pc);
57 stuck = INIT_STUCK;
58 /* steal the lock */
59 /*xchg_u32((void *)&lock->lock,0);*/
60 }
61 }
62 }
63 lock->owner_pc = (unsigned long)__builtin_return_address(0);
64 lock->owner_cpu = cpu;
65}
66EXPORT_SYMBOL(_raw_spin_lock);
67
68int _raw_spin_trylock(spinlock_t *lock)
69{
70 if (__spin_trylock(&lock->lock))
71 return 0;
72 lock->owner_cpu = smp_processor_id();
73 lock->owner_pc = (unsigned long)__builtin_return_address(0);
74 return 1;
75}
76EXPORT_SYMBOL(_raw_spin_trylock);
77
78void _raw_spin_unlock(spinlock_t *lp)
79{
80 if ( !lp->lock )
81 printk("_spin_unlock(%p): no lock cpu %d curr PC %p %s/%d\n",
82 lp, smp_processor_id(), __builtin_return_address(0),
83 current->comm, current->pid);
84 if ( lp->owner_cpu != smp_processor_id() )
85 printk("_spin_unlock(%p): cpu %d trying clear of cpu %d pc %lx val %lx\n",
86 lp, smp_processor_id(), (int)lp->owner_cpu,
87 lp->owner_pc,lp->lock);
88 lp->owner_pc = lp->owner_cpu = 0;
89 wmb();
90 lp->lock = 0;
91}
92EXPORT_SYMBOL(_raw_spin_unlock);
93
94/*
95 * For rwlocks, zero is unlocked, -1 is write-locked,
96 * positive is read-locked.
97 */
98static __inline__ int __read_trylock(rwlock_t *rw)
99{
100 signed int tmp;
101
102 __asm__ __volatile__(
103"2: lwarx %0,0,%1 # __read_trylock\n\
104 addic. %0,%0,1\n\
105 ble- 1f\n"
106 PPC405_ERR77(0,%1)
107" stwcx. %0,0,%1\n\
108 bne- 2b\n\
109 isync\n\
1101:"
111 : "=&r"(tmp)
112 : "r"(&rw->lock)
113 : "cr0", "memory");
114
115 return tmp;
116}
117
118int _raw_read_trylock(rwlock_t *rw)
119{
120 return __read_trylock(rw) > 0;
121}
122EXPORT_SYMBOL(_raw_read_trylock);
123
124void _raw_read_lock(rwlock_t *rw)
125{
126 unsigned int stuck;
127
128 while (__read_trylock(rw) <= 0) {
129 stuck = INIT_STUCK;
130 while (!read_can_lock(rw)) {
131 if (--stuck == 0) {
132 printk("_read_lock(%p) CPU#%d lock %d\n",
133 rw, raw_smp_processor_id(), rw->lock);
134 stuck = INIT_STUCK;
135 }
136 }
137 }
138}
139EXPORT_SYMBOL(_raw_read_lock);
140
141void _raw_read_unlock(rwlock_t *rw)
142{
143 if ( rw->lock == 0 )
144 printk("_read_unlock(): %s/%d (nip %08lX) lock %d\n",
145 current->comm,current->pid,current->thread.regs->nip,
146 rw->lock);
147 wmb();
148 atomic_dec((atomic_t *) &(rw)->lock);
149}
150EXPORT_SYMBOL(_raw_read_unlock);
151
152void _raw_write_lock(rwlock_t *rw)
153{
154 unsigned int stuck;
155
156 while (cmpxchg(&rw->lock, 0, -1) != 0) {
157 stuck = INIT_STUCK;
158 while (!write_can_lock(rw)) {
159 if (--stuck == 0) {
160 printk("write_lock(%p) CPU#%d lock %d)\n",
161 rw, raw_smp_processor_id(), rw->lock);
162 stuck = INIT_STUCK;
163 }
164 }
165 }
166 wmb();
167}
168EXPORT_SYMBOL(_raw_write_lock);
169
170int _raw_write_trylock(rwlock_t *rw)
171{
172 if (cmpxchg(&rw->lock, 0, -1) != 0)
173 return 0;
174 wmb();
175 return 1;
176}
177EXPORT_SYMBOL(_raw_write_trylock);
178
179void _raw_write_unlock(rwlock_t *rw)
180{
181 if (rw->lock >= 0)
182 printk("_write_lock(): %s/%d (nip %08lX) lock %d\n",
183 current->comm,current->pid,current->thread.regs->nip,
184 rw->lock);
185 wmb();
186 rw->lock = 0;
187}
188EXPORT_SYMBOL(_raw_write_unlock);
189
190#endif