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
  89         if (invalid_policy(policy)) {
  90                 return KERN_INVALID_ARGUMENT;
  91         }
  92
  93         switch (policy) {
  94         case POLICY_RR:
  95         {
  96                 policy_rr_base_t                rr_base = (policy_rr_base_t) base;
  97                 policy_rr_limit_t               rr_limit = (policy_rr_limit_t) limit;
  98
  99                 if (base_count != POLICY_RR_BASE_COUNT ||
 100                     limit_count != POLICY_RR_LIMIT_COUNT) {
 101                         result = KERN_INVALID_ARGUMENT;
 102                         break;
 103                 }
 104
 105                 bas = rr_base->base_priority;
 106                 max = rr_limit->max_priority;
 107                 if (invalid_pri(bas) || invalid_pri(max)) {
 108                         result = KERN_INVALID_ARGUMENT;
 109                         break;
 110                 }
 111
 112                 break;
 113         }
 114
 115         case POLICY_FIFO:
 116         {
 117                 policy_fifo_base_t              fifo_base = (policy_fifo_base_t) base;
 118                 policy_fifo_limit_t             fifo_limit = (policy_fifo_limit_t) limit;
 119
 120                 if (base_count != POLICY_FIFO_BASE_COUNT ||
 121                     limit_count != POLICY_FIFO_LIMIT_COUNT) {
 122                         result = KERN_INVALID_ARGUMENT;
 123                         break;
 124                 }
 125
 126                 bas = fifo_base->base_priority;
 127                 max = fifo_limit->max_priority;
 128                 if (invalid_pri(bas) || invalid_pri(max)) {
 129                         result = KERN_INVALID_ARGUMENT;
 130                         break;
 131                 }
 132
 133                 break;
 134         }
 135
 136         case POLICY_TIMESHARE:
 137         {
 138                 policy_timeshare_base_t         ts_base = (policy_timeshare_base_t) base;
 139                 policy_timeshare_limit_t        ts_limit =
 140                     (policy_timeshare_limit_t) limit;
 141
 142                 if (base_count != POLICY_TIMESHARE_BASE_COUNT ||
 143                     limit_count != POLICY_TIMESHARE_LIMIT_COUNT) {
 144                         result = KERN_INVALID_ARGUMENT;
 145                         break;
 146                 }
 147
 148                 bas = ts_base->base_priority;
 149                 max = ts_limit->max_priority;
 150                 if (invalid_pri(bas) || invalid_pri(max)) {
 151                         result = KERN_INVALID_ARGUMENT;
 152                         break;
 153                 }
 154
 155                 break;
 156         }
 157
 158         default:
 159                 result = KERN_INVALID_POLICY;
 160         }
 161
 162         if (result != KERN_SUCCESS) {
 163                 return result;
 164         }
 165
 166         /* Note that we do not pass on max priority. */
 167         if (result == KERN_SUCCESS) {
 168                 result = thread_set_mode_and_absolute_pri(thread, policy, bas);
 169         }
 170
 171         return result;
 172 }
 173
 174
 175 /*
 176  *      thread_policy
 177  *
 178  *      Set scheduling policy and parameters, both base and limit, for
 179  *      the given thread. Policy must be a policy which is enabled for the
 180  *      processor set. Change contained threads if requested.
 181  */
 182 kern_return_t
 183 thread_policy(
 184         thread_t                                thread,
 185         policy_t                                policy,
 186         policy_base_t                   base,
 187         mach_msg_type_number_t  count,
 188         boolean_t                               set_limit)
 189 {
 190         kern_return_t                   result = KERN_SUCCESS;
 191         processor_set_t                 pset = &pset0;
 192         policy_limit_t                  limit = NULL;
 193         int                                             limcount = 0;
 194         policy_rr_limit_data_t                  rr_limit;
 195         policy_fifo_limit_data_t                fifo_limit;
 196         policy_timeshare_limit_data_t   ts_limit;
 197
 198         if (thread == THREAD_NULL) {
 199                 return KERN_INVALID_ARGUMENT;
 200         }
 201
 202         thread_mtx_lock(thread);
 203
 204         if (invalid_policy(policy) ||
 205             ((POLICY_TIMESHARE | POLICY_RR | POLICY_FIFO) & policy) == 0) {
 206                 thread_mtx_unlock(thread);
 207
 208                 return KERN_INVALID_POLICY;
 209         }
 210
 211         if (set_limit) {
 212                 /*
 213                  *      Set scheduling limits to base priority.
 214                  */
 215                 switch (policy) {
 216                 case POLICY_RR:
 217                 {
 218                         policy_rr_base_t rr_base;
 219
 220                         if (count != POLICY_RR_BASE_COUNT) {
 221                                 result = KERN_INVALID_ARGUMENT;
 222                                 break;
 223                         }
 224
 225                         limcount = POLICY_RR_LIMIT_COUNT;
 226                         rr_base = (policy_rr_base_t) base;
 227                         rr_limit.max_priority = rr_base->base_priority;
 228                         limit = (policy_limit_t) &rr_limit;
 229
 230                         break;
 231                 }
 232
 233                 case POLICY_FIFO:
 234                 {
 235                         policy_fifo_base_t fifo_base;
 236
 237                         if (count != POLICY_FIFO_BASE_COUNT) {
 238                                 result = KERN_INVALID_ARGUMENT;
 239                                 break;
 240                         }
 241
 242                         limcount = POLICY_FIFO_LIMIT_COUNT;
 243                         fifo_base = (policy_fifo_base_t) base;
 244                         fifo_limit.max_priority = fifo_base->base_priority;
 245                         limit = (policy_limit_t) &fifo_limit;
 246
 247                         break;
 248                 }
 249
 250                 case POLICY_TIMESHARE:
 251                 {
 252                         policy_timeshare_base_t ts_base;
 253
 254                         if (count != POLICY_TIMESHARE_BASE_COUNT) {
 255                                 result = KERN_INVALID_ARGUMENT;
 256                                 break;
 257                         }
 258
 259                         limcount = POLICY_TIMESHARE_LIMIT_COUNT;
 260                         ts_base = (policy_timeshare_base_t) base;
 261                         ts_limit.max_priority = ts_base->base_priority;
 262                         limit = (policy_limit_t) &ts_limit;
 263
 264                         break;
 265                 }
 266
 267                 default:
 268                         result = KERN_INVALID_POLICY;
 269                         break;
 270                 }
 271         } else {
 272                 /*
 273                  *      Use current scheduling limits. Ensure that the
 274                  *      new base priority will not exceed current limits.
 275                  */
 276                 switch (policy) {
 277                 case POLICY_RR:
 278                 {
 279                         policy_rr_base_t rr_base;
 280
 281                         if (count != POLICY_RR_BASE_COUNT) {
 282                                 result = KERN_INVALID_ARGUMENT;
 283                                 break;
 284                         }
 285
 286                         limcount = POLICY_RR_LIMIT_COUNT;
 287                         rr_base = (policy_rr_base_t) base;
 288                         if (rr_base->base_priority > thread->max_priority) {
 289                                 result = KERN_POLICY_LIMIT;
 290                                 break;
 291                         }
 292
 293                         rr_limit.max_priority = thread->max_priority;
 294                         limit = (policy_limit_t) &rr_limit;
 295
 296                         break;
 297                 }
 298
 299                 case POLICY_FIFO:
 300                 {
 301                         policy_fifo_base_t fifo_base;
 302
 303                         if (count != POLICY_FIFO_BASE_COUNT) {
 304                                 result = KERN_INVALID_ARGUMENT;
 305                                 break;
 306                         }
 307
 308                         limcount = POLICY_FIFO_LIMIT_COUNT;
 309                         fifo_base = (policy_fifo_base_t) base;
 310                         if (fifo_base->base_priority > thread->max_priority) {
 311                                 result = KERN_POLICY_LIMIT;
 312                                 break;
 313                         }
 314
 315                         fifo_limit.max_priority = thread->max_priority;
 316                         limit = (policy_limit_t) &fifo_limit;
 317
 318                         break;
 319                 }
 320
 321                 case POLICY_TIMESHARE:
 322                 {
 323                         policy_timeshare_base_t ts_base;
 324
 325                         if (count != POLICY_TIMESHARE_BASE_COUNT) {
 326                                 result = KERN_INVALID_ARGUMENT;
 327                                 break;
 328                         }
 329
 330                         limcount = POLICY_TIMESHARE_LIMIT_COUNT;
 331                         ts_base = (policy_timeshare_base_t) base;
 332                         if (ts_base->base_priority > thread->max_priority) {
 333                                 result = KERN_POLICY_LIMIT;
 334                                 break;
 335                         }
 336
 337                         ts_limit.max_priority = thread->max_priority;
 338                         limit = (policy_limit_t) &ts_limit;
 339
 340                         break;
 341                 }
 342
 343                 default:
 344                         result = KERN_INVALID_POLICY;
 345                         break;
 346                 }
 347         }
 348
 349         thread_mtx_unlock(thread);
 350
 351         if (result == KERN_SUCCESS) {
 352                 result = thread_set_policy(thread, pset,
 353                     policy, base, count, limit, limcount);
 354         }
 355
 356         return result;
 357 }