kernel/syscall/pset.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24
  25 #include <sys/types.h>
  26 #include <sys/systm.h>
  27 #include <sys/cmn_err.h>
  28 #include <sys/cpuvar.h>
  29 #include <sys/thread.h>
  30 #include <sys/disp.h>
  31 #include <sys/kmem.h>
  32 #include <sys/debug.h>
  33 #include <sys/sysmacros.h>
  34 #include <sys/cpupart.h>
  35 #include <sys/pset.h>
  36 #include <sys/modctl.h>
  37 #include <sys/syscall.h>
  38 #include <sys/task.h>
  39 #include <sys/loadavg.h>
  40 #include <sys/fss.h>
  41 #include <sys/pool.h>
  42 #include <sys/pool_pset.h>
  43 #include <sys/policy.h>
  44 #include <sys/zone.h>
  45 #include <sys/contract/process_impl.h>
  46
  47 static int      pset(int, long, long, long, long);
  48
  49 static struct sysent pset_sysent = {
  50         5,
  51         SE_ARGC | SE_NOUNLOAD,
  52         (int (*)())pset,
  53 };
  54
  55 static struct modlsys modlsys = {
  56         &mod_syscallops, "processor sets", &pset_sysent
  57 };
  58
  59 #ifdef _SYSCALL32_IMPL
  60 static struct modlsys modlsys32 = {
  61         &mod_syscallops32, "32-bit pset(2) syscall", &pset_sysent
  62 };
  63 #endif
  64
  65 static struct modlinkage modlinkage = {
  66         MODREV_1,
  67         &modlsys,
  68 #ifdef _SYSCALL32_IMPL
  69         &modlsys32,
  70 #endif
  71         NULL
  72 };
  73
  74 #define PSET_BADATTR(attr)      ((~PSET_NOESCAPE) & (attr))
  75
  76 int
  77 _init(void)
  78 {
  79         return (mod_install(&modlinkage));
  80 }
  81
  82 int
  83 _info(struct modinfo *modinfop)
  84 {
  85         return (mod_info(&modlinkage, modinfop));
  86 }
  87
  88 static int
  89 pset_create(psetid_t *psetp)
  90 {
  91         psetid_t newpset;
  92         int error;
  93
  94         if (secpolicy_pset(CRED()) != 0)
  95                 return (set_errno(EPERM));
  96
  97         pool_lock();
  98         if (pool_state == POOL_ENABLED) {
  99                 pool_unlock();
 100                 return (set_errno(ENOTSUP));
 101         }
 102         error = cpupart_create(&newpset);
 103         if (error) {
 104                 pool_unlock();
 105                 return (set_errno(error));
 106         }
 107         if (copyout(&newpset, psetp, sizeof (psetid_t)) != 0) {
 108                 (void) cpupart_destroy(newpset);
 109                 pool_unlock();
 110                 return (set_errno(EFAULT));
 111         }
 112         pool_unlock();
 113         return (error);
 114 }
 115
 116 static int
 117 pset_destroy(psetid_t pset)
 118 {
 119         int error;
 120
 121         if (secpolicy_pset(CRED()) != 0)
 122                 return (set_errno(EPERM));
 123
 124         pool_lock();
 125         if (pool_state == POOL_ENABLED) {
 126                 pool_unlock();
 127                 return (set_errno(ENOTSUP));
 128         }
 129         error = cpupart_destroy(pset);
 130         pool_unlock();
 131         if (error)
 132                 return (set_errno(error));
 133         else
 134                 return (0);
 135 }
 136
 137 static int
 138 pset_assign(psetid_t pset, processorid_t cpuid, psetid_t *opset, int forced)
 139 {
 140         psetid_t oldpset;
 141         int     error = 0;
 142         cpu_t   *cp;
 143
 144         if (pset != PS_QUERY && secpolicy_pset(CRED()) != 0)
 145                 return (set_errno(EPERM));
 146
 147         pool_lock();
 148         if (pset != PS_QUERY && pool_state == POOL_ENABLED) {
 149                 pool_unlock();
 150                 return (set_errno(ENOTSUP));
 151         }
 152
 153         mutex_enter(&cpu_lock);
 154         if ((cp = cpu_get(cpuid)) == NULL) {
 155                 mutex_exit(&cpu_lock);
 156                 pool_unlock();
 157                 return (set_errno(EINVAL));
 158         }
 159
 160         oldpset = cpupart_query_cpu(cp);
 161
 162         if (pset != PS_QUERY)
 163                 error = cpupart_attach_cpu(pset, cp, forced);
 164         mutex_exit(&cpu_lock);
 165         pool_unlock();
 166
 167         if (error)
 168                 return (set_errno(error));
 169
 170         if (opset != NULL)
 171                 if (copyout(&oldpset, opset, sizeof (psetid_t)) != 0)
 172                         return (set_errno(EFAULT));
 173
 174         return (0);
 175 }
 176
 177 static int
 178 pset_info(psetid_t pset, int *typep, uint_t *numcpusp,
 179     processorid_t *cpulistp)
 180 {
 181         int pset_type;
 182         uint_t user_ncpus = 0, real_ncpus, copy_ncpus;
 183         processorid_t *pset_cpus = NULL;
 184         int error = 0;
 185
 186         if (numcpusp != NULL) {
 187                 if (copyin(numcpusp, &user_ncpus, sizeof (uint_t)) != 0)
 188                         return (set_errno(EFAULT));
 189         }
 190
 191         if (user_ncpus > max_ncpus)     /* sanity check */
 192                 user_ncpus = max_ncpus;
 193         if (user_ncpus != 0 && cpulistp != NULL)
 194                 pset_cpus = kmem_alloc(sizeof (processorid_t) * user_ncpus,
 195                     KM_SLEEP);
 196
 197         real_ncpus = user_ncpus;
 198         if ((error = cpupart_get_cpus(&pset, pset_cpus, &real_ncpus)) != 0)
 199                 goto out;
 200
 201         /*
 202          * Now copyout the information about this processor set.
 203          */
 204
 205         /*
 206          * Get number of cpus to copy back.  If the user didn't pass in
 207          * a big enough buffer, only copy back as many cpus as fits in
 208          * the buffer but copy back the real number of cpus.
 209          */
 210
 211         if (user_ncpus != 0 && cpulistp != NULL) {
 212                 copy_ncpus = MIN(real_ncpus, user_ncpus);
 213                 if (copyout(pset_cpus, cpulistp,
 214                     sizeof (processorid_t) * copy_ncpus) != 0) {
 215                         error = EFAULT;
 216                         goto out;
 217                 }
 218         }
 219         if (pset_cpus != NULL)
 220                 kmem_free(pset_cpus, sizeof (processorid_t) * user_ncpus);
 221         if (typep != NULL) {
 222                 if (pset == PS_NONE)
 223                         pset_type = PS_NONE;
 224                 else
 225                         pset_type = PS_PRIVATE;
 226                 if (copyout(&pset_type, typep, sizeof (int)) != 0)
 227                         return (set_errno(EFAULT));
 228         }
 229         if (numcpusp != NULL)
 230                 if (copyout(&real_ncpus, numcpusp, sizeof (uint_t)) != 0)
 231                         return (set_errno(EFAULT));
 232         return (0);
 233
 234 out:
 235         if (pset_cpus != NULL)
 236                 kmem_free(pset_cpus, sizeof (processorid_t) * user_ncpus);
 237         return (set_errno(error));
 238 }
 239
 240 static int
 241 pset_bind_thread(kthread_t *tp, psetid_t pset, psetid_t *oldpset, void *projbuf,
 242     void *zonebuf)
 243 {
 244         int error = 0;
 245
 246         ASSERT(pool_lock_held());
 247         ASSERT(MUTEX_HELD(&cpu_lock));
 248         ASSERT(MUTEX_HELD(&ttoproc(tp)->p_lock));
 249
 250         *oldpset = tp->t_bind_pset;
 251
 252         switch (pset) {
 253         case PS_SOFT:
 254                 TB_PSET_SOFT_SET(tp);
 255                 break;
 256
 257         case PS_HARD:
 258                 TB_PSET_HARD_SET(tp);
 259                 break;
 260
 261         case PS_QUERY:
 262                 break;
 263
 264         case PS_QUERY_TYPE:
 265                 *oldpset = TB_PSET_IS_SOFT(tp) ? PS_SOFT : PS_HARD;
 266                 break;
 267
 268         default:
 269                 /*
 270                  * Must have the same UID as the target process or
 271                  * have PRIV_PROC_OWNER privilege.
 272                  */
 273                 if (!hasprocperm(tp->t_cred, CRED()))
 274                         return (EPERM);
 275                 /*
 276                  * Unbinding of an unbound thread should always succeed.
 277                  */
 278                 if (*oldpset == PS_NONE && pset == PS_NONE)
 279                         return (0);
 280                 /*
 281                  * Only privileged processes can move threads from psets with
 282                  * PSET_NOESCAPE attribute.
 283                  */
 284                 if ((tp->t_cpupart->cp_attr & PSET_NOESCAPE) &&
 285                     secpolicy_pbind(CRED()) != 0)
 286                         return (EPERM);
 287                 if ((error = cpupart_bind_thread(tp, pset, 0,
 288                     projbuf, zonebuf)) == 0)
 289                         tp->t_bind_pset = pset;
 290
 291                 break;
 292         }
 293
 294         return (error);
 295 }
 296
 297 static int
 298 pset_bind_process(proc_t *pp, psetid_t pset, psetid_t *oldpset, void *projbuf,
 299     void *zonebuf)
 300 {
 301         int error = 0;
 302         kthread_t *tp;
 303
 304         /* skip kernel processes */
 305         if ((pset != PS_QUERY) && pp->p_flag & SSYS) {
 306                 *oldpset = PS_NONE;
 307                 return (ENOTSUP);
 308         }
 309
 310         mutex_enter(&pp->p_lock);
 311         tp = pp->p_tlist;
 312         if (tp != NULL) {
 313                 do {
 314                         int rval;
 315
 316                         rval = pset_bind_thread(tp, pset, oldpset, projbuf,
 317                             zonebuf);
 318                         if (error == 0)
 319                                 error = rval;
 320                 } while ((tp = tp->t_forw) != pp->p_tlist);
 321         } else
 322                 error = ESRCH;
 323         mutex_exit(&pp->p_lock);
 324
 325         return (error);
 326 }
 327
 328 static int
 329 pset_bind_task(task_t *tk, psetid_t pset, psetid_t *oldpset, void *projbuf,
 330     void *zonebuf)
 331 {
 332         int error = 0;
 333         proc_t *pp;
 334
 335         ASSERT(MUTEX_HELD(&pidlock));
 336
 337         if ((pp = tk->tk_memb_list) == NULL) {
 338                 return (ESRCH);
 339         }
 340
 341         do {
 342                 int rval;
 343
 344                 if (!(pp->p_flag & SSYS)) {
 345                         rval = pset_bind_process(pp, pset, oldpset, projbuf,
 346                             zonebuf);
 347                         if (error == 0)
 348                                 error = rval;
 349                 }
 350         } while ((pp = pp->p_tasknext) != tk->tk_memb_list);
 351
 352         return (error);
 353 }
 354
 355 static int
 356 pset_bind_project(kproject_t *kpj, psetid_t pset, psetid_t *oldpset,
 357     void *projbuf, void *zonebuf)
 358 {
 359         int error = 0;
 360         proc_t *pp;
 361
 362         ASSERT(MUTEX_HELD(&pidlock));
 363
 364         for (pp = practive; pp != NULL; pp = pp->p_next) {
 365                 if (pp->p_tlist == NULL)
 366                         continue;
 367                 if (pp->p_task->tk_proj == kpj && !(pp->p_flag & SSYS)) {
 368                         int rval;
 369
 370                         rval = pset_bind_process(pp, pset, oldpset, projbuf,
 371                             zonebuf);
 372                         if (error == 0)
 373                                 error = rval;
 374                 }
 375         }
 376
 377         return (error);
 378 }
 379
 380 static int
 381 pset_bind_zone(zone_t *zptr, psetid_t pset, psetid_t *oldpset, void *projbuf,
 382     void *zonebuf)
 383 {
 384         int error = 0;
 385         proc_t *pp;
 386
 387         ASSERT(MUTEX_HELD(&pidlock));
 388
 389         for (pp = practive; pp != NULL; pp = pp->p_next) {
 390                 if (pp->p_zone == zptr && !(pp->p_flag & SSYS)) {
 391                         int rval;
 392
 393                         rval = pset_bind_process(pp, pset, oldpset, projbuf,
 394                             zonebuf);
 395                         if (error == 0)
 396                                 error = rval;
 397                 }
 398         }
 399
 400         return (error);
 401 }
 402
 403 /*
 404  * Unbind all threads from the specified processor set, or from all
 405  * processor sets.
 406  */
 407 static int
 408 pset_unbind(psetid_t pset, void *projbuf, void *zonebuf, idtype_t idtype)
 409 {
 410         psetid_t olbind;
 411         kthread_t *tp;
 412         int error = 0;
 413         int rval;
 414         proc_t *pp;
 415
 416         ASSERT(MUTEX_HELD(&cpu_lock));
 417
 418         if (idtype == P_PSETID && cpupart_find(pset) == NULL)
 419                 return (EINVAL);
 420
 421         mutex_enter(&pidlock);
 422         for (pp = practive; pp != NULL; pp = pp->p_next) {
 423                 mutex_enter(&pp->p_lock);
 424                 tp = pp->p_tlist;
 425                 /*
 426                  * Skip zombies and kernel processes, and processes in
 427                  * other zones, if called from a non-global zone.
 428                  */
 429                 if (tp == NULL || (pp->p_flag & SSYS) ||
 430                     !HASZONEACCESS(curproc, pp->p_zone->zone_id)) {
 431                         mutex_exit(&pp->p_lock);
 432                         continue;
 433                 }
 434                 do {
 435                         if ((idtype == P_PSETID && tp->t_bind_pset != pset) ||
 436                             (idtype == P_ALL && tp->t_bind_pset == PS_NONE))
 437                                 continue;
 438                         rval = pset_bind_thread(tp, PS_NONE, &olbind,
 439                             projbuf, zonebuf);
 440                         if (error == 0)
 441                                 error = rval;
 442                 } while ((tp = tp->t_forw) != pp->p_tlist);
 443                 mutex_exit(&pp->p_lock);
 444         }
 445         mutex_exit(&pidlock);
 446         return (error);
 447 }
 448
 449 static int
 450 pset_bind_contract(cont_process_t *ctp, psetid_t pset, psetid_t *oldpset,
 451     void *projbuf, void *zonebuf)
 452 {
 453         int error = 0;
 454         proc_t *pp;
 455
 456         ASSERT(MUTEX_HELD(&pidlock));
 457
 458         for (pp = practive; pp != NULL; pp = pp->p_next) {
 459                 if (pp->p_ct_process == ctp) {
 460                         int rval;
 461
 462                         rval = pset_bind_process(pp, pset, oldpset, projbuf,
 463                             zonebuf);
 464                         if (error == 0)
 465                                 error = rval;
 466                 }
 467         }
 468
 469         return (error);
 470 }
 471
 472 /*
 473  * Bind the lwp:id of process:pid to processor set: pset
 474  */
 475 static int
 476 pset_bind_lwp(psetid_t pset, id_t id, pid_t pid, psetid_t *opset)
 477 {
 478         kthread_t       *tp;
 479         proc_t          *pp;
 480         psetid_t        oldpset;
 481         void            *projbuf, *zonebuf;
 482         int             error = 0;
 483
 484         pool_lock();
 485         mutex_enter(&cpu_lock);
 486         projbuf = fss_allocbuf(FSS_NPROJ_BUF, FSS_ALLOC_PROJ);
 487         zonebuf = fss_allocbuf(FSS_NPROJ_BUF, FSS_ALLOC_ZONE);
 488
 489         mutex_enter(&pidlock);
 490         if ((pid == P_MYID && id == P_MYID) ||
 491             (pid == curproc->p_pid && id == P_MYID)) {
 492                 pp = curproc;
 493                 tp = curthread;
 494                 mutex_enter(&pp->p_lock);
 495         } else {
 496                 if (pid == P_MYID) {
 497                         pp = curproc;
 498                 } else if ((pp = prfind(pid)) == NULL) {
 499                         error = ESRCH;
 500                         goto err;
 501                 }
 502                 if (pp != curproc && id == P_MYID) {
 503                         error = EINVAL;
 504                         goto err;
 505                 }
 506                 mutex_enter(&pp->p_lock);
 507                 if ((tp = idtot(pp, id)) == NULL) {
 508                         mutex_exit(&pp->p_lock);
 509                         error = ESRCH;
 510                         goto err;
 511                 }
 512         }
 513
 514         error = pset_bind_thread(tp, pset, &oldpset, projbuf, zonebuf);
 515         mutex_exit(&pp->p_lock);
 516 err:
 517         mutex_exit(&pidlock);
 518
 519         fss_freebuf(projbuf, FSS_ALLOC_PROJ);
 520         fss_freebuf(zonebuf, FSS_ALLOC_ZONE);
 521         mutex_exit(&cpu_lock);
 522         pool_unlock();
 523         if (opset != NULL) {
 524                 if (copyout(&oldpset, opset, sizeof (psetid_t)) != 0)
 525                         return (set_errno(EFAULT));
 526         }
 527         if (error != 0)
 528                 return (set_errno(error));
 529         return (0);
 530 }
 531
 532 static int
 533 pset_bind(psetid_t pset, idtype_t idtype, id_t id, psetid_t *opset)
 534 {
 535         kthread_t       *tp;
 536         proc_t          *pp;
 537         task_t          *tk;
 538         kproject_t      *kpj;
 539         contract_t      *ct;
 540         zone_t          *zptr;
 541         psetid_t        oldpset;
 542         int             error = 0;
 543         void            *projbuf, *zonebuf;
 544
 545         pool_lock();
 546         if ((pset != PS_QUERY) && (pset != PS_SOFT) &&
 547             (pset != PS_HARD) && (pset != PS_QUERY_TYPE)) {
 548                 /*
 549                  * Check if the set actually exists before checking
 550                  * permissions.  This is the historical error
 551                  * precedence.  Note that if pset was PS_MYID, the
 552                  * cpupart_get_cpus call will change it to the
 553                  * processor set id of the caller (or PS_NONE if the
 554                  * caller is not bound to a processor set).
 555                  */
 556                 if (pool_state == POOL_ENABLED) {
 557                         pool_unlock();
 558                         return (set_errno(ENOTSUP));
 559                 }
 560                 if (cpupart_get_cpus(&pset, NULL, NULL) != 0) {
 561                         pool_unlock();
 562                         return (set_errno(EINVAL));
 563                 } else if (pset != PS_NONE && secpolicy_pbind(CRED()) != 0) {
 564                         pool_unlock();
 565                         return (set_errno(EPERM));
 566                 }
 567         }
 568
 569         /*
 570          * Pre-allocate enough buffers for FSS for all active projects
 571          * and for all active zones on the system.  Unused buffers will
 572          * be freed later by fss_freebuf().
 573          */
 574         mutex_enter(&cpu_lock);
 575         projbuf = fss_allocbuf(FSS_NPROJ_BUF, FSS_ALLOC_PROJ);
 576         zonebuf = fss_allocbuf(FSS_NPROJ_BUF, FSS_ALLOC_ZONE);
 577
 578         switch (idtype) {
 579         case P_LWPID:
 580                 pp = curproc;
 581                 mutex_enter(&pidlock);
 582                 mutex_enter(&pp->p_lock);
 583                 if (id == P_MYID) {
 584                         tp = curthread;
 585                 } else {
 586                         if ((tp = idtot(pp, id)) == NULL) {
 587                                 mutex_exit(&pp->p_lock);
 588                                 mutex_exit(&pidlock);
 589                                 error = ESRCH;
 590                                 break;
 591                         }
 592                 }
 593                 error = pset_bind_thread(tp, pset, &oldpset, projbuf, zonebuf);
 594                 mutex_exit(&pp->p_lock);
 595                 mutex_exit(&pidlock);
 596                 break;
 597
 598         case P_PID:
 599                 mutex_enter(&pidlock);
 600                 if (id == P_MYID) {
 601                         pp = curproc;
 602                 } else if ((pp = prfind(id)) == NULL) {
 603                         mutex_exit(&pidlock);
 604                         error = ESRCH;
 605                         break;
 606                 }
 607                 error = pset_bind_process(pp, pset, &oldpset, projbuf, zonebuf);
 608                 mutex_exit(&pidlock);
 609                 break;
 610
 611         case P_TASKID:
 612                 mutex_enter(&pidlock);
 613                 if (id == P_MYID)
 614                         id = curproc->p_task->tk_tkid;
 615                 if ((tk = task_hold_by_id(id)) == NULL) {
 616                         mutex_exit(&pidlock);
 617                         error = ESRCH;
 618                         break;
 619                 }
 620                 error = pset_bind_task(tk, pset, &oldpset, projbuf, zonebuf);
 621                 mutex_exit(&pidlock);
 622                 task_rele(tk);
 623                 break;
 624
 625         case P_PROJID:
 626                 pp = curproc;
 627                 if (id == P_MYID)
 628                         id = curprojid();
 629                 if ((kpj = project_hold_by_id(id, pp->p_zone,
 630                     PROJECT_HOLD_FIND)) == NULL) {
 631                         error = ESRCH;
 632                         break;
 633                 }
 634                 mutex_enter(&pidlock);
 635                 error = pset_bind_project(kpj, pset, &oldpset, projbuf,
 636                     zonebuf);
 637                 mutex_exit(&pidlock);
 638                 project_rele(kpj);
 639                 break;
 640
 641         case P_ZONEID:
 642                 if (id == P_MYID)
 643                         id = getzoneid();
 644                 if ((zptr = zone_find_by_id(id)) == NULL) {
 645                         error = ESRCH;
 646                         break;
 647                 }
 648                 mutex_enter(&pidlock);
 649                 error = pset_bind_zone(zptr, pset, &oldpset, projbuf, zonebuf);
 650                 mutex_exit(&pidlock);
 651                 zone_rele(zptr);
 652                 break;
 653
 654         case P_CTID:
 655                 if (id == P_MYID)
 656                         id = PRCTID(curproc);
 657                 if ((ct = contract_type_ptr(process_type, id,
 658                     curproc->p_zone->zone_uniqid)) == NULL) {
 659                         error = ESRCH;
 660                         break;
 661                 }
 662                 mutex_enter(&pidlock);
 663                 error = pset_bind_contract(ct->ct_data, pset, &oldpset, projbuf,
 664                     zonebuf);
 665                 mutex_exit(&pidlock);
 666                 contract_rele(ct);
 667                 break;
 668
 669         case P_PSETID:
 670                 if (id == P_MYID || pset != PS_NONE || !INGLOBALZONE(curproc)) {
 671                         error = EINVAL;
 672                         break;
 673                 }
 674                 error = pset_unbind(id, projbuf, zonebuf, idtype);
 675                 break;
 676
 677         case P_ALL:
 678                 if (id == P_MYID || pset != PS_NONE || !INGLOBALZONE(curproc)) {
 679                         error = EINVAL;
 680                         break;
 681                 }
 682                 error = pset_unbind(PS_NONE, projbuf, zonebuf, idtype);
 683                 break;
 684
 685         default:
 686                 error = EINVAL;
 687                 break;
 688         }
 689
 690         fss_freebuf(projbuf, FSS_ALLOC_PROJ);
 691         fss_freebuf(zonebuf, FSS_ALLOC_ZONE);
 692         mutex_exit(&cpu_lock);
 693         pool_unlock();
 694
 695         if (error != 0)
 696                 return (set_errno(error));
 697         if (opset != NULL) {
 698                 if (copyout(&oldpset, opset, sizeof (psetid_t)) != 0)
 699                         return (set_errno(EFAULT));
 700         }
 701         return (0);
 702 }
 703
 704 /*
 705  * Report load average statistics for the specified processor set.
 706  */
 707 static int
 708 pset_getloadavg(psetid_t pset, int *buf, int nelem)
 709 {
 710         int loadbuf[LOADAVG_NSTATS];
 711         int error = 0;
 712
 713         if (nelem < 0)
 714                 return (set_errno(EINVAL));
 715
 716         /*
 717          * We keep the same number of load average statistics for processor
 718          * sets as we do for the system as a whole.
 719          */
 720         if (nelem > LOADAVG_NSTATS)
 721                 nelem = LOADAVG_NSTATS;
 722
 723         mutex_enter(&cpu_lock);
 724         error = cpupart_get_loadavg(pset, loadbuf, nelem);
 725         mutex_exit(&cpu_lock);
 726         if (!error && nelem && copyout(loadbuf, buf, nelem * sizeof (int)) != 0)
 727                 error = EFAULT;
 728
 729         if (error)
 730                 return (set_errno(error));
 731         else
 732                 return (0);
 733 }
 734
 735
 736 /*
 737  * Return list of active processor sets, up to a maximum indicated by
 738  * numpsets.  The total number of processor sets is stored in the
 739  * location pointed to by numpsets.
 740  */
 741 static int
 742 pset_list(psetid_t *psetlist, uint_t *numpsets)
 743 {
 744         uint_t user_npsets = 0;
 745         uint_t real_npsets;
 746         psetid_t *psets = NULL;
 747         int error = 0;
 748
 749         if (numpsets != NULL) {
 750                 if (copyin(numpsets, &user_npsets, sizeof (uint_t)) != 0)
 751                         return (set_errno(EFAULT));
 752         }
 753
 754         /*
 755          * Get the list of all processor sets.  First we need to find
 756          * out how many there are, so we can allocate a large enough
 757          * buffer.
 758          */
 759         mutex_enter(&cpu_lock);
 760         if (!INGLOBALZONE(curproc) && pool_pset_enabled()) {
 761                 psetid_t psetid = zone_pset_get(curproc->p_zone);
 762
 763                 if (psetid == PS_NONE) {
 764                         real_npsets = 0;
 765                 } else {
 766                         real_npsets = 1;
 767                         psets = kmem_alloc(real_npsets * sizeof (psetid_t),
 768                             KM_SLEEP);
 769                         psets[0] = psetid;
 770                 }
 771         } else {
 772                 real_npsets = cpupart_list(0, 0, CP_ALL);
 773                 if (real_npsets) {
 774                         psets = kmem_alloc(real_npsets * sizeof (psetid_t),
 775                             KM_SLEEP);
 776                         (void) cpupart_list(psets, real_npsets, CP_ALL);
 777                 }
 778         }
 779         mutex_exit(&cpu_lock);
 780
 781         if (user_npsets > real_npsets)
 782                 user_npsets = real_npsets;
 783
 784         if (numpsets != NULL) {
 785                 if (copyout(&real_npsets, numpsets, sizeof (uint_t)) != 0)
 786                         error = EFAULT;
 787                 else if (psetlist != NULL && user_npsets != 0) {
 788                         if (copyout(psets, psetlist,
 789                             user_npsets * sizeof (psetid_t)) != 0)
 790                                 error = EFAULT;
 791                 }
 792         }
 793
 794         if (real_npsets)
 795                 kmem_free(psets, real_npsets * sizeof (psetid_t));
 796
 797         if (error)
 798                 return (set_errno(error));
 799         else
 800                 return (0);
 801 }
 802
 803 static int
 804 pset_setattr(psetid_t pset, uint_t attr)
 805 {
 806         int error;
 807
 808         if (secpolicy_pset(CRED()) != 0)
 809                 return (set_errno(EPERM));
 810         pool_lock();
 811         if (pool_state == POOL_ENABLED) {
 812                 pool_unlock();
 813                 return (set_errno(ENOTSUP));
 814         }
 815         if (pset == PS_QUERY || PSET_BADATTR(attr)) {
 816                 pool_unlock();
 817                 return (set_errno(EINVAL));
 818         }
 819         if ((error = cpupart_setattr(pset, attr)) != 0) {
 820                 pool_unlock();
 821                 return (set_errno(error));
 822         }
 823         pool_unlock();
 824         return (0);
 825 }
 826
 827 static int
 828 pset_getattr(psetid_t pset, uint_t *attrp)
 829 {
 830         int error = 0;
 831         uint_t attr;
 832
 833         if (pset == PS_QUERY)
 834                 return (set_errno(EINVAL));
 835         if ((error = cpupart_getattr(pset, &attr)) != 0)
 836                 return (set_errno(error));
 837         if (copyout(&attr, attrp, sizeof (uint_t)) != 0)
 838                 return (set_errno(EFAULT));
 839         return (0);
 840 }
 841
 842 static int
 843 pset(int subcode, long arg1, long arg2, long arg3, long arg4)
 844 {
 845         switch (subcode) {
 846         case PSET_CREATE:
 847                 return (pset_create((psetid_t *)arg1));
 848         case PSET_DESTROY:
 849                 return (pset_destroy((psetid_t)arg1));
 850         case PSET_ASSIGN:
 851                 return (pset_assign((psetid_t)arg1,
 852                     (processorid_t)arg2, (psetid_t *)arg3, 0));
 853         case PSET_INFO:
 854                 return (pset_info((psetid_t)arg1, (int *)arg2,
 855                     (uint_t *)arg3, (processorid_t *)arg4));
 856         case PSET_BIND:
 857                 return (pset_bind((psetid_t)arg1, (idtype_t)arg2,
 858                     (id_t)arg3, (psetid_t *)arg4));
 859         case PSET_BIND_LWP:
 860                 return (pset_bind_lwp((psetid_t)arg1, (id_t)arg2,
 861                     (pid_t)arg3, (psetid_t *)arg4));
 862         case PSET_GETLOADAVG:
 863                 return (pset_getloadavg((psetid_t)arg1, (int *)arg2,
 864                     (int)arg3));
 865         case PSET_LIST:
 866                 return (pset_list((psetid_t *)arg1, (uint_t *)arg2));
 867         case PSET_SETATTR:
 868                 return (pset_setattr((psetid_t)arg1, (uint_t)arg2));
 869         case PSET_GETATTR:
 870                 return (pset_getattr((psetid_t)arg1, (uint_t *)arg2));
 871         case PSET_ASSIGN_FORCED:
 872                 return (pset_assign((psetid_t)arg1,
 873                     (processorid_t)arg2, (psetid_t *)arg3, 1));
 874         default:
 875                 return (set_errno(EINVAL));
 876         }
 877 }