sys/kern/sys_lwp.c

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