git.ipfire.org Git - thirdparty/glibc.git/blob

2 This file is part of the GNU C Library.

3 Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.

5 The GNU C Library is free software; you can redistribute it and/or

6 modify it under the terms of the GNU Lesser General Public

7 License as published by the Free Software Foundation; either

8 version 2.1 of the License, or (at your option) any later version.

10 The GNU C Library is distributed in the hope that it will be useful,

11 but WITHOUT ANY WARRANTY; without even the implied warranty of

12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 Lesser General Public License for more details.

15 You should have received a copy of the GNU Lesser General Public

16 License along with the GNU C Library; if not, see

17 <http://www.gnu.org/licenses/>. */

19 #include <assert.h>

20 #include <errno.h>

21 #include <stdlib.h>

22 #include "pthreadP.h"

23 #include <lowlevellock.h>

25 #ifndef lll_trylock_elision

26 #define lll_trylock_elision(a,t) lll_trylock(a)

27 #endif

29 #ifndef FORCE_ELISION

30 #define FORCE_ELISION(m, s)

31 #endif

33 /* We don't force elision in trylock, because this can lead to inconsistent

34 lock state if the lock was actually busy. */

36 int

37 __pthread_mutex_trylock (mutex)

38 pthread_mutex_t *mutex;

39 {

40 int oldval;

41 pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

43 switch (__builtin_expect (PTHREAD_MUTEX_TYPE_ELISION (mutex),

44 PTHREAD_MUTEX_TIMED_NP))

45 {

46 /* Recursive mutex. */

47 case PTHREAD_MUTEX_RECURSIVE_NP|PTHREAD_MUTEX_ELISION_NP:

48 case PTHREAD_MUTEX_RECURSIVE_NP:

49 /* Check whether we already hold the mutex. */

50 if (mutex->__data.__owner == id)

51 {

52 /* Just bump the counter. */

53 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))

54 /* Overflow of the counter. */

55 return EAGAIN;

57 ++mutex->__data.__count;

58 return 0;

59 }

61 if (lll_trylock (mutex->__data.__lock) == 0)

62 {

63 /* Record the ownership. */

64 mutex->__data.__owner = id;

65 mutex->__data.__count = 1;

66 ++mutex->__data.__nusers;

67 return 0;

68 }

69 break;

71 case PTHREAD_MUTEX_TIMED_ELISION_NP:

72 elision: __attribute__((unused))

73 if (lll_trylock_elision (mutex->__data.__lock,

74 mutex->__data.__elision) != 0)

75 break;

76 /* Don't record the ownership. */

77 return 0;

79 case PTHREAD_MUTEX_TIMED_NP:

80 FORCE_ELISION (mutex, goto elision);

81 /*FALL THROUGH*/

82 case PTHREAD_MUTEX_ADAPTIVE_NP:

83 case PTHREAD_MUTEX_ERRORCHECK_NP:

84 if (lll_trylock (mutex->__data.__lock) != 0)

85 break;

87 /* Record the ownership. */

88 mutex->__data.__owner = id;

89 ++mutex->__data.__nusers;

91 return 0;

93 case PTHREAD_MUTEX_ROBUST_RECURSIVE_NP:

94 case PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP:

95 case PTHREAD_MUTEX_ROBUST_NORMAL_NP:

96 case PTHREAD_MUTEX_ROBUST_ADAPTIVE_NP:

97 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,

98 &mutex->__data.__list.__next);

100 oldval = mutex->__data.__lock;

101 do

102 {

103 again:

104 if ((oldval & FUTEX_OWNER_DIED) != 0)

105 {

106 /* The previous owner died. Try locking the mutex. */

107 int newval = id | (oldval & FUTEX_WAITERS);

108

109 newval

110 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,

111 newval, oldval);

112

113 if (newval != oldval)

114 {

115 oldval = newval;

116 goto again;

117 }

118

119 /* We got the mutex. */

120 mutex->__data.__count = 1;

121 /* But it is inconsistent unless marked otherwise. */

122 mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;

123

124 ENQUEUE_MUTEX (mutex);

125 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

126

127 /* Note that we deliberately exist here. If we fall

128 through to the end of the function __nusers would be

129 incremented which is not correct because the old

130 owner has to be discounted. */

131 return EOWNERDEAD;

132 }

133

134 /* Check whether we already hold the mutex. */

135 if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))

