← Back to branch summary

~ubuntu-branches/ubuntu/lucid/9base/lucid

« back to all changes in this revision

Viewing changes to lib9/qlock.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-08-20 17:34:06 UTC
  • mfrom: (6.2.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090820173406-xpwqa9ruyevvc0ut
Tags: 1:3-3
* Updating maintainer field.
* Updating vcs fields.
* Updating package to standards version 3.8.3.
* Updatin variables writing in rules to consistent style.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib9/qlock.c
21
21
void
22
22
lock(Lock *l)
23
23
{
24
 
        /*
25
24
        if(_lock)
26
25
                (*_lock)(l, 1, getcallerpc(&l));
27
26
        else
28
27
                l->held = 1;
29
 
                */
30
28
}
31
29
 
32
30
int
33
31
canlock(Lock *l)
34
32
{
35
 
        /*
36
33
        if(_lock)
37
34
                return (*_lock)(l, 0, getcallerpc(&l));
38
35
        else{
41
38
                l->held = 1;
42
39
                return 1;
43
40
        }
44
 
        */
45
 
        return 1;
46
41
}
47
42
 
48
43
void
49
44
unlock(Lock *l)
50
45
{
51
 
        /*
52
46
        if(_unlock)
53
47
                (*_unlock)(l, getcallerpc(&l));
54
48
        else
55
49
                l->held = 0;
56
 
                */
57
50
}
58
51
 
59
52
void
60
53
qlock(QLock *l)
61
54
{
62
 
        /*
63
55
        if(_qlock)
64
56
                (*_qlock)(l, 1, getcallerpc(&l));
65
57
        else
66
58
                l->l.held = 1;
67
 
                */
68
59
}
69
60
 
70
61
int
71
62
canqlock(QLock *l)
72
63
{
73
 
        /*
74
64
        if(_qlock)
75
65
                return (*_qlock)(l, 0, getcallerpc(&l));
76
66
        else{
79
69
                l->l.held = 1;
80
70
                return 1;
81
71
        }
82
 
        */
83
 
        return 1;
84
72
}
85
73
 
86
74
void
87
75
qunlock(QLock *l)
88
76
{
89
 
        /*
90
77
        if(_qunlock)
91
78
                (*_qunlock)(l, getcallerpc(&l));
92
79
        else
93
80
                l->l.held = 0;
94
 
                */
95
81
}
96
82
 
97
83
void
98
84
rlock(RWLock *l)
99
85
{
100
 
        /*
101
86
        if(_rlock)
102
87
                (*_rlock)(l, 1, getcallerpc(&l));
103
88
        else
104
89
                l->readers++;
105
 
                */
106
90
}
107
91
 
108
92
int
109
93
canrlock(RWLock *l)
110
94
{
111
 
        /*
112
95
        if(_rlock)
113
96
                return (*_rlock)(l, 0, getcallerpc(&l));
114
97
        else{
117
100
                l->readers++;
118
101
                return 1;
119
102
        }
120
 
        */
121
 
        return 1;
122
103
}
123
104
 
124
105
void
125
106
runlock(RWLock *l)
126
107
{
127
 
        /*
128
108
        if(_runlock)
129
109
                (*_runlock)(l, getcallerpc(&l));
130
110
        else
131
111
                l->readers--;
132
 
                */
133
112
}
134
113
 
135
114
void
136
115
wlock(RWLock *l)
137
116
{
138
 
        /*
139
117
        if(_wlock)
140
118
                (*_wlock)(l, 1, getcallerpc(&l));
141
119
        else
142
120
                l->writer = (void*)1;
143
 
                */
144
121
}
145
122
 
146
123
int
147
124
canwlock(RWLock *l)
148
125
{
149
 
        /*
150
126
        if(_wlock)
151
127
                return (*_wlock)(l, 0, getcallerpc(&l));
152
128
        else{
155
131
                l->writer = (void*)1;
156
132
                return 1;
157
133
        }
158
 
        */
159
 
        return 1;
160
134
}
161
135
 
162
136
void
163
137
wunlock(RWLock *l)
164
138
{
165
 
        /*
166
139
        if(_wunlock)
167
140
                (*_wunlock)(l, getcallerpc(&l));
168
141
        else
169
142
                l->writer = nil;
170
 
                */
171
143
}
172
144
 
173
145
void
174
146
rsleep(Rendez *r)
175
147
{
176
 
        /*
177
148
        if(_rsleep)
178
149
                (*_rsleep)(r, getcallerpc(&r));
179
 
                */
180
150
}
181
151
 
182
152
int
183
153
rwakeup(Rendez *r)
184
154
{
185
 
        /*
186
155
        if(_rwakeup)
187
156
                return (*_rwakeup)(r, 0, getcallerpc(&r));
188
 
                */
189
157
        return 0;
190
158
}
191
159
 
192
160
int
193
161
rwakeupall(Rendez *r)
194
162
{
195
 
        /*
196
163
        if(_rwakeup)
197
164
                return (*_rwakeup)(r, 1, getcallerpc(&r));
198
 
                */
199
165
        return 0;
200
166
}