1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2015, 2016 The FreeBSD Foundation 5 * Copyright (c) 2004, David Xu <davidxu@freebsd.org> 6 * Copyright (c) 2002, Jeffrey Roberson <jeff@freebsd.org> 7 * All rights reserved. 8 * 9 * Portions of this software were developed by Konstantin Belousov 10 * under sponsorship from the FreeBSD Foundation. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice unmodified, this list of conditions, and the following 17 * disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #include "opt_compat.h" 38 #include "opt_umtx_profiling.h" 39 40 #include <sys/param.h> 41 #include <sys/kernel.h> 42 #include <sys/fcntl.h> 43 #include <sys/file.h> 44 #include <sys/filedesc.h> 45 #include <sys/limits.h> 46 #include <sys/lock.h> 47 #include <sys/malloc.h> 48 #include <sys/mman.h> 49 #include <sys/mutex.h> 50 #include <sys/priv.h> 51 #include <sys/proc.h> 52 #include <sys/resource.h> 53 #include <sys/resourcevar.h> 54 #include <sys/rwlock.h> 55 #include <sys/sbuf.h> 56 #include <sys/sched.h> 57 #include <sys/smp.h> 58 #include <sys/sysctl.h> 59 #include <sys/sysent.h> 60 #include <sys/systm.h> 61 #include <sys/sysproto.h> 62 #include <sys/syscallsubr.h> 63 #include <sys/taskqueue.h> 64 #include <sys/time.h> 65 #include <sys/eventhandler.h> 66 #include <sys/umtx.h> 67 68 #include <security/mac/mac_framework.h> 69 70 #include <vm/vm.h> 71 #include <vm/vm_param.h> 72 #include <vm/pmap.h> 73 #include <vm/vm_map.h> 74 #include <vm/vm_object.h> 75 76 #include <machine/atomic.h> 77 #include <machine/cpu.h> 78 79 #ifdef COMPAT_FREEBSD32 80 #include <compat/freebsd32/freebsd32_proto.h> 81 #endif 82 83 #define _UMUTEX_TRY 1 84 #define _UMUTEX_WAIT 2 85 86 #ifdef UMTX_PROFILING 87 #define UPROF_PERC_BIGGER(w, f, sw, sf) \ 88 (((w) > (sw)) || ((w) == (sw) && (f) > (sf))) 89 #endif 90 91 /* Priority inheritance mutex info. */ 92 struct umtx_pi { 93 /* Owner thread */ 94 struct thread *pi_owner; 95 96 /* Reference count */ 97 int pi_refcount; 98 99 /* List entry to link umtx holding by thread */ 100 TAILQ_ENTRY(umtx_pi) pi_link; 101 102 /* List entry in hash */ 103 TAILQ_ENTRY(umtx_pi) pi_hashlink; 104 105 /* List for waiters */ 106 TAILQ_HEAD(,umtx_q) pi_blocked; 107 108 /* Identify a userland lock object */ 109 struct umtx_key pi_key; 110 }; 111 112 /* A userland synchronous object user. */ 113 struct umtx_q { 114 /* Linked list for the hash. */ 115 TAILQ_ENTRY(umtx_q) uq_link; 116 117 /* Umtx key. */ 118 struct umtx_key uq_key; 119 120 /* Umtx flags. */ 121 int uq_flags; 122 #define UQF_UMTXQ 0x0001 123 124 /* The thread waits on. */ 125 struct thread *uq_thread; 126 127 /* 128 * Blocked on PI mutex. read can use chain lock 129 * or umtx_lock, write must have both chain lock and 130 * umtx_lock being hold. 131 */ 132 struct umtx_pi *uq_pi_blocked; 133 134 /* On blocked list */ 135 TAILQ_ENTRY(umtx_q) uq_lockq; 136 137 /* Thread contending with us */ 138 TAILQ_HEAD(,umtx_pi) uq_pi_contested; 139 140 /* Inherited priority from PP mutex */ 141 u_char uq_inherited_pri; 142 143 /* Spare queue ready to be reused */ 144 struct umtxq_queue *uq_spare_queue; 145 146 /* The queue we on */ 147 struct umtxq_queue *uq_cur_queue; 148 }; 149 150 TAILQ_HEAD(umtxq_head, umtx_q); 151 152 /* Per-key wait-queue */ 153 struct umtxq_queue { 154 struct umtxq_head head; 155 struct umtx_key key; 156 LIST_ENTRY(umtxq_queue) link; 157 int length; 158 }; 159 160 LIST_HEAD(umtxq_list, umtxq_queue); 161 162 /* Userland lock object's wait-queue chain */ 163 struct umtxq_chain { 164 /* Lock for this chain. */ 165 struct mtx uc_lock; 166 167 /* List of sleep queues. */ 168 struct umtxq_list uc_queue[2]; 169 #define UMTX_SHARED_QUEUE 0 170 #define UMTX_EXCLUSIVE_QUEUE 1 171 172 LIST_HEAD(, umtxq_queue) uc_spare_queue; 173 174 /* Busy flag */ 175 char uc_busy; 176 177 /* Chain lock waiters */ 178 int uc_waiters; 179 180 /* All PI in the list */ 181 TAILQ_HEAD(,umtx_pi) uc_pi_list; 182 183 #ifdef UMTX_PROFILING 184 u_int length; 185 u_int max_length; 186 #endif 187 }; 188 189 #define UMTXQ_LOCKED_ASSERT(uc) mtx_assert(&(uc)->uc_lock, MA_OWNED) 190 191 /* 192 * Don't propagate time-sharing priority, there is a security reason, 193 * a user can simply introduce PI-mutex, let thread A lock the mutex, 194 * and let another thread B block on the mutex, because B is 195 * sleeping, its priority will be boosted, this causes A's priority to 196 * be boosted via priority propagating too and will never be lowered even 197 * if it is using 100%CPU, this is unfair to other processes. 198 */ 199 200 #define UPRI(td) (((td)->td_user_pri >= PRI_MIN_TIMESHARE &&\ 201 (td)->td_user_pri <= PRI_MAX_TIMESHARE) ?\ 202 PRI_MAX_TIMESHARE : (td)->td_user_pri) 203 204 #define GOLDEN_RATIO_PRIME 2654404609U 205 #ifndef UMTX_CHAINS 206 #define UMTX_CHAINS 512 207 #endif 208 #define UMTX_SHIFTS (__WORD_BIT - 9) 209 210 #define GET_SHARE(flags) \ 211 (((flags) & USYNC_PROCESS_SHARED) == 0 ? THREAD_SHARE : PROCESS_SHARE) 212 213 #define BUSY_SPINS 200 214 215 struct abs_timeout { 216 int clockid; 217 bool is_abs_real; /* TIMER_ABSTIME && CLOCK_REALTIME* */ 218 struct timespec cur; 219 struct timespec end; 220 }; 221 222 #ifdef COMPAT_FREEBSD32 223 struct umutex32 { 224 volatile __lwpid_t m_owner; /* Owner of the mutex */ 225 __uint32_t m_flags; /* Flags of the mutex */ 226 __uint32_t m_ceilings[2]; /* Priority protect ceiling */ 227 __uint32_t m_rb_lnk; /* Robust linkage */ 228 __uint32_t m_pad; 229 __uint32_t m_spare[2]; 230 }; 231 232 _Static_assert(sizeof(struct umutex) == sizeof(struct umutex32), "umutex32"); 233 _Static_assert(__offsetof(struct umutex, m_spare[0]) == 234 __offsetof(struct umutex32, m_spare[0]), "m_spare32"); 235 #endif 236 237 int umtx_shm_vnobj_persistent = 0; 238 SYSCTL_INT(_kern_ipc, OID_AUTO, umtx_vnode_persistent, CTLFLAG_RWTUN, 239 &umtx_shm_vnobj_persistent, 0, 240 "False forces destruction of umtx attached to file, on last close"); 241 static int umtx_max_rb = 1000; 242 SYSCTL_INT(_kern_ipc, OID_AUTO, umtx_max_robust, CTLFLAG_RWTUN, 243 &umtx_max_rb, 0, 244 ""); 245 246 static uma_zone_t umtx_pi_zone; 247 static struct umtxq_chain umtxq_chains[2][UMTX_CHAINS]; 248 static MALLOC_DEFINE(M_UMTX, "umtx", "UMTX queue memory"); 249 static int umtx_pi_allocated; 250 251 static SYSCTL_NODE(_debug, OID_AUTO, umtx, CTLFLAG_RW, 0, "umtx debug"); 252 SYSCTL_INT(_debug_umtx, OID_AUTO, umtx_pi_allocated, CTLFLAG_RD, 253 &umtx_pi_allocated, 0, "Allocated umtx_pi"); 254 static int umtx_verbose_rb = 1; 255 SYSCTL_INT(_debug_umtx, OID_AUTO, robust_faults_verbose, CTLFLAG_RWTUN, 256 &umtx_verbose_rb, 0, 257 ""); 258 259 #ifdef UMTX_PROFILING 260 static long max_length; 261 SYSCTL_LONG(_debug_umtx, OID_AUTO, max_length, CTLFLAG_RD, &max_length, 0, "max_length"); 262 static SYSCTL_NODE(_debug_umtx, OID_AUTO, chains, CTLFLAG_RD, 0, "umtx chain stats"); 263 #endif 264 265 static void abs_timeout_update(struct abs_timeout *timo); 266 267 static void umtx_shm_init(void); 268 static void umtxq_sysinit(void *); 269 static void umtxq_hash(struct umtx_key *key); 270 static struct umtxq_chain *umtxq_getchain(struct umtx_key *key); 271 static void umtxq_lock(struct umtx_key *key); 272 static void umtxq_unlock(struct umtx_key *key); 273 static void umtxq_busy(struct umtx_key *key); 274 static void umtxq_unbusy(struct umtx_key *key); 275 static void umtxq_insert_queue(struct umtx_q *uq, int q); 276 static void umtxq_remove_queue(struct umtx_q *uq, int q); 277 static int umtxq_sleep(struct umtx_q *uq, const char *wmesg, struct abs_timeout *); 278 static int umtxq_count(struct umtx_key *key); 279 static struct umtx_pi *umtx_pi_alloc(int); 280 static void umtx_pi_free(struct umtx_pi *pi); 281 static int do_unlock_pp(struct thread *td, struct umutex *m, uint32_t flags, 282 bool rb); 283 static void umtx_thread_cleanup(struct thread *td); 284 static void umtx_exec_hook(void *arg __unused, struct proc *p __unused, 285 struct image_params *imgp __unused); 286 SYSINIT(umtx, SI_SUB_EVENTHANDLER+1, SI_ORDER_MIDDLE, umtxq_sysinit, NULL); 287 288 #define umtxq_signal(key, nwake) umtxq_signal_queue((key), (nwake), UMTX_SHARED_QUEUE) 289 #define umtxq_insert(uq) umtxq_insert_queue((uq), UMTX_SHARED_QUEUE) 290 #define umtxq_remove(uq) umtxq_remove_queue((uq), UMTX_SHARED_QUEUE) 291 292 static struct mtx umtx_lock; 293 294 #ifdef UMTX_PROFILING 295 static void 296 umtx_init_profiling(void) 297 { 298 struct sysctl_oid *chain_oid; 299 char chain_name[10]; 300 int i; 301 302 for (i = 0; i < UMTX_CHAINS; ++i) { 303 snprintf(chain_name, sizeof(chain_name), "%d", i); 304 chain_oid = SYSCTL_ADD_NODE(NULL, 305 SYSCTL_STATIC_CHILDREN(_debug_umtx_chains), OID_AUTO, 306 chain_name, CTLFLAG_RD, NULL, "umtx hash stats"); 307 SYSCTL_ADD_INT(NULL, SYSCTL_CHILDREN(chain_oid), OID_AUTO, 308 "max_length0", CTLFLAG_RD, &umtxq_chains[0][i].max_length, 0, NULL); 309 SYSCTL_ADD_INT(NULL, SYSCTL_CHILDREN(chain_oid), OID_AUTO, 310 "max_length1", CTLFLAG_RD, &umtxq_chains[1][i].max_length, 0, NULL); 311 } 312 } 313 314 static int 315 sysctl_debug_umtx_chains_peaks(SYSCTL_HANDLER_ARGS) 316 { 317 char buf[512]; 318 struct sbuf sb; 319 struct umtxq_chain *uc; 320 u_int fract, i, j, tot, whole; 321 u_int sf0, sf1, sf2, sf3, sf4; 322 u_int si0, si1, si2, si3, si4; 323 u_int sw0, sw1, sw2, sw3, sw4; 324 325 sbuf_new(&sb, buf, sizeof(buf), SBUF_FIXEDLEN); 326 for (i = 0; i < 2; i++) { 327 tot = 0; 328 for (j = 0; j < UMTX_CHAINS; ++j) { 329 uc = &umtxq_chains[i][j]; 330 mtx_lock(&uc->uc_lock); 331 tot += uc->max_length; 332 mtx_unlock(&uc->uc_lock); 333 } 334 if (tot == 0) 335 sbuf_printf(&sb, "%u) Empty ", i); 336 else { 337 sf0 = sf1 = sf2 = sf3 = sf4 = 0; 338 si0 = si1 = si2 = si3 = si4 = 0; 339 sw0 = sw1 = sw2 = sw3 = sw4 = 0; 340 for (j = 0; j < UMTX_CHAINS; j++) { 341 uc = &umtxq_chains[i][j]; 342 mtx_lock(&uc->uc_lock); 343 whole = uc->max_length * 100; 344 mtx_unlock(&uc->uc_lock); 345 fract = (whole % tot) * 100; 346 if (UPROF_PERC_BIGGER(whole, fract, sw0, sf0)) { 347 sf0 = fract; 348 si0 = j; 349 sw0 = whole; 350 } else if (UPROF_PERC_BIGGER(whole, fract, sw1, 351 sf1)) { 352 sf1 = fract; 353 si1 = j; 354 sw1 = whole; 355 } else if (UPROF_PERC_BIGGER(whole, fract, sw2, 356 sf2)) { 357 sf2 = fract; 358 si2 = j; 359 sw2 = whole; 360 } else if (UPROF_PERC_BIGGER(whole, fract, sw3, 361 sf3)) { 362 sf3 = fract; 363 si3 = j; 364 sw3 = whole; 365 } else if (UPROF_PERC_BIGGER(whole, fract, sw4, 366 sf4)) { 367 sf4 = fract; 368 si4 = j; 369 sw4 = whole; 370 } 371 } 372 sbuf_printf(&sb, "queue %u:\n", i); 373 sbuf_printf(&sb, "1st: %u.%u%% idx: %u\n", sw0 / tot, 374 sf0 / tot, si0); 375 sbuf_printf(&sb, "2nd: %u.%u%% idx: %u\n", sw1 / tot, 376 sf1 / tot, si1); 377 sbuf_printf(&sb, "3rd: %u.%u%% idx: %u\n", sw2 / tot, 378 sf2 / tot, si2); 379 sbuf_printf(&sb, "4th: %u.%u%% idx: %u\n", sw3 / tot, 380 sf3 / tot, si3); 381 sbuf_printf(&sb, "5th: %u.%u%% idx: %u\n", sw4 / tot, 382 sf4 / tot, si4); 383 } 384 } 385 sbuf_trim(&sb); 386 sbuf_finish(&sb); 387 sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req); 388 sbuf_delete(&sb); 389 return (0); 390 } 391 392 static int 393 sysctl_debug_umtx_chains_clear(SYSCTL_HANDLER_ARGS) 394 { 395 struct umtxq_chain *uc; 396 u_int i, j; 397 int clear, error; 398 399 clear = 0; 400 error = sysctl_handle_int(oidp, &clear, 0, req); 401 if (error != 0 || req->newptr == NULL) 402 return (error); 403 404 if (clear != 0) { 405 for (i = 0; i < 2; ++i) { 406 for (j = 0; j < UMTX_CHAINS; ++j) { 407 uc = &umtxq_chains[i][j]; 408 mtx_lock(&uc->uc_lock); 409 uc->length = 0; 410 uc->max_length = 0; 411 mtx_unlock(&uc->uc_lock); 412 } 413 } 414 } 415 return (0); 416 } 417 418 SYSCTL_PROC(_debug_umtx_chains, OID_AUTO, clear, 419 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 0, 420 sysctl_debug_umtx_chains_clear, "I", "Clear umtx chains statistics"); 421 SYSCTL_PROC(_debug_umtx_chains, OID_AUTO, peaks, 422 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, 0, 0, 423 sysctl_debug_umtx_chains_peaks, "A", "Highest peaks in chains max length"); 424 #endif 425 426 static void 427 umtxq_sysinit(void *arg __unused) 428 { 429 int i, j; 430 431 umtx_pi_zone = uma_zcreate("umtx pi", sizeof(struct umtx_pi), 432 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0); 433 for (i = 0; i < 2; ++i) { 434 for (j = 0; j < UMTX_CHAINS; ++j) { 435 mtx_init(&umtxq_chains[i][j].uc_lock, "umtxql", NULL, 436 MTX_DEF | MTX_DUPOK); 437 LIST_INIT(&umtxq_chains[i][j].uc_queue[0]); 438 LIST_INIT(&umtxq_chains[i][j].uc_queue[1]); 439 LIST_INIT(&umtxq_chains[i][j].uc_spare_queue); 440 TAILQ_INIT(&umtxq_chains[i][j].uc_pi_list); 441 umtxq_chains[i][j].uc_busy = 0; 442 umtxq_chains[i][j].uc_waiters = 0; 443 #ifdef UMTX_PROFILING 444 umtxq_chains[i][j].length = 0; 445 umtxq_chains[i][j].max_length = 0; 446 #endif 447 } 448 } 449 #ifdef UMTX_PROFILING 450 umtx_init_profiling(); 451 #endif 452 mtx_init(&umtx_lock, "umtx lock", NULL, MTX_DEF); 453 EVENTHANDLER_REGISTER(process_exec, umtx_exec_hook, NULL, 454 EVENTHANDLER_PRI_ANY); 455 umtx_shm_init(); 456 } 457 458 struct umtx_q * 459 umtxq_alloc(void) 460 { 461 struct umtx_q *uq; 462 463 uq = malloc(sizeof(struct umtx_q), M_UMTX, M_WAITOK | M_ZERO); 464 uq->uq_spare_queue = malloc(sizeof(struct umtxq_queue), M_UMTX, 465 M_WAITOK | M_ZERO); 466 TAILQ_INIT(&uq->uq_spare_queue->head); 467 TAILQ_INIT(&uq->uq_pi_contested); 468 uq->uq_inherited_pri = PRI_MAX; 469 return (uq); 470 } 471 472 void 473 umtxq_free(struct umtx_q *uq) 474 { 475 476 MPASS(uq->uq_spare_queue != NULL); 477 free(uq->uq_spare_queue, M_UMTX); 478 free(uq, M_UMTX); 479 } 480 481 static inline void 482 umtxq_hash(struct umtx_key *key) 483 { 484 unsigned n; 485 486 n = (uintptr_t)key->info.both.a + key->info.both.b; 487 key->hash = ((n * GOLDEN_RATIO_PRIME) >> UMTX_SHIFTS) % UMTX_CHAINS; 488 } 489 490 static inline struct umtxq_chain * 491 umtxq_getchain(struct umtx_key *key) 492 { 493 494 if (key->type <= TYPE_SEM) 495 return (&umtxq_chains[1][key->hash]); 496 return (&umtxq_chains[0][key->hash]); 497 } 498 499 /* 500 * Lock a chain. 501 */ 502 static inline void 503 umtxq_lock(struct umtx_key *key) 504 { 505 struct umtxq_chain *uc; 506 507 uc = umtxq_getchain(key); 508 mtx_lock(&uc->uc_lock); 509 } 510 511 /* 512 * Unlock a chain. 513 */ 514 static inline void 515 umtxq_unlock(struct umtx_key *key) 516 { 517 struct umtxq_chain *uc; 518 519 uc = umtxq_getchain(key); 520 mtx_unlock(&uc->uc_lock); 521 } 522 523 /* 524 * Set chain to busy state when following operation 525 * may be blocked (kernel mutex can not be used). 526 */ 527 static inline void 528 umtxq_busy(struct umtx_key *key) 529 { 530 struct umtxq_chain *uc; 531 532 uc = umtxq_getchain(key); 533 mtx_assert(&uc->uc_lock, MA_OWNED); 534 if (uc->uc_busy) { 535 #ifdef SMP 536 if (smp_cpus > 1) { 537 int count = BUSY_SPINS; 538 if (count > 0) { 539 umtxq_unlock(key); 540 while (uc->uc_busy && --count > 0) 541 cpu_spinwait(); 542 umtxq_lock(key); 543 } 544 } 545 #endif 546 while (uc->uc_busy) { 547 uc->uc_waiters++; 548 msleep(uc, &uc->uc_lock, 0, "umtxqb", 0); 549 uc->uc_waiters--; 550 } 551 } 552 uc->uc_busy = 1; 553 } 554 555 /* 556 * Unbusy a chain. 557 */ 558 static inline void 559 umtxq_unbusy(struct umtx_key *key) 560 { 561 struct umtxq_chain *uc; 562 563 uc = umtxq_getchain(key); 564 mtx_assert(&uc->uc_lock, MA_OWNED); 565 KASSERT(uc->uc_busy != 0, ("not busy")); 566 uc->uc_busy = 0; 567 if (uc->uc_waiters) 568 wakeup_one(uc); 569 } 570 571 static inline void 572 umtxq_unbusy_unlocked(struct umtx_key *key) 573 { 574 575 umtxq_lock(key); 576 umtxq_unbusy(key); 577 umtxq_unlock(key); 578 } 579 580 static struct umtxq_queue * 581 umtxq_queue_lookup(struct umtx_key *key, int q) 582 { 583 struct umtxq_queue *uh; 584 struct umtxq_chain *uc; 585 586 uc = umtxq_getchain(key); 587 UMTXQ_LOCKED_ASSERT(uc); 588 LIST_FOREACH(uh, &uc->uc_queue[q], link) { 589 if (umtx_key_match(&uh->key, key)) 590 return (uh); 591 } 592 593 return (NULL); 594 } 595 596 static inline void 597 umtxq_insert_queue(struct umtx_q *uq, int q) 598 { 599 struct umtxq_queue *uh; 600 struct umtxq_chain *uc; 601 602 uc = umtxq_getchain(&uq->uq_key); 603 UMTXQ_LOCKED_ASSERT(uc); 604 KASSERT((uq->uq_flags & UQF_UMTXQ) == 0, ("umtx_q is already on queue")); 605 uh = umtxq_queue_lookup(&uq->uq_key, q); 606 if (uh != NULL) { 607 LIST_INSERT_HEAD(&uc->uc_spare_queue, uq->uq_spare_queue, link); 608 } else { 609 uh = uq->uq_spare_queue; 610 uh->key = uq->uq_key; 611 LIST_INSERT_HEAD(&uc->uc_queue[q], uh, link); 612 #ifdef UMTX_PROFILING 613 uc->length++; 614 if (uc->length > uc->max_length) { 615 uc->max_length = uc->length; 616 if (uc->max_length > max_length) 617 max_length = uc->max_length; 618 } 619 #endif 620 } 621 uq->uq_spare_queue = NULL; 622 623 TAILQ_INSERT_TAIL(&uh->head, uq, uq_link); 624 uh->length++; 625 uq->uq_flags |= UQF_UMTXQ; 626 uq->uq_cur_queue = uh; 627 return; 628 } 629 630 static inline void 631 umtxq_remove_queue(struct umtx_q *uq, int q) 632 { 633 struct umtxq_chain *uc; 634 struct umtxq_queue *uh; 635 636 uc = umtxq_getchain(&uq->uq_key); 637 UMTXQ_LOCKED_ASSERT(uc); 638 if (uq->uq_flags & UQF_UMTXQ) { 639 uh = uq->uq_cur_queue; 640 TAILQ_REMOVE(&uh->head, uq, uq_link); 641 uh->length--; 642 uq->uq_flags &= ~UQF_UMTXQ; 643 if (TAILQ_EMPTY(&uh->head)) { 644 KASSERT(uh->length == 0, 645 ("inconsistent umtxq_queue length")); 646 #ifdef UMTX_PROFILING 647 uc->length--; 648 #endif 649 LIST_REMOVE(uh, link); 650 } else { 651 uh = LIST_FIRST(&uc->uc_spare_queue); 652 KASSERT(uh != NULL, ("uc_spare_queue is empty")); 653 LIST_REMOVE(uh, link); 654 } 655 uq->uq_spare_queue = uh; 656 uq->uq_cur_queue = NULL; 657 } 658 } 659 660 /* 661 * Check if there are multiple waiters 662 */ 663 static int 664 umtxq_count(struct umtx_key *key) 665 { 666 struct umtxq_chain *uc; 667 struct umtxq_queue *uh; 668 669 uc = umtxq_getchain(key); 670 UMTXQ_LOCKED_ASSERT(uc); 671 uh = umtxq_queue_lookup(key, UMTX_SHARED_QUEUE); 672 if (uh != NULL) 673 return (uh->length); 674 return (0); 675 } 676 677 /* 678 * Check if there are multiple PI waiters and returns first 679 * waiter. 680 */ 681 static int 682 umtxq_count_pi(struct umtx_key *key, struct umtx_q **first) 683 { 684 struct umtxq_chain *uc; 685 struct umtxq_queue *uh; 686 687 *first = NULL; 688 uc = umtxq_getchain(key); 689 UMTXQ_LOCKED_ASSERT(uc); 690 uh = umtxq_queue_lookup(key, UMTX_SHARED_QUEUE); 691 if (uh != NULL) { 692 *first = TAILQ_FIRST(&uh->head); 693 return (uh->length); 694 } 695 return (0); 696 } 697 698 static int 699 umtxq_check_susp(struct thread *td) 700 { 701 struct proc *p; 702 int error; 703 704 /* 705 * The check for TDF_NEEDSUSPCHK is racy, but it is enough to 706 * eventually break the lockstep loop. 707 */ 708 if ((td->td_flags & TDF_NEEDSUSPCHK) == 0) 709 return (0); 710 error = 0; 711 p = td->td_proc; 712 PROC_LOCK(p); 713 if (P_SHOULDSTOP(p) || 714 ((p->p_flag & P_TRACED) && (td->td_dbgflags & TDB_SUSPEND))) { 715 if (p->p_flag & P_SINGLE_EXIT) 716 error = EINTR; 717 else 718 error = ERESTART; 719 } 720 PROC_UNLOCK(p); 721 return (error); 722 } 723 724 /* 725 * Wake up threads waiting on an userland object. 726 */ 727 728 static int 729 umtxq_signal_queue(struct umtx_key *key, int n_wake, int q) 730 { 731 struct umtxq_chain *uc; 732 struct umtxq_queue *uh; 733 struct umtx_q *uq; 734 int ret; 735 736 ret = 0; 737 uc = umtxq_getchain(key); 738 UMTXQ_LOCKED_ASSERT(uc); 739 uh = umtxq_queue_lookup(key, q); 740 if (uh != NULL) { 741 while ((uq = TAILQ_FIRST(&uh->head)) != NULL) { 742 umtxq_remove_queue(uq, q); 743 wakeup(uq); 744 if (++ret >= n_wake) 745 return (ret); 746 } 747 } 748 return (ret); 749 } 750 751 752 /* 753 * Wake up specified thread. 754 */ 755 static inline void 756 umtxq_signal_thread(struct umtx_q *uq) 757 { 758 struct umtxq_chain *uc; 759 760 uc = umtxq_getchain(&uq->uq_key); 761 UMTXQ_LOCKED_ASSERT(uc); 762 umtxq_remove(uq); 763 wakeup(uq); 764 } 765 766 static inline int 767 tstohz(const struct timespec *tsp) 768 { 769 struct timeval tv; 770 771 TIMESPEC_TO_TIMEVAL(&tv, tsp); 772 return tvtohz(&tv); 773 } 774 775 static void 776 abs_timeout_init(struct abs_timeout *timo, int clockid, int absolute, 777 const struct timespec *timeout) 778 { 779 780 timo->clockid = clockid; 781 if (!absolute) { 782 timo->is_abs_real = false; 783 abs_timeout_update(timo); 784 timo->end = timo->cur; 785 timespecadd(&timo->end, timeout); 786 } else { 787 timo->end = *timeout; 788 timo->is_abs_real = clockid == CLOCK_REALTIME || 789 clockid == CLOCK_REALTIME_FAST || 790 clockid == CLOCK_REALTIME_PRECISE; 791 /* 792 * If is_abs_real, umtxq_sleep will read the clock 793 * after setting td_rtcgen; otherwise, read it here. 794 */ 795 if (!timo->is_abs_real) { 796 abs_timeout_update(timo); 797 } 798 } 799 } 800 801 static void 802 abs_timeout_init2(struct abs_timeout *timo, const struct _umtx_time *umtxtime) 803 { 804 805 abs_timeout_init(timo, umtxtime->_clockid, 806 (umtxtime->_flags & UMTX_ABSTIME) != 0, &umtxtime->_timeout); 807 } 808 809 static inline void 810 abs_timeout_update(struct abs_timeout *timo) 811 { 812 813 kern_clock_gettime(curthread, timo->clockid, &timo->cur); 814 } 815 816 static int 817 abs_timeout_gethz(struct abs_timeout *timo) 818 { 819 struct timespec tts; 820 821 if (timespeccmp(&timo->end, &timo->cur, <=)) 822 return (-1); 823 tts = timo->end; 824 timespecsub(&tts, &timo->cur); 825 return (tstohz(&tts)); 826 } 827 828 static uint32_t 829 umtx_unlock_val(uint32_t flags, bool rb) 830 { 831 832 if (rb) 833 return (UMUTEX_RB_OWNERDEAD); 834 else if ((flags & UMUTEX_NONCONSISTENT) != 0) 835 return (UMUTEX_RB_NOTRECOV); 836 else 837 return (UMUTEX_UNOWNED); 838 839 } 840 841 /* 842 * Put thread into sleep state, before sleeping, check if 843 * thread was removed from umtx queue. 844 */ 845 static inline int 846 umtxq_sleep(struct umtx_q *uq, const char *wmesg, struct abs_timeout *abstime) 847 { 848 struct umtxq_chain *uc; 849 int error, timo; 850 851 if (abstime != NULL && abstime->is_abs_real) { 852 curthread->td_rtcgen = atomic_load_acq_int(&rtc_generation); 853 abs_timeout_update(abstime); 854 } 855 856 uc = umtxq_getchain(&uq->uq_key); 857 UMTXQ_LOCKED_ASSERT(uc); 858 for (;;) { 859 if (!(uq->uq_flags & UQF_UMTXQ)) { 860 error = 0; 861 break; 862 } 863 if (abstime != NULL) { 864 timo = abs_timeout_gethz(abstime); 865 if (timo < 0) { 866 error = ETIMEDOUT; 867 break; 868 } 869 } else 870 timo = 0; 871 error = msleep(uq, &uc->uc_lock, PCATCH | PDROP, wmesg, timo); 872 if (error == EINTR || error == ERESTART) { 873 umtxq_lock(&uq->uq_key); 874 break; 875 } 876 if (abstime != NULL) { 877 if (abstime->is_abs_real) 878 curthread->td_rtcgen = 879 atomic_load_acq_int(&rtc_generation); 880 abs_timeout_update(abstime); 881 } 882 umtxq_lock(&uq->uq_key); 883 } 884 885 curthread->td_rtcgen = 0; 886 return (error); 887 } 888 889 /* 890 * Convert userspace address into unique logical address. 891 */ 892 int 893 umtx_key_get(const void *addr, int type, int share, struct umtx_key *key) 894 { 895 struct thread *td = curthread; 896 vm_map_t map; 897 vm_map_entry_t entry; 898 vm_pindex_t pindex; 899 vm_prot_t prot; 900 boolean_t wired; 901 902 key->type = type; 903 if (share == THREAD_SHARE) { 904 key->shared = 0; 905 key->info.private.vs = td->td_proc->p_vmspace; 906 key->info.private.addr = (uintptr_t)addr; 907 } else { 908 MPASS(share == PROCESS_SHARE || share == AUTO_SHARE); 909 map = &td->td_proc->p_vmspace->vm_map; 910 if (vm_map_lookup(&map, (vm_offset_t)addr, VM_PROT_WRITE, 911 &entry, &key->info.shared.object, &pindex, &prot, 912 &wired) != KERN_SUCCESS) { 913 return (EFAULT); 914 } 915 916 if ((share == PROCESS_SHARE) || 917 (share == AUTO_SHARE && 918 VM_INHERIT_SHARE == entry->inheritance)) { 919 key->shared = 1; 920 key->info.shared.offset = (vm_offset_t)addr - 921 entry->start + entry->offset; 922 vm_object_reference(key->info.shared.object); 923 } else { 924 key->shared = 0; 925 key->info.private.vs = td->td_proc->p_vmspace; 926 key->info.private.addr = (uintptr_t)addr; 927 } 928 vm_map_lookup_done(map, entry); 929 } 930 931 umtxq_hash(key); 932 return (0); 933 } 934 935 /* 936 * Release key. 937 */ 938 void 939 umtx_key_release(struct umtx_key *key) 940 { 941 if (key->shared) 942 vm_object_deallocate(key->info.shared.object); 943 } 944 945 /* 946 * Fetch and compare value, sleep on the address if value is not changed. 947 */ 948 static int 949 do_wait(struct thread *td, void *addr, u_long id, 950 struct _umtx_time *timeout, int compat32, int is_private) 951 { 952 struct abs_timeout timo; 953 struct umtx_q *uq; 954 u_long tmp; 955 uint32_t tmp32; 956 int error = 0; 957 958 uq = td->td_umtxq; 959 if ((error = umtx_key_get(addr, TYPE_SIMPLE_WAIT, 960 is_private ? THREAD_SHARE : AUTO_SHARE, &uq->uq_key)) != 0) 961 return (error); 962 963 if (timeout != NULL) 964 abs_timeout_init2(&timo, timeout); 965 966 umtxq_lock(&uq->uq_key); 967 umtxq_insert(uq); 968 umtxq_unlock(&uq->uq_key); 969 if (compat32 == 0) { 970 error = fueword(addr, &tmp); 971 if (error != 0) 972 error = EFAULT; 973 } else { 974 error = fueword32(addr, &tmp32); 975 if (error == 0) 976 tmp = tmp32; 977 else 978 error = EFAULT; 979 } 980 umtxq_lock(&uq->uq_key); 981 if (error == 0) { 982 if (tmp == id) 983 error = umtxq_sleep(uq, "uwait", timeout == NULL ? 984 NULL : &timo); 985 if ((uq->uq_flags & UQF_UMTXQ) == 0) 986 error = 0; 987 else 988 umtxq_remove(uq); 989 } else if ((uq->uq_flags & UQF_UMTXQ) != 0) { 990 umtxq_remove(uq); 991 } 992 umtxq_unlock(&uq->uq_key); 993 umtx_key_release(&uq->uq_key); 994 if (error == ERESTART) 995 error = EINTR; 996 return (error); 997 } 998 999 /* 1000 * Wake up threads sleeping on the specified address. 1001 */ 1002 int 1003 kern_umtx_wake(struct thread *td, void *uaddr, int n_wake, int is_private) 1004 { 1005 struct umtx_key key; 1006 int ret; 1007 1008 if ((ret = umtx_key_get(uaddr, TYPE_SIMPLE_WAIT, 1009 is_private ? THREAD_SHARE : AUTO_SHARE, &key)) != 0) 1010 return (ret); 1011 umtxq_lock(&key); 1012 umtxq_signal(&key, n_wake); 1013 umtxq_unlock(&key); 1014 umtx_key_release(&key); 1015 return (0); 1016 } 1017 1018 /* 1019 * Lock PTHREAD_PRIO_NONE protocol POSIX mutex. 1020 */ 1021 static int 1022 do_lock_normal(struct thread *td, struct umutex *m, uint32_t flags, 1023 struct _umtx_time *timeout, int mode) 1024 { 1025 struct abs_timeout timo; 1026 struct umtx_q *uq; 1027 uint32_t owner, old, id; 1028 int error, rv; 1029 1030 id = td->td_tid; 1031 uq = td->td_umtxq; 1032 error = 0; 1033 if (timeout != NULL) 1034 abs_timeout_init2(&timo, timeout); 1035 1036 /* 1037 * Care must be exercised when dealing with umtx structure. It 1038 * can fault on any access. 1039 */ 1040 for (;;) { 1041 rv = fueword32(&m->m_owner, &owner); 1042 if (rv == -1) 1043 return (EFAULT); 1044 if (mode == _UMUTEX_WAIT) { 1045 if (owner == UMUTEX_UNOWNED || 1046 owner == UMUTEX_CONTESTED || 1047 owner == UMUTEX_RB_OWNERDEAD || 1048 owner == UMUTEX_RB_NOTRECOV) 1049 return (0); 1050 } else { 1051 /* 1052 * Robust mutex terminated. Kernel duty is to 1053 * return EOWNERDEAD to the userspace. The 1054 * umutex.m_flags UMUTEX_NONCONSISTENT is set 1055 * by the common userspace code. 1056 */ 1057 if (owner == UMUTEX_RB_OWNERDEAD) { 1058 rv = casueword32(&m->m_owner, 1059 UMUTEX_RB_OWNERDEAD, &owner, 1060 id | UMUTEX_CONTESTED); 1061 if (rv == -1) 1062 return (EFAULT); 1063 if (owner == UMUTEX_RB_OWNERDEAD) 1064 return (EOWNERDEAD); /* success */ 1065 rv = umtxq_check_susp(td); 1066 if (rv != 0) 1067 return (rv); 1068 continue; 1069 } 1070 if (owner == UMUTEX_RB_NOTRECOV) 1071 return (ENOTRECOVERABLE); 1072 1073 1074 /* 1075 * Try the uncontested case. This should be 1076 * done in userland. 1077 */ 1078 rv = casueword32(&m->m_owner, UMUTEX_UNOWNED, 1079 &owner, id); 1080 /* The address was invalid. */ 1081 if (rv == -1) 1082 return (EFAULT); 1083 1084 /* The acquire succeeded. */ 1085 if (owner == UMUTEX_UNOWNED) 1086 return (0); 1087 1088 /* 1089 * If no one owns it but it is contested try 1090 * to acquire it. 1091 */ 1092 if (owner == UMUTEX_CONTESTED) { 1093 rv = casueword32(&m->m_owner, 1094 UMUTEX_CONTESTED, &owner, 1095 id | UMUTEX_CONTESTED); 1096 /* The address was invalid. */ 1097 if (rv == -1) 1098 return (EFAULT); 1099 1100 if (owner == UMUTEX_CONTESTED) 1101 return (0); 1102 1103 rv = umtxq_check_susp(td); 1104 if (rv != 0) 1105 return (rv); 1106 1107 /* 1108 * If this failed the lock has 1109 * changed, restart. 1110 */ 1111 continue; 1112 } 1113 } 1114 1115 if (mode == _UMUTEX_TRY) 1116 return (EBUSY); 1117 1118 /* 1119 * If we caught a signal, we have retried and now 1120 * exit immediately. 1121 */ 1122 if (error != 0) 1123 return (error); 1124 1125 if ((error = umtx_key_get(m, TYPE_NORMAL_UMUTEX, 1126 GET_SHARE(flags), &uq->uq_key)) != 0) 1127 return (error); 1128 1129 umtxq_lock(&uq->uq_key); 1130 umtxq_busy(&uq->uq_key); 1131 umtxq_insert(uq); 1132 umtxq_unlock(&uq->uq_key); 1133 1134 /* 1135 * Set the contested bit so that a release in user space 1136 * knows to use the system call for unlock. If this fails 1137 * either some one else has acquired the lock or it has been 1138 * released. 1139 */ 1140 rv = casueword32(&m->m_owner, owner, &old, 1141 owner | UMUTEX_CONTESTED); 1142 1143 /* The address was invalid. */ 1144 if (rv == -1) { 1145 umtxq_lock(&uq->uq_key); 1146 umtxq_remove(uq); 1147 umtxq_unbusy(&uq->uq_key); 1148 umtxq_unlock(&uq->uq_key); 1149 umtx_key_release(&uq->uq_key); 1150 return (EFAULT); 1151 } 1152 1153 /* 1154 * We set the contested bit, sleep. Otherwise the lock changed 1155 * and we need to retry or we lost a race to the thread 1156 * unlocking the umtx. 1157 */ 1158 umtxq_lock(&uq->uq_key); 1159 umtxq_unbusy(&uq->uq_key); 1160 if (old == owner) 1161 error = umtxq_sleep(uq, "umtxn", timeout == NULL ? 1162 NULL : &timo); 1163 umtxq_remove(uq); 1164 umtxq_unlock(&uq->uq_key); 1165 umtx_key_release(&uq->uq_key); 1166 1167 if (error == 0) 1168 error = umtxq_check_susp(td); 1169 } 1170 1171 return (0); 1172 } 1173 1174 /* 1175 * Unlock PTHREAD_PRIO_NONE protocol POSIX mutex. 1176 */ 1177 static int 1178 do_unlock_normal(struct thread *td, struct umutex *m, uint32_t flags, bool rb) 1179 { 1180 struct umtx_key key; 1181 uint32_t owner, old, id, newlock; 1182 int error, count; 1183 1184 id = td->td_tid; 1185 /* 1186 * Make sure we own this mtx. 1187 */ 1188 error = fueword32(&m->m_owner, &owner); 1189 if (error == -1) 1190 return (EFAULT); 1191 1192 if ((owner & ~UMUTEX_CONTESTED) != id) 1193 return (EPERM); 1194 1195 newlock = umtx_unlock_val(flags, rb); 1196 if ((owner & UMUTEX_CONTESTED) == 0) { 1197 error = casueword32(&m->m_owner, owner, &old, newlock); 1198 if (error == -1) 1199 return (EFAULT); 1200 if (old == owner) 1201 return (0); 1202 owner = old; 1203 } 1204 1205 /* We should only ever be in here for contested locks */ 1206 if ((error = umtx_key_get(m, TYPE_NORMAL_UMUTEX, GET_SHARE(flags), 1207 &key)) != 0) 1208 return (error); 1209 1210 umtxq_lock(&key); 1211 umtxq_busy(&key); 1212 count = umtxq_count(&key); 1213 umtxq_unlock(&key); 1214 1215 /* 1216 * When unlocking the umtx, it must be marked as unowned if 1217 * there is zero or one thread only waiting for it. 1218 * Otherwise, it must be marked as contested. 1219 */ 1220 if (count > 1) 1221 newlock |= UMUTEX_CONTESTED; 1222 error = casueword32(&m->m_owner, owner, &old, newlock); 1223 umtxq_lock(&key); 1224 umtxq_signal(&key, 1); 1225 umtxq_unbusy(&key); 1226 umtxq_unlock(&key); 1227 umtx_key_release(&key); 1228 if (error == -1) 1229 return (EFAULT); 1230 if (old != owner) 1231 return (EINVAL); 1232 return (0); 1233 } 1234 1235 /* 1236 * Check if the mutex is available and wake up a waiter, 1237 * only for simple mutex. 1238 */ 1239 static int 1240 do_wake_umutex(struct thread *td, struct umutex *m) 1241 { 1242 struct umtx_key key; 1243 uint32_t owner; 1244 uint32_t flags; 1245 int error; 1246 int count; 1247 1248 error = fueword32(&m->m_owner, &owner); 1249 if (error == -1) 1250 return (EFAULT); 1251 1252 if ((owner & ~UMUTEX_CONTESTED) != 0 && owner != UMUTEX_RB_OWNERDEAD && 1253 owner != UMUTEX_RB_NOTRECOV) 1254 return (0); 1255 1256 error = fueword32(&m->m_flags, &flags); 1257 if (error == -1) 1258 return (EFAULT); 1259 1260 /* We should only ever be in here for contested locks */ 1261 if ((error = umtx_key_get(m, TYPE_NORMAL_UMUTEX, GET_SHARE(flags), 1262 &key)) != 0) 1263 return (error); 1264 1265 umtxq_lock(&key); 1266 umtxq_busy(&key); 1267 count = umtxq_count(&key); 1268 umtxq_unlock(&key); 1269 1270 if (count <= 1 && owner != UMUTEX_RB_OWNERDEAD && 1271 owner != UMUTEX_RB_NOTRECOV) { 1272 error = casueword32(&m->m_owner, UMUTEX_CONTESTED, &owner, 1273 UMUTEX_UNOWNED); 1274 if (error == -1) 1275 error = EFAULT; 1276 } 1277 1278 umtxq_lock(&key); 1279 if (error == 0 && count != 0 && ((owner & ~UMUTEX_CONTESTED) == 0 || 1280 owner == UMUTEX_RB_OWNERDEAD || owner == UMUTEX_RB_NOTRECOV)) 1281 umtxq_signal(&key, 1); 1282 umtxq_unbusy(&key); 1283 umtxq_unlock(&key); 1284 umtx_key_release(&key); 1285 return (error); 1286 } 1287 1288 /* 1289 * Check if the mutex has waiters and tries to fix contention bit. 1290 */ 1291 static int 1292 do_wake2_umutex(struct thread *td, struct umutex *m, uint32_t flags) 1293 { 1294 struct umtx_key key; 1295 uint32_t owner, old; 1296 int type; 1297 int error; 1298 int count; 1299 1300 switch (flags & (UMUTEX_PRIO_INHERIT | UMUTEX_PRIO_PROTECT | 1301 UMUTEX_ROBUST)) { 1302 case 0: 1303 case UMUTEX_ROBUST: 1304 type = TYPE_NORMAL_UMUTEX; 1305 break; 1306 case UMUTEX_PRIO_INHERIT: 1307 type = TYPE_PI_UMUTEX; 1308 break; 1309 case (UMUTEX_PRIO_INHERIT | UMUTEX_ROBUST): 1310 type = TYPE_PI_ROBUST_UMUTEX; 1311 break; 1312 case UMUTEX_PRIO_PROTECT: 1313 type = TYPE_PP_UMUTEX; 1314 break; 1315 case (UMUTEX_PRIO_PROTECT | UMUTEX_ROBUST): 1316 type = TYPE_PP_ROBUST_UMUTEX; 1317 break; 1318 default: 1319 return (EINVAL); 1320 } 1321 if ((error = umtx_key_get(m, type, GET_SHARE(flags), &key)) != 0) 1322 return (error); 1323 1324 owner = 0; 1325 umtxq_lock(&key); 1326 umtxq_busy(&key); 1327 count = umtxq_count(&key); 1328 umtxq_unlock(&key); 1329 /* 1330 * Only repair contention bit if there is a waiter, this means the mutex 1331 * is still being referenced by userland code, otherwise don't update 1332 * any memory. 1333 */ 1334 if (count > 1) { 1335 error = fueword32(&m->m_owner, &owner); 1336 if (error == -1) 1337 error = EFAULT; 1338 while (error == 0 && (owner & UMUTEX_CONTESTED) == 0) { 1339 error = casueword32(&m->m_owner, owner, &old, 1340 owner | UMUTEX_CONTESTED); 1341 if (error == -1) { 1342 error = EFAULT; 1343 break; 1344 } 1345 if (old == owner) 1346 break; 1347 owner = old; 1348 error = umtxq_check_susp(td); 1349 if (error != 0) 1350 break; 1351 } 1352 } else if (count == 1) { 1353 error = fueword32(&m->m_owner, &owner); 1354 if (error == -1) 1355 error = EFAULT; 1356 while (error == 0 && (owner & ~UMUTEX_CONTESTED) != 0 && 1357 (owner & UMUTEX_CONTESTED) == 0) { 1358 error = casueword32(&m->m_owner, owner, &old, 1359 owner | UMUTEX_CONTESTED); 1360 if (error == -1) { 1361 error = EFAULT; 1362 break; 1363 } 1364 if (old == owner) 1365 break; 1366 owner = old; 1367 error = umtxq_check_susp(td); 1368 if (error != 0) 1369 break; 1370 } 1371 } 1372 umtxq_lock(&key); 1373 if (error == EFAULT) { 1374 umtxq_signal(&key, INT_MAX); 1375 } else if (count != 0 && ((owner & ~UMUTEX_CONTESTED) == 0 || 1376 owner == UMUTEX_RB_OWNERDEAD || owner == UMUTEX_RB_NOTRECOV)) 1377 umtxq_signal(&key, 1); 1378 umtxq_unbusy(&key); 1379 umtxq_unlock(&key); 1380 umtx_key_release(&key); 1381 return (error); 1382 } 1383 1384 static inline struct umtx_pi * 1385 umtx_pi_alloc(int flags) 1386 { 1387 struct umtx_pi *pi; 1388 1389 pi = uma_zalloc(umtx_pi_zone, M_ZERO | flags); 1390 TAILQ_INIT(&pi->pi_blocked); 1391 atomic_add_int(&umtx_pi_allocated, 1); 1392 return (pi); 1393 } 1394 1395 static inline void 1396 umtx_pi_free(struct umtx_pi *pi) 1397 { 1398 uma_zfree(umtx_pi_zone, pi); 1399 atomic_add_int(&umtx_pi_allocated, -1); 1400 } 1401 1402 /* 1403 * Adjust the thread's position on a pi_state after its priority has been 1404 * changed. 1405 */ 1406 static int 1407 umtx_pi_adjust_thread(struct umtx_pi *pi, struct thread *td) 1408 { 1409 struct umtx_q *uq, *uq1, *uq2; 1410 struct thread *td1; 1411 1412 mtx_assert(&umtx_lock, MA_OWNED); 1413 if (pi == NULL) 1414 return (0); 1415 1416 uq = td->td_umtxq; 1417 1418 /* 1419 * Check if the thread needs to be moved on the blocked chain. 1420 * It needs to be moved if either its priority is lower than 1421 * the previous thread or higher than the next thread. 1422 */ 1423 uq1 = TAILQ_PREV(uq, umtxq_head, uq_lockq); 1424 uq2 = TAILQ_NEXT(uq, uq_lockq); 1425 if ((uq1 != NULL && UPRI(td) < UPRI(uq1->uq_thread)) || 1426 (uq2 != NULL && UPRI(td) > UPRI(uq2->uq_thread))) { 1427 /* 1428 * Remove thread from blocked chain and determine where 1429 * it should be moved to. 1430 */ 1431 TAILQ_REMOVE(&pi->pi_blocked, uq, uq_lockq); 1432 TAILQ_FOREACH(uq1, &pi->pi_blocked, uq_lockq) { 1433 td1 = uq1->uq_thread; 1434 MPASS(td1->td_proc->p_magic == P_MAGIC); 1435 if (UPRI(td1) > UPRI(td)) 1436 break; 1437 } 1438 1439 if (uq1 == NULL) 1440 TAILQ_INSERT_TAIL(&pi->pi_blocked, uq, uq_lockq); 1441 else 1442 TAILQ_INSERT_BEFORE(uq1, uq, uq_lockq); 1443 } 1444 return (1); 1445 } 1446 1447 static struct umtx_pi * 1448 umtx_pi_next(struct umtx_pi *pi) 1449 { 1450 struct umtx_q *uq_owner; 1451 1452 if (pi->pi_owner == NULL) 1453 return (NULL); 1454 uq_owner = pi->pi_owner->td_umtxq; 1455 if (uq_owner == NULL) 1456 return (NULL); 1457 return (uq_owner->uq_pi_blocked); 1458 } 1459 1460 /* 1461 * Floyd's Cycle-Finding Algorithm. 1462 */ 1463 static bool 1464 umtx_pi_check_loop(struct umtx_pi *pi) 1465 { 1466 struct umtx_pi *pi1; /* fast iterator */ 1467 1468 mtx_assert(&umtx_lock, MA_OWNED); 1469 if (pi == NULL) 1470 return (false); 1471 pi1 = pi; 1472 for (;;) { 1473 pi = umtx_pi_next(pi); 1474 if (pi == NULL) 1475 break; 1476 pi1 = umtx_pi_next(pi1); 1477 if (pi1 == NULL) 1478 break; 1479 pi1 = umtx_pi_next(pi1); 1480 if (pi1 == NULL) 1481 break; 1482 if (pi == pi1) 1483 return (true); 1484 } 1485 return (false); 1486 } 1487 1488 /* 1489 * Propagate priority when a thread is blocked on POSIX 1490 * PI mutex. 1491 */ 1492 static void 1493 umtx_propagate_priority(struct thread *td) 1494 { 1495 struct umtx_q *uq; 1496 struct umtx_pi *pi; 1497 int pri; 1498 1499 mtx_assert(&umtx_lock, MA_OWNED); 1500 pri = UPRI(td); 1501 uq = td->td_umtxq; 1502 pi = uq->uq_pi_blocked; 1503 if (pi == NULL) 1504 return; 1505 if (umtx_pi_check_loop(pi)) 1506 return; 1507 1508 for (;;) { 1509 td = pi->pi_owner; 1510 if (td == NULL || td == curthread) 1511 return; 1512 1513 MPASS(td->td_proc != NULL); 1514 MPASS(td->td_proc->p_magic == P_MAGIC); 1515 1516 thread_lock(td); 1517 if (td->td_lend_user_pri > pri) 1518 sched_lend_user_prio(td, pri); 1519 else { 1520 thread_unlock(td); 1521 break; 1522 } 1523 thread_unlock(td); 1524 1525 /* 1526 * Pick up the lock that td is blocked on. 1527 */ 1528 uq = td->td_umtxq; 1529 pi = uq->uq_pi_blocked; 1530 if (pi == NULL) 1531 break; 1532 /* Resort td on the list if needed. */ 1533 umtx_pi_adjust_thread(pi, td); 1534 } 1535 } 1536 1537 /* 1538 * Unpropagate priority for a PI mutex when a thread blocked on 1539 * it is interrupted by signal or resumed by others. 1540 */ 1541 static void 1542 umtx_repropagate_priority(struct umtx_pi *pi) 1543 { 1544 struct umtx_q *uq, *uq_owner; 1545 struct umtx_pi *pi2; 1546 int pri; 1547 1548 mtx_assert(&umtx_lock, MA_OWNED); 1549 1550 if (umtx_pi_check_loop(pi)) 1551 return; 1552 while (pi != NULL && pi->pi_owner != NULL) { 1553 pri = PRI_MAX; 1554 uq_owner = pi->pi_owner->td_umtxq; 1555 1556 TAILQ_FOREACH(pi2, &uq_owner->uq_pi_contested, pi_link) { 1557 uq = TAILQ_FIRST(&pi2->pi_blocked); 1558 if (uq != NULL) { 1559 if (pri > UPRI(uq->uq_thread)) 1560 pri = UPRI(uq->uq_thread); 1561 } 1562 } 1563 1564 if (pri > uq_owner->uq_inherited_pri) 1565 pri = uq_owner->uq_inherited_pri; 1566 thread_lock(pi->pi_owner); 1567 sched_lend_user_prio(pi->pi_owner, pri); 1568 thread_unlock(pi->pi_owner); 1569 if ((pi = uq_owner->uq_pi_blocked) != NULL) 1570 umtx_pi_adjust_thread(pi, uq_owner->uq_thread); 1571 } 1572 } 1573 1574 /* 1575 * Insert a PI mutex into owned list. 1576 */ 1577 static void 1578 umtx_pi_setowner(struct umtx_pi *pi, struct thread *owner) 1579 { 1580 struct umtx_q *uq_owner; 1581 1582 uq_owner = owner->td_umtxq; 1583 mtx_assert(&umtx_lock, MA_OWNED); 1584 MPASS(pi->pi_owner == NULL); 1585 pi->pi_owner = owner; 1586 TAILQ_INSERT_TAIL(&uq_owner->uq_pi_contested, pi, pi_link); 1587 } 1588 1589 1590 /* 1591 * Disown a PI mutex, and remove it from the owned list. 1592 */ 1593 static void 1594 umtx_pi_disown(struct umtx_pi *pi) 1595 { 1596 1597 mtx_assert(&umtx_lock, MA_OWNED); 1598 TAILQ_REMOVE(&pi->pi_owner->td_umtxq->uq_pi_contested, pi, pi_link); 1599 pi->pi_owner = NULL; 1600 } 1601 1602 /* 1603 * Claim ownership of a PI mutex. 1604 */ 1605 static int 1606 umtx_pi_claim(struct umtx_pi *pi, struct thread *owner) 1607 { 1608 struct umtx_q *uq; 1609 int pri; 1610 1611 mtx_lock(&umtx_lock); 1612 if (pi->pi_owner == owner) { 1613 mtx_unlock(&umtx_lock); 1614 return (0); 1615 } 1616 1617 if (pi->pi_owner != NULL) { 1618 /* 1619 * userland may have already messed the mutex, sigh. 1620 */ 1621 mtx_unlock(&umtx_lock); 1622 return (EPERM); 1623 } 1624 umtx_pi_setowner(pi, owner); 1625 uq = TAILQ_FIRST(&pi->pi_blocked); 1626 if (uq != NULL) { 1627 pri = UPRI(uq->uq_thread); 1628 thread_lock(owner); 1629 if (pri < UPRI(owner)) 1630 sched_lend_user_prio(owner, pri); 1631 thread_unlock(owner); 1632 } 1633 mtx_unlock(&umtx_lock); 1634 return (0); 1635 } 1636 1637 /* 1638 * Adjust a thread's order position in its blocked PI mutex, 1639 * this may result new priority propagating process. 1640 */ 1641 void 1642 umtx_pi_adjust(struct thread *td, u_char oldpri) 1643 { 1644 struct umtx_q *uq; 1645 struct umtx_pi *pi; 1646 1647 uq = td->td_umtxq; 1648 mtx_lock(&umtx_lock); 1649 /* 1650 * Pick up the lock that td is blocked on. 1651 */ 1652 pi = uq->uq_pi_blocked; 1653 if (pi != NULL) { 1654 umtx_pi_adjust_thread(pi, td); 1655 umtx_repropagate_priority(pi); 1656 } 1657 mtx_unlock(&umtx_lock); 1658 } 1659 1660 /* 1661 * Sleep on a PI mutex. 1662 */ 1663 static int 1664 umtxq_sleep_pi(struct umtx_q *uq, struct umtx_pi *pi, uint32_t owner, 1665 const char *wmesg, struct abs_timeout *timo, bool shared) 1666 { 1667 struct umtxq_chain *uc; 1668 struct thread *td, *td1; 1669 struct umtx_q *uq1; 1670 int error, pri; 1671 1672 error = 0; 1673 td = uq->uq_thread; 1674 KASSERT(td == curthread, ("inconsistent uq_thread")); 1675 uc = umtxq_getchain(&uq->uq_key); 1676 UMTXQ_LOCKED_ASSERT(uc); 1677 KASSERT(uc->uc_busy != 0, ("umtx chain is not busy")); 1678 umtxq_insert(uq); 1679 mtx_lock(&umtx_lock); 1680 if (pi->pi_owner == NULL) { 1681 mtx_unlock(&umtx_lock); 1682 td1 = tdfind(owner, shared ? -1 : td->td_proc->p_pid); 1683 mtx_lock(&umtx_lock); 1684 if (td1 != NULL) { 1685 if (pi->pi_owner == NULL) 1686 umtx_pi_setowner(pi, td1); 1687 PROC_UNLOCK(td1->td_proc); 1688 } 1689 } 1690 1691 TAILQ_FOREACH(uq1, &pi->pi_blocked, uq_lockq) { 1692 pri = UPRI(uq1->uq_thread); 1693 if (pri > UPRI(td)) 1694 break; 1695 } 1696 1697 if (uq1 != NULL) 1698 TAILQ_INSERT_BEFORE(uq1, uq, uq_lockq); 1699 else 1700 TAILQ_INSERT_TAIL(&pi->pi_blocked, uq, uq_lockq); 1701 1702 uq->uq_pi_blocked = pi; 1703 thread_lock(td); 1704 td->td_flags |= TDF_UPIBLOCKED; 1705 thread_unlock(td); 1706 umtx_propagate_priority(td); 1707 mtx_unlock(&umtx_lock); 1708 umtxq_unbusy(&uq->uq_key); 1709 1710 error = umtxq_sleep(uq, wmesg, timo); 1711 umtxq_remove(uq); 1712 1713 mtx_lock(&umtx_lock); 1714 uq->uq_pi_blocked = NULL; 1715 thread_lock(td); 1716 td->td_flags &= ~TDF_UPIBLOCKED; 1717 thread_unlock(td); 1718 TAILQ_REMOVE(&pi->pi_blocked, uq, uq_lockq); 1719 umtx_repropagate_priority(pi); 1720 mtx_unlock(&umtx_lock); 1721 umtxq_unlock(&uq->uq_key); 1722 1723 return (error); 1724 } 1725 1726 /* 1727 * Add reference count for a PI mutex. 1728 */ 1729 static void 1730 umtx_pi_ref(struct umtx_pi *pi) 1731 { 1732 struct umtxq_chain *uc; 1733 1734 uc = umtxq_getchain(&pi->pi_key); 1735 UMTXQ_LOCKED_ASSERT(uc); 1736 pi->pi_refcount++; 1737 } 1738 1739 /* 1740 * Decrease reference count for a PI mutex, if the counter 1741 * is decreased to zero, its memory space is freed. 1742 */ 1743 static void 1744 umtx_pi_unref(struct umtx_pi *pi) 1745 { 1746 struct umtxq_chain *uc; 1747 1748 uc = umtxq_getchain(&pi->pi_key); 1749 UMTXQ_LOCKED_ASSERT(uc); 1750 KASSERT(pi->pi_refcount > 0, ("invalid reference count")); 1751 if (--pi->pi_refcount == 0) { 1752 mtx_lock(&umtx_lock); 1753 if (pi->pi_owner != NULL) 1754 umtx_pi_disown(pi); 1755 KASSERT(TAILQ_EMPTY(&pi->pi_blocked), 1756 ("blocked queue not empty")); 1757 mtx_unlock(&umtx_lock); 1758 TAILQ_REMOVE(&uc->uc_pi_list, pi, pi_hashlink); 1759 umtx_pi_free(pi); 1760 } 1761 } 1762 1763 /* 1764 * Find a PI mutex in hash table. 1765 */ 1766 static struct umtx_pi * 1767 umtx_pi_lookup(struct umtx_key *key) 1768 { 1769 struct umtxq_chain *uc; 1770 struct umtx_pi *pi; 1771 1772 uc = umtxq_getchain(key); 1773 UMTXQ_LOCKED_ASSERT(uc); 1774 1775 TAILQ_FOREACH(pi, &uc->uc_pi_list, pi_hashlink) { 1776 if (umtx_key_match(&pi->pi_key, key)) { 1777 return (pi); 1778 } 1779 } 1780 return (NULL); 1781 } 1782 1783 /* 1784 * Insert a PI mutex into hash table. 1785 */ 1786 static inline void 1787 umtx_pi_insert(struct umtx_pi *pi) 1788 { 1789 struct umtxq_chain *uc; 1790 1791 uc = umtxq_getchain(&pi->pi_key); 1792 UMTXQ_LOCKED_ASSERT(uc); 1793 TAILQ_INSERT_TAIL(&uc->uc_pi_list, pi, pi_hashlink); 1794 } 1795 1796 /* 1797 * Lock a PI mutex. 1798 */ 1799 static int 1800 do_lock_pi(struct thread *td, struct umutex *m, uint32_t flags, 1801 struct _umtx_time *timeout, int try) 1802 { 1803 struct abs_timeout timo; 1804 struct umtx_q *uq; 1805 struct umtx_pi *pi, *new_pi; 1806 uint32_t id, old_owner, owner, old; 1807 int error, rv; 1808 1809 id = td->td_tid; 1810 uq = td->td_umtxq; 1811 1812 if ((error = umtx_key_get(m, (flags & UMUTEX_ROBUST) != 0 ? 1813 TYPE_PI_ROBUST_UMUTEX : TYPE_PI_UMUTEX, GET_SHARE(flags), 1814 &uq->uq_key)) != 0) 1815 return (error); 1816 1817 if (timeout != NULL) 1818 abs_timeout_init2(&timo, timeout); 1819 1820 umtxq_lock(&uq->uq_key); 1821 pi = umtx_pi_lookup(&uq->uq_key); 1822 if (pi == NULL) { 1823 new_pi = umtx_pi_alloc(M_NOWAIT); 1824 if (new_pi == NULL) { 1825 umtxq_unlock(&uq->uq_key); 1826 new_pi = umtx_pi_alloc(M_WAITOK); 1827 umtxq_lock(&uq->uq_key); 1828 pi = umtx_pi_lookup(&uq->uq_key); 1829 if (pi != NULL) { 1830 umtx_pi_free(new_pi); 1831 new_pi = NULL; 1832 } 1833 } 1834 if (new_pi != NULL) { 1835 new_pi->pi_key = uq->uq_key; 1836 umtx_pi_insert(new_pi); 1837 pi = new_pi; 1838 } 1839 } 1840 umtx_pi_ref(pi); 1841 umtxq_unlock(&uq->uq_key); 1842 1843 /* 1844 * Care must be exercised when dealing with umtx structure. It 1845 * can fault on any access. 1846 */ 1847 for (;;) { 1848 /* 1849 * Try the uncontested case. This should be done in userland. 1850 */ 1851 rv = casueword32(&m->m_owner, UMUTEX_UNOWNED, &owner, id); 1852 /* The address was invalid. */ 1853 if (rv == -1) { 1854 error = EFAULT; 1855 break; 1856 } 1857 1858 /* The acquire succeeded. */ 1859 if (owner == UMUTEX_UNOWNED) { 1860 error = 0; 1861 break; 1862 } 1863 1864 if (owner == UMUTEX_RB_NOTRECOV) { 1865 error = ENOTRECOVERABLE; 1866 break; 1867 } 1868 1869 /* If no one owns it but it is contested try to acquire it. */ 1870 if (owner == UMUTEX_CONTESTED || owner == UMUTEX_RB_OWNERDEAD) { 1871 old_owner = owner; 1872 rv = casueword32(&m->m_owner, owner, &owner, 1873 id | UMUTEX_CONTESTED); 1874 /* The address was invalid. */ 1875 if (rv == -1) { 1876 error = EFAULT; 1877 break; 1878 } 1879 1880 if (owner == old_owner) { 1881 umtxq_lock(&uq->uq_key); 1882 umtxq_busy(&uq->uq_key); 1883 error = umtx_pi_claim(pi, td); 1884 umtxq_unbusy(&uq->uq_key); 1885 umtxq_unlock(&uq->uq_key); 1886 if (error != 0) { 1887 /* 1888 * Since we're going to return an 1889 * error, restore the m_owner to its 1890 * previous, unowned state to avoid 1891 * compounding the problem. 1892 */ 1893 (void)casuword32(&m->m_owner, 1894 id | UMUTEX_CONTESTED, 1895 old_owner); 1896 } 1897 if (error == 0 && 1898 old_owner == UMUTEX_RB_OWNERDEAD) 1899 error = EOWNERDEAD; 1900 break; 1901 } 1902 1903 error = umtxq_check_susp(td); 1904 if (error != 0) 1905 break; 1906 1907 /* If this failed the lock has changed, restart. */ 1908 continue; 1909 } 1910 1911 if ((owner & ~UMUTEX_CONTESTED) == id) { 1912 error = EDEADLK; 1913 break; 1914 } 1915 1916 if (try != 0) { 1917 error = EBUSY; 1918 break; 1919 } 1920 1921 /* 1922 * If we caught a signal, we have retried and now 1923 * exit immediately. 1924 */ 1925 if (error != 0) 1926 break; 1927 1928 umtxq_lock(&uq->uq_key); 1929 umtxq_busy(&uq->uq_key); 1930 umtxq_unlock(&uq->uq_key); 1931 1932 /* 1933 * Set the contested bit so that a release in user space 1934 * knows to use the system call for unlock. If this fails 1935 * either some one else has acquired the lock or it has been 1936 * released. 1937 */ 1938 rv = casueword32(&m->m_owner, owner, &old, owner | 1939 UMUTEX_CONTESTED); 1940 1941 /* The address was invalid. */ 1942 if (rv == -1) { 1943 umtxq_unbusy_unlocked(&uq->uq_key); 1944 error = EFAULT; 1945 break; 1946 } 1947 1948 umtxq_lock(&uq->uq_key); 1949 /* 1950 * We set the contested bit, sleep. Otherwise the lock changed 1951 * and we need to retry or we lost a race to the thread 1952 * unlocking the umtx. Note that the UMUTEX_RB_OWNERDEAD 1953 * value for owner is impossible there. 1954 */ 1955 if (old == owner) { 1956 error = umtxq_sleep_pi(uq, pi, 1957 owner & ~UMUTEX_CONTESTED, 1958 "umtxpi", timeout == NULL ? NULL : &timo, 1959 (flags & USYNC_PROCESS_SHARED) != 0); 1960 if (error != 0) 1961 continue; 1962 } else { 1963 umtxq_unbusy(&uq->uq_key); 1964 umtxq_unlock(&uq->uq_key); 1965 } 1966 1967 error = umtxq_check_susp(td); 1968 if (error != 0) 1969 break; 1970 } 1971 1972 umtxq_lock(&uq->uq_key); 1973 umtx_pi_unref(pi); 1974 umtxq_unlock(&uq->uq_key); 1975 1976 umtx_key_release(&uq->uq_key); 1977 return (error); 1978 } 1979 1980 /* 1981 * Unlock a PI mutex. 1982 */ 1983 static int 1984 do_unlock_pi(struct thread *td, struct umutex *m, uint32_t flags, bool rb) 1985 { 1986 struct umtx_key key; 1987 struct umtx_q *uq_first, *uq_first2, *uq_me; 1988 struct umtx_pi *pi, *pi2; 1989 uint32_t id, new_owner, old, owner; 1990 int count, error, pri; 1991 1992 id = td->td_tid; 1993 /* 1994 * Make sure we own this mtx. 1995 */ 1996 error = fueword32(&m->m_owner, &owner); 1997 if (error == -1) 1998 return (EFAULT); 1999 2000 if ((owner & ~UMUTEX_CONTESTED) != id) 2001 return (EPERM); 2002 2003 new_owner = umtx_unlock_val(flags, rb); 2004 2005 /* This should be done in userland */ 2006 if ((owner & UMUTEX_CONTESTED) == 0) { 2007 error = casueword32(&m->m_owner, owner, &old, new_owner); 2008 if (error == -1) 2009 return (EFAULT); 2010 if (old == owner) 2011 return (0); 2012 owner = old; 2013 } 2014 2015 /* We should only ever be in here for contested locks */ 2016 if ((error = umtx_key_get(m, (flags & UMUTEX_ROBUST) != 0 ? 2017 TYPE_PI_ROBUST_UMUTEX : TYPE_PI_UMUTEX, GET_SHARE(flags), 2018 &key)) != 0) 2019 return (error); 2020 2021 umtxq_lock(&key); 2022 umtxq_busy(&key); 2023 count = umtxq_count_pi(&key, &uq_first); 2024 if (uq_first != NULL) { 2025 mtx_lock(&umtx_lock); 2026 pi = uq_first->uq_pi_blocked; 2027 KASSERT(pi != NULL, ("pi == NULL?")); 2028 if (pi->pi_owner != td && !(rb && pi->pi_owner == NULL)) { 2029 mtx_unlock(&umtx_lock); 2030 umtxq_unbusy(&key); 2031 umtxq_unlock(&key); 2032 umtx_key_release(&key); 2033 /* userland messed the mutex */ 2034 return (EPERM); 2035 } 2036 uq_me = td->td_umtxq; 2037 if (pi->pi_owner == td) 2038 umtx_pi_disown(pi); 2039 /* get highest priority thread which is still sleeping. */ 2040 uq_first = TAILQ_FIRST(&pi->pi_blocked); 2041 while (uq_first != NULL && 2042 (uq_first->uq_flags & UQF_UMTXQ) == 0) { 2043 uq_first = TAILQ_NEXT(uq_first, uq_lockq); 2044 } 2045 pri = PRI_MAX; 2046 TAILQ_FOREACH(pi2, &uq_me->uq_pi_contested, pi_link) { 2047 uq_first2 = TAILQ_FIRST(&pi2->pi_blocked); 2048 if (uq_first2 != NULL) { 2049 if (pri > UPRI(uq_first2->uq_thread)) 2050 pri = UPRI(uq_first2->uq_thread); 2051 } 2052 } 2053 thread_lock(td); 2054 sched_lend_user_prio(td, pri); 2055 thread_unlock(td); 2056 mtx_unlock(&umtx_lock); 2057 if (uq_first) 2058 umtxq_signal_thread(uq_first); 2059 } else { 2060 pi = umtx_pi_lookup(&key); 2061 /* 2062 * A umtx_pi can exist if a signal or timeout removed the 2063 * last waiter from the umtxq, but there is still 2064 * a thread in do_lock_pi() holding the umtx_pi. 2065 */ 2066 if (pi != NULL) { 2067 /* 2068 * The umtx_pi can be unowned, such as when a thread 2069 * has just entered do_lock_pi(), allocated the 2070 * umtx_pi, and unlocked the umtxq. 2071 * If the current thread owns it, it must disown it. 2072 */ 2073 mtx_lock(&umtx_lock); 2074 if (pi->pi_owner == td) 2075 umtx_pi_disown(pi); 2076 mtx_unlock(&umtx_lock); 2077 } 2078 } 2079 umtxq_unlock(&key); 2080 2081 /* 2082 * When unlocking the umtx, it must be marked as unowned if 2083 * there is zero or one thread only waiting for it. 2084 * Otherwise, it must be marked as contested. 2085 */ 2086 2087 if (count > 1) 2088 new_owner |= UMUTEX_CONTESTED; 2089 error = casueword32(&m->m_owner, owner, &old, new_owner); 2090 2091 umtxq_unbusy_unlocked(&key); 2092 umtx_key_release(&key); 2093 if (error == -1) 2094 return (EFAULT); 2095 if (old != owner) 2096 return (EINVAL); 2097 return (0); 2098 } 2099 2100 /* 2101 * Lock a PP mutex. 2102 */ 2103 static int 2104 do_lock_pp(struct thread *td, struct umutex *m, uint32_t flags, 2105 struct _umtx_time *timeout, int try) 2106 { 2107 struct abs_timeout timo; 2108 struct umtx_q *uq, *uq2; 2109 struct umtx_pi *pi; 2110 uint32_t ceiling; 2111 uint32_t owner, id; 2112 int error, pri, old_inherited_pri, su, rv; 2113 2114 id = td->td_tid; 2115 uq = td->td_umtxq; 2116 if ((error = umtx_key_get(m, (flags & UMUTEX_ROBUST) != 0 ? 2117 TYPE_PP_ROBUST_UMUTEX : TYPE_PP_UMUTEX, GET_SHARE(flags), 2118 &uq->uq_key)) != 0) 2119 return (error); 2120 2121 if (timeout != NULL) 2122 abs_timeout_init2(&timo, timeout); 2123 2124 su = (priv_check(td, PRIV_SCHED_RTPRIO) == 0); 2125 for (;;) { 2126 old_inherited_pri = uq->uq_inherited_pri; 2127 umtxq_lock(&uq->uq_key); 2128 umtxq_busy(&uq->uq_key); 2129 umtxq_unlock(&uq->uq_key); 2130 2131 rv = fueword32(&m->m_ceilings[0], &ceiling); 2132 if (rv == -1) { 2133 error = EFAULT; 2134 goto out; 2135 } 2136 ceiling = RTP_PRIO_MAX - ceiling; 2137 if (ceiling > RTP_PRIO_MAX) { 2138 error = EINVAL; 2139 goto out; 2140 } 2141 2142 mtx_lock(&umtx_lock); 2143 if (UPRI(td) < PRI_MIN_REALTIME + ceiling) { 2144 mtx_unlock(&umtx_lock); 2145 error = EINVAL; 2146 goto out; 2147 } 2148 if (su && PRI_MIN_REALTIME + ceiling < uq->uq_inherited_pri) { 2149 uq->uq_inherited_pri = PRI_MIN_REALTIME + ceiling; 2150 thread_lock(td); 2151 if (uq->uq_inherited_pri < UPRI(td)) 2152 sched_lend_user_prio(td, uq->uq_inherited_pri); 2153 thread_unlock(td); 2154 } 2155 mtx_unlock(&umtx_lock); 2156 2157 rv = casueword32(&m->m_owner, UMUTEX_CONTESTED, &owner, 2158 id | UMUTEX_CONTESTED); 2159 /* The address was invalid. */ 2160 if (rv == -1) { 2161 error = EFAULT; 2162 break; 2163 } 2164 2165 if (owner == UMUTEX_CONTESTED) { 2166 error = 0; 2167 break; 2168 } else if (owner == UMUTEX_RB_OWNERDEAD) { 2169 rv = casueword32(&m->m_owner, UMUTEX_RB_OWNERDEAD, 2170 &owner, id | UMUTEX_CONTESTED); 2171 if (rv == -1) { 2172 error = EFAULT; 2173 break; 2174 } 2175 if (owner == UMUTEX_RB_OWNERDEAD) { 2176 error = EOWNERDEAD; /* success */ 2177 break; 2178 } 2179 error = 0; 2180 } else if (owner == UMUTEX_RB_NOTRECOV) { 2181 error = ENOTRECOVERABLE; 2182 break; 2183 } 2184 2185 if (try != 0) { 2186 error = EBUSY; 2187 break; 2188 } 2189 2190 /* 2191 * If we caught a signal, we have retried and now 2192 * exit immediately. 2193 */ 2194 if (error != 0) 2195 break; 2196 2197 umtxq_lock(&uq->uq_key); 2198 umtxq_insert(uq); 2199 umtxq_unbusy(&uq->uq_key); 2200 error = umtxq_sleep(uq, "umtxpp", timeout == NULL ? 2201 NULL : &timo); 2202 umtxq_remove(uq); 2203 umtxq_unlock(&uq->uq_key); 2204 2205 mtx_lock(&umtx_lock); 2206 uq->uq_inherited_pri = old_inherited_pri; 2207 pri = PRI_MAX; 2208 TAILQ_FOREACH(pi, &uq->uq_pi_contested, pi_link) { 2209 uq2 = TAILQ_FIRST(&pi->pi_blocked); 2210 if (uq2 != NULL) { 2211 if (pri > UPRI(uq2->uq_thread)) 2212 pri = UPRI(uq2->uq_thread); 2213 } 2214 } 2215 if (pri > uq->uq_inherited_pri) 2216 pri = uq->uq_inherited_pri; 2217 thread_lock(td); 2218 sched_lend_user_prio(td, pri); 2219 thread_unlock(td); 2220 mtx_unlock(&umtx_lock); 2221 } 2222 2223 if (error != 0 && error != EOWNERDEAD) { 2224 mtx_lock(&umtx_lock); 2225 uq->uq_inherited_pri = old_inherited_pri; 2226 pri = PRI_MAX; 2227 TAILQ_FOREACH(pi, &uq->uq_pi_contested, pi_link) { 2228 uq2 = TAILQ_FIRST(&pi->pi_blocked); 2229 if (uq2 != NULL) { 2230 if (pri > UPRI(uq2->uq_thread)) 2231 pri = UPRI(uq2->uq_thread); 2232 } 2233 } 2234 if (pri > uq->uq_inherited_pri) 2235 pri = uq->uq_inherited_pri; 2236 thread_lock(td); 2237 sched_lend_user_prio(td, pri); 2238 thread_unlock(td); 2239 mtx_unlock(&umtx_lock); 2240 } 2241 2242 out: 2243 umtxq_unbusy_unlocked(&uq->uq_key); 2244 umtx_key_release(&uq->uq_key); 2245 return (error); 2246 } 2247 2248 /* 2249 * Unlock a PP mutex. 2250 */ 2251 static int 2252 do_unlock_pp(struct thread *td, struct umutex *m, uint32_t flags, bool rb) 2253 { 2254 struct umtx_key key; 2255 struct umtx_q *uq, *uq2; 2256 struct umtx_pi *pi; 2257 uint32_t id, owner, rceiling; 2258 int error, pri, new_inherited_pri, su; 2259 2260 id = td->td_tid; 2261 uq = td->td_umtxq; 2262 su = (priv_check(td, PRIV_SCHED_RTPRIO) == 0); 2263 2264 /* 2265 * Make sure we own this mtx. 2266 */ 2267 error = fueword32(&m->m_owner, &owner); 2268 if (error == -1) 2269 return (EFAULT); 2270 2271 if ((owner & ~UMUTEX_CONTESTED) != id) 2272 return (EPERM); 2273 2274 error = copyin(&m->m_ceilings[1], &rceiling, sizeof(uint32_t)); 2275 if (error != 0) 2276 return (error); 2277 2278 if (rceiling == -1) 2279 new_inherited_pri = PRI_MAX; 2280 else { 2281 rceiling = RTP_PRIO_MAX - rceiling; 2282 if (rceiling > RTP_PRIO_MAX) 2283 return (EINVAL); 2284 new_inherited_pri = PRI_MIN_REALTIME + rceiling; 2285 } 2286 2287 if ((error = umtx_key_get(m, (flags & UMUTEX_ROBUST) != 0 ? 2288 TYPE_PP_ROBUST_UMUTEX : TYPE_PP_UMUTEX, GET_SHARE(flags), 2289 &key)) != 0) 2290 return (error); 2291 umtxq_lock(&key); 2292 umtxq_busy(&key); 2293 umtxq_unlock(&key); 2294 /* 2295 * For priority protected mutex, always set unlocked state 2296 * to UMUTEX_CONTESTED, so that userland always enters kernel 2297 * to lock the mutex, it is necessary because thread priority 2298 * has to be adjusted for such mutex. 2299 */ 2300 error = suword32(&m->m_owner, umtx_unlock_val(flags, rb) | 2301 UMUTEX_CONTESTED); 2302 2303 umtxq_lock(&key); 2304 if (error == 0) 2305 umtxq_signal(&key, 1); 2306 umtxq_unbusy(&key); 2307 umtxq_unlock(&key); 2308 2309 if (error == -1) 2310 error = EFAULT; 2311 else { 2312 mtx_lock(&umtx_lock); 2313 if (su != 0) 2314 uq->uq_inherited_pri = new_inherited_pri; 2315 pri = PRI_MAX; 2316 TAILQ_FOREACH(pi, &uq->uq_pi_contested, pi_link) { 2317 uq2 = TAILQ_FIRST(&pi->pi_blocked); 2318 if (uq2 != NULL) { 2319 if (pri > UPRI(uq2->uq_thread)) 2320 pri = UPRI(uq2->uq_thread); 2321 } 2322 } 2323 if (pri > uq->uq_inherited_pri) 2324 pri = uq->uq_inherited_pri; 2325 thread_lock(td); 2326 sched_lend_user_prio(td, pri); 2327 thread_unlock(td); 2328 mtx_unlock(&umtx_lock); 2329 } 2330 umtx_key_release(&key); 2331 return (error); 2332 } 2333 2334 static int 2335 do_set_ceiling(struct thread *td, struct umutex *m, uint32_t ceiling, 2336 uint32_t *old_ceiling) 2337 { 2338 struct umtx_q *uq; 2339 uint32_t flags, id, owner, save_ceiling; 2340 int error, rv, rv1; 2341 2342 error = fueword32(&m->m_flags, &flags); 2343 if (error == -1) 2344 return (EFAULT); 2345 if ((flags & UMUTEX_PRIO_PROTECT) == 0) 2346 return (EINVAL); 2347 if (ceiling > RTP_PRIO_MAX) 2348 return (EINVAL); 2349 id = td->td_tid; 2350 uq = td->td_umtxq; 2351 if ((error = umtx_key_get(m, (flags & UMUTEX_ROBUST) != 0 ? 2352 TYPE_PP_ROBUST_UMUTEX : TYPE_PP_UMUTEX, GET_SHARE(flags), 2353 &uq->uq_key)) != 0) 2354 return (error); 2355 for (;;) { 2356 umtxq_lock(&uq->uq_key); 2357 umtxq_busy(&uq->uq_key); 2358 umtxq_unlock(&uq->uq_key); 2359 2360 rv = fueword32(&m->m_ceilings[0], &save_ceiling); 2361 if (rv == -1) { 2362 error = EFAULT; 2363 break; 2364 } 2365 2366 rv = casueword32(&m->m_owner, UMUTEX_CONTESTED, &owner, 2367 id | UMUTEX_CONTESTED); 2368 if (rv == -1) { 2369 error = EFAULT; 2370 break; 2371 } 2372 2373 if (owner == UMUTEX_CONTESTED) { 2374 rv = suword32(&m->m_ceilings[0], ceiling); 2375 rv1 = suword32(&m->m_owner, UMUTEX_CONTESTED); 2376 error = (rv == 0 && rv1 == 0) ? 0: EFAULT; 2377 break; 2378 } 2379 2380 if ((owner & ~UMUTEX_CONTESTED) == id) { 2381 rv = suword32(&m->m_ceilings[0], ceiling); 2382 error = rv == 0 ? 0 : EFAULT; 2383 break; 2384 } 2385 2386 if (owner == UMUTEX_RB_OWNERDEAD) { 2387 error = EOWNERDEAD; 2388 break; 2389 } else if (owner == UMUTEX_RB_NOTRECOV) { 2390 error = ENOTRECOVERABLE; 2391 break; 2392 } 2393 2394 /* 2395 * If we caught a signal, we have retried and now 2396 * exit immediately. 2397 */ 2398 if (error != 0) 2399 break; 2400 2401 /* 2402 * We set the contested bit, sleep. Otherwise the lock changed 2403 * and we need to retry or we lost a race to the thread 2404 * unlocking the umtx. 2405 */ 2406 umtxq_lock(&uq->uq_key); 2407 umtxq_insert(uq); 2408 umtxq_unbusy(&uq->uq_key); 2409 error = umtxq_sleep(uq, "umtxpp", NULL); 2410 umtxq_remove(uq); 2411 umtxq_unlock(&uq->uq_key); 2412 } 2413 umtxq_lock(&uq->uq_key); 2414 if (error == 0) 2415 umtxq_signal(&uq->uq_key, INT_MAX); 2416 umtxq_unbusy(&uq->uq_key); 2417 umtxq_unlock(&uq->uq_key); 2418 umtx_key_release(&uq->uq_key); 2419 if (error == 0 && old_ceiling != NULL) { 2420 rv = suword32(old_ceiling, save_ceiling); 2421 error = rv == 0 ? 0 : EFAULT; 2422 } 2423 return (error); 2424 } 2425 2426 /* 2427 * Lock a userland POSIX mutex. 2428 */ 2429 static int 2430 do_lock_umutex(struct thread *td, struct umutex *m, 2431 struct _umtx_time *timeout, int mode) 2432 { 2433 uint32_t flags; 2434 int error; 2435 2436 error = fueword32(&m->m_flags, &flags); 2437 if (error == -1) 2438 return (EFAULT); 2439 2440 switch (flags & (UMUTEX_PRIO_INHERIT | UMUTEX_PRIO_PROTECT)) { 2441 case 0: 2442 error = do_lock_normal(td, m, flags, timeout, mode); 2443 break; 2444 case UMUTEX_PRIO_INHERIT: 2445 error = do_lock_pi(td, m, flags, timeout, mode); 2446 break; 2447 case UMUTEX_PRIO_PROTECT: 2448 error = do_lock_pp(td, m, flags, timeout, mode); 2449 break; 2450 default: 2451 return (EINVAL); 2452 } 2453 if (timeout == NULL) { 2454 if (error == EINTR && mode != _UMUTEX_WAIT) 2455 error = ERESTART; 2456 } else { 2457 /* Timed-locking is not restarted. */ 2458 if (error == ERESTART) 2459 error = EINTR; 2460 } 2461 return (error); 2462 } 2463 2464 /* 2465 * Unlock a userland POSIX mutex. 2466 */ 2467 static int 2468 do_unlock_umutex(struct thread *td, struct umutex *m, bool rb) 2469 { 2470 uint32_t flags; 2471 int error; 2472 2473 error = fueword32(&m->m_flags, &flags); 2474 if (error == -1) 2475 return (EFAULT); 2476 2477 switch (flags & (UMUTEX_PRIO_INHERIT | UMUTEX_PRIO_PROTECT)) { 2478 case 0: 2479 return (do_unlock_normal(td, m, flags, rb)); 2480 case UMUTEX_PRIO_INHERIT: 2481 return (do_unlock_pi(td, m, flags, rb)); 2482 case UMUTEX_PRIO_PROTECT: 2483 return (do_unlock_pp(td, m, flags, rb)); 2484 } 2485 2486 return (EINVAL); 2487 } 2488 2489 static int 2490 do_cv_wait(struct thread *td, struct ucond *cv, struct umutex *m, 2491 struct timespec *timeout, u_long wflags) 2492 { 2493 struct abs_timeout timo; 2494 struct umtx_q *uq; 2495 uint32_t flags, clockid, hasw; 2496 int error; 2497 2498 uq = td->td_umtxq; 2499 error = fueword32(&cv->c_flags, &flags); 2500 if (error == -1) 2501 return (EFAULT); 2502 error = umtx_key_get(cv, TYPE_CV, GET_SHARE(flags), &uq->uq_key); 2503 if (error != 0) 2504 return (error); 2505 2506 if ((wflags & CVWAIT_CLOCKID) != 0) { 2507 error = fueword32(&cv->c_clockid, &clockid); 2508 if (error == -1) { 2509 umtx_key_release(&uq->uq_key); 2510 return (EFAULT); 2511 } 2512 if (clockid < CLOCK_REALTIME || 2513 clockid >= CLOCK_THREAD_CPUTIME_ID) { 2514 /* hmm, only HW clock id will work. */ 2515 umtx_key_release(&uq->uq_key); 2516 return (EINVAL); 2517 } 2518 } else { 2519 clockid = CLOCK_REALTIME; 2520 } 2521 2522 umtxq_lock(&uq->uq_key); 2523 umtxq_busy(&uq->uq_key); 2524 umtxq_insert(uq); 2525 umtxq_unlock(&uq->uq_key); 2526 2527 /* 2528 * Set c_has_waiters to 1 before releasing user mutex, also 2529 * don't modify cache line when unnecessary. 2530 */ 2531 error = fueword32(&cv->c_has_waiters, &hasw); 2532 if (error == 0 && hasw == 0) 2533 suword32(&cv->c_has_waiters, 1); 2534 2535 umtxq_unbusy_unlocked(&uq->uq_key); 2536 2537 error = do_unlock_umutex(td, m, false); 2538 2539 if (timeout != NULL) 2540 abs_timeout_init(&timo, clockid, (wflags & CVWAIT_ABSTIME) != 0, 2541 timeout); 2542 2543 umtxq_lock(&uq->uq_key); 2544 if (error == 0) { 2545 error = umtxq_sleep(uq, "ucond", timeout == NULL ? 2546 NULL : &timo); 2547 } 2548 2549 if ((uq->uq_flags & UQF_UMTXQ) == 0) 2550 error = 0; 2551 else { 2552 /* 2553 * This must be timeout,interrupted by signal or 2554 * surprious wakeup, clear c_has_waiter flag when 2555 * necessary. 2556 */ 2557 umtxq_busy(&uq->uq_key); 2558 if ((uq->uq_flags & UQF_UMTXQ) != 0) { 2559 int oldlen = uq->uq_cur_queue->length; 2560 umtxq_remove(uq); 2561 if (oldlen == 1) { 2562 umtxq_unlock(&uq->uq_key); 2563 suword32(&cv->c_has_waiters, 0); 2564 umtxq_lock(&uq->uq_key); 2565 } 2566 } 2567 umtxq_unbusy(&uq->uq_key); 2568 if (error == ERESTART) 2569 error = EINTR; 2570 } 2571 2572 umtxq_unlock(&uq->uq_key); 2573 umtx_key_release(&uq->uq_key); 2574 return (error); 2575 } 2576 2577 /* 2578 * Signal a userland condition variable. 2579 */ 2580 static int 2581 do_cv_signal(struct thread *td, struct ucond *cv) 2582 { 2583 struct umtx_key key; 2584 int error, cnt, nwake; 2585 uint32_t flags; 2586 2587 error = fueword32(&cv->c_flags, &flags); 2588 if (error == -1) 2589 return (EFAULT); 2590 if ((error = umtx_key_get(cv, TYPE_CV, GET_SHARE(flags), &key)) != 0) 2591 return (error); 2592 umtxq_lock(&key); 2593 umtxq_busy(&key); 2594 cnt = umtxq_count(&key); 2595 nwake = umtxq_signal(&key, 1); 2596 if (cnt <= nwake) { 2597 umtxq_unlock(&key); 2598 error = suword32(&cv->c_has_waiters, 0); 2599 if (error == -1) 2600 error = EFAULT; 2601 umtxq_lock(&key); 2602 } 2603 umtxq_unbusy(&key); 2604 umtxq_unlock(&key); 2605 umtx_key_release(&key); 2606 return (error); 2607 } 2608 2609 static int 2610 do_cv_broadcast(struct thread *td, struct ucond *cv) 2611 { 2612 struct umtx_key key; 2613 int error; 2614 uint32_t flags; 2615 2616 error = fueword32(&cv->c_flags, &flags); 2617 if (error == -1) 2618 return (EFAULT); 2619 if ((error = umtx_key_get(cv, TYPE_CV, GET_SHARE(flags), &key)) != 0) 2620 return (error); 2621 2622 umtxq_lock(&key); 2623 umtxq_busy(&key); 2624 umtxq_signal(&key, INT_MAX); 2625 umtxq_unlock(&key); 2626 2627 error = suword32(&cv->c_has_waiters, 0); 2628 if (error == -1) 2629 error = EFAULT; 2630 2631 umtxq_unbusy_unlocked(&key); 2632 2633 umtx_key_release(&key); 2634 return (error); 2635 } 2636 2637 static int 2638 do_rw_rdlock(struct thread *td, struct urwlock *rwlock, long fflag, struct _umtx_time *timeout) 2639 { 2640 struct abs_timeout timo; 2641 struct umtx_q *uq; 2642 uint32_t flags, wrflags; 2643 int32_t state, oldstate; 2644 int32_t blocked_readers; 2645 int error, error1, rv; 2646 2647 uq = td->td_umtxq; 2648 error = fueword32(&rwlock->rw_flags, &flags); 2649 if (error == -1) 2650 return (EFAULT); 2651 error = umtx_key_get(rwlock, TYPE_RWLOCK, GET_SHARE(flags), &uq->uq_key); 2652 if (error != 0) 2653 return (error); 2654 2655 if (timeout != NULL) 2656 abs_timeout_init2(&timo, timeout); 2657 2658 wrflags = URWLOCK_WRITE_OWNER; 2659 if (!(fflag & URWLOCK_PREFER_READER) && !(flags & URWLOCK_PREFER_READER)) 2660 wrflags |= URWLOCK_WRITE_WAITERS; 2661 2662 for (;;) { 2663 rv = fueword32(&rwlock->rw_state, &state); 2664 if (rv == -1) { 2665 umtx_key_release(&uq->uq_key); 2666 return (EFAULT); 2667 } 2668 2669 /* try to lock it */ 2670 while (!(state & wrflags)) { 2671 if (__predict_false(URWLOCK_READER_COUNT(state) == URWLOCK_MAX_READERS)) { 2672 umtx_key_release(&uq->uq_key); 2673 return (EAGAIN); 2674 } 2675 rv = casueword32(&rwlock->rw_state, state, 2676 &oldstate, state + 1); 2677 if (rv == -1) { 2678 umtx_key_release(&uq->uq_key); 2679 return (EFAULT); 2680 } 2681 if (oldstate == state) { 2682 umtx_key_release(&uq->uq_key); 2683 return (0); 2684 } 2685 error = umtxq_check_susp(td); 2686 if (error != 0) 2687 break; 2688 state = oldstate; 2689 } 2690 2691 if (error) 2692 break; 2693 2694 /* grab monitor lock */ 2695 umtxq_lock(&uq->uq_key); 2696 umtxq_busy(&uq->uq_key); 2697 umtxq_unlock(&uq->uq_key); 2698 2699 /* 2700 * re-read the state, in case it changed between the try-lock above 2701 * and the check below 2702 */ 2703 rv = fueword32(&rwlock->rw_state, &state); 2704 if (rv == -1) 2705 error = EFAULT; 2706 2707 /* set read contention bit */ 2708 while (error == 0 && (state & wrflags) && 2709 !(state & URWLOCK_READ_WAITERS)) { 2710 rv = casueword32(&rwlock->rw_state, state, 2711 &oldstate, state | URWLOCK_READ_WAITERS); 2712 if (rv == -1) { 2713 error = EFAULT; 2714 break; 2715 } 2716 if (oldstate == state) 2717 goto sleep; 2718 state = oldstate; 2719 error = umtxq_check_susp(td); 2720 if (error != 0) 2721 break; 2722 } 2723 if (error != 0) { 2724 umtxq_unbusy_unlocked(&uq->uq_key); 2725 break; 2726 } 2727 2728 /* state is changed while setting flags, restart */ 2729 if (!(state & wrflags)) { 2730 umtxq_unbusy_unlocked(&uq->uq_key); 2731 error = umtxq_check_susp(td); 2732 if (error != 0) 2733 break; 2734 continue; 2735 } 2736 2737 sleep: 2738 /* contention bit is set, before sleeping, increase read waiter count */ 2739 rv = fueword32(&rwlock->rw_blocked_readers, 2740 &blocked_readers); 2741 if (rv == -1) { 2742 umtxq_unbusy_unlocked(&uq->uq_key); 2743 error = EFAULT; 2744 break; 2745 } 2746 suword32(&rwlock->rw_blocked_readers, blocked_readers+1); 2747 2748 while (state & wrflags) { 2749 umtxq_lock(&uq->uq_key); 2750 umtxq_insert(uq); 2751 umtxq_unbusy(&uq->uq_key); 2752 2753 error = umtxq_sleep(uq, "urdlck", timeout == NULL ? 2754 NULL : &timo); 2755 2756 umtxq_busy(&uq->uq_key); 2757 umtxq_remove(uq); 2758 umtxq_unlock(&uq->uq_key); 2759 if (error) 2760 break; 2761 rv = fueword32(&rwlock->rw_state, &state); 2762 if (rv == -1) { 2763 error = EFAULT; 2764 break; 2765 } 2766 } 2767 2768 /* decrease read waiter count, and may clear read contention bit */ 2769 rv = fueword32(&rwlock->rw_blocked_readers, 2770 &blocked_readers); 2771 if (rv == -1) { 2772 umtxq_unbusy_unlocked(&uq->uq_key); 2773 error = EFAULT; 2774 break; 2775 } 2776 suword32(&rwlock->rw_blocked_readers, blocked_readers-1); 2777 if (blocked_readers == 1) { 2778 rv = fueword32(&rwlock->rw_state, &state); 2779 if (rv == -1) { 2780 umtxq_unbusy_unlocked(&uq->uq_key); 2781 error = EFAULT; 2782 break; 2783 } 2784 for (;;) { 2785 rv = casueword32(&rwlock->rw_state, state, 2786 &oldstate, state & ~URWLOCK_READ_WAITERS); 2787 if (rv == -1) { 2788 error = EFAULT; 2789 break; 2790 } 2791 if (oldstate == state) 2792 break; 2793 state = oldstate; 2794 error1 = umtxq_check_susp(td); 2795 if (error1 != 0) { 2796 if (error == 0) 2797 error = error1; 2798 break; 2799 } 2800 } 2801 } 2802 2803 umtxq_unbusy_unlocked(&uq->uq_key); 2804 if (error != 0) 2805 break; 2806 } 2807 umtx_key_release(&uq->uq_key); 2808 if (error == ERESTART) 2809 error = EINTR; 2810 return (error); 2811 } 2812 2813 static int 2814 do_rw_wrlock(struct thread *td, struct urwlock *rwlock, struct _umtx_time *timeout) 2815 { 2816 struct abs_timeout timo; 2817 struct umtx_q *uq; 2818 uint32_t flags; 2819 int32_t state, oldstate; 2820 int32_t blocked_writers; 2821 int32_t blocked_readers; 2822 int error, error1, rv; 2823 2824 uq = td->td_umtxq; 2825 error = fueword32(&rwlock->rw_flags, &flags); 2826 if (error == -1) 2827 return (EFAULT); 2828 error = umtx_key_get(rwlock, TYPE_RWLOCK, GET_SHARE(flags), &uq->uq_key); 2829 if (error != 0) 2830 return (error); 2831 2832 if (timeout != NULL) 2833 abs_timeout_init2(&timo, timeout); 2834 2835 blocked_readers = 0; 2836 for (;;) { 2837 rv = fueword32(&rwlock->rw_state, &state); 2838 if (rv == -1) { 2839 umtx_key_release(&uq->uq_key); 2840 return (EFAULT); 2841 } 2842 while (!(state & URWLOCK_WRITE_OWNER) && URWLOCK_READER_COUNT(state) == 0) { 2843 rv = casueword32(&rwlock->rw_state, state, 2844 &oldstate, state | URWLOCK_WRITE_OWNER); 2845 if (rv == -1) { 2846 umtx_key_release(&uq->uq_key); 2847 return (EFAULT); 2848 } 2849 if (oldstate == state) { 2850 umtx_key_release(&uq->uq_key); 2851 return (0); 2852 } 2853 state = oldstate; 2854 error = umtxq_check_susp(td); 2855 if (error != 0) 2856 break; 2857 } 2858 2859 if (error) { 2860 if (!(state & (URWLOCK_WRITE_OWNER|URWLOCK_WRITE_WAITERS)) && 2861 blocked_readers != 0) { 2862 umtxq_lock(&uq->uq_key); 2863 umtxq_busy(&uq->uq_key); 2864 umtxq_signal_queue(&uq->uq_key, INT_MAX, UMTX_SHARED_QUEUE); 2865 umtxq_unbusy(&uq->uq_key); 2866 umtxq_unlock(&uq->uq_key); 2867 } 2868 2869 break; 2870 } 2871 2872 /* grab monitor lock */ 2873 umtxq_lock(&uq->uq_key); 2874 umtxq_busy(&uq->uq_key); 2875 umtxq_unlock(&uq->uq_key); 2876 2877 /* 2878 * re-read the state, in case it changed between the try-lock above 2879 * and the check below 2880 */ 2881 rv = fueword32(&rwlock->rw_state, &state); 2882 if (rv == -1) 2883 error = EFAULT; 2884 2885 while (error == 0 && ((state & URWLOCK_WRITE_OWNER) || 2886 URWLOCK_READER_COUNT(state) != 0) && 2887 (state & URWLOCK_WRITE_WAITERS) == 0) { 2888 rv = casueword32(&rwlock->rw_state, state, 2889 &oldstate, state | URWLOCK_WRITE_WAITERS); 2890 if (rv == -1) { 2891 error = EFAULT; 2892 break; 2893 } 2894 if (oldstate == state) 2895 goto sleep; 2896 state = oldstate; 2897 error = umtxq_check_susp(td); 2898 if (error != 0) 2899 break; 2900 } 2901 if (error != 0) { 2902 umtxq_unbusy_unlocked(&uq->uq_key); 2903 break; 2904 } 2905 2906 if (!(state & URWLOCK_WRITE_OWNER) && URWLOCK_READER_COUNT(state) == 0) { 2907 umtxq_unbusy_unlocked(&uq->uq_key); 2908 error = umtxq_check_susp(td); 2909 if (error != 0) 2910 break; 2911 continue; 2912 } 2913 sleep: 2914 rv = fueword32(&rwlock->rw_blocked_writers, 2915 &blocked_writers); 2916 if (rv == -1) { 2917 umtxq_unbusy_unlocked(&uq->uq_key); 2918 error = EFAULT; 2919 break; 2920 } 2921 suword32(&rwlock->rw_blocked_writers, blocked_writers+1); 2922 2923 while ((state & URWLOCK_WRITE_OWNER) || URWLOCK_READER_COUNT(state) != 0) { 2924 umtxq_lock(&uq->uq_key); 2925 umtxq_insert_queue(uq, UMTX_EXCLUSIVE_QUEUE); 2926 umtxq_unbusy(&uq->uq_key); 2927 2928 error = umtxq_sleep(uq, "uwrlck", timeout == NULL ? 2929 NULL : &timo); 2930 2931 umtxq_busy(&uq->uq_key); 2932 umtxq_remove_queue(uq, UMTX_EXCLUSIVE_QUEUE); 2933 umtxq_unlock(&uq->uq_key); 2934 if (error) 2935 break; 2936 rv = fueword32(&rwlock->rw_state, &state); 2937 if (rv == -1) { 2938 error = EFAULT; 2939 break; 2940 } 2941 } 2942 2943 rv = fueword32(&rwlock->rw_blocked_writers, 2944 &blocked_writers); 2945 if (rv == -1) { 2946 umtxq_unbusy_unlocked(&uq->uq_key); 2947 error = EFAULT; 2948 break; 2949 } 2950 suword32(&rwlock->rw_blocked_writers, blocked_writers-1); 2951 if (blocked_writers == 1) { 2952 rv = fueword32(&rwlock->rw_state, &state); 2953 if (rv == -1) { 2954 umtxq_unbusy_unlocked(&uq->uq_key); 2955 error = EFAULT; 2956 break; 2957 } 2958 for (;;) { 2959 rv = casueword32(&rwlock->rw_state, state, 2960 &oldstate, state & ~URWLOCK_WRITE_WAITERS); 2961 if (rv == -1) { 2962 error = EFAULT; 2963 break; 2964 } 2965 if (oldstate == state) 2966 break; 2967 state = oldstate; 2968 error1 = umtxq_check_susp(td); 2969 /* 2970 * We are leaving the URWLOCK_WRITE_WAITERS 2971 * behind, but this should not harm the 2972 * correctness. 2973 */ 2974 if (error1 != 0) { 2975 if (error == 0) 2976 error = error1; 2977 break; 2978 } 2979 } 2980 rv = fueword32(&rwlock->rw_blocked_readers, 2981 &blocked_readers); 2982 if (rv == -1) { 2983 umtxq_unbusy_unlocked(&uq->uq_key); 2984 error = EFAULT; 2985 break; 2986 } 2987 } else 2988 blocked_readers = 0; 2989 2990 umtxq_unbusy_unlocked(&uq->uq_key); 2991 } 2992 2993 umtx_key_release(&uq->uq_key); 2994 if (error == ERESTART) 2995 error = EINTR; 2996 return (error); 2997 } 2998 2999 static int 3000 do_rw_unlock(struct thread *td, struct urwlock *rwlock) 3001 { 3002 struct umtx_q *uq; 3003 uint32_t flags; 3004 int32_t state, oldstate; 3005 int error, rv, q, count; 3006 3007 uq = td->td_umtxq; 3008 error = fueword32(&rwlock->rw_flags, &flags); 3009 if (error == -1) 3010 return (EFAULT); 3011 error = umtx_key_get(rwlock, TYPE_RWLOCK, GET_SHARE(flags), &uq->uq_key); 3012 if (error != 0) 3013 return (error); 3014 3015 error = fueword32(&rwlock->rw_state, &state); 3016 if (error == -1) { 3017 error = EFAULT; 3018 goto out; 3019 } 3020 if (state & URWLOCK_WRITE_OWNER) { 3021 for (;;) { 3022 rv = casueword32(&rwlock->rw_state, state, 3023 &oldstate, state & ~URWLOCK_WRITE_OWNER); 3024 if (rv == -1) { 3025 error = EFAULT; 3026 goto out; 3027 } 3028 if (oldstate != state) { 3029 state = oldstate; 3030 if (!(oldstate & URWLOCK_WRITE_OWNER)) { 3031 error = EPERM; 3032 goto out; 3033 } 3034 error = umtxq_check_susp(td); 3035 if (error != 0) 3036 goto out; 3037 } else 3038 break; 3039 } 3040 } else if (URWLOCK_READER_COUNT(state) != 0) { 3041 for (;;) { 3042 rv = casueword32(&rwlock->rw_state, state, 3043 &oldstate, state - 1); 3044 if (rv == -1) { 3045 error = EFAULT; 3046 goto out; 3047 } 3048 if (oldstate != state) { 3049 state = oldstate; 3050 if (URWLOCK_READER_COUNT(oldstate) == 0) { 3051 error = EPERM; 3052 goto out; 3053 } 3054 error = umtxq_check_susp(td); 3055 if (error != 0) 3056 goto out; 3057 } else 3058 break; 3059 } 3060 } else { 3061 error = EPERM; 3062 goto out; 3063 } 3064 3065 count = 0; 3066 3067 if (!(flags & URWLOCK_PREFER_READER)) { 3068 if (state & URWLOCK_WRITE_WAITERS) { 3069 count = 1; 3070 q = UMTX_EXCLUSIVE_QUEUE; 3071 } else if (state & URWLOCK_READ_WAITERS) { 3072 count = INT_MAX; 3073 q = UMTX_SHARED_QUEUE; 3074 } 3075 } else { 3076 if (state & URWLOCK_READ_WAITERS) { 3077 count = INT_MAX; 3078 q = UMTX_SHARED_QUEUE; 3079 } else if (state & URWLOCK_WRITE_WAITERS) { 3080 count = 1; 3081 q = UMTX_EXCLUSIVE_QUEUE; 3082 } 3083 } 3084 3085 if (count) { 3086 umtxq_lock(&uq->uq_key); 3087 umtxq_busy(&uq->uq_key); 3088 umtxq_signal_queue(&uq->uq_key, count, q); 3089 umtxq_unbusy(&uq->uq_key); 3090 umtxq_unlock(&uq->uq_key); 3091 } 3092 out: 3093 umtx_key_release(&uq->uq_key); 3094 return (error); 3095 } 3096 3097 #if defined(COMPAT_FREEBSD9) || defined(COMPAT_FREEBSD10) 3098 static int 3099 do_sem_wait(struct thread *td, struct _usem *sem, struct _umtx_time *timeout) 3100 { 3101 struct abs_timeout timo; 3102 struct umtx_q *uq; 3103 uint32_t flags, count, count1; 3104 int error, rv; 3105 3106 uq = td->td_umtxq; 3107 error = fueword32(&sem->_flags, &flags); 3108 if (error == -1) 3109 return (EFAULT); 3110 error = umtx_key_get(sem, TYPE_SEM, GET_SHARE(flags), &uq->uq_key); 3111 if (error != 0) 3112 return (error); 3113 3114 if (timeout != NULL) 3115 abs_timeout_init2(&timo, timeout); 3116 3117 umtxq_lock(&uq->uq_key); 3118 umtxq_busy(&uq->uq_key); 3119 umtxq_insert(uq); 3120 umtxq_unlock(&uq->uq_key); 3121 rv = casueword32(&sem->_has_waiters, 0, &count1, 1); 3122 if (rv == 0) 3123 rv = fueword32(&sem->_count, &count); 3124 if (rv == -1 || count != 0) { 3125 umtxq_lock(&uq->uq_key); 3126 umtxq_unbusy(&uq->uq_key); 3127 umtxq_remove(uq); 3128 umtxq_unlock(&uq->uq_key); 3129 umtx_key_release(&uq->uq_key); 3130 return (rv == -1 ? EFAULT : 0); 3131 } 3132 umtxq_lock(&uq->uq_key); 3133 umtxq_unbusy(&uq->uq_key); 3134 3135 error = umtxq_sleep(uq, "usem", timeout == NULL ? NULL : &timo); 3136 3137 if ((uq->uq_flags & UQF_UMTXQ) == 0) 3138 error = 0; 3139 else { 3140 umtxq_remove(uq); 3141 /* A relative timeout cannot be restarted. */ 3142 if (error == ERESTART && timeout != NULL && 3143 (timeout->_flags & UMTX_ABSTIME) == 0) 3144 error = EINTR; 3145 } 3146 umtxq_unlock(&uq->uq_key); 3147 umtx_key_release(&uq->uq_key); 3148 return (error); 3149 } 3150 3151 /* 3152 * Signal a userland semaphore. 3153 */ 3154 static int 3155 do_sem_wake(struct thread *td, struct _usem *sem) 3156 { 3157 struct umtx_key key; 3158 int error, cnt; 3159 uint32_t flags; 3160 3161 error = fueword32(&sem->_flags, &flags); 3162 if (error == -1) 3163 return (EFAULT); 3164 if ((error = umtx_key_get(sem, TYPE_SEM, GET_SHARE(flags), &key)) != 0) 3165 return (error); 3166 umtxq_lock(&key); 3167 umtxq_busy(&key); 3168 cnt = umtxq_count(&key); 3169 if (cnt > 0) { 3170 /* 3171 * Check if count is greater than 0, this means the memory is 3172 * still being referenced by user code, so we can safely 3173 * update _has_waiters flag. 3174 */ 3175 if (cnt == 1) { 3176 umtxq_unlock(&key); 3177 error = suword32(&sem->_has_waiters, 0); 3178 umtxq_lock(&key); 3179 if (error == -1) 3180 error = EFAULT; 3181 } 3182 umtxq_signal(&key, 1); 3183 } 3184 umtxq_unbusy(&key); 3185 umtxq_unlock(&key); 3186 umtx_key_release(&key); 3187 return (error); 3188 } 3189 #endif 3190 3191 static int 3192 do_sem2_wait(struct thread *td, struct _usem2 *sem, struct _umtx_time *timeout) 3193 { 3194 struct abs_timeout timo; 3195 struct umtx_q *uq; 3196 uint32_t count, flags; 3197 int error, rv; 3198 3199 uq = td->td_umtxq; 3200 flags = fuword32(&sem->_flags); 3201 error = umtx_key_get(sem, TYPE_SEM, GET_SHARE(flags), &uq->uq_key); 3202 if (error != 0) 3203 return (error); 3204 3205 if (timeout != NULL) 3206 abs_timeout_init2(&timo, timeout); 3207 3208 umtxq_lock(&uq->uq_key); 3209 umtxq_busy(&uq->uq_key); 3210 umtxq_insert(uq); 3211 umtxq_unlock(&uq->uq_key); 3212 rv = fueword32(&sem->_count, &count); 3213 if (rv == -1) { 3214 umtxq_lock(&uq->uq_key); 3215 umtxq_unbusy(&uq->uq_key); 3216 umtxq_remove(uq); 3217 umtxq_unlock(&uq->uq_key); 3218 umtx_key_release(&uq->uq_key); 3219 return (EFAULT); 3220 } 3221 for (;;) { 3222 if (USEM_COUNT(count) != 0) { 3223 umtxq_lock(&uq->uq_key); 3224 umtxq_unbusy(&uq->uq_key); 3225 umtxq_remove(uq); 3226 umtxq_unlock(&uq->uq_key); 3227 umtx_key_release(&uq->uq_key); 3228 return (0); 3229 } 3230 if (count == USEM_HAS_WAITERS) 3231 break; 3232 rv = casueword32(&sem->_count, 0, &count, USEM_HAS_WAITERS); 3233 if (rv == -1) { 3234 umtxq_lock(&uq->uq_key); 3235 umtxq_unbusy(&uq->uq_key); 3236 umtxq_remove(uq); 3237 umtxq_unlock(&uq->uq_key); 3238 umtx_key_release(&uq->uq_key); 3239 return (EFAULT); 3240 } 3241 if (count == 0) 3242 break; 3243 } 3244 umtxq_lock(&uq->uq_key); 3245 umtxq_unbusy(&uq->uq_key); 3246 3247 error = umtxq_sleep(uq, "usem", timeout == NULL ? NULL : &timo); 3248 3249 if ((uq->uq_flags & UQF_UMTXQ) == 0) 3250 error = 0; 3251 else { 3252 umtxq_remove(uq); 3253 if (timeout != NULL && (timeout->_flags & UMTX_ABSTIME) == 0) { 3254 /* A relative timeout cannot be restarted. */ 3255 if (error == ERESTART) 3256 error = EINTR; 3257 if (error == EINTR) { 3258 abs_timeout_update(&timo); 3259 timeout->_timeout = timo.end; 3260 timespecsub(&timeout->_timeout, &timo.cur); 3261 } 3262 } 3263 } 3264 umtxq_unlock(&uq->uq_key); 3265 umtx_key_release(&uq->uq_key); 3266 return (error); 3267 } 3268 3269 /* 3270 * Signal a userland semaphore. 3271 */ 3272 static int 3273 do_sem2_wake(struct thread *td, struct _usem2 *sem) 3274 { 3275 struct umtx_key key; 3276 int error, cnt, rv; 3277 uint32_t count, flags; 3278 3279 rv = fueword32(&sem->_flags, &flags); 3280 if (rv == -1) 3281 return (EFAULT); 3282 if ((error = umtx_key_get(sem, TYPE_SEM, GET_SHARE(flags), &key)) != 0) 3283 return (error); 3284 umtxq_lock(&key); 3285 umtxq_busy(&key); 3286 cnt = umtxq_count(&key); 3287 if (cnt > 0) { 3288 /* 3289 * If this was the last sleeping thread, clear the waiters 3290 * flag in _count. 3291 */ 3292 if (cnt == 1) { 3293 umtxq_unlock(&key); 3294 rv = fueword32(&sem->_count, &count); 3295 while (rv != -1 && count & USEM_HAS_WAITERS) 3296 rv = casueword32(&sem->_count, count, &count, 3297 count & ~USEM_HAS_WAITERS); 3298 if (rv == -1) 3299 error = EFAULT; 3300 umtxq_lock(&key); 3301 } 3302 3303 umtxq_signal(&key, 1); 3304 } 3305 umtxq_unbusy(&key); 3306 umtxq_unlock(&key); 3307 umtx_key_release(&key); 3308 return (error); 3309 } 3310 3311 inline int 3312 umtx_copyin_timeout(const void *addr, struct timespec *tsp) 3313 { 3314 int error; 3315 3316 error = copyin(addr, tsp, sizeof(struct timespec)); 3317 if (error == 0) { 3318 if (tsp->tv_sec < 0 || 3319 tsp->tv_nsec >= 1000000000 || 3320 tsp->tv_nsec < 0) 3321 error = EINVAL; 3322 } 3323 return (error); 3324 } 3325 3326 static inline int 3327 umtx_copyin_umtx_time(const void *addr, size_t size, struct _umtx_time *tp) 3328 { 3329 int error; 3330 3331 if (size <= sizeof(struct timespec)) { 3332 tp->_clockid = CLOCK_REALTIME; 3333 tp->_flags = 0; 3334 error = copyin(addr, &tp->_timeout, sizeof(struct timespec)); 3335 } else 3336 error = copyin(addr, tp, sizeof(struct _umtx_time)); 3337 if (error != 0) 3338 return (error); 3339 if (tp->_timeout.tv_sec < 0 || 3340 tp->_timeout.tv_nsec >= 1000000000 || tp->_timeout.tv_nsec < 0) 3341 return (EINVAL); 3342 return (0); 3343 } 3344 3345 static int 3346 __umtx_op_unimpl(struct thread *td, struct _umtx_op_args *uap) 3347 { 3348 3349 return (EOPNOTSUPP); 3350 } 3351 3352 static int 3353 __umtx_op_wait(struct thread *td, struct _umtx_op_args *uap) 3354 { 3355 struct _umtx_time timeout, *tm_p; 3356 int error; 3357 3358 if (uap->uaddr2 == NULL) 3359 tm_p = NULL; 3360 else { 3361 error = umtx_copyin_umtx_time( 3362 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3363 if (error != 0) 3364 return (error); 3365 tm_p = &timeout; 3366 } 3367 return (do_wait(td, uap->obj, uap->val, tm_p, 0, 0)); 3368 } 3369 3370 static int 3371 __umtx_op_wait_uint(struct thread *td, struct _umtx_op_args *uap) 3372 { 3373 struct _umtx_time timeout, *tm_p; 3374 int error; 3375 3376 if (uap->uaddr2 == NULL) 3377 tm_p = NULL; 3378 else { 3379 error = umtx_copyin_umtx_time( 3380 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3381 if (error != 0) 3382 return (error); 3383 tm_p = &timeout; 3384 } 3385 return (do_wait(td, uap->obj, uap->val, tm_p, 1, 0)); 3386 } 3387 3388 static int 3389 __umtx_op_wait_uint_private(struct thread *td, struct _umtx_op_args *uap) 3390 { 3391 struct _umtx_time *tm_p, timeout; 3392 int error; 3393 3394 if (uap->uaddr2 == NULL) 3395 tm_p = NULL; 3396 else { 3397 error = umtx_copyin_umtx_time( 3398 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3399 if (error != 0) 3400 return (error); 3401 tm_p = &timeout; 3402 } 3403 return (do_wait(td, uap->obj, uap->val, tm_p, 1, 1)); 3404 } 3405 3406 static int 3407 __umtx_op_wake(struct thread *td, struct _umtx_op_args *uap) 3408 { 3409 3410 return (kern_umtx_wake(td, uap->obj, uap->val, 0)); 3411 } 3412 3413 #define BATCH_SIZE 128 3414 static int 3415 __umtx_op_nwake_private(struct thread *td, struct _umtx_op_args *uap) 3416 { 3417 char *uaddrs[BATCH_SIZE], **upp; 3418 int count, error, i, pos, tocopy; 3419 3420 upp = (char **)uap->obj; 3421 error = 0; 3422 for (count = uap->val, pos = 0; count > 0; count -= tocopy, 3423 pos += tocopy) { 3424 tocopy = MIN(count, BATCH_SIZE); 3425 error = copyin(upp + pos, uaddrs, tocopy * sizeof(char *)); 3426 if (error != 0) 3427 break; 3428 for (i = 0; i < tocopy; ++i) 3429 kern_umtx_wake(td, uaddrs[i], INT_MAX, 1); 3430 maybe_yield(); 3431 } 3432 return (error); 3433 } 3434 3435 static int 3436 __umtx_op_wake_private(struct thread *td, struct _umtx_op_args *uap) 3437 { 3438 3439 return (kern_umtx_wake(td, uap->obj, uap->val, 1)); 3440 } 3441 3442 static int 3443 __umtx_op_lock_umutex(struct thread *td, struct _umtx_op_args *uap) 3444 { 3445 struct _umtx_time *tm_p, timeout; 3446 int error; 3447 3448 /* Allow a null timespec (wait forever). */ 3449 if (uap->uaddr2 == NULL) 3450 tm_p = NULL; 3451 else { 3452 error = umtx_copyin_umtx_time( 3453 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3454 if (error != 0) 3455 return (error); 3456 tm_p = &timeout; 3457 } 3458 return (do_lock_umutex(td, uap->obj, tm_p, 0)); 3459 } 3460 3461 static int 3462 __umtx_op_trylock_umutex(struct thread *td, struct _umtx_op_args *uap) 3463 { 3464 3465 return (do_lock_umutex(td, uap->obj, NULL, _UMUTEX_TRY)); 3466 } 3467 3468 static int 3469 __umtx_op_wait_umutex(struct thread *td, struct _umtx_op_args *uap) 3470 { 3471 struct _umtx_time *tm_p, timeout; 3472 int error; 3473 3474 /* Allow a null timespec (wait forever). */ 3475 if (uap->uaddr2 == NULL) 3476 tm_p = NULL; 3477 else { 3478 error = umtx_copyin_umtx_time( 3479 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3480 if (error != 0) 3481 return (error); 3482 tm_p = &timeout; 3483 } 3484 return (do_lock_umutex(td, uap->obj, tm_p, _UMUTEX_WAIT)); 3485 } 3486 3487 static int 3488 __umtx_op_wake_umutex(struct thread *td, struct _umtx_op_args *uap) 3489 { 3490 3491 return (do_wake_umutex(td, uap->obj)); 3492 } 3493 3494 static int 3495 __umtx_op_unlock_umutex(struct thread *td, struct _umtx_op_args *uap) 3496 { 3497 3498 return (do_unlock_umutex(td, uap->obj, false)); 3499 } 3500 3501 static int 3502 __umtx_op_set_ceiling(struct thread *td, struct _umtx_op_args *uap) 3503 { 3504 3505 return (do_set_ceiling(td, uap->obj, uap->val, uap->uaddr1)); 3506 } 3507 3508 static int 3509 __umtx_op_cv_wait(struct thread *td, struct _umtx_op_args *uap) 3510 { 3511 struct timespec *ts, timeout; 3512 int error; 3513 3514 /* Allow a null timespec (wait forever). */ 3515 if (uap->uaddr2 == NULL) 3516 ts = NULL; 3517 else { 3518 error = umtx_copyin_timeout(uap->uaddr2, &timeout); 3519 if (error != 0) 3520 return (error); 3521 ts = &timeout; 3522 } 3523 return (do_cv_wait(td, uap->obj, uap->uaddr1, ts, uap->val)); 3524 } 3525 3526 static int 3527 __umtx_op_cv_signal(struct thread *td, struct _umtx_op_args *uap) 3528 { 3529 3530 return (do_cv_signal(td, uap->obj)); 3531 } 3532 3533 static int 3534 __umtx_op_cv_broadcast(struct thread *td, struct _umtx_op_args *uap) 3535 { 3536 3537 return (do_cv_broadcast(td, uap->obj)); 3538 } 3539 3540 static int 3541 __umtx_op_rw_rdlock(struct thread *td, struct _umtx_op_args *uap) 3542 { 3543 struct _umtx_time timeout; 3544 int error; 3545 3546 /* Allow a null timespec (wait forever). */ 3547 if (uap->uaddr2 == NULL) { 3548 error = do_rw_rdlock(td, uap->obj, uap->val, 0); 3549 } else { 3550 error = umtx_copyin_umtx_time(uap->uaddr2, 3551 (size_t)uap->uaddr1, &timeout); 3552 if (error != 0) 3553 return (error); 3554 error = do_rw_rdlock(td, uap->obj, uap->val, &timeout); 3555 } 3556 return (error); 3557 } 3558 3559 static int 3560 __umtx_op_rw_wrlock(struct thread *td, struct _umtx_op_args *uap) 3561 { 3562 struct _umtx_time timeout; 3563 int error; 3564 3565 /* Allow a null timespec (wait forever). */ 3566 if (uap->uaddr2 == NULL) { 3567 error = do_rw_wrlock(td, uap->obj, 0); 3568 } else { 3569 error = umtx_copyin_umtx_time(uap->uaddr2, 3570 (size_t)uap->uaddr1, &timeout); 3571 if (error != 0) 3572 return (error); 3573 3574 error = do_rw_wrlock(td, uap->obj, &timeout); 3575 } 3576 return (error); 3577 } 3578 3579 static int 3580 __umtx_op_rw_unlock(struct thread *td, struct _umtx_op_args *uap) 3581 { 3582 3583 return (do_rw_unlock(td, uap->obj)); 3584 } 3585 3586 #if defined(COMPAT_FREEBSD9) || defined(COMPAT_FREEBSD10) 3587 static int 3588 __umtx_op_sem_wait(struct thread *td, struct _umtx_op_args *uap) 3589 { 3590 struct _umtx_time *tm_p, timeout; 3591 int error; 3592 3593 /* Allow a null timespec (wait forever). */ 3594 if (uap->uaddr2 == NULL) 3595 tm_p = NULL; 3596 else { 3597 error = umtx_copyin_umtx_time( 3598 uap->uaddr2, (size_t)uap->uaddr1, &timeout); 3599 if (error != 0) 3600 return (error); 3601 tm_p = &timeout; 3602 } 3603 return (do_sem_wait(td, uap->obj, tm_p)); 3604 } 3605 3606 static int 3607 __umtx_op_sem_wake(struct thread *td, struct _umtx_op_args *uap) 3608 { 3609 3610 return (do_sem_wake(td, uap->obj)); 3611 } 3612 #endif 3613 3614 static int 3615 __umtx_op_wake2_umutex(struct thread *td, struct _umtx_op_args *uap) 3616 { 3617 3618 return (do_wake2_umutex(td, uap->obj, uap->val)); 3619 } 3620 3621 static int 3622 __umtx_op_sem2_wait(struct thread *td, struct _umtx_op_args *uap) 3623 { 3624 struct _umtx_time *tm_p, timeout; 3625 size_t uasize; 3626 int error; 3627 3628 /* Allow a null timespec (wait forever). */ 3629 if (uap->uaddr2 == NULL) { 3630 uasize = 0; 3631 tm_p = NULL; 3632 } else { 3633 uasize = (size_t)uap->uaddr1; 3634 error = umtx_copyin_umtx_time(uap->uaddr2, uasize, &timeout); 3635 if (error != 0) 3636 return (error); 3637 tm_p = &timeout; 3638 } 3639 error = do_sem2_wait(td, uap->obj, tm_p); 3640 if (error == EINTR && uap->uaddr2 != NULL && 3641 (timeout._flags & UMTX_ABSTIME) == 0 && 3642 uasize >= sizeof(struct _umtx_time) + sizeof(struct timespec)) { 3643 error = copyout(&timeout._timeout, 3644 (struct _umtx_time *)uap->uaddr2 + 1, 3645 sizeof(struct timespec)); 3646 if (error == 0) { 3647 error = EINTR; 3648 } 3649 } 3650 3651 return (error); 3652 } 3653 3654 static int 3655 __umtx_op_sem2_wake(struct thread *td, struct _umtx_op_args *uap) 3656 { 3657 3658 return (do_sem2_wake(td, uap->obj)); 3659 } 3660 3661 #define USHM_OBJ_UMTX(o) \ 3662 ((struct umtx_shm_obj_list *)(&(o)->umtx_data)) 3663 3664 #define USHMF_REG_LINKED 0x0001 3665 #define USHMF_OBJ_LINKED 0x0002 3666 struct umtx_shm_reg { 3667 TAILQ_ENTRY(umtx_shm_reg) ushm_reg_link; 3668 LIST_ENTRY(umtx_shm_reg) ushm_obj_link; 3669 struct umtx_key ushm_key; 3670 struct ucred *ushm_cred; 3671 struct shmfd *ushm_obj; 3672 u_int ushm_refcnt; 3673 u_int ushm_flags; 3674 }; 3675 3676 LIST_HEAD(umtx_shm_obj_list, umtx_shm_reg); 3677 TAILQ_HEAD(umtx_shm_reg_head, umtx_shm_reg); 3678 3679 static uma_zone_t umtx_shm_reg_zone; 3680 static struct umtx_shm_reg_head umtx_shm_registry[UMTX_CHAINS]; 3681 static struct mtx umtx_shm_lock; 3682 static struct umtx_shm_reg_head umtx_shm_reg_delfree = 3683 TAILQ_HEAD_INITIALIZER(umtx_shm_reg_delfree); 3684 3685 static void umtx_shm_free_reg(struct umtx_shm_reg *reg); 3686 3687 static void 3688 umtx_shm_reg_delfree_tq(void *context __unused, int pending __unused) 3689 { 3690 struct umtx_shm_reg_head d; 3691 struct umtx_shm_reg *reg, *reg1; 3692 3693 TAILQ_INIT(&d); 3694 mtx_lock(&umtx_shm_lock); 3695 TAILQ_CONCAT(&d, &umtx_shm_reg_delfree, ushm_reg_link); 3696 mtx_unlock(&umtx_shm_lock); 3697 TAILQ_FOREACH_SAFE(reg, &d, ushm_reg_link, reg1) { 3698 TAILQ_REMOVE(&d, reg, ushm_reg_link); 3699 umtx_shm_free_reg(reg); 3700 } 3701 } 3702 3703 static struct task umtx_shm_reg_delfree_task = 3704 TASK_INITIALIZER(0, umtx_shm_reg_delfree_tq, NULL); 3705 3706 static struct umtx_shm_reg * 3707 umtx_shm_find_reg_locked(const struct umtx_key *key) 3708 { 3709 struct umtx_shm_reg *reg; 3710 struct umtx_shm_reg_head *reg_head; 3711 3712 KASSERT(key->shared, ("umtx_p_find_rg: private key")); 3713 mtx_assert(&umtx_shm_lock, MA_OWNED); 3714 reg_head = &umtx_shm_registry[key->hash]; 3715 TAILQ_FOREACH(reg, reg_head, ushm_reg_link) { 3716 KASSERT(reg->ushm_key.shared, 3717 ("non-shared key on reg %p %d", reg, reg->ushm_key.shared)); 3718 if (reg->ushm_key.info.shared.object == 3719 key->info.shared.object && 3720 reg->ushm_key.info.shared.offset == 3721 key->info.shared.offset) { 3722 KASSERT(reg->ushm_key.type == TYPE_SHM, ("TYPE_USHM")); 3723 KASSERT(reg->ushm_refcnt > 0, 3724 ("reg %p refcnt 0 onlist", reg)); 3725 KASSERT((reg->ushm_flags & USHMF_REG_LINKED) != 0, 3726 ("reg %p not linked", reg)); 3727 reg->ushm_refcnt++; 3728 return (reg); 3729 } 3730 } 3731 return (NULL); 3732 } 3733 3734 static struct umtx_shm_reg * 3735 umtx_shm_find_reg(const struct umtx_key *key) 3736 { 3737 struct umtx_shm_reg *reg; 3738 3739 mtx_lock(&umtx_shm_lock); 3740 reg = umtx_shm_find_reg_locked(key); 3741 mtx_unlock(&umtx_shm_lock); 3742 return (reg); 3743 } 3744 3745 static void 3746 umtx_shm_free_reg(struct umtx_shm_reg *reg) 3747 { 3748 3749 chgumtxcnt(reg->ushm_cred->cr_ruidinfo, -1, 0); 3750 crfree(reg->ushm_cred); 3751 shm_drop(reg->ushm_obj); 3752 uma_zfree(umtx_shm_reg_zone, reg); 3753 } 3754 3755 static bool 3756 umtx_shm_unref_reg_locked(struct umtx_shm_reg *reg, bool force) 3757 { 3758 bool res; 3759 3760 mtx_assert(&umtx_shm_lock, MA_OWNED); 3761 KASSERT(reg->ushm_refcnt > 0, ("ushm_reg %p refcnt 0", reg)); 3762 reg->ushm_refcnt--; 3763 res = reg->ushm_refcnt == 0; 3764 if (res || force) { 3765 if ((reg->ushm_flags & USHMF_REG_LINKED) != 0) { 3766 TAILQ_REMOVE(&umtx_shm_registry[reg->ushm_key.hash], 3767 reg, ushm_reg_link); 3768 reg->ushm_flags &= ~USHMF_REG_LINKED; 3769 } 3770 if ((reg->ushm_flags & USHMF_OBJ_LINKED) != 0) { 3771 LIST_REMOVE(reg, ushm_obj_link); 3772 reg->ushm_flags &= ~USHMF_OBJ_LINKED; 3773 } 3774 } 3775 return (res); 3776 } 3777 3778 static void 3779 umtx_shm_unref_reg(struct umtx_shm_reg *reg, bool force) 3780 { 3781 vm_object_t object; 3782 bool dofree; 3783 3784 if (force) { 3785 object = reg->ushm_obj->shm_object; 3786 VM_OBJECT_WLOCK(object); 3787 object->flags |= OBJ_UMTXDEAD; 3788 VM_OBJECT_WUNLOCK(object); 3789 } 3790 mtx_lock(&umtx_shm_lock); 3791 dofree = umtx_shm_unref_reg_locked(reg, force); 3792 mtx_unlock(&umtx_shm_lock); 3793 if (dofree) 3794 umtx_shm_free_reg(reg); 3795 } 3796 3797 void 3798 umtx_shm_object_init(vm_object_t object) 3799 { 3800 3801 LIST_INIT(USHM_OBJ_UMTX(object)); 3802 } 3803 3804 void 3805 umtx_shm_object_terminated(vm_object_t object) 3806 { 3807 struct umtx_shm_reg *reg, *reg1; 3808 bool dofree; 3809 3810 dofree = false; 3811 mtx_lock(&umtx_shm_lock); 3812 LIST_FOREACH_SAFE(reg, USHM_OBJ_UMTX(object), ushm_obj_link, reg1) { 3813 if (umtx_shm_unref_reg_locked(reg, true)) { 3814 TAILQ_INSERT_TAIL(&umtx_shm_reg_delfree, reg, 3815 ushm_reg_link); 3816 dofree = true; 3817 } 3818 } 3819 mtx_unlock(&umtx_shm_lock); 3820 if (dofree) 3821 taskqueue_enqueue(taskqueue_thread, &umtx_shm_reg_delfree_task); 3822 } 3823 3824 static int 3825 umtx_shm_create_reg(struct thread *td, const struct umtx_key *key, 3826 struct umtx_shm_reg **res) 3827 { 3828 struct umtx_shm_reg *reg, *reg1; 3829 struct ucred *cred; 3830 int error; 3831 3832 reg = umtx_shm_find_reg(key); 3833 if (reg != NULL) { 3834 *res = reg; 3835 return (0); 3836 } 3837 cred = td->td_ucred; 3838 if (!chgumtxcnt(cred->cr_ruidinfo, 1, lim_cur(td, RLIMIT_UMTXP))) 3839 return (ENOMEM); 3840 reg = uma_zalloc(umtx_shm_reg_zone, M_WAITOK | M_ZERO); 3841 reg->ushm_refcnt = 1; 3842 bcopy(key, ®->ushm_key, sizeof(*key)); 3843 reg->ushm_obj = shm_alloc(td->td_ucred, O_RDWR); 3844 reg->ushm_cred = crhold(cred); 3845 error = shm_dotruncate(reg->ushm_obj, PAGE_SIZE); 3846 if (error != 0) { 3847 umtx_shm_free_reg(reg); 3848 return (error); 3849 } 3850 mtx_lock(&umtx_shm_lock); 3851 reg1 = umtx_shm_find_reg_locked(key); 3852 if (reg1 != NULL) { 3853 mtx_unlock(&umtx_shm_lock); 3854 umtx_shm_free_reg(reg); 3855 *res = reg1; 3856 return (0); 3857 } 3858 reg->ushm_refcnt++; 3859 TAILQ_INSERT_TAIL(&umtx_shm_registry[key->hash], reg, ushm_reg_link); 3860 LIST_INSERT_HEAD(USHM_OBJ_UMTX(key->info.shared.object), reg, 3861 ushm_obj_link); 3862 reg->ushm_flags = USHMF_REG_LINKED | USHMF_OBJ_LINKED; 3863 mtx_unlock(&umtx_shm_lock); 3864 *res = reg; 3865 return (0); 3866 } 3867 3868 static int 3869 umtx_shm_alive(struct thread *td, void *addr) 3870 { 3871 vm_map_t map; 3872 vm_map_entry_t entry; 3873 vm_object_t object; 3874 vm_pindex_t pindex; 3875 vm_prot_t prot; 3876 int res, ret; 3877 boolean_t wired; 3878 3879 map = &td->td_proc->p_vmspace->vm_map; 3880 res = vm_map_lookup(&map, (uintptr_t)addr, VM_PROT_READ, &entry, 3881 &object, &pindex, &prot, &wired); 3882 if (res != KERN_SUCCESS) 3883 return (EFAULT); 3884 if (object == NULL) 3885 ret = EINVAL; 3886 else 3887 ret = (object->flags & OBJ_UMTXDEAD) != 0 ? ENOTTY : 0; 3888 vm_map_lookup_done(map, entry); 3889 return (ret); 3890 } 3891 3892 static void 3893 umtx_shm_init(void) 3894 { 3895 int i; 3896 3897 umtx_shm_reg_zone = uma_zcreate("umtx_shm", sizeof(struct umtx_shm_reg), 3898 NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0); 3899 mtx_init(&umtx_shm_lock, "umtxshm", NULL, MTX_DEF); 3900 for (i = 0; i < nitems(umtx_shm_registry); i++) 3901 TAILQ_INIT(&umtx_shm_registry[i]); 3902 } 3903 3904 static int 3905 umtx_shm(struct thread *td, void *addr, u_int flags) 3906 { 3907 struct umtx_key key; 3908 struct umtx_shm_reg *reg; 3909 struct file *fp; 3910 int error, fd; 3911 3912 if (__bitcount(flags & (UMTX_SHM_CREAT | UMTX_SHM_LOOKUP | 3913 UMTX_SHM_DESTROY| UMTX_SHM_ALIVE)) != 1) 3914 return (EINVAL); 3915 if ((flags & UMTX_SHM_ALIVE) != 0) 3916 return (umtx_shm_alive(td, addr)); 3917 error = umtx_key_get(addr, TYPE_SHM, PROCESS_SHARE, &key); 3918 if (error != 0) 3919 return (error); 3920 KASSERT(key.shared == 1, ("non-shared key")); 3921 if ((flags & UMTX_SHM_CREAT) != 0) { 3922 error = umtx_shm_create_reg(td, &key, ®); 3923 } else { 3924 reg = umtx_shm_find_reg(&key); 3925 if (reg == NULL) 3926 error = ESRCH; 3927 } 3928 umtx_key_release(&key); 3929 if (error != 0) 3930 return (error); 3931 KASSERT(reg != NULL, ("no reg")); 3932 if ((flags & UMTX_SHM_DESTROY) != 0) { 3933 umtx_shm_unref_reg(reg, true); 3934 } else { 3935 #if 0 3936 #ifdef MAC 3937 error = mac_posixshm_check_open(td->td_ucred, 3938 reg->ushm_obj, FFLAGS(O_RDWR)); 3939 if (error == 0) 3940 #endif 3941 error = shm_access(reg->ushm_obj, td->td_ucred, 3942 FFLAGS(O_RDWR)); 3943 if (error == 0) 3944 #endif 3945 error = falloc_caps(td, &fp, &fd, O_CLOEXEC, NULL); 3946 if (error == 0) { 3947 shm_hold(reg->ushm_obj); 3948 finit(fp, FFLAGS(O_RDWR), DTYPE_SHM, reg->ushm_obj, 3949 &shm_ops); 3950 td->td_retval[0] = fd; 3951 fdrop(fp, td); 3952 } 3953 } 3954 umtx_shm_unref_reg(reg, false); 3955 return (error); 3956 } 3957 3958 static int 3959 __umtx_op_shm(struct thread *td, struct _umtx_op_args *uap) 3960 { 3961 3962 return (umtx_shm(td, uap->uaddr1, uap->val)); 3963 } 3964 3965 static int 3966 umtx_robust_lists(struct thread *td, struct umtx_robust_lists_params *rbp) 3967 { 3968 3969 td->td_rb_list = rbp->robust_list_offset; 3970 td->td_rbp_list = rbp->robust_priv_list_offset; 3971 td->td_rb_inact = rbp->robust_inact_offset; 3972 return (0); 3973 } 3974 3975 static int 3976 __umtx_op_robust_lists(struct thread *td, struct _umtx_op_args *uap) 3977 { 3978 struct umtx_robust_lists_params rb; 3979 int error; 3980 3981 if (uap->val > sizeof(rb)) 3982 return (EINVAL); 3983 bzero(&rb, sizeof(rb)); 3984 error = copyin(uap->uaddr1, &rb, uap->val); 3985 if (error != 0) 3986 return (error); 3987 return (umtx_robust_lists(td, &rb)); 3988 } 3989 3990 typedef int (*_umtx_op_func)(struct thread *td, struct _umtx_op_args *uap); 3991 3992 static const _umtx_op_func op_table[] = { 3993 [UMTX_OP_RESERVED0] = __umtx_op_unimpl, 3994 [UMTX_OP_RESERVED1] = __umtx_op_unimpl, 3995 [UMTX_OP_WAIT] = __umtx_op_wait, 3996 [UMTX_OP_WAKE] = __umtx_op_wake, 3997 [UMTX_OP_MUTEX_TRYLOCK] = __umtx_op_trylock_umutex, 3998 [UMTX_OP_MUTEX_LOCK] = __umtx_op_lock_umutex, 3999 [UMTX_OP_MUTEX_UNLOCK] = __umtx_op_unlock_umutex, 4000 [UMTX_OP_SET_CEILING] = __umtx_op_set_ceiling, 4001 [UMTX_OP_CV_WAIT] = __umtx_op_cv_wait, 4002 [UMTX_OP_CV_SIGNAL] = __umtx_op_cv_signal, 4003 [UMTX_OP_CV_BROADCAST] = __umtx_op_cv_broadcast, 4004 [UMTX_OP_WAIT_UINT] = __umtx_op_wait_uint, 4005 [UMTX_OP_RW_RDLOCK] = __umtx_op_rw_rdlock, 4006 [UMTX_OP_RW_WRLOCK] = __umtx_op_rw_wrlock, 4007 [UMTX_OP_RW_UNLOCK] = __umtx_op_rw_unlock, 4008 [UMTX_OP_WAIT_UINT_PRIVATE] = __umtx_op_wait_uint_private, 4009 [UMTX_OP_WAKE_PRIVATE] = __umtx_op_wake_private, 4010 [UMTX_OP_MUTEX_WAIT] = __umtx_op_wait_umutex, 4011 [UMTX_OP_MUTEX_WAKE] = __umtx_op_wake_umutex, 4012 #if defined(COMPAT_FREEBSD9) || defined(COMPAT_FREEBSD10) 4013 [UMTX_OP_SEM_WAIT] = __umtx_op_sem_wait, 4014 [UMTX_OP_SEM_WAKE] = __umtx_op_sem_wake, 4015 #else 4016 [UMTX_OP_SEM_WAIT] = __umtx_op_unimpl, 4017 [UMTX_OP_SEM_WAKE] = __umtx_op_unimpl, 4018 #endif 4019 [UMTX_OP_NWAKE_PRIVATE] = __umtx_op_nwake_private, 4020 [UMTX_OP_MUTEX_WAKE2] = __umtx_op_wake2_umutex, 4021 [UMTX_OP_SEM2_WAIT] = __umtx_op_sem2_wait, 4022 [UMTX_OP_SEM2_WAKE] = __umtx_op_sem2_wake, 4023 [UMTX_OP_SHM] = __umtx_op_shm, 4024 [UMTX_OP_ROBUST_LISTS] = __umtx_op_robust_lists, 4025 }; 4026 4027 int 4028 sys__umtx_op(struct thread *td, struct _umtx_op_args *uap) 4029 { 4030 4031 if ((unsigned)uap->op < nitems(op_table)) 4032 return (*op_table[uap->op])(td, uap); 4033 return (EINVAL); 4034 } 4035 4036 #ifdef COMPAT_FREEBSD32 4037 4038 struct timespec32 { 4039 int32_t tv_sec; 4040 int32_t tv_nsec; 4041 }; 4042 4043 struct umtx_time32 { 4044 struct timespec32 timeout; 4045 uint32_t flags; 4046 uint32_t clockid; 4047 }; 4048 4049 static inline int 4050 umtx_copyin_timeout32(void *addr, struct timespec *tsp) 4051 { 4052 struct timespec32 ts32; 4053 int error; 4054 4055 error = copyin(addr, &ts32, sizeof(struct timespec32)); 4056 if (error == 0) { 4057 if (ts32.tv_sec < 0 || 4058 ts32.tv_nsec >= 1000000000 || 4059 ts32.tv_nsec < 0) 4060 error = EINVAL; 4061 else { 4062 tsp->tv_sec = ts32.tv_sec; 4063 tsp->tv_nsec = ts32.tv_nsec; 4064 } 4065 } 4066 return (error); 4067 } 4068 4069 static inline int 4070 umtx_copyin_umtx_time32(const void *addr, size_t size, struct _umtx_time *tp) 4071 { 4072 struct umtx_time32 t32; 4073 int error; 4074 4075 t32.clockid = CLOCK_REALTIME; 4076 t32.flags = 0; 4077 if (size <= sizeof(struct timespec32)) 4078 error = copyin(addr, &t32.timeout, sizeof(struct timespec32)); 4079 else 4080 error = copyin(addr, &t32, sizeof(struct umtx_time32)); 4081 if (error != 0) 4082 return (error); 4083 if (t32.timeout.tv_sec < 0 || 4084 t32.timeout.tv_nsec >= 1000000000 || t32.timeout.tv_nsec < 0) 4085 return (EINVAL); 4086 tp->_timeout.tv_sec = t32.timeout.tv_sec; 4087 tp->_timeout.tv_nsec = t32.timeout.tv_nsec; 4088 tp->_flags = t32.flags; 4089 tp->_clockid = t32.clockid; 4090 return (0); 4091 } 4092 4093 static int 4094 __umtx_op_wait_compat32(struct thread *td, struct _umtx_op_args *uap) 4095 { 4096 struct _umtx_time *tm_p, timeout; 4097 int error; 4098 4099 if (uap->uaddr2 == NULL) 4100 tm_p = NULL; 4101 else { 4102 error = umtx_copyin_umtx_time32(uap->uaddr2, 4103 (size_t)uap->uaddr1, &timeout); 4104 if (error != 0) 4105 return (error); 4106 tm_p = &timeout; 4107 } 4108 return (do_wait(td, uap->obj, uap->val, tm_p, 1, 0)); 4109 } 4110 4111 static int 4112 __umtx_op_lock_umutex_compat32(struct thread *td, struct _umtx_op_args *uap) 4113 { 4114 struct _umtx_time *tm_p, timeout; 4115 int error; 4116 4117 /* Allow a null timespec (wait forever). */ 4118 if (uap->uaddr2 == NULL) 4119 tm_p = NULL; 4120 else { 4121 error = umtx_copyin_umtx_time32(uap->uaddr2, 4122 (size_t)uap->uaddr1, &timeout); 4123 if (error != 0) 4124 return (error); 4125 tm_p = &timeout; 4126 } 4127 return (do_lock_umutex(td, uap->obj, tm_p, 0)); 4128 } 4129 4130 static int 4131 __umtx_op_wait_umutex_compat32(struct thread *td, struct _umtx_op_args *uap) 4132 { 4133 struct _umtx_time *tm_p, timeout; 4134 int error; 4135 4136 /* Allow a null timespec (wait forever). */ 4137 if (uap->uaddr2 == NULL) 4138 tm_p = NULL; 4139 else { 4140 error = umtx_copyin_umtx_time32(uap->uaddr2, 4141 (size_t)uap->uaddr1, &timeout); 4142 if (error != 0) 4143 return (error); 4144 tm_p = &timeout; 4145 } 4146 return (do_lock_umutex(td, uap->obj, tm_p, _UMUTEX_WAIT)); 4147 } 4148 4149 static int 4150 __umtx_op_cv_wait_compat32(struct thread *td, struct _umtx_op_args *uap) 4151 { 4152 struct timespec *ts, timeout; 4153 int error; 4154 4155 /* Allow a null timespec (wait forever). */ 4156 if (uap->uaddr2 == NULL) 4157 ts = NULL; 4158 else { 4159 error = umtx_copyin_timeout32(uap->uaddr2, &timeout); 4160 if (error != 0) 4161 return (error); 4162 ts = &timeout; 4163 } 4164 return (do_cv_wait(td, uap->obj, uap->uaddr1, ts, uap->val)); 4165 } 4166 4167 static int 4168 __umtx_op_rw_rdlock_compat32(struct thread *td, struct _umtx_op_args *uap) 4169 { 4170 struct _umtx_time timeout; 4171 int error; 4172 4173 /* Allow a null timespec (wait forever). */ 4174 if (uap->uaddr2 == NULL) { 4175 error = do_rw_rdlock(td, uap->obj, uap->val, 0); 4176 } else { 4177 error = umtx_copyin_umtx_time32(uap->uaddr2, 4178 (size_t)uap->uaddr1, &timeout); 4179 if (error != 0) 4180 return (error); 4181 error = do_rw_rdlock(td, uap->obj, uap->val, &timeout); 4182 } 4183 return (error); 4184 } 4185 4186 static int 4187 __umtx_op_rw_wrlock_compat32(struct thread *td, struct _umtx_op_args *uap) 4188 { 4189 struct _umtx_time timeout; 4190 int error; 4191 4192 /* Allow a null timespec (wait forever). */ 4193 if (uap->uaddr2 == NULL) { 4194 error = do_rw_wrlock(td, uap->obj, 0); 4195 } else { 4196 error = umtx_copyin_umtx_time32(uap->uaddr2, 4197 (size_t)uap->uaddr1, &timeout); 4198 if (error != 0) 4199 return (error); 4200 error = do_rw_wrlock(td, uap->obj, &timeout); 4201 } 4202 return (error); 4203 } 4204 4205 static int 4206 __umtx_op_wait_uint_private_compat32(struct thread *td, struct _umtx_op_args *uap) 4207 { 4208 struct _umtx_time *tm_p, timeout; 4209 int error; 4210 4211 if (uap->uaddr2 == NULL) 4212 tm_p = NULL; 4213 else { 4214 error = umtx_copyin_umtx_time32( 4215 uap->uaddr2, (size_t)uap->uaddr1,&timeout); 4216 if (error != 0) 4217 return (error); 4218 tm_p = &timeout; 4219 } 4220 return (do_wait(td, uap->obj, uap->val, tm_p, 1, 1)); 4221 } 4222 4223 #if defined(COMPAT_FREEBSD9) || defined(COMPAT_FREEBSD10) 4224 static int 4225 __umtx_op_sem_wait_compat32(struct thread *td, struct _umtx_op_args *uap) 4226 { 4227 struct _umtx_time *tm_p, timeout; 4228 int error; 4229 4230 /* Allow a null timespec (wait forever). */ 4231 if (uap->uaddr2 == NULL) 4232 tm_p = NULL; 4233 else { 4234 error = umtx_copyin_umtx_time32(uap->uaddr2, 4235 (size_t)uap->uaddr1, &timeout); 4236 if (error != 0) 4237 return (error); 4238 tm_p = &timeout; 4239 } 4240 return (do_sem_wait(td, uap->obj, tm_p)); 4241 } 4242 #endif 4243 4244 static int 4245 __umtx_op_sem2_wait_compat32(struct thread *td, struct _umtx_op_args *uap) 4246 { 4247 struct _umtx_time *tm_p, timeout; 4248 size_t uasize; 4249 int error; 4250 4251 /* Allow a null timespec (wait forever). */ 4252 if (uap->uaddr2 == NULL) { 4253 uasize = 0; 4254 tm_p = NULL; 4255 } else { 4256 uasize = (size_t)uap->uaddr1; 4257 error = umtx_copyin_umtx_time32(uap->uaddr2, uasize, &timeout); 4258 if (error != 0) 4259 return (error); 4260 tm_p = &timeout; 4261 } 4262 error = do_sem2_wait(td, uap->obj, tm_p); 4263 if (error == EINTR && uap->uaddr2 != NULL && 4264 (timeout._flags & UMTX_ABSTIME) == 0 && 4265 uasize >= sizeof(struct umtx_time32) + sizeof(struct timespec32)) { 4266 struct timespec32 remain32 = { 4267 .tv_sec = timeout._timeout.tv_sec, 4268 .tv_nsec = timeout._timeout.tv_nsec 4269 }; 4270 error = copyout(&remain32, 4271 (struct umtx_time32 *)uap->uaddr2 + 1, 4272 sizeof(struct timespec32)); 4273 if (error == 0) { 4274 error = EINTR; 4275 } 4276 } 4277 4278 return (error); 4279 } 4280 4281 static int 4282 __umtx_op_nwake_private32(struct thread *td, struct _umtx_op_args *uap) 4283 { 4284 uint32_t uaddrs[BATCH_SIZE], **upp; 4285 int count, error, i, pos, tocopy; 4286 4287 upp = (uint32_t **)uap->obj; 4288 error = 0; 4289 for (count = uap->val, pos = 0; count > 0; count -= tocopy, 4290 pos += tocopy) { 4291 tocopy = MIN(count, BATCH_SIZE); 4292 error = copyin(upp + pos, uaddrs, tocopy * sizeof(uint32_t)); 4293 if (error != 0) 4294 break; 4295 for (i = 0; i < tocopy; ++i) 4296 kern_umtx_wake(td, (void *)(intptr_t)uaddrs[i], 4297 INT_MAX, 1); 4298 maybe_yield(); 4299 } 4300 return (error); 4301 } 4302 4303 struct umtx_robust_lists_params_compat32 { 4304 uint32_t robust_list_offset; 4305 uint32_t robust_priv_list_offset; 4306 uint32_t robust_inact_offset; 4307 }; 4308 4309 static int 4310 __umtx_op_robust_lists_compat32(struct thread *td, struct _umtx_op_args *uap) 4311 { 4312 struct umtx_robust_lists_params rb; 4313 struct umtx_robust_lists_params_compat32 rb32; 4314 int error; 4315 4316 if (uap->val > sizeof(rb32)) 4317 return (EINVAL); 4318 bzero(&rb, sizeof(rb)); 4319 bzero(&rb32, sizeof(rb32)); 4320 error = copyin(uap->uaddr1, &rb32, uap->val); 4321 if (error != 0) 4322 return (error); 4323 rb.robust_list_offset = rb32.robust_list_offset; 4324 rb.robust_priv_list_offset = rb32.robust_priv_list_offset; 4325 rb.robust_inact_offset = rb32.robust_inact_offset; 4326 return (umtx_robust_lists(td, &rb)); 4327 } 4328 4329 static const _umtx_op_func op_table_compat32[] = { 4330 [UMTX_OP_RESERVED0] = __umtx_op_unimpl, 4331 [UMTX_OP_RESERVED1] = __umtx_op_unimpl, 4332 [UMTX_OP_WAIT] = __umtx_op_wait_compat32, 4333 [UMTX_OP_WAKE] = __umtx_op_wake, 4334 [UMTX_OP_MUTEX_TRYLOCK] = __umtx_op_trylock_umutex, 4335 [UMTX_OP_MUTEX_LOCK] = __umtx_op_lock_umutex_compat32, 4336 [UMTX_OP_MUTEX_UNLOCK] = __umtx_op_unlock_umutex, 4337 [UMTX_OP_SET_CEILING] = __umtx_op_set_ceiling, 4338 [UMTX_OP_CV_WAIT] = __umtx_op_cv_wait_compat32, 4339 [UMTX_OP_CV_SIGNAL] = __umtx_op_cv_signal, 4340 [UMTX_OP_CV_BROADCAST] = __umtx_op_cv_broadcast, 4341 [UMTX_OP_WAIT_UINT] = __umtx_op_wait_compat32, 4342 [UMTX_OP_RW_RDLOCK] = __umtx_op_rw_rdlock_compat32, 4343 [UMTX_OP_RW_WRLOCK] = __umtx_op_rw_wrlock_compat32, 4344 [UMTX_OP_RW_UNLOCK] = __umtx_op_rw_unlock, 4345 [UMTX_OP_WAIT_UINT_PRIVATE] = __umtx_op_wait_uint_private_compat32, 4346 [UMTX_OP_WAKE_PRIVATE] = __umtx_op_wake_private, 4347 [UMTX_OP_MUTEX_WAIT] = __umtx_op_wait_umutex_compat32, 4348 [UMTX_OP_MUTEX_WAKE] = __umtx_op_wake_umutex, 4349 #if defined(COMPAT_FREEBSD9) || defined(COMPAT_FREEBSD10) 4350 [UMTX_OP_SEM_WAIT] = __umtx_op_sem_wait_compat32, 4351 [UMTX_OP_SEM_WAKE] = __umtx_op_sem_wake, 4352 #else 4353 [UMTX_OP_SEM_WAIT] = __umtx_op_unimpl, 4354 [UMTX_OP_SEM_WAKE] = __umtx_op_unimpl, 4355 #endif 4356 [UMTX_OP_NWAKE_PRIVATE] = __umtx_op_nwake_private32, 4357 [UMTX_OP_MUTEX_WAKE2] = __umtx_op_wake2_umutex, 4358 [UMTX_OP_SEM2_WAIT] = __umtx_op_sem2_wait_compat32, 4359 [UMTX_OP_SEM2_WAKE] = __umtx_op_sem2_wake, 4360 [UMTX_OP_SHM] = __umtx_op_shm, 4361 [UMTX_OP_ROBUST_LISTS] = __umtx_op_robust_lists_compat32, 4362 }; 4363 4364 int 4365 freebsd32_umtx_op(struct thread *td, struct freebsd32_umtx_op_args *uap) 4366 { 4367 4368 if ((unsigned)uap->op < nitems(op_table_compat32)) { 4369 return (*op_table_compat32[uap->op])(td, 4370 (struct _umtx_op_args *)uap); 4371 } 4372 return (EINVAL); 4373 } 4374 #endif 4375 4376 void 4377 umtx_thread_init(struct thread *td) 4378 { 4379 4380 td->td_umtxq = umtxq_alloc(); 4381 td->td_umtxq->uq_thread = td; 4382 } 4383 4384 void 4385 umtx_thread_fini(struct thread *td) 4386 { 4387 4388 umtxq_free(td->td_umtxq); 4389 } 4390 4391 /* 4392 * It will be called when new thread is created, e.g fork(). 4393 */ 4394 void 4395 umtx_thread_alloc(struct thread *td) 4396 { 4397 struct umtx_q *uq; 4398 4399 uq = td->td_umtxq; 4400 uq->uq_inherited_pri = PRI_MAX; 4401 4402 KASSERT(uq->uq_flags == 0, ("uq_flags != 0")); 4403 KASSERT(uq->uq_thread == td, ("uq_thread != td")); 4404 KASSERT(uq->uq_pi_blocked == NULL, ("uq_pi_blocked != NULL")); 4405 KASSERT(TAILQ_EMPTY(&uq->uq_pi_contested), ("uq_pi_contested is not empty")); 4406 } 4407 4408 /* 4409 * exec() hook. 4410 * 4411 * Clear robust lists for all process' threads, not delaying the 4412 * cleanup to thread_exit hook, since the relevant address space is 4413 * destroyed right now. 4414 */ 4415 static void 4416 umtx_exec_hook(void *arg __unused, struct proc *p, 4417 struct image_params *imgp __unused) 4418 { 4419 struct thread *td; 4420 4421 KASSERT(p == curproc, ("need curproc")); 4422 PROC_LOCK(p); 4423 KASSERT((p->p_flag & P_HADTHREADS) == 0 || 4424 (p->p_flag & P_STOPPED_SINGLE) != 0, 4425 ("curproc must be single-threaded")); 4426 FOREACH_THREAD_IN_PROC(p, td) { 4427 KASSERT(td == curthread || 4428 ((td->td_flags & TDF_BOUNDARY) != 0 && TD_IS_SUSPENDED(td)), 4429 ("running thread %p %p", p, td)); 4430 PROC_UNLOCK(p); 4431 umtx_thread_cleanup(td); 4432 PROC_LOCK(p); 4433 td->td_rb_list = td->td_rbp_list = td->td_rb_inact = 0; 4434 } 4435 PROC_UNLOCK(p); 4436 } 4437 4438 /* 4439 * thread_exit() hook. 4440 */ 4441 void 4442 umtx_thread_exit(struct thread *td) 4443 { 4444 4445 umtx_thread_cleanup(td); 4446 } 4447 4448 static int 4449 umtx_read_uptr(struct thread *td, uintptr_t ptr, uintptr_t *res) 4450 { 4451 u_long res1; 4452 #ifdef COMPAT_FREEBSD32 4453 uint32_t res32; 4454 #endif 4455 int error; 4456 4457 #ifdef COMPAT_FREEBSD32 4458 if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) { 4459 error = fueword32((void *)ptr, &res32); 4460 if (error == 0) 4461 res1 = res32; 4462 } else 4463 #endif 4464 { 4465 error = fueword((void *)ptr, &res1); 4466 } 4467 if (error == 0) 4468 *res = res1; 4469 else 4470 error = EFAULT; 4471 return (error); 4472 } 4473 4474 static void 4475 umtx_read_rb_list(struct thread *td, struct umutex *m, uintptr_t *rb_list) 4476 { 4477 #ifdef COMPAT_FREEBSD32 4478 struct umutex32 m32; 4479 4480 if (SV_PROC_FLAG(td->td_proc, SV_ILP32)) { 4481 memcpy(&m32, m, sizeof(m32)); 4482 *rb_list = m32.m_rb_lnk; 4483 } else 4484 #endif 4485 *rb_list = m->m_rb_lnk; 4486 } 4487 4488 static int 4489 umtx_handle_rb(struct thread *td, uintptr_t rbp, uintptr_t *rb_list, bool inact) 4490 { 4491 struct umutex m; 4492 int error; 4493 4494 KASSERT(td->td_proc == curproc, ("need current vmspace")); 4495 error = copyin((void *)rbp, &m, sizeof(m)); 4496 if (error != 0) 4497 return (error); 4498 if (rb_list != NULL) 4499 umtx_read_rb_list(td, &m, rb_list); 4500 if ((m.m_flags & UMUTEX_ROBUST) == 0) 4501 return (EINVAL); 4502 if ((m.m_owner & ~UMUTEX_CONTESTED) != td->td_tid) 4503 /* inact is cleared after unlock, allow the inconsistency */ 4504 return (inact ? 0 : EINVAL); 4505 return (do_unlock_umutex(td, (struct umutex *)rbp, true)); 4506 } 4507 4508 static void 4509 umtx_cleanup_rb_list(struct thread *td, uintptr_t rb_list, uintptr_t *rb_inact, 4510 const char *name) 4511 { 4512 int error, i; 4513 uintptr_t rbp; 4514 bool inact; 4515 4516 if (rb_list == 0) 4517 return; 4518 error = umtx_read_uptr(td, rb_list, &rbp); 4519 for (i = 0; error == 0 && rbp != 0 && i < umtx_max_rb; i++) { 4520 if (rbp == *rb_inact) { 4521 inact = true; 4522 *rb_inact = 0; 4523 } else 4524 inact = false; 4525 error = umtx_handle_rb(td, rbp, &rbp, inact); 4526 } 4527 if (i == umtx_max_rb && umtx_verbose_rb) { 4528 uprintf("comm %s pid %d: reached umtx %smax rb %d\n", 4529 td->td_proc->p_comm, td->td_proc->p_pid, name, umtx_max_rb); 4530 } 4531 if (error != 0 && umtx_verbose_rb) { 4532 uprintf("comm %s pid %d: handling %srb error %d\n", 4533 td->td_proc->p_comm, td->td_proc->p_pid, name, error); 4534 } 4535 } 4536 4537 /* 4538 * Clean up umtx data. 4539 */ 4540 static void 4541 umtx_thread_cleanup(struct thread *td) 4542 { 4543 struct umtx_q *uq; 4544 struct umtx_pi *pi; 4545 uintptr_t rb_inact; 4546 4547 /* 4548 * Disown pi mutexes. 4549 */ 4550 uq = td->td_umtxq; 4551 if (uq != NULL) { 4552 mtx_lock(&umtx_lock); 4553 uq->uq_inherited_pri = PRI_MAX; 4554 while ((pi = TAILQ_FIRST(&uq->uq_pi_contested)) != NULL) { 4555 pi->pi_owner = NULL; 4556 TAILQ_REMOVE(&uq->uq_pi_contested, pi, pi_link); 4557 } 4558 mtx_unlock(&umtx_lock); 4559 thread_lock(td); 4560 sched_lend_user_prio(td, PRI_MAX); 4561 thread_unlock(td); 4562 } 4563 4564 /* 4565 * Handle terminated robust mutexes. Must be done after 4566 * robust pi disown, otherwise unlock could see unowned 4567 * entries. 4568 */ 4569 rb_inact = td->td_rb_inact; 4570 if (rb_inact != 0) 4571 (void)umtx_read_uptr(td, rb_inact, &rb_inact); 4572 umtx_cleanup_rb_list(td, td->td_rb_list, &rb_inact, ""); 4573 umtx_cleanup_rb_list(td, td->td_rbp_list, &rb_inact, "priv "); 4574 if (rb_inact != 0) 4575 (void)umtx_handle_rb(td, rb_inact, NULL, true); 4576 } 4577