136 {

137 int kind = PTHREAD_MUTEX_TYPE (mutex);

138 if (kind == PTHREAD_MUTEX_ROBUST_ERRORCHECK_NP)

139 {

140 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,

141 NULL);

142 return EDEADLK;

143 }

144

145 if (kind == PTHREAD_MUTEX_ROBUST_RECURSIVE_NP)

146 {

147 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,

148 NULL);

149

150 /* Just bump the counter. */

151 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))

152 /* Overflow of the counter. */

153 return EAGAIN;

154

155 ++mutex->__data.__count;

156

157 return 0;

158 }

159 }

160

161 oldval = lll_robust_trylock (mutex->__data.__lock, id);

162 if (oldval != 0 && (oldval & FUTEX_OWNER_DIED) == 0)

163 {

164 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

165

166 return EBUSY;

167 }

168

169 if (__builtin_expect (mutex->__data.__owner

170 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))

171 {

172 /* This mutex is now not recoverable. */

173 mutex->__data.__count = 0;

174 if (oldval == id)

175 lll_unlock (mutex->__data.__lock,

176 PTHREAD_ROBUST_MUTEX_PSHARED (mutex));

177 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

178 return ENOTRECOVERABLE;

179 }

180 }

181 while ((oldval & FUTEX_OWNER_DIED) != 0);

182

183 ENQUEUE_MUTEX (mutex);

184 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

185

186 mutex->__data.__owner = id;

187 ++mutex->__data.__nusers;

188 mutex->__data.__count = 1;

189

190 return 0;

191

192 case PTHREAD_MUTEX_PI_RECURSIVE_NP:

193 case PTHREAD_MUTEX_PI_ERRORCHECK_NP:

194 case PTHREAD_MUTEX_PI_NORMAL_NP:

195 case PTHREAD_MUTEX_PI_ADAPTIVE_NP:

196 case PTHREAD_MUTEX_PI_ROBUST_RECURSIVE_NP:

197 case PTHREAD_MUTEX_PI_ROBUST_ERRORCHECK_NP:

198 case PTHREAD_MUTEX_PI_ROBUST_NORMAL_NP:

199 case PTHREAD_MUTEX_PI_ROBUST_ADAPTIVE_NP:

200 {

201 int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;

202 int robust = mutex->__data.__kind & PTHREAD_MUTEX_ROBUST_NORMAL_NP;

203

204 if (robust)

205 /* Note: robust PI futexes are signaled by setting bit 0. */

206 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending,

207 (void *) (((uintptr_t) &mutex->__data.__list.__next)

208 | 1));

209

210 oldval = mutex->__data.__lock;

211

212 /* Check whether we already hold the mutex. */

213 if (__builtin_expect ((oldval & FUTEX_TID_MASK) == id, 0))

214 {

215 if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)

216 {

217 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

218 return EDEADLK;

219 }

220

221 if (kind == PTHREAD_MUTEX_RECURSIVE_NP)

222 {

223 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

224

225 /* Just bump the counter. */

226 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))

227 /* Overflow of the counter. */

228 return EAGAIN;

229

230 ++mutex->__data.__count;

231

232 return 0;

233 }

234 }

235

236 oldval

237 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,

238 id, 0);

239

240 if (oldval != 0)

241 {

242 if ((oldval & FUTEX_OWNER_DIED) == 0)

243 {

244 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

245

246 return EBUSY;

247 }

248

249 assert (robust);

250

251 /* The mutex owner died. The kernel will now take care of

252 everything. */

253 int private = (robust

254 ? PTHREAD_ROBUST_MUTEX_PSHARED (mutex)

255 : PTHREAD_MUTEX_PSHARED (mutex));

256 INTERNAL_SYSCALL_DECL (__err);

257 int e = INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,

258 __lll_private_flag (FUTEX_TRYLOCK_PI,

259 private), 0, 0);

260

261 if (INTERNAL_SYSCALL_ERROR_P (e, __err)

262 && INTERNAL_SYSCALL_ERRNO (e, __err) == EWOULDBLOCK)

263 {

264 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

265

266 return EBUSY;

267 }

268

269 oldval = mutex->__data.__lock;

270 }

271

272 if (__builtin_expect (oldval & FUTEX_OWNER_DIED, 0))

