1 /* $NetBSD: sys_lwp.c,v 1.67 2019/05/03 22:34:21 kamil Exp $ */ 2 3 /*- 4 * Copyright (c) 2001, 2006, 2007, 2008 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Nathan J. Williams, and Andrew Doran. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * Lightweight process (LWP) system calls. See kern_lwp.c for a description 34 * of LWPs. 35 */ 36 37 #include <sys/cdefs.h> 38 __KERNEL_RCSID(0, "$NetBSD: sys_lwp.c,v 1.67 2019/05/03 22:34:21 kamil Exp $"); 39 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/pool.h> 43 #include <sys/proc.h> 44 #include <sys/types.h> 45 #include <sys/syscallargs.h> 46 #include <sys/kauth.h> 47 #include <sys/kmem.h> 48 #include <sys/sleepq.h> 49 #include <sys/lwpctl.h> 50 #include <sys/cpu.h> 51 52 #include <uvm/uvm_extern.h> 53 54 #define LWP_UNPARK_MAX 1024 55 56 static syncobj_t lwp_park_sobj = { 57 .sobj_flag = SOBJ_SLEEPQ_LIFO, 58 .sobj_unsleep = sleepq_unsleep, 59 .sobj_changepri = sleepq_changepri, 60 .sobj_lendpri = sleepq_lendpri, 61 .sobj_owner = syncobj_noowner, 62 }; 63 64 static sleeptab_t lwp_park_tab; 65 66 void 67 lwp_sys_init(void) 68 { 69 sleeptab_init(&lwp_park_tab); 70 } 71 72 static void 73 mi_startlwp(void *arg) 74 { 75 struct lwp *l = curlwp; 76 struct proc *p = l->l_proc; 77 78 (p->p_emul->e_startlwp)(arg); 79 80 /* If the process is traced, report lwp creation to a debugger */ 81 if ((p->p_slflag & (PSL_TRACED|PSL_TRACELWP_CREATE)) == 82 (PSL_TRACED|PSL_TRACELWP_CREATE)) { 83 /* Paranoid check */ 84 mutex_enter(proc_lock); 85 if ((p->p_slflag & (PSL_TRACED|PSL_TRACELWP_CREATE)) != 86 (PSL_TRACED|PSL_TRACELWP_CREATE)) { 87 mutex_exit(proc_lock); 88 return; 89 } 90 91 mutex_enter(p->p_lock); 92 p->p_lwp_created = l->l_lid; 93 eventswitch(TRAP_LWP); 94 } 95 } 96 97 int 98 do_lwp_create(lwp_t *l, void *arg, u_long flags, lwpid_t *new_lwp, 99 const sigset_t *sigmask, const stack_t *sigstk) 100 { 101 struct proc *p = l->l_proc; 102 struct lwp *l2; 103 struct schedstate_percpu *spc; 104 vaddr_t uaddr; 105 int error; 106 107 /* XXX check against resource limits */ 108 109 uaddr = uvm_uarea_alloc(); 110 if (__predict_false(uaddr == 0)) 111 return ENOMEM; 112 113 error = lwp_create(l, p, uaddr, flags & LWP_DETACHED, NULL, 0, 114 mi_startlwp, arg, &l2, l->l_class, sigmask, &SS_INIT); 115 if (__predict_false(error)) { 116 uvm_uarea_free(uaddr); 117 return error; 118 } 119 120 *new_lwp = l2->l_lid; 121 122 /* 123 * Set the new LWP running, unless the caller has requested that 124 * it be created in suspended state. If the process is stopping, 125 * then the LWP is created stopped. 126 */ 127 mutex_enter(p->p_lock); 128 lwp_lock(l2); 129 spc = &l2->l_cpu->ci_schedstate; 130 if ((flags & LWP_SUSPENDED) == 0 && 131 (l->l_flag & (LW_WREBOOT | LW_WSUSPEND | LW_WEXIT)) == 0) { 132 if (p->p_stat == SSTOP || (p->p_sflag & PS_STOPPING) != 0) { 133 KASSERT(l2->l_wchan == NULL); 134 l2->l_stat = LSSTOP; 135 p->p_nrlwps--; 136 lwp_unlock_to(l2, spc->spc_lwplock); 137 } else { 138 KASSERT(lwp_locked(l2, spc->spc_mutex)); 139 l2->l_stat = LSRUN; 140 sched_enqueue(l2, false); 141 lwp_unlock(l2); 142 } 143 } else { 144 l2->l_stat = LSSUSPENDED; 145 p->p_nrlwps--; 146 lwp_unlock_to(l2, spc->spc_lwplock); 147 } 148 mutex_exit(p->p_lock); 149 150 return 0; 151 } 152 153 int 154 sys__lwp_create(struct lwp *l, const struct sys__lwp_create_args *uap, 155 register_t *retval) 156 { 157 /* { 158 syscallarg(const ucontext_t *) ucp; 159 syscallarg(u_long) flags; 160 syscallarg(lwpid_t *) new_lwp; 161 } */ 162 struct proc *p = l->l_proc; 163 ucontext_t *newuc; 164 lwpid_t lid; 165 int error; 166 167 newuc = kmem_alloc(sizeof(ucontext_t), KM_SLEEP); 168 error = copyin(SCARG(uap, ucp), newuc, p->p_emul->e_ucsize); 169 if (error) 170 goto fail; 171 172 /* validate the ucontext */ 173 if ((newuc->uc_flags & _UC_CPU) == 0) { 174 error = EINVAL; 175 goto fail; 176 } 177 error = cpu_mcontext_validate(l, &newuc->uc_mcontext); 178 if (error) 179 goto fail; 180 181 const sigset_t *sigmask = newuc->uc_flags & _UC_SIGMASK ? 182 &newuc->uc_sigmask : &l->l_sigmask; 183 error = do_lwp_create(l, newuc, SCARG(uap, flags), &lid, sigmask, 184 &SS_INIT); 185 if (error) 186 goto fail; 187 188 /* 189 * do not free ucontext in case of an error here, 190 * the lwp will actually run and access it 191 */ 192 return copyout(&lid, SCARG(uap, new_lwp), sizeof(lid)); 193 194 fail: 195 kmem_free(newuc, sizeof(ucontext_t)); 196 return error; 197 } 198 199 int 200 sys__lwp_exit(struct lwp *l, const void *v, register_t *retval) 201 { 202 203 lwp_exit(l); 204 return 0; 205 } 206 207 int 208 sys__lwp_self(struct lwp *l, const void *v, register_t *retval) 209 { 210 211 *retval = l->l_lid; 212 return 0; 213 } 214 215 int 216 sys__lwp_getprivate(struct lwp *l, const void *v, register_t *retval) 217 { 218 219 *retval = (uintptr_t)l->l_private; 220 return 0; 221 } 222 223 int 224 sys__lwp_setprivate(struct lwp *l, const struct sys__lwp_setprivate_args *uap, 225 register_t *retval) 226 { 227 /* { 228 syscallarg(void *) ptr; 229 } */ 230 231 return lwp_setprivate(l, SCARG(uap, ptr)); 232 } 233 234 int 235 sys__lwp_suspend(struct lwp *l, const struct sys__lwp_suspend_args *uap, 236 register_t *retval) 237 { 238 /* { 239 syscallarg(lwpid_t) target; 240 } */ 241 struct proc *p = l->l_proc; 242 struct lwp *t; 243 int error; 244 245 mutex_enter(p->p_lock); 246 if ((t = lwp_find(p, SCARG(uap, target))) == NULL) { 247 mutex_exit(p->p_lock); 248 return ESRCH; 249 } 250 251 /* 252 * Check for deadlock, which is only possible when we're suspending 253 * ourself. XXX There is a short race here, as p_nrlwps is only 254 * incremented when an LWP suspends itself on the kernel/user 255 * boundary. It's still possible to kill -9 the process so we 256 * don't bother checking further. 257 */ 258 lwp_lock(t); 259 if ((t == l && p->p_nrlwps == 1) || 260 (l->l_flag & (LW_WCORE | LW_WEXIT)) != 0) { 261 lwp_unlock(t); 262 mutex_exit(p->p_lock); 263 return EDEADLK; 264 } 265 266 /* 267 * Suspend the LWP. XXX If it's on a different CPU, we should wait 268 * for it to be preempted, where it will put itself to sleep. 269 * 270 * Suspension of the current LWP will happen on return to userspace. 271 */ 272 error = lwp_suspend(l, t); 273 if (error) { 274 mutex_exit(p->p_lock); 275 return error; 276 } 277 278 /* 279 * Wait for: 280 * o process exiting 281 * o target LWP suspended 282 * o target LWP not suspended and L_WSUSPEND clear 283 * o target LWP exited 284 */ 285 for (;;) { 286 error = cv_wait_sig(&p->p_lwpcv, p->p_lock); 287 if (error) { 288 error = ERESTART; 289 break; 290 } 291 if (lwp_find(p, SCARG(uap, target)) == NULL) { 292 error = ESRCH; 293 break; 294 } 295 if ((l->l_flag | t->l_flag) & (LW_WCORE | LW_WEXIT)) { 296 error = ERESTART; 297 break; 298 } 299 if (t->l_stat == LSSUSPENDED || 300 (t->l_flag & LW_WSUSPEND) == 0) 301 break; 302 } 303 mutex_exit(p->p_lock); 304 305 return error; 306 } 307 308 int 309 sys__lwp_continue(struct lwp *l, const struct sys__lwp_continue_args *uap, 310 register_t *retval) 311 { 312 /* { 313 syscallarg(lwpid_t) target; 314 } */ 315 int error; 316 struct proc *p = l->l_proc; 317 struct lwp *t; 318 319 error = 0; 320 321 mutex_enter(p->p_lock); 322 if ((t = lwp_find(p, SCARG(uap, target))) == NULL) { 323 mutex_exit(p->p_lock); 324 return ESRCH; 325 } 326 327 lwp_lock(t); 328 lwp_continue(t); 329 mutex_exit(p->p_lock); 330 331 return error; 332 } 333 334 int 335 sys__lwp_wakeup(struct lwp *l, const struct sys__lwp_wakeup_args *uap, 336 register_t *retval) 337 { 338 /* { 339 syscallarg(lwpid_t) target; 340 } */ 341 struct lwp *t; 342 struct proc *p; 343 int error; 344 345 p = l->l_proc; 346 mutex_enter(p->p_lock); 347 348 if ((t = lwp_find(p, SCARG(uap, target))) == NULL) { 349 mutex_exit(p->p_lock); 350 return ESRCH; 351 } 352 353 lwp_lock(t); 354 t->l_flag |= (LW_CANCELLED | LW_UNPARKED); 355 356 if (t->l_stat != LSSLEEP) { 357 lwp_unlock(t); 358 error = ENODEV; 359 } else if ((t->l_flag & LW_SINTR) == 0) { 360 lwp_unlock(t); 361 error = EBUSY; 362 } else { 363 /* Wake it up. lwp_unsleep() will release the LWP lock. */ 364 lwp_unsleep(t, true); 365 error = 0; 366 } 367 368 mutex_exit(p->p_lock); 369 370 return error; 371 } 372 373 int 374 sys__lwp_wait(struct lwp *l, const struct sys__lwp_wait_args *uap, 375 register_t *retval) 376 { 377 /* { 378 syscallarg(lwpid_t) wait_for; 379 syscallarg(lwpid_t *) departed; 380 } */ 381 struct proc *p = l->l_proc; 382 int error; 383 lwpid_t dep; 384 385 mutex_enter(p->p_lock); 386 error = lwp_wait(l, SCARG(uap, wait_for), &dep, false); 387 mutex_exit(p->p_lock); 388 389 if (!error && SCARG(uap, departed)) { 390 error = copyout(&dep, SCARG(uap, departed), sizeof(dep)); 391 } 392 393 return error; 394 } 395 396 int 397 sys__lwp_kill(struct lwp *l, const struct sys__lwp_kill_args *uap, 398 register_t *retval) 399 { 400 /* { 401 syscallarg(lwpid_t) target; 402 syscallarg(int) signo; 403 } */ 404 struct proc *p = l->l_proc; 405 struct lwp *t; 406 ksiginfo_t ksi; 407 int signo = SCARG(uap, signo); 408 int error = 0; 409 410 if ((u_int)signo >= NSIG) 411 return EINVAL; 412 413 KSI_INIT(&ksi); 414 ksi.ksi_signo = signo; 415 ksi.ksi_code = SI_LWP; 416 ksi.ksi_pid = p->p_pid; 417 ksi.ksi_uid = kauth_cred_geteuid(l->l_cred); 418 ksi.ksi_lid = SCARG(uap, target); 419 420 mutex_enter(proc_lock); 421 mutex_enter(p->p_lock); 422 if ((t = lwp_find(p, ksi.ksi_lid)) == NULL) 423 error = ESRCH; 424 else if (signo != 0) 425 kpsignal2(p, &ksi); 426 mutex_exit(p->p_lock); 427 mutex_exit(proc_lock); 428 429 return error; 430 } 431 432 int 433 sys__lwp_detach(struct lwp *l, const struct sys__lwp_detach_args *uap, 434 register_t *retval) 435 { 436 /* { 437 syscallarg(lwpid_t) target; 438 } */ 439 struct proc *p; 440 struct lwp *t; 441 lwpid_t target; 442 int error; 443 444 target = SCARG(uap, target); 445 p = l->l_proc; 446 447 mutex_enter(p->p_lock); 448 449 if (l->l_lid == target) 450 t = l; 451 else { 452 /* 453 * We can't use lwp_find() here because the target might 454 * be a zombie. 455 */ 456 LIST_FOREACH(t, &p->p_lwps, l_sibling) 457 if (t->l_lid == target) 458 break; 459 } 460 461 /* 462 * If the LWP is already detached, there's nothing to do. 463 * If it's a zombie, we need to clean up after it. LSZOMB 464 * is visible with the proc mutex held. 465 * 466 * After we have detached or released the LWP, kick any 467 * other LWPs that may be sitting in _lwp_wait(), waiting 468 * for the target LWP to exit. 469 */ 470 if (t != NULL && t->l_stat != LSIDL) { 471 if ((t->l_prflag & LPR_DETACHED) == 0) { 472 p->p_ndlwps++; 473 t->l_prflag |= LPR_DETACHED; 474 if (t->l_stat == LSZOMB) { 475 /* Releases proc mutex. */ 476 lwp_free(t, false, false); 477 return 0; 478 } 479 error = 0; 480 481 /* 482 * Have any LWPs sleeping in lwp_wait() recheck 483 * for deadlock. 484 */ 485 cv_broadcast(&p->p_lwpcv); 486 } else 487 error = EINVAL; 488 } else 489 error = ESRCH; 490 491 mutex_exit(p->p_lock); 492 493 return error; 494 } 495 496 static inline wchan_t 497 lwp_park_wchan(struct proc *p, const void *hint) 498 { 499 500 return (wchan_t)((uintptr_t)p ^ (uintptr_t)hint); 501 } 502 503 int 504 lwp_unpark(lwpid_t target, const void *hint) 505 { 506 sleepq_t *sq; 507 wchan_t wchan; 508 kmutex_t *mp; 509 proc_t *p; 510 lwp_t *t; 511 512 /* 513 * Easy case: search for the LWP on the sleep queue. If 514 * it's parked, remove it from the queue and set running. 515 */ 516 p = curproc; 517 wchan = lwp_park_wchan(p, hint); 518 sq = sleeptab_lookup(&lwp_park_tab, wchan, &mp); 519 520 TAILQ_FOREACH(t, sq, l_sleepchain) 521 if (t->l_proc == p && t->l_lid == target) 522 break; 523 524 if (__predict_true(t != NULL)) { 525 sleepq_remove(sq, t); 526 mutex_spin_exit(mp); 527 return 0; 528 } 529 530 /* 531 * The LWP hasn't parked yet. Take the hit and mark the 532 * operation as pending. 533 */ 534 mutex_spin_exit(mp); 535 536 mutex_enter(p->p_lock); 537 if ((t = lwp_find(p, target)) == NULL) { 538 mutex_exit(p->p_lock); 539 return ESRCH; 540 } 541 542 /* 543 * It may not have parked yet, we may have raced, or it 544 * is parked on a different user sync object. 545 */ 546 lwp_lock(t); 547 if (t->l_syncobj == &lwp_park_sobj) { 548 /* Releases the LWP lock. */ 549 lwp_unsleep(t, true); 550 } else { 551 /* 552 * Set the operation pending. The next call to _lwp_park 553 * will return early. 554 */ 555 t->l_flag |= LW_UNPARKED; 556 lwp_unlock(t); 557 } 558 559 mutex_exit(p->p_lock); 560 return 0; 561 } 562 563 int 564 lwp_park(clockid_t clock_id, int flags, struct timespec *ts, const void *hint) 565 { 566 sleepq_t *sq; 567 kmutex_t *mp; 568 wchan_t wchan; 569 int timo, error; 570 struct timespec start; 571 lwp_t *l; 572 bool timeremain = !(flags & TIMER_ABSTIME) && ts; 573 574 if (ts != NULL) { 575 if ((error = ts2timo(clock_id, flags, ts, &timo, 576 timeremain ? &start : NULL)) != 0) 577 return error; 578 KASSERT(timo != 0); 579 } else { 580 timo = 0; 581 } 582 583 /* Find and lock the sleep queue. */ 584 l = curlwp; 585 wchan = lwp_park_wchan(l->l_proc, hint); 586 sq = sleeptab_lookup(&lwp_park_tab, wchan, &mp); 587 588 /* 589 * Before going the full route and blocking, check to see if an 590 * unpark op is pending. 591 */ 592 lwp_lock(l); 593 if ((l->l_flag & (LW_CANCELLED | LW_UNPARKED)) != 0) { 594 l->l_flag &= ~(LW_CANCELLED | LW_UNPARKED); 595 lwp_unlock(l); 596 mutex_spin_exit(mp); 597 return EALREADY; 598 } 599 lwp_unlock_to(l, mp); 600 l->l_biglocks = 0; 601 sleepq_enqueue(sq, wchan, "parked", &lwp_park_sobj); 602 error = sleepq_block(timo, true); 603 switch (error) { 604 case EWOULDBLOCK: 605 error = ETIMEDOUT; 606 if (timeremain) 607 memset(ts, 0, sizeof(*ts)); 608 break; 609 case ERESTART: 610 error = EINTR; 611 /*FALLTHROUGH*/ 612 default: 613 if (timeremain) 614 clock_timeleft(clock_id, ts, &start); 615 break; 616 } 617 return error; 618 } 619 620 /* 621 * 'park' an LWP waiting on a user-level synchronisation object. The LWP 622 * will remain parked until another LWP in the same process calls in and 623 * requests that it be unparked. 624 */ 625 int 626 sys____lwp_park60(struct lwp *l, const struct sys____lwp_park60_args *uap, 627 register_t *retval) 628 { 629 /* { 630 syscallarg(clockid_t) clock_id; 631 syscallarg(int) flags; 632 syscallarg(struct timespec *) ts; 633 syscallarg(lwpid_t) unpark; 634 syscallarg(const void *) hint; 635 syscallarg(const void *) unparkhint; 636 } */ 637 struct timespec ts, *tsp; 638 int error; 639 640 if (SCARG(uap, ts) == NULL) 641 tsp = NULL; 642 else { 643 error = copyin(SCARG(uap, ts), &ts, sizeof(ts)); 644 if (error != 0) 645 return error; 646 tsp = &ts; 647 } 648 649 if (SCARG(uap, unpark) != 0) { 650 error = lwp_unpark(SCARG(uap, unpark), SCARG(uap, unparkhint)); 651 if (error != 0) 652 return error; 653 } 654 655 error = lwp_park(SCARG(uap, clock_id), SCARG(uap, flags), tsp, 656 SCARG(uap, hint)); 657 if (SCARG(uap, ts) != NULL && (SCARG(uap, flags) & TIMER_ABSTIME) == 0) 658 (void)copyout(tsp, SCARG(uap, ts), sizeof(*tsp)); 659 return error; 660 } 661 662 int 663 sys__lwp_unpark(struct lwp *l, const struct sys__lwp_unpark_args *uap, 664 register_t *retval) 665 { 666 /* { 667 syscallarg(lwpid_t) target; 668 syscallarg(const void *) hint; 669 } */ 670 671 return lwp_unpark(SCARG(uap, target), SCARG(uap, hint)); 672 } 673 674 int 675 sys__lwp_unpark_all(struct lwp *l, const struct sys__lwp_unpark_all_args *uap, 676 register_t *retval) 677 { 678 /* { 679 syscallarg(const lwpid_t *) targets; 680 syscallarg(size_t) ntargets; 681 syscallarg(const void *) hint; 682 } */ 683 struct proc *p; 684 struct lwp *t; 685 sleepq_t *sq; 686 wchan_t wchan; 687 lwpid_t targets[32], *tp, *tpp, *tmax, target; 688 int error; 689 kmutex_t *mp; 690 u_int ntargets; 691 size_t sz; 692 693 p = l->l_proc; 694 ntargets = SCARG(uap, ntargets); 695 696 if (SCARG(uap, targets) == NULL) { 697 /* 698 * Let the caller know how much we are willing to do, and 699 * let it unpark the LWPs in blocks. 700 */ 701 *retval = LWP_UNPARK_MAX; 702 return 0; 703 } 704 if (ntargets > LWP_UNPARK_MAX || ntargets == 0) 705 return EINVAL; 706 707 /* 708 * Copy in the target array. If it's a small number of LWPs, then 709 * place the numbers on the stack. 710 */ 711 sz = sizeof(target) * ntargets; 712 if (sz <= sizeof(targets)) 713 tp = targets; 714 else 715 tp = kmem_alloc(sz, KM_SLEEP); 716 error = copyin(SCARG(uap, targets), tp, sz); 717 if (error != 0) { 718 if (tp != targets) { 719 kmem_free(tp, sz); 720 } 721 return error; 722 } 723 724 wchan = lwp_park_wchan(p, SCARG(uap, hint)); 725 sq = sleeptab_lookup(&lwp_park_tab, wchan, &mp); 726 727 for (tmax = tp + ntargets, tpp = tp; tpp < tmax; tpp++) { 728 target = *tpp; 729 730 /* 731 * Easy case: search for the LWP on the sleep queue. If 732 * it's parked, remove it from the queue and set running. 733 */ 734 TAILQ_FOREACH(t, sq, l_sleepchain) 735 if (t->l_proc == p && t->l_lid == target) 736 break; 737 738 if (t != NULL) { 739 sleepq_remove(sq, t); 740 continue; 741 } 742 743 /* 744 * The LWP hasn't parked yet. Take the hit and 745 * mark the operation as pending. 746 */ 747 mutex_spin_exit(mp); 748 mutex_enter(p->p_lock); 749 if ((t = lwp_find(p, target)) == NULL) { 750 mutex_exit(p->p_lock); 751 mutex_spin_enter(mp); 752 continue; 753 } 754 lwp_lock(t); 755 756 /* 757 * It may not have parked yet, we may have raced, or 758 * it is parked on a different user sync object. 759 */ 760 if (t->l_syncobj == &lwp_park_sobj) { 761 /* Releases the LWP lock. */ 762 lwp_unsleep(t, true); 763 } else { 764 /* 765 * Set the operation pending. The next call to 766 * _lwp_park will return early. 767 */ 768 t->l_flag |= LW_UNPARKED; 769 lwp_unlock(t); 770 } 771 772 mutex_exit(p->p_lock); 773 mutex_spin_enter(mp); 774 } 775 776 mutex_spin_exit(mp); 777 if (tp != targets) 778 kmem_free(tp, sz); 779 780 return 0; 781 } 782 783 int 784 sys__lwp_setname(struct lwp *l, const struct sys__lwp_setname_args *uap, 785 register_t *retval) 786 { 787 /* { 788 syscallarg(lwpid_t) target; 789 syscallarg(const char *) name; 790 } */ 791 char *name, *oname; 792 lwpid_t target; 793 proc_t *p; 794 lwp_t *t; 795 int error; 796 797 if ((target = SCARG(uap, target)) == 0) 798 target = l->l_lid; 799 800 name = kmem_alloc(MAXCOMLEN, KM_SLEEP); 801 error = copyinstr(SCARG(uap, name), name, MAXCOMLEN, NULL); 802 switch (error) { 803 case ENAMETOOLONG: 804 case 0: 805 name[MAXCOMLEN - 1] = '\0'; 806 break; 807 default: 808 kmem_free(name, MAXCOMLEN); 809 return error; 810 } 811 812 p = curproc; 813 mutex_enter(p->p_lock); 814 if ((t = lwp_find(p, target)) == NULL) { 815 mutex_exit(p->p_lock); 816 kmem_free(name, MAXCOMLEN); 817 return ESRCH; 818 } 819 lwp_lock(t); 820 oname = t->l_name; 821 t->l_name = name; 822 lwp_unlock(t); 823 mutex_exit(p->p_lock); 824 825 if (oname != NULL) 826 kmem_free(oname, MAXCOMLEN); 827 828 return 0; 829 } 830 831 int 832 sys__lwp_getname(struct lwp *l, const struct sys__lwp_getname_args *uap, 833 register_t *retval) 834 { 835 /* { 836 syscallarg(lwpid_t) target; 837 syscallarg(char *) name; 838 syscallarg(size_t) len; 839 } */ 840 char name[MAXCOMLEN]; 841 lwpid_t target; 842 proc_t *p; 843 lwp_t *t; 844 845 if ((target = SCARG(uap, target)) == 0) 846 target = l->l_lid; 847 848 p = curproc; 849 mutex_enter(p->p_lock); 850 if ((t = lwp_find(p, target)) == NULL) { 851 mutex_exit(p->p_lock); 852 return ESRCH; 853 } 854 lwp_lock(t); 855 if (t->l_name == NULL) 856 name[0] = '\0'; 857 else 858 strlcpy(name, t->l_name, sizeof(name)); 859 lwp_unlock(t); 860 mutex_exit(p->p_lock); 861 862 return copyoutstr(name, SCARG(uap, name), SCARG(uap, len), NULL); 863 } 864 865 int 866 sys__lwp_ctl(struct lwp *l, const struct sys__lwp_ctl_args *uap, 867 register_t *retval) 868 { 869 /* { 870 syscallarg(int) features; 871 syscallarg(struct lwpctl **) address; 872 } */ 873 int error, features; 874 vaddr_t vaddr; 875 876 features = SCARG(uap, features); 877 features &= ~(LWPCTL_FEATURE_CURCPU | LWPCTL_FEATURE_PCTR); 878 if (features != 0) 879 return ENODEV; 880 if ((error = lwp_ctl_alloc(&vaddr)) != 0) 881 return error; 882 return copyout(&vaddr, SCARG(uap, address), sizeof(void *)); 883 } 884