kernel/syscall/processor_bind.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 2009 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <sys/param.h>
  28 #include <sys/var.h>
  29 #include <sys/thread.h>
  30 #include <sys/cpuvar.h>
  31 #include <sys/kstat.h>
  32 #include <sys/uadmin.h>
  33 #include <sys/systm.h>
  34 #include <sys/errno.h>
  35 #include <sys/cmn_err.h>
  36 #include <sys/procset.h>
  37 #include <sys/processor.h>
  38 #include <sys/debug.h>
  39 #include <sys/task.h>
  40 #include <sys/project.h>
  41 #include <sys/zone.h>
  42 #include <sys/contract_impl.h>
  43 #include <sys/contract/process_impl.h>
  44
  45 /*
  46  * Bind all the threads of a process to a CPU.
  47  */
  48 static int
  49 cpu_bind_process(proc_t *pp, processorid_t bind, processorid_t *obind,
  50     int *error)
  51 {
  52         kthread_t       *tp;
  53         kthread_t       *fp;
  54         int             err = 0;
  55         int             i;
  56
  57         ASSERT(MUTEX_HELD(&pidlock));
  58
  59         /* skip kernel processes */
  60         if (pp->p_flag & SSYS) {
  61                 *obind = PBIND_NONE;
  62                 *error = ENOTSUP;
  63                 return (0);
  64         }
  65
  66         mutex_enter(&pp->p_lock);
  67         tp = pp->p_tlist;
  68         if (tp != NULL) {
  69                 fp = tp;
  70                 do {
  71                         i = cpu_bind_thread(tp, bind, obind, error);
  72                         if (err == 0)
  73                                 err = i;
  74                 } while ((tp = tp->t_forw) != fp);
  75         }
  76
  77         mutex_exit(&pp->p_lock);
  78         return (err);
  79 }
  80
  81 /*
  82  * Bind all the processes of a task to a CPU.
  83  */
  84 static int
  85 cpu_bind_task(task_t *tk, processorid_t bind, processorid_t *obind,
  86     int *error)
  87 {
  88         proc_t  *p;
  89         int     err = 0;
  90         int     i;
  91
  92         ASSERT(MUTEX_HELD(&pidlock));
  93
  94         if ((p = tk->tk_memb_list) == NULL)
  95                 return (ESRCH);
  96
  97         do {
  98                 if (!(p->p_flag & SSYS)) {
  99                         i = cpu_bind_process(p, bind, obind, error);
 100                         if (err == 0)
 101                                 err = i;
 102                 }
 103         } while ((p = p->p_tasknext) != tk->tk_memb_list);
 104
 105         return (err);
 106 }
 107
 108 /*
 109  * Bind all the processes in a project to a CPU.
 110  */
 111 static int
 112 cpu_bind_project(kproject_t *kpj, processorid_t bind, processorid_t *obind,
 113     int *error)
 114 {
 115         proc_t *p;
 116         int err = 0;
 117         int i;
 118
 119         ASSERT(MUTEX_HELD(&pidlock));
 120
 121         for (p = practive; p != NULL; p = p->p_next) {
 122                 if (p->p_tlist == NULL)
 123                         continue;
 124                 if (p->p_task->tk_proj == kpj && !(p->p_flag & SSYS)) {
 125                         i = cpu_bind_process(p, bind, obind, error);
 126                         if (err == 0)
 127                                 err = i;
 128                 }
 129         }
 130         return (err);
 131 }
 132
 133 /*
 134  * Bind all the processes in a zone to a CPU.
 135  */
 136 int
 137 cpu_bind_zone(zone_t *zptr, processorid_t bind, processorid_t *obind,
 138     int *error)
 139 {
 140         proc_t *p;
 141         int err = 0;
 142         int i;
 143
 144         ASSERT(MUTEX_HELD(&pidlock));
 145
 146         for (p = practive; p != NULL; p = p->p_next) {
 147                 if (p->p_tlist == NULL)
 148                         continue;
 149                 if (p->p_zone == zptr && !(p->p_flag & SSYS)) {
 150                         i = cpu_bind_process(p, bind, obind, error);
 151                         if (err == 0)
 152                                 err = i;
 153                 }
 154         }
 155         return (err);
 156 }
 157
 158 /*
 159  * Bind all the processes in a process contract to a CPU.
 160  */
 161 int
 162 cpu_bind_contract(cont_process_t *ctp, processorid_t bind, processorid_t *obind,
 163     int *error)
 164 {
 165         proc_t *p;
 166         int err = 0;
 167         int i;
 168
 169         ASSERT(MUTEX_HELD(&pidlock));
 170
 171         for (p = practive; p != NULL; p = p->p_next) {
 172                 if (p->p_tlist == NULL)
 173                         continue;
 174                 if (p->p_ct_process == ctp) {
 175                         i = cpu_bind_process(p, bind, obind, error);
 176                         if (err == 0)
 177                                 err = i;
 178                 }
 179         }
 180         return (err);
 181 }
 182
 183 /*
 184  * processor_bind(2) - Processor binding interfaces.
 185  */
 186 int
 187 processor_bind(idtype_t idtype, id_t id, processorid_t bind,
 188     processorid_t *obindp)
 189 {
 190         processorid_t   obind = PBIND_NONE;
 191         int             ret = 0;
 192         int             err = 0;
 193         cpu_t           *cp;
 194         kthread_id_t    tp;
 195         proc_t          *pp;
 196         task_t          *tk;
 197         kproject_t      *kpj;
 198         zone_t          *zptr;
 199         contract_t      *ct;
 200
 201         /*
 202          * Since we might be making a binding to a processor, hold the
 203          * cpu_lock so that the processor cannot be taken offline while
 204          * we do this.
 205          */
 206         mutex_enter(&cpu_lock);
 207
 208         /*
 209          * Check to be sure binding processor ID is valid.
 210          */
 211         switch (bind) {
 212         default:
 213                 if ((cp = cpu_get(bind)) == NULL ||
 214                     (cp->cpu_flags & (CPU_QUIESCED | CPU_OFFLINE)))
 215                         ret = EINVAL;
 216                 else if ((cp->cpu_flags & CPU_READY) == 0)
 217                         ret = EIO;
 218                 break;
 219
 220         case PBIND_NONE:
 221         case PBIND_QUERY:
 222         case PBIND_HARD:
 223         case PBIND_SOFT:
 224         case PBIND_QUERY_TYPE:
 225                 break;
 226         }
 227
 228         if (ret) {
 229                 mutex_exit(&cpu_lock);
 230                 return (set_errno(ret));
 231         }
 232
 233         switch (idtype) {
 234         case P_LWPID:
 235                 pp = curproc;
 236                 mutex_enter(&pp->p_lock);
 237                 if (id == P_MYID) {
 238                         ret = cpu_bind_thread(curthread, bind, &obind, &err);
 239                 } else {
 240                         int     found = 0;
 241
 242                         tp = pp->p_tlist;
 243                         do {
 244                                 if (tp->t_tid == id) {
 245                                         ret = cpu_bind_thread(tp,
 246                                             bind, &obind, &err);
 247                                         found = 1;
 248                                         break;
 249                                 }
 250                         } while ((tp = tp->t_forw) != pp->p_tlist);
 251                         if (!found)
 252                                 ret = ESRCH;
 253                 }
 254                 mutex_exit(&pp->p_lock);
 255                 break;
 256
 257         case P_PID:
 258                 /*
 259                  * Note.  Cannot use dotoprocs here because it doesn't find
 260                  * system class processes, which are legal to query.
 261                  */
 262                 mutex_enter(&pidlock);
 263                 if (id == P_MYID) {
 264                         ret = cpu_bind_process(curproc, bind, &obind, &err);
 265                 } else if ((pp = prfind(id)) != NULL) {
 266                         ret = cpu_bind_process(pp, bind, &obind, &err);
 267                 } else {
 268                         ret = ESRCH;
 269                 }
 270                 mutex_exit(&pidlock);
 271                 break;
 272
 273         case P_TASKID:
 274                 mutex_enter(&pidlock);
 275                 if (id == P_MYID) {
 276                         proc_t *p = curproc;
 277                         id = p->p_task->tk_tkid;
 278                 }
 279
 280                 if ((tk = task_hold_by_id(id)) != NULL) {
 281                         ret = cpu_bind_task(tk, bind, &obind, &err);
 282                         mutex_exit(&pidlock);
 283                         task_rele(tk);
 284                 } else {
 285                         mutex_exit(&pidlock);
 286                         ret = ESRCH;
 287                 }
 288                 break;
 289
 290         case P_PROJID:
 291                 pp = curproc;
 292                 if (id == P_MYID)
 293                         id = curprojid();
 294                 if ((kpj = project_hold_by_id(id, pp->p_zone,
 295                     PROJECT_HOLD_FIND)) == NULL) {
 296                         ret = ESRCH;
 297                 } else {
 298                         mutex_enter(&pidlock);
 299                         ret = cpu_bind_project(kpj, bind, &obind, &err);
 300                         mutex_exit(&pidlock);
 301                         project_rele(kpj);
 302                 }
 303                 break;
 304
 305         case P_ZONEID:
 306                 if (id == P_MYID)
 307                         id = getzoneid();
 308
 309                 if ((zptr = zone_find_by_id(id)) == NULL) {
 310                         ret = ESRCH;
 311                 } else {
 312                         mutex_enter(&pidlock);
 313                         ret = cpu_bind_zone(zptr, bind, &obind, &err);
 314                         mutex_exit(&pidlock);
 315                         zone_rele(zptr);
 316                 }
 317                 break;
 318
 319         case P_CTID:
 320                 if (id == P_MYID)
 321                         id = PRCTID(curproc);
 322
 323                 if ((ct = contract_type_ptr(process_type, id,
 324                     curproc->p_zone->zone_uniqid)) == NULL) {
 325                         ret = ESRCH;
 326                 } else {
 327                         mutex_enter(&pidlock);
 328                         ret = cpu_bind_contract(ct->ct_data,
 329                             bind, &obind, &err);
 330                         mutex_exit(&pidlock);
 331                         contract_rele(ct);
 332                 }
 333                 break;
 334
 335         case P_CPUID:
 336                 if (id == P_MYID || bind != PBIND_NONE || cpu_get(id) == NULL)
 337                         ret = EINVAL;
 338                 else
 339                         ret = cpu_unbind(id, B_TRUE);
 340                 break;
 341
 342         case P_ALL:
 343                 if (id == P_MYID || bind != PBIND_NONE) {
 344                         ret = EINVAL;
 345                 } else {
 346                         int i;
 347                         cpu_t *cp = cpu_list;
 348                         do {
 349                                 if ((cp->cpu_flags & CPU_EXISTS) == 0)
 350                                         continue;
 351                                 i = cpu_unbind(cp->cpu_id, B_TRUE);
 352                                 if (ret == 0)
 353                                         ret = i;
 354                         } while ((cp = cp->cpu_next) != cpu_list);
 355                 }
 356                 break;
 357
 358         default:
 359                 /*
 360                  * Spec says this is invalid, even though we could
 361                  * handle other idtypes.
 362                  */
 363                 ret = EINVAL;
 364                 break;
 365         }
 366         mutex_exit(&cpu_lock);
 367
 368         /*
 369          * If no search error occurred, see if any permissions errors did.
 370          */
 371         if (ret == 0)
 372                 ret = err;
 373
 374         if (ret == 0 && obindp != NULL)
 375                 if (copyout((caddr_t)&obind, (caddr_t)obindp,
 376                     sizeof (obind)) == -1)
 377                         ret = EFAULT;
 378         return (ret ? set_errno(ret) : 0);      /* return success or failure */
 379 }