osfmk/kern/mk_sp.c

   1 /*
   2  * Copyright (c) 2000-2007 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  *
  31  */
  32
  33 /* The routines in this module are all obsolete */
  34
  35 #include <mach/boolean.h>
  36 #include <mach/thread_switch.h>
  37 #include <ipc/ipc_port.h>
  38 #include <ipc/ipc_space.h>
  39 #include <kern/ipc_kobject.h>
  40 #include <kern/processor.h>
  41 #include <kern/sched.h>
  42 #include <kern/sched_prim.h>
  43 #include <kern/spl.h>
  44 #include <kern/task.h>
  45 #include <kern/thread.h>
  46 #include <mach/policy.h>
  47 #include <kern/policy_internal.h>
  48
  49 #include <kern/syscall_subr.h>
  50 #include <mach/mach_host_server.h>
  51 #include <mach/mach_syscalls.h>
  52
  53 #include <kern/misc_protos.h>
  54 #include <kern/spl.h>
  55 #include <kern/sched.h>
  56 #include <kern/sched_prim.h>
  57 #include <kern/assert.h>
  58 #include <kern/thread.h>
  59 #include <mach/mach_host_server.h>
  60 #include <mach/thread_act_server.h>
  61 #include <mach/host_priv_server.h>
  62
  63
  64 /*
  65  *      thread_set_policy
  66  *
  67  *      Set scheduling policy and parameters, both base and limit, for
  68  *      the given thread. Policy can be any policy implemented by the
  69  *      processor set, whether enabled or not.
  70  */
  71 kern_return_t
  72 thread_set_policy(
  73         thread_t                                thread,
  74         processor_set_t                 pset,
  75         policy_t                                policy,
  76         policy_base_t                   base,
  77         mach_msg_type_number_t  base_count,
  78         policy_limit_t                  limit,
  79         mach_msg_type_number_t  limit_count)
  80 {
  81         int                                     max, bas;
  82         kern_return_t                   result = KERN_SUCCESS;
  83
  84         if (    thread == THREAD_NULL                   ||
  85                         pset == PROCESSOR_SET_NULL || pset != &pset0)
  86                 return (KERN_INVALID_ARGUMENT);
  87
  88         if (invalid_policy(policy))
  89                 return(KERN_INVALID_ARGUMENT);
  90
  91         switch (policy) {
  92
  93         case POLICY_RR:
  94         {
  95                 policy_rr_base_t                rr_base = (policy_rr_base_t) base;
  96                 policy_rr_limit_t               rr_limit = (policy_rr_limit_t) limit;
  97
  98                 if (    base_count != POLICY_RR_BASE_COUNT              ||
  99                                 limit_count != POLICY_RR_LIMIT_COUNT            ) {
 100                         result = KERN_INVALID_ARGUMENT;
 101                         break;
 102                 }
 103
 104                 bas = rr_base->base_priority;
 105                 max = rr_limit->max_priority;
 106                 if (invalid_pri(bas) || invalid_pri(max)) {
 107                         result = KERN_INVALID_ARGUMENT;
 108                         break;
 109                 }
 110
 111                 break;
 112         }
 113
 114         case POLICY_FIFO:
 115         {
 116                 policy_fifo_base_t              fifo_base = (policy_fifo_base_t) base;
 117                 policy_fifo_limit_t             fifo_limit = (policy_fifo_limit_t) limit;
 118
 119                 if (    base_count != POLICY_FIFO_BASE_COUNT    ||
 120                                 limit_count != POLICY_FIFO_LIMIT_COUNT)         {
 121                         result = KERN_INVALID_ARGUMENT;
 122                         break;
 123                 }
 124
 125                 bas = fifo_base->base_priority;
 126                 max = fifo_limit->max_priority;
 127                 if (invalid_pri(bas) || invalid_pri(max)) {
 128                         result = KERN_INVALID_ARGUMENT;
 129                         break;
 130                 }
 131
 132                 break;
 133         }
 134
 135         case POLICY_TIMESHARE:
 136         {
 137                 policy_timeshare_base_t         ts_base = (policy_timeshare_base_t) base;
 138                 policy_timeshare_limit_t        ts_limit =
 139                                                 (policy_timeshare_limit_t) limit;
 140
 141                 if (    base_count != POLICY_TIMESHARE_BASE_COUNT               ||
 142                                 limit_count != POLICY_TIMESHARE_LIMIT_COUNT                     ) {
 143                         result = KERN_INVALID_ARGUMENT;
 144                         break;
 145                 }
 146
 147                 bas = ts_base->base_priority;
 148                 max = ts_limit->max_priority;
 149                 if (invalid_pri(bas) || invalid_pri(max)) {
 150                         result = KERN_INVALID_ARGUMENT;
 151                         break;
 152                 }
 153
 154                 break;
 155         }
 156
 157         default:
 158                 result = KERN_INVALID_POLICY;
 159         }
 160
 161         if (result != KERN_SUCCESS) {
 162                 return (result);
 163         }
 164
 165         /* Note that we do not pass on max priority. */
 166         if (result == KERN_SUCCESS) {
 167             result = thread_set_mode_and_absolute_pri(thread, policy, bas);
 168         }
 169
 170         return (result);
 171 }
 172
 173
 174 /*
 175  *      thread_policy
 176  *
 177  *      Set scheduling policy and parameters, both base and limit, for
 178  *      the given thread. Policy must be a policy which is enabled for the
 179  *      processor set. Change contained threads if requested.
 180  */
 181 kern_return_t
 182 thread_policy(
 183         thread_t                                thread,
 184         policy_t                                policy,
 185         policy_base_t                   base,
 186         mach_msg_type_number_t  count,
 187         boolean_t                               set_limit)
 188 {
 189         kern_return_t                   result = KERN_SUCCESS;
 190         processor_set_t                 pset = &pset0;
 191         policy_limit_t                  limit = NULL;
 192         int                                             limcount = 0;
 193         policy_rr_limit_data_t                  rr_limit;
 194         policy_fifo_limit_data_t                fifo_limit;
 195         policy_timeshare_limit_data_t   ts_limit;
 196
 197         if (thread == THREAD_NULL)
 198                 return (KERN_INVALID_ARGUMENT);
 199
 200         thread_mtx_lock(thread);
 201
 202         if (    invalid_policy(policy)                                                                                  ||
 203                         ((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0    ) {
 204                 thread_mtx_unlock(thread);
 205
 206                 return (KERN_INVALID_POLICY);
 207         }
 208
 209         if (set_limit) {
 210                 /*
 211                  *      Set scheduling limits to base priority.
 212                  */
 213                 switch (policy) {
 214
 215                 case POLICY_RR:
 216                 {
 217                         policy_rr_base_t rr_base;
 218
 219                         if (count != POLICY_RR_BASE_COUNT) {
 220                                 result = KERN_INVALID_ARGUMENT;
 221                                 break;
 222                         }
 223
 224                         limcount = POLICY_RR_LIMIT_COUNT;
 225                         rr_base = (policy_rr_base_t) base;
 226                         rr_limit.max_priority = rr_base->base_priority;
 227                         limit = (policy_limit_t) &rr_limit;
 228
 229                         break;
 230                 }
 231
 232                 case POLICY_FIFO:
 233                 {
 234                         policy_fifo_base_t fifo_base;
 235
 236                         if (count != POLICY_FIFO_BASE_COUNT) {
 237                                 result = KERN_INVALID_ARGUMENT;
 238                                 break;
 239                         }
 240
 241                         limcount = POLICY_FIFO_LIMIT_COUNT;
 242                         fifo_base = (policy_fifo_base_t) base;
 243                         fifo_limit.max_priority = fifo_base->base_priority;
 244                         limit = (policy_limit_t) &fifo_limit;
 245
 246                         break;
 247                 }
 248
 249                 case POLICY_TIMESHARE:
 250                 {
 251                         policy_timeshare_base_t ts_base;
 252
 253                         if (count != POLICY_TIMESHARE_BASE_COUNT) {
 254                                 result = KERN_INVALID_ARGUMENT;
 255                                 break;
 256                         }
 257
 258                         limcount = POLICY_TIMESHARE_LIMIT_COUNT;
 259                         ts_base = (policy_timeshare_base_t) base;
 260                         ts_limit.max_priority = ts_base->base_priority;
 261                         limit = (policy_limit_t) &ts_limit;
 262
 263                         break;
 264                 }
 265
 266                 default:
 267                         result = KERN_INVALID_POLICY;
 268                         break;
 269                 }
 270
 271         }
 272         else {
 273                 /*
 274                  *      Use current scheduling limits. Ensure that the
 275                  *      new base priority will not exceed current limits.
 276                  */
 277                 switch (policy) {
 278
 279                 case POLICY_RR:
 280                 {
 281                         policy_rr_base_t rr_base;
 282
 283                         if (count != POLICY_RR_BASE_COUNT) {
 284                                 result = KERN_INVALID_ARGUMENT;
 285                                 break;
 286                         }
 287
 288                         limcount = POLICY_RR_LIMIT_COUNT;
 289                         rr_base = (policy_rr_base_t) base;
 290                         if (rr_base->base_priority > thread->max_priority) {
 291                                 result = KERN_POLICY_LIMIT;
 292                                 break;
 293                         }
 294
 295                         rr_limit.max_priority = thread->max_priority;
 296                         limit = (policy_limit_t) &rr_limit;
 297
 298                         break;
 299                 }
 300
 301                 case POLICY_FIFO:
 302                 {
 303                         policy_fifo_base_t fifo_base;
 304
 305                         if (count != POLICY_FIFO_BASE_COUNT) {
 306                                 result = KERN_INVALID_ARGUMENT;
 307                                 break;
 308                         }
 309
 310                         limcount = POLICY_FIFO_LIMIT_COUNT;
 311                         fifo_base = (policy_fifo_base_t) base;
 312                         if (fifo_base->base_priority > thread->max_priority) {
 313                                 result = KERN_POLICY_LIMIT;
 314                                 break;
 315                         }
 316
 317                         fifo_limit.max_priority = thread->max_priority;
 318                         limit = (policy_limit_t) &fifo_limit;
 319
 320                         break;
 321                 }
 322
 323                 case POLICY_TIMESHARE:
 324                 {
 325                         policy_timeshare_base_t ts_base;
 326
 327                         if (count != POLICY_TIMESHARE_BASE_COUNT) {
 328                                 result = KERN_INVALID_ARGUMENT;
 329                                 break;
 330                         }
 331
 332                         limcount = POLICY_TIMESHARE_LIMIT_COUNT;
 333                         ts_base = (policy_timeshare_base_t) base;
 334                         if (ts_base->base_priority > thread->max_priority) {
 335                                 result = KERN_POLICY_LIMIT;
 336                                 break;
 337                         }
 338
 339                         ts_limit.max_priority = thread->max_priority;
 340                         limit = (policy_limit_t) &ts_limit;
 341
 342                         break;
 343                 }
 344
 345                 default:
 346                         result = KERN_INVALID_POLICY;
 347                         break;
 348                 }
 349
 350         }
 351
 352         thread_mtx_unlock(thread);
 353
 354         if (result == KERN_SUCCESS)
 355             result = thread_set_policy(thread, pset,
 356                                          policy, base, count, limit, limcount);
 357
 358         return(result);
 359 }