273 {

274 atomic_and (&mutex->__data.__lock, ~FUTEX_OWNER_DIED);

275

276 /* We got the mutex. */

277 mutex->__data.__count = 1;

278 /* But it is inconsistent unless marked otherwise. */

279 mutex->__data.__owner = PTHREAD_MUTEX_INCONSISTENT;

280

281 ENQUEUE_MUTEX (mutex);

282 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

283

284 /* Note that we deliberately exit here. If we fall

285 through to the end of the function __nusers would be

286 incremented which is not correct because the old owner

287 has to be discounted. */

288 return EOWNERDEAD;

289 }

290

291 if (robust

292 && __builtin_expect (mutex->__data.__owner

293 == PTHREAD_MUTEX_NOTRECOVERABLE, 0))

294 {

295 /* This mutex is now not recoverable. */

296 mutex->__data.__count = 0;

297

298 INTERNAL_SYSCALL_DECL (__err);

299 INTERNAL_SYSCALL (futex, __err, 4, &mutex->__data.__lock,

300 __lll_private_flag (FUTEX_UNLOCK_PI,

301 PTHREAD_ROBUST_MUTEX_PSHARED (mutex)),

302 0, 0);

303

304 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

305 return ENOTRECOVERABLE;

306 }

307

308 if (robust)

309 {

310 ENQUEUE_MUTEX_PI (mutex);

311 THREAD_SETMEM (THREAD_SELF, robust_head.list_op_pending, NULL);

312 }

313

314 mutex->__data.__owner = id;

315 ++mutex->__data.__nusers;

316 mutex->__data.__count = 1;

317

318 return 0;

319 }

320

321 case PTHREAD_MUTEX_PP_RECURSIVE_NP:

322 case PTHREAD_MUTEX_PP_ERRORCHECK_NP:

323 case PTHREAD_MUTEX_PP_NORMAL_NP:

324 case PTHREAD_MUTEX_PP_ADAPTIVE_NP:

325 {

326 int kind = mutex->__data.__kind & PTHREAD_MUTEX_KIND_MASK_NP;

327

328 oldval = mutex->__data.__lock;

329

330 /* Check whether we already hold the mutex. */

331 if (mutex->__data.__owner == id)

332 {

333 if (kind == PTHREAD_MUTEX_ERRORCHECK_NP)

334 return EDEADLK;

335

336 if (kind == PTHREAD_MUTEX_RECURSIVE_NP)

337 {

338 /* Just bump the counter. */

339 if (__builtin_expect (mutex->__data.__count + 1 == 0, 0))

340 /* Overflow of the counter. */

341 return EAGAIN;

342

343 ++mutex->__data.__count;

344

345 return 0;

346 }

347 }

348

349 int oldprio = -1, ceilval;

350 do

351 {

352 int ceiling = (oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK)

353 >> PTHREAD_MUTEX_PRIO_CEILING_SHIFT;

354

355 if (__pthread_current_priority () > ceiling)

356 {

357 if (oldprio != -1)

358 __pthread_tpp_change_priority (oldprio, -1);

359 return EINVAL;

360 }

361

362 int retval = __pthread_tpp_change_priority (oldprio, ceiling);

363 if (retval)

364 return retval;

365

366 ceilval = ceiling << PTHREAD_MUTEX_PRIO_CEILING_SHIFT;

367 oldprio = ceiling;

368

369 oldval

370 = atomic_compare_and_exchange_val_acq (&mutex->__data.__lock,

371 ceilval | 1, ceilval);

372

373 if (oldval == ceilval)

374 break;

375 }

376 while ((oldval & PTHREAD_MUTEX_PRIO_CEILING_MASK) != ceilval);

377

378 if (oldval != ceilval)

379 {

380 __pthread_tpp_change_priority (oldprio, -1);

381 break;

382 }

383

384 assert (mutex->__data.__owner == 0);

385 /* Record the ownership. */

386 mutex->__data.__owner = id;

387 ++mutex->__data.__nusers;

388 mutex->__data.__count = 1;

389

390 return 0;

391 }

392 break;

393

394 default:

395 /* Correct code cannot set any other type. */

396 return EINVAL;

397 }

398

399 return EBUSY;

400 }

401

402 #ifndef __pthread_mutex_trylock

403 #ifndef pthread_mutex_trylock

404 strong_alias (__pthread_mutex_trylock, pthread_mutex_trylock)

405 #endif

406 #endif