Subversion Repositories HelenOS-historic

Rev

Rev 195 | Rev 383 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 195 Rev 223
Line 29... Line 29...
29 
#include <arch.h>
 29 
#include <arch.h>
30 
 
 30 
 
31 
#include <arch/atomic.h>
 31 
#include <arch/atomic.h>
32 
#include <arch/barrier.h>
 32 
#include <arch/barrier.h>
33 
#include <synch/spinlock.h>
 33 
#include <synch/spinlock.h>
- 
 
 34 
#include <preemption.h>
34 
#include <print.h>
 35 
#include <print.h>
35 
 
 36 
 
36 
#ifdef __SMP__
 37 
#ifdef __SMP__
37 
 
 38 
 
38 
void spinlock_initialize(spinlock_t *sl)
 39 
void spinlock_initialize(spinlock_t *sl)
Line 44... Line 45...
44 
void spinlock_lock(spinlock_t *sl)
 45 
void spinlock_lock(spinlock_t *sl)
45 
{
 46 
{
46 
    int i = 0;
 47 
    int i = 0;
47 
    __address caller = ((__u32 *) &sl)[-1];
 48 
    __address caller = ((__u32 *) &sl)[-1];
48 
 
 49 
 
- 
 
 50 
    preemption_disable();
49 
    while (test_and_set(&sl->val)) {
 51 
    while (test_and_set(&sl->val)) {
50 
        if (i++ > 300000) {
 52 
        if (i++ > 300000) {
51 
            printf("cpu%d: looping on spinlock %X, caller=%X\n", CPU->id, sl, caller);
 53 
            printf("cpu%d: looping on spinlock %X, caller=%X\n", CPU->id, sl, caller);
52 
            i = 0;
 54 
            i = 0;
53 
        }
 55 
        }
Line 56... Line 58...
56 
 
 58 
 
57 
}
 59 
}
58 
#else
 60 
#else
59 
void spinlock_lock(spinlock_t *sl)
 61 
void spinlock_lock(spinlock_t *sl)
60 
{
 62 
{
- 
 
 63 
    preemption_disable();
- 
 
 64 
 
61 
    /*
 65 
    /*
62 
     * Each architecture has its own efficient/recommended
 66 
     * Each architecture has its own efficient/recommended
63 
     * implementation of spinlock.
 67 
     * implementation of spinlock.
64 
     */
 68 
     */
65 
    spinlock_arch(&sl->val);
 69 
    spinlock_arch(&sl->val);
Line 69... Line 73...
69 
 
 73 
 
70 
int spinlock_trylock(spinlock_t *sl)
 74 
int spinlock_trylock(spinlock_t *sl)
71 
{
 75 
{
72 
    int rc;
 76 
    int rc;
73 
   
 77 
   
- 
 
 78 
    preemption_disable();
74 
    rc = !test_and_set(&sl->val);
 79 
    rc = !test_and_set(&sl->val);
75 
    CS_ENTER_BARRIER();
 80 
    CS_ENTER_BARRIER();
- 
 
 81 
 
- 
 
 82 
    if (!rc)
- 
 
 83 
        preemption_enable();
76 
   
 84 
   
77 
    return rc;
 85 
    return rc;
78 
}
 86 
}
79 
 
 87 
 
80 
void spinlock_unlock(spinlock_t *sl)
 88 
void spinlock_unlock(spinlock_t *sl)
81 
{
 89 
{
82 
    CS_LEAVE_BARRIER();
 90 
    CS_LEAVE_BARRIER();
83 
    sl->val = 0;
 91 
    sl->val = 0;
- 
 
 92 
    preemption_enable();
84 
}
 93 
}
85 
 
 94 
 
86 
#endif
 95 
#endif