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 /* 23 * Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2013, Joyent, Inc. All rights reserved. 25 */ 26 27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 #include <sys/types.h> 31 #include <sys/param.h> 32 #include <sys/sysmacros.h> 33 #include <sys/cred.h> 34 #include <sys/proc.h> 35 #include <sys/session.h> 36 #include <sys/strsubr.h> 37 #include <sys/signal.h> 38 #include <sys/user.h> 39 #include <sys/priocntl.h> 40 #include <sys/class.h> 41 #include <sys/disp.h> 42 #include <sys/procset.h> 43 #include <sys/debug.h> 44 #include <sys/ts.h> 45 #include <sys/tspriocntl.h> 46 #include <sys/iapriocntl.h> 47 #include <sys/kmem.h> 48 #include <sys/errno.h> 49 #include <sys/cpuvar.h> 50 #include <sys/systm.h> /* for lbolt */ 51 #include <sys/vtrace.h> 52 #include <sys/vmsystm.h> 53 #include <sys/schedctl.h> 54 #include <sys/tnf_probe.h> 55 #include <sys/atomic.h> 56 #include <sys/policy.h> 57 #include <sys/sdt.h> 58 #include <sys/cpupart.h> 59 #include <vm/rm.h> 60 #include <vm/seg_kmem.h> 61 #include <sys/modctl.h> 62 #include <sys/cpucaps.h> 63 64 static pri_t ts_init(id_t, int, classfuncs_t **); 65 66 static struct sclass csw = { 67 "TS", 68 ts_init, 69 0 70 }; 71 72 static struct modlsched modlsched = { 73 &mod_schedops, "time sharing sched class", &csw 74 }; 75 76 static struct modlinkage modlinkage = { 77 MODREV_1, { (void *)&modlsched, NULL } 78 }; 79 80 int 81 _init() 82 { 83 return (mod_install(&modlinkage)); 84 } 85 86 int 87 _fini() 88 { 89 return (EBUSY); /* don't remove TS for now */ 90 } 91 92 int 93 _info(struct modinfo *modinfop) 94 { 95 return (mod_info(&modlinkage, modinfop)); 96 } 97 98 /* 99 * Class specific code for the time-sharing class 100 */ 101 102 103 /* 104 * Extern declarations for variables defined in the ts master file 105 */ 106 #define TSMAXUPRI 60 107 108 pri_t ts_maxupri = TSMAXUPRI; /* max time-sharing user priority */ 109 pri_t ts_maxumdpri; /* maximum user mode ts priority */ 110 111 pri_t ia_maxupri = IAMAXUPRI; /* max interactive user priority */ 112 pri_t ia_boost = IA_BOOST; /* boost value for interactive */ 113 114 tsdpent_t *ts_dptbl; /* time-sharing disp parameter table */ 115 pri_t *ts_kmdpris; /* array of global pris used by ts procs when */ 116 /* sleeping or running in kernel after sleep */ 117 118 static id_t ia_cid; 119 120 int ts_sleep_promote = 1; 121 122 #define tsmedumdpri (ts_maxumdpri >> 1) 123 124 #define TS_NEWUMDPRI(tspp) \ 125 { \ 126 pri_t pri; \ 127 pri = (tspp)->ts_cpupri + (tspp)->ts_upri + (tspp)->ts_boost; \ 128 if (pri > ts_maxumdpri) \ 129 (tspp)->ts_umdpri = ts_maxumdpri; \ 130 else if (pri < 0) \ 131 (tspp)->ts_umdpri = 0; \ 132 else \ 133 (tspp)->ts_umdpri = pri; \ 134 ASSERT((tspp)->ts_umdpri >= 0 && (tspp)->ts_umdpri <= ts_maxumdpri); \ 135 } 136 137 /* 138 * The tsproc_t structures are kept in an array of circular doubly linked 139 * lists. A hash on the thread pointer is used to determine which list 140 * each thread should be placed. Each list has a dummy "head" which is 141 * never removed, so the list is never empty. ts_update traverses these 142 * lists to update the priorities of threads that have been waiting on 143 * the run queue. 144 */ 145 146 #define TS_LISTS 16 /* number of lists, must be power of 2 */ 147 148 /* hash function, argument is a thread pointer */ 149 #define TS_LIST_HASH(tp) (((uintptr_t)(tp) >> 9) & (TS_LISTS - 1)) 150 151 /* iterate to the next list */ 152 #define TS_LIST_NEXT(i) (((i) + 1) & (TS_LISTS - 1)) 153 154 /* 155 * Insert thread into the appropriate tsproc list. 156 */ 157 #define TS_LIST_INSERT(tspp) \ 158 { \ 159 int index = TS_LIST_HASH(tspp->ts_tp); \ 160 kmutex_t *lockp = &ts_list_lock[index]; \ 161 tsproc_t *headp = &ts_plisthead[index]; \ 162 mutex_enter(lockp); \ 163 tspp->ts_next = headp->ts_next; \ 164 tspp->ts_prev = headp; \ 165 headp->ts_next->ts_prev = tspp; \ 166 headp->ts_next = tspp; \ 167 mutex_exit(lockp); \ 168 } 169 170 /* 171 * Remove thread from tsproc list. 172 */ 173 #define TS_LIST_DELETE(tspp) \ 174 { \ 175 int index = TS_LIST_HASH(tspp->ts_tp); \ 176 kmutex_t *lockp = &ts_list_lock[index]; \ 177 mutex_enter(lockp); \ 178 tspp->ts_prev->ts_next = tspp->ts_next; \ 179 tspp->ts_next->ts_prev = tspp->ts_prev; \ 180 mutex_exit(lockp); \ 181 } 182 183 184 static int ts_admin(caddr_t, cred_t *); 185 static int ts_enterclass(kthread_t *, id_t, void *, cred_t *, void *); 186 static int ts_fork(kthread_t *, kthread_t *, void *); 187 static int ts_getclinfo(void *); 188 static int ts_getclpri(pcpri_t *); 189 static int ts_parmsin(void *); 190 static int ts_parmsout(void *, pc_vaparms_t *); 191 static int ts_vaparmsin(void *, pc_vaparms_t *); 192 static int ts_vaparmsout(void *, pc_vaparms_t *); 193 static int ts_parmsset(kthread_t *, void *, id_t, cred_t *); 194 static void ts_exit(kthread_t *); 195 static int ts_donice(kthread_t *, cred_t *, int, int *); 196 static int ts_doprio(kthread_t *, cred_t *, int, int *); 197 static void ts_exitclass(void *); 198 static int ts_canexit(kthread_t *, cred_t *); 199 static void ts_forkret(kthread_t *, kthread_t *); 200 static void ts_nullsys(); 201 static void ts_parmsget(kthread_t *, void *); 202 static void ts_preempt(kthread_t *); 203 static void ts_setrun(kthread_t *); 204 static void ts_sleep(kthread_t *); 205 static pri_t ts_swapin(kthread_t *, int); 206 static pri_t ts_swapout(kthread_t *, int); 207 static void ts_tick(kthread_t *); 208 static void ts_trapret(kthread_t *); 209 static void ts_update(void *); 210 static int ts_update_list(int); 211 static void ts_wakeup(kthread_t *); 212 static pri_t ts_globpri(kthread_t *); 213 static void ts_yield(kthread_t *); 214 extern tsdpent_t *ts_getdptbl(void); 215 extern pri_t *ts_getkmdpris(void); 216 extern pri_t td_getmaxumdpri(void); 217 static int ts_alloc(void **, int); 218 static void ts_free(void *); 219 220 pri_t ia_init(id_t, int, classfuncs_t **); 221 static int ia_getclinfo(void *); 222 static int ia_getclpri(pcpri_t *); 223 static int ia_parmsin(void *); 224 static int ia_vaparmsin(void *, pc_vaparms_t *); 225 static int ia_vaparmsout(void *, pc_vaparms_t *); 226 static int ia_parmsset(kthread_t *, void *, id_t, cred_t *); 227 static void ia_parmsget(kthread_t *, void *); 228 static void ia_set_process_group(pid_t, pid_t, pid_t); 229 230 static void ts_change_priority(kthread_t *, tsproc_t *); 231 232 extern pri_t ts_maxkmdpri; /* maximum kernel mode ts priority */ 233 static pri_t ts_maxglobpri; /* maximum global priority used by ts class */ 234 static kmutex_t ts_dptblock; /* protects time sharing dispatch table */ 235 static kmutex_t ts_list_lock[TS_LISTS]; /* protects tsproc lists */ 236 static tsproc_t ts_plisthead[TS_LISTS]; /* dummy tsproc at head of lists */ 237 238 static gid_t IA_gid = 0; 239 240 static struct classfuncs ts_classfuncs = { 241 /* class functions */ 242 { ts_admin, 243 ts_getclinfo, 244 ts_parmsin, 245 ts_parmsout, 246 ts_vaparmsin, 247 ts_vaparmsout, 248 ts_getclpri, 249 ts_alloc, 250 ts_free }, 251 252 /* thread functions */ 253 { ts_enterclass, 254 ts_exitclass, 255 ts_canexit, 256 ts_fork, 257 ts_forkret, 258 ts_parmsget, 259 ts_parmsset, 260 ts_nullsys, /* stop */ 261 ts_exit, 262 ts_nullsys, /* active */ 263 ts_nullsys, /* inactive */ 264 ts_swapin, 265 ts_swapout, 266 ts_trapret, 267 ts_preempt, 268 ts_setrun, 269 ts_sleep, 270 ts_tick, 271 ts_wakeup, 272 ts_donice, 273 ts_globpri, 274 ts_nullsys, /* set_process_group */ 275 ts_yield, 276 ts_doprio }, 277 }; 278 279 /* 280 * ia_classfuncs is used for interactive class threads; IA threads are stored 281 * on the same class list as TS threads, and most of the class functions are 282 * identical, but a few have different enough functionality to require their 283 * own functions. 284 */ 285 static struct classfuncs ia_classfuncs = { 286 /* class functions */ 287 { ts_admin, 288 ia_getclinfo, 289 ia_parmsin, 290 ts_parmsout, 291 ia_vaparmsin, 292 ia_vaparmsout, 293 ia_getclpri, 294 ts_alloc, 295 ts_free }, 296 297 /* thread functions */ 298 { ts_enterclass, 299 ts_exitclass, 300 ts_canexit, 301 ts_fork, 302 ts_forkret, 303 ia_parmsget, 304 ia_parmsset, 305 ts_nullsys, /* stop */ 306 ts_exit, 307 ts_nullsys, /* active */ 308 ts_nullsys, /* inactive */ 309 ts_swapin, 310 ts_swapout, 311 ts_trapret, 312 ts_preempt, 313 ts_setrun, 314 ts_sleep, 315 ts_tick, 316 ts_wakeup, 317 ts_donice, 318 ts_globpri, 319 ia_set_process_group, 320 ts_yield, 321 ts_doprio }, 322 }; 323 324 325 /* 326 * Time sharing class initialization. Called by dispinit() at boot time. 327 * We can ignore the clparmsz argument since we know that the smallest 328 * possible parameter buffer is big enough for us. 329 */ 330 /* ARGSUSED */ 331 static pri_t 332 ts_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp) 333 { 334 int i; 335 extern pri_t ts_getmaxumdpri(void); 336 337 ts_dptbl = ts_getdptbl(); 338 ts_kmdpris = ts_getkmdpris(); 339 ts_maxumdpri = ts_getmaxumdpri(); 340 ts_maxglobpri = MAX(ts_kmdpris[0], ts_dptbl[ts_maxumdpri].ts_globpri); 341 342 /* 343 * Initialize the tsproc lists. 344 */ 345 for (i = 0; i < TS_LISTS; i++) { 346 ts_plisthead[i].ts_next = ts_plisthead[i].ts_prev = 347 &ts_plisthead[i]; 348 } 349 350 /* 351 * We're required to return a pointer to our classfuncs 352 * structure and the highest global priority value we use. 353 */ 354 *clfuncspp = &ts_classfuncs; 355 return (ts_maxglobpri); 356 } 357 358 359 /* 360 * Interactive class scheduler initialization 361 */ 362 /* ARGSUSED */ 363 pri_t 364 ia_init(id_t cid, int clparmsz, classfuncs_t **clfuncspp) 365 { 366 /* 367 * We're required to return a pointer to our classfuncs 368 * structure and the highest global priority value we use. 369 */ 370 ia_cid = cid; 371 *clfuncspp = &ia_classfuncs; 372 return (ts_maxglobpri); 373 } 374 375 376 /* 377 * Get or reset the ts_dptbl values per the user's request. 378 */ 379 static int 380 ts_admin(caddr_t uaddr, cred_t *reqpcredp) 381 { 382 tsadmin_t tsadmin; 383 tsdpent_t *tmpdpp; 384 int userdpsz; 385 int i; 386 size_t tsdpsz; 387 388 if (get_udatamodel() == DATAMODEL_NATIVE) { 389 if (copyin(uaddr, &tsadmin, sizeof (tsadmin_t))) 390 return (EFAULT); 391 } 392 #ifdef _SYSCALL32_IMPL 393 else { 394 /* get tsadmin struct from ILP32 caller */ 395 tsadmin32_t tsadmin32; 396 if (copyin(uaddr, &tsadmin32, sizeof (tsadmin32_t))) 397 return (EFAULT); 398 tsadmin.ts_dpents = 399 (struct tsdpent *)(uintptr_t)tsadmin32.ts_dpents; 400 tsadmin.ts_ndpents = tsadmin32.ts_ndpents; 401 tsadmin.ts_cmd = tsadmin32.ts_cmd; 402 } 403 #endif /* _SYSCALL32_IMPL */ 404 405 tsdpsz = (ts_maxumdpri + 1) * sizeof (tsdpent_t); 406 407 switch (tsadmin.ts_cmd) { 408 case TS_GETDPSIZE: 409 tsadmin.ts_ndpents = ts_maxumdpri + 1; 410 411 if (get_udatamodel() == DATAMODEL_NATIVE) { 412 if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t))) 413 return (EFAULT); 414 } 415 #ifdef _SYSCALL32_IMPL 416 else { 417 /* return tsadmin struct to ILP32 caller */ 418 tsadmin32_t tsadmin32; 419 tsadmin32.ts_dpents = 420 (caddr32_t)(uintptr_t)tsadmin.ts_dpents; 421 tsadmin32.ts_ndpents = tsadmin.ts_ndpents; 422 tsadmin32.ts_cmd = tsadmin.ts_cmd; 423 if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t))) 424 return (EFAULT); 425 } 426 #endif /* _SYSCALL32_IMPL */ 427 break; 428 429 case TS_GETDPTBL: 430 userdpsz = MIN(tsadmin.ts_ndpents * sizeof (tsdpent_t), 431 tsdpsz); 432 if (copyout(ts_dptbl, tsadmin.ts_dpents, userdpsz)) 433 return (EFAULT); 434 435 tsadmin.ts_ndpents = userdpsz / sizeof (tsdpent_t); 436 437 if (get_udatamodel() == DATAMODEL_NATIVE) { 438 if (copyout(&tsadmin, uaddr, sizeof (tsadmin_t))) 439 return (EFAULT); 440 } 441 #ifdef _SYSCALL32_IMPL 442 else { 443 /* return tsadmin struct to ILP32 callers */ 444 tsadmin32_t tsadmin32; 445 tsadmin32.ts_dpents = 446 (caddr32_t)(uintptr_t)tsadmin.ts_dpents; 447 tsadmin32.ts_ndpents = tsadmin.ts_ndpents; 448 tsadmin32.ts_cmd = tsadmin.ts_cmd; 449 if (copyout(&tsadmin32, uaddr, sizeof (tsadmin32_t))) 450 return (EFAULT); 451 } 452 #endif /* _SYSCALL32_IMPL */ 453 break; 454 455 case TS_SETDPTBL: 456 /* 457 * We require that the requesting process has sufficient 458 * priveleges. We also require that the table supplied by 459 * the user exactly match the current ts_dptbl in size. 460 */ 461 if (secpolicy_dispadm(reqpcredp) != 0) 462 return (EPERM); 463 464 if (tsadmin.ts_ndpents * sizeof (tsdpent_t) != tsdpsz) { 465 return (EINVAL); 466 } 467 468 /* 469 * We read the user supplied table into a temporary buffer 470 * where it is validated before being copied over the 471 * ts_dptbl. 472 */ 473 tmpdpp = kmem_alloc(tsdpsz, KM_SLEEP); 474 if (copyin((caddr_t)tsadmin.ts_dpents, (caddr_t)tmpdpp, 475 tsdpsz)) { 476 kmem_free(tmpdpp, tsdpsz); 477 return (EFAULT); 478 } 479 for (i = 0; i < tsadmin.ts_ndpents; i++) { 480 481 /* 482 * Validate the user supplied values. All we are doing 483 * here is verifying that the values are within their 484 * allowable ranges and will not panic the system. We 485 * make no attempt to ensure that the resulting 486 * configuration makes sense or results in reasonable 487 * performance. 488 */ 489 if (tmpdpp[i].ts_quantum <= 0) { 490 kmem_free(tmpdpp, tsdpsz); 491 return (EINVAL); 492 } 493 if (tmpdpp[i].ts_tqexp > ts_maxumdpri || 494 tmpdpp[i].ts_tqexp < 0) { 495 kmem_free(tmpdpp, tsdpsz); 496 return (EINVAL); 497 } 498 if (tmpdpp[i].ts_slpret > ts_maxumdpri || 499 tmpdpp[i].ts_slpret < 0) { 500 kmem_free(tmpdpp, tsdpsz); 501 return (EINVAL); 502 } 503 if (tmpdpp[i].ts_maxwait < 0) { 504 kmem_free(tmpdpp, tsdpsz); 505 return (EINVAL); 506 } 507 if (tmpdpp[i].ts_lwait > ts_maxumdpri || 508 tmpdpp[i].ts_lwait < 0) { 509 kmem_free(tmpdpp, tsdpsz); 510 return (EINVAL); 511 } 512 } 513 514 /* 515 * Copy the user supplied values over the current ts_dptbl 516 * values. The ts_globpri member is read-only so we don't 517 * overwrite it. 518 */ 519 mutex_enter(&ts_dptblock); 520 for (i = 0; i < tsadmin.ts_ndpents; i++) { 521 ts_dptbl[i].ts_quantum = tmpdpp[i].ts_quantum; 522 ts_dptbl[i].ts_tqexp = tmpdpp[i].ts_tqexp; 523 ts_dptbl[i].ts_slpret = tmpdpp[i].ts_slpret; 524 ts_dptbl[i].ts_maxwait = tmpdpp[i].ts_maxwait; 525 ts_dptbl[i].ts_lwait = tmpdpp[i].ts_lwait; 526 } 527 mutex_exit(&ts_dptblock); 528 kmem_free(tmpdpp, tsdpsz); 529 break; 530 531 default: 532 return (EINVAL); 533 } 534 return (0); 535 } 536 537 538 /* 539 * Allocate a time-sharing class specific thread structure and 540 * initialize it with the parameters supplied. Also move the thread 541 * to specified time-sharing priority. 542 */ 543 static int 544 ts_enterclass(kthread_t *t, id_t cid, void *parmsp, 545 cred_t *reqpcredp, void *bufp) 546 { 547 tsparms_t *tsparmsp = (tsparms_t *)parmsp; 548 tsproc_t *tspp; 549 pri_t reqtsuprilim; 550 pri_t reqtsupri; 551 static uint32_t tspexists = 0; /* set on first occurrence of */ 552 /* a time-sharing process */ 553 554 tspp = (tsproc_t *)bufp; 555 ASSERT(tspp != NULL); 556 557 /* 558 * Initialize the tsproc structure. 559 */ 560 tspp->ts_cpupri = tsmedumdpri; 561 if (cid == ia_cid) { 562 /* 563 * Check to make sure caller is either privileged or the 564 * window system. When the window system is converted 565 * to using privileges, the second check can go away. 566 */ 567 if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) && 568 secpolicy_setpriority(reqpcredp) != 0) 569 return (EPERM); 570 /* 571 * Belongs to IA "class", so set appropriate flags. 572 * Mark as 'on' so it will not be a swap victim 573 * while forking. 574 */ 575 tspp->ts_flags = TSIA | TSIASET; 576 tspp->ts_boost = ia_boost; 577 } else { 578 tspp->ts_flags = 0; 579 tspp->ts_boost = 0; 580 } 581 582 if (tsparmsp == NULL) { 583 /* 584 * Use default values. 585 */ 586 tspp->ts_uprilim = tspp->ts_upri = 0; 587 tspp->ts_nice = NZERO; 588 } else { 589 /* 590 * Use supplied values. 591 */ 592 if (tsparmsp->ts_uprilim == TS_NOCHANGE) 593 reqtsuprilim = 0; 594 else { 595 if (tsparmsp->ts_uprilim > 0 && 596 secpolicy_setpriority(reqpcredp) != 0) 597 return (EPERM); 598 reqtsuprilim = tsparmsp->ts_uprilim; 599 } 600 601 if (tsparmsp->ts_upri == TS_NOCHANGE) { 602 reqtsupri = reqtsuprilim; 603 } else { 604 if (tsparmsp->ts_upri > 0 && 605 secpolicy_setpriority(reqpcredp) != 0) 606 return (EPERM); 607 /* 608 * Set the user priority to the requested value 609 * or the upri limit, whichever is lower. 610 */ 611 reqtsupri = tsparmsp->ts_upri; 612 if (reqtsupri > reqtsuprilim) 613 reqtsupri = reqtsuprilim; 614 } 615 616 617 tspp->ts_uprilim = reqtsuprilim; 618 tspp->ts_upri = reqtsupri; 619 tspp->ts_nice = NZERO - (NZERO * reqtsupri) / ts_maxupri; 620 } 621 TS_NEWUMDPRI(tspp); 622 623 tspp->ts_dispwait = 0; 624 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 625 tspp->ts_tp = t; 626 cpucaps_sc_init(&tspp->ts_caps); 627 628 /* 629 * Reset priority. Process goes to a "user mode" priority 630 * here regardless of whether or not it has slept since 631 * entering the kernel. 632 */ 633 thread_lock(t); /* get dispatcher lock on thread */ 634 t->t_clfuncs = &(sclass[cid].cl_funcs->thread); 635 t->t_cid = cid; 636 t->t_cldata = (void *)tspp; 637 t->t_schedflag &= ~TS_RUNQMATCH; 638 ts_change_priority(t, tspp); 639 thread_unlock(t); 640 641 /* 642 * Link new structure into tsproc list. 643 */ 644 TS_LIST_INSERT(tspp); 645 646 /* 647 * If this is the first time-sharing thread to occur since 648 * boot we set up the initial call to ts_update() here. 649 * Use an atomic compare-and-swap since that's easier and 650 * faster than a mutex (but check with an ordinary load first 651 * since most of the time this will already be done). 652 */ 653 if (tspexists == 0 && atomic_cas_32(&tspexists, 0, 1) == 0) 654 (void) timeout(ts_update, NULL, hz); 655 656 return (0); 657 } 658 659 660 /* 661 * Free tsproc structure of thread. 662 */ 663 static void 664 ts_exitclass(void *procp) 665 { 666 tsproc_t *tspp = (tsproc_t *)procp; 667 668 /* Remove tsproc_t structure from list */ 669 TS_LIST_DELETE(tspp); 670 kmem_free(tspp, sizeof (tsproc_t)); 671 } 672 673 /* ARGSUSED */ 674 static int 675 ts_canexit(kthread_t *t, cred_t *cred) 676 { 677 /* 678 * A thread can always leave a TS/IA class 679 */ 680 return (0); 681 } 682 683 static int 684 ts_fork(kthread_t *t, kthread_t *ct, void *bufp) 685 { 686 tsproc_t *ptspp; /* ptr to parent's tsproc structure */ 687 tsproc_t *ctspp; /* ptr to child's tsproc structure */ 688 689 ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock)); 690 691 ctspp = (tsproc_t *)bufp; 692 ASSERT(ctspp != NULL); 693 ptspp = (tsproc_t *)t->t_cldata; 694 /* 695 * Initialize child's tsproc structure. 696 */ 697 thread_lock(t); 698 ctspp->ts_timeleft = ts_dptbl[ptspp->ts_cpupri].ts_quantum; 699 ctspp->ts_cpupri = ptspp->ts_cpupri; 700 ctspp->ts_boost = ptspp->ts_boost; 701 ctspp->ts_uprilim = ptspp->ts_uprilim; 702 ctspp->ts_upri = ptspp->ts_upri; 703 TS_NEWUMDPRI(ctspp); 704 ctspp->ts_nice = ptspp->ts_nice; 705 ctspp->ts_dispwait = 0; 706 ctspp->ts_flags = ptspp->ts_flags & ~(TSKPRI | TSBACKQ | TSRESTORE); 707 ctspp->ts_tp = ct; 708 cpucaps_sc_init(&ctspp->ts_caps); 709 thread_unlock(t); 710 711 /* 712 * Link new structure into tsproc list. 713 */ 714 ct->t_cldata = (void *)ctspp; 715 TS_LIST_INSERT(ctspp); 716 return (0); 717 } 718 719 720 /* 721 * Child is placed at back of dispatcher queue and parent gives 722 * up processor so that the child runs first after the fork. 723 * This allows the child immediately execing to break the multiple 724 * use of copy on write pages with no disk home. The parent will 725 * get to steal them back rather than uselessly copying them. 726 */ 727 static void 728 ts_forkret(kthread_t *t, kthread_t *ct) 729 { 730 proc_t *pp = ttoproc(t); 731 proc_t *cp = ttoproc(ct); 732 tsproc_t *tspp; 733 734 ASSERT(t == curthread); 735 ASSERT(MUTEX_HELD(&pidlock)); 736 737 /* 738 * Grab the child's p_lock before dropping pidlock to ensure 739 * the process does not disappear before we set it running. 740 */ 741 mutex_enter(&cp->p_lock); 742 continuelwps(cp); 743 mutex_exit(&cp->p_lock); 744 745 mutex_enter(&pp->p_lock); 746 mutex_exit(&pidlock); 747 continuelwps(pp); 748 749 thread_lock(t); 750 tspp = (tsproc_t *)(t->t_cldata); 751 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp; 752 TS_NEWUMDPRI(tspp); 753 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 754 tspp->ts_dispwait = 0; 755 t->t_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri; 756 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 757 tspp->ts_flags &= ~TSKPRI; 758 THREAD_TRANSITION(t); 759 ts_setrun(t); 760 thread_unlock(t); 761 /* 762 * Safe to drop p_lock now since since it is safe to change 763 * the scheduling class after this point. 764 */ 765 mutex_exit(&pp->p_lock); 766 767 swtch(); 768 } 769 770 771 /* 772 * Get information about the time-sharing class into the buffer 773 * pointed to by tsinfop. The maximum configured user priority 774 * is the only information we supply. ts_getclinfo() is called 775 * for TS threads, and ia_getclinfo() is called for IA threads. 776 */ 777 static int 778 ts_getclinfo(void *infop) 779 { 780 tsinfo_t *tsinfop = (tsinfo_t *)infop; 781 tsinfop->ts_maxupri = ts_maxupri; 782 return (0); 783 } 784 785 static int 786 ia_getclinfo(void *infop) 787 { 788 iainfo_t *iainfop = (iainfo_t *)infop; 789 iainfop->ia_maxupri = ia_maxupri; 790 return (0); 791 } 792 793 794 /* 795 * Return the user mode scheduling priority range. 796 */ 797 static int 798 ts_getclpri(pcpri_t *pcprip) 799 { 800 pcprip->pc_clpmax = ts_maxupri; 801 pcprip->pc_clpmin = -ts_maxupri; 802 return (0); 803 } 804 805 806 static int 807 ia_getclpri(pcpri_t *pcprip) 808 { 809 pcprip->pc_clpmax = ia_maxupri; 810 pcprip->pc_clpmin = -ia_maxupri; 811 return (0); 812 } 813 814 815 static void 816 ts_nullsys() 817 {} 818 819 820 /* 821 * Get the time-sharing parameters of the thread pointed to by 822 * tsprocp into the buffer pointed to by tsparmsp. ts_parmsget() 823 * is called for TS threads, and ia_parmsget() is called for IA 824 * threads. 825 */ 826 static void 827 ts_parmsget(kthread_t *t, void *parmsp) 828 { 829 tsproc_t *tspp = (tsproc_t *)t->t_cldata; 830 tsparms_t *tsparmsp = (tsparms_t *)parmsp; 831 832 tsparmsp->ts_uprilim = tspp->ts_uprilim; 833 tsparmsp->ts_upri = tspp->ts_upri; 834 } 835 836 static void 837 ia_parmsget(kthread_t *t, void *parmsp) 838 { 839 tsproc_t *tspp = (tsproc_t *)t->t_cldata; 840 iaparms_t *iaparmsp = (iaparms_t *)parmsp; 841 842 iaparmsp->ia_uprilim = tspp->ts_uprilim; 843 iaparmsp->ia_upri = tspp->ts_upri; 844 if (tspp->ts_flags & TSIASET) 845 iaparmsp->ia_mode = IA_SET_INTERACTIVE; 846 else 847 iaparmsp->ia_mode = IA_INTERACTIVE_OFF; 848 } 849 850 851 /* 852 * Check the validity of the time-sharing parameters in the buffer 853 * pointed to by tsparmsp. 854 * ts_parmsin() is called for TS threads, and ia_parmsin() is called 855 * for IA threads. 856 */ 857 static int 858 ts_parmsin(void *parmsp) 859 { 860 tsparms_t *tsparmsp = (tsparms_t *)parmsp; 861 /* 862 * Check validity of parameters. 863 */ 864 if ((tsparmsp->ts_uprilim > ts_maxupri || 865 tsparmsp->ts_uprilim < -ts_maxupri) && 866 tsparmsp->ts_uprilim != TS_NOCHANGE) 867 return (EINVAL); 868 869 if ((tsparmsp->ts_upri > ts_maxupri || 870 tsparmsp->ts_upri < -ts_maxupri) && 871 tsparmsp->ts_upri != TS_NOCHANGE) 872 return (EINVAL); 873 874 return (0); 875 } 876 877 static int 878 ia_parmsin(void *parmsp) 879 { 880 iaparms_t *iaparmsp = (iaparms_t *)parmsp; 881 882 if ((iaparmsp->ia_uprilim > ia_maxupri || 883 iaparmsp->ia_uprilim < -ia_maxupri) && 884 iaparmsp->ia_uprilim != IA_NOCHANGE) { 885 return (EINVAL); 886 } 887 888 if ((iaparmsp->ia_upri > ia_maxupri || 889 iaparmsp->ia_upri < -ia_maxupri) && 890 iaparmsp->ia_upri != IA_NOCHANGE) { 891 return (EINVAL); 892 } 893 894 return (0); 895 } 896 897 898 /* 899 * Check the validity of the time-sharing parameters in the pc_vaparms_t 900 * structure vaparmsp and put them in the buffer pointed to by tsparmsp. 901 * pc_vaparms_t contains (key, value) pairs of parameter. 902 * ts_vaparmsin() is called for TS threads, and ia_vaparmsin() is called 903 * for IA threads. ts_vaparmsin() is the variable parameter version of 904 * ts_parmsin() and ia_vaparmsin() is the variable parameter version of 905 * ia_parmsin(). 906 */ 907 static int 908 ts_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp) 909 { 910 tsparms_t *tsparmsp = (tsparms_t *)parmsp; 911 int priflag = 0; 912 int limflag = 0; 913 uint_t cnt; 914 pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; 915 916 917 /* 918 * TS_NOCHANGE (-32768) is outside of the range of values for 919 * ts_uprilim and ts_upri. If the structure tsparms_t is changed, 920 * TS_NOCHANGE should be replaced by a flag word (in the same manner 921 * as in rt.c). 922 */ 923 tsparmsp->ts_uprilim = TS_NOCHANGE; 924 tsparmsp->ts_upri = TS_NOCHANGE; 925 926 /* 927 * Get the varargs parameter and check validity of parameters. 928 */ 929 if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) 930 return (EINVAL); 931 932 for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { 933 934 switch (vpp->pc_key) { 935 case TS_KY_UPRILIM: 936 if (limflag++) 937 return (EINVAL); 938 tsparmsp->ts_uprilim = (pri_t)vpp->pc_parm; 939 if (tsparmsp->ts_uprilim > ts_maxupri || 940 tsparmsp->ts_uprilim < -ts_maxupri) 941 return (EINVAL); 942 break; 943 944 case TS_KY_UPRI: 945 if (priflag++) 946 return (EINVAL); 947 tsparmsp->ts_upri = (pri_t)vpp->pc_parm; 948 if (tsparmsp->ts_upri > ts_maxupri || 949 tsparmsp->ts_upri < -ts_maxupri) 950 return (EINVAL); 951 break; 952 953 default: 954 return (EINVAL); 955 } 956 } 957 958 if (vaparmsp->pc_vaparmscnt == 0) { 959 /* 960 * Use default parameters. 961 */ 962 tsparmsp->ts_upri = tsparmsp->ts_uprilim = 0; 963 } 964 965 return (0); 966 } 967 968 static int 969 ia_vaparmsin(void *parmsp, pc_vaparms_t *vaparmsp) 970 { 971 iaparms_t *iaparmsp = (iaparms_t *)parmsp; 972 int priflag = 0; 973 int limflag = 0; 974 int mflag = 0; 975 uint_t cnt; 976 pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; 977 978 /* 979 * IA_NOCHANGE (-32768) is outside of the range of values for 980 * ia_uprilim, ia_upri and ia_mode. If the structure iaparms_t is 981 * changed, IA_NOCHANGE should be replaced by a flag word (in the 982 * same manner as in rt.c). 983 */ 984 iaparmsp->ia_uprilim = IA_NOCHANGE; 985 iaparmsp->ia_upri = IA_NOCHANGE; 986 iaparmsp->ia_mode = IA_NOCHANGE; 987 988 /* 989 * Get the varargs parameter and check validity of parameters. 990 */ 991 if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) 992 return (EINVAL); 993 994 for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { 995 996 switch (vpp->pc_key) { 997 case IA_KY_UPRILIM: 998 if (limflag++) 999 return (EINVAL); 1000 iaparmsp->ia_uprilim = (pri_t)vpp->pc_parm; 1001 if (iaparmsp->ia_uprilim > ia_maxupri || 1002 iaparmsp->ia_uprilim < -ia_maxupri) 1003 return (EINVAL); 1004 break; 1005 1006 case IA_KY_UPRI: 1007 if (priflag++) 1008 return (EINVAL); 1009 iaparmsp->ia_upri = (pri_t)vpp->pc_parm; 1010 if (iaparmsp->ia_upri > ia_maxupri || 1011 iaparmsp->ia_upri < -ia_maxupri) 1012 return (EINVAL); 1013 break; 1014 1015 case IA_KY_MODE: 1016 if (mflag++) 1017 return (EINVAL); 1018 iaparmsp->ia_mode = (int)vpp->pc_parm; 1019 if (iaparmsp->ia_mode != IA_SET_INTERACTIVE && 1020 iaparmsp->ia_mode != IA_INTERACTIVE_OFF) 1021 return (EINVAL); 1022 break; 1023 1024 default: 1025 return (EINVAL); 1026 } 1027 } 1028 1029 if (vaparmsp->pc_vaparmscnt == 0) { 1030 /* 1031 * Use default parameters. 1032 */ 1033 iaparmsp->ia_upri = iaparmsp->ia_uprilim = 0; 1034 iaparmsp->ia_mode = IA_SET_INTERACTIVE; 1035 } 1036 1037 return (0); 1038 } 1039 1040 /* 1041 * Nothing to do here but return success. 1042 */ 1043 /* ARGSUSED */ 1044 static int 1045 ts_parmsout(void *parmsp, pc_vaparms_t *vaparmsp) 1046 { 1047 return (0); 1048 } 1049 1050 1051 /* 1052 * Copy all selected time-sharing class parameters to the user. 1053 * The parameters are specified by a key. 1054 */ 1055 static int 1056 ts_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp) 1057 { 1058 tsparms_t *tsprmsp = (tsparms_t *)prmsp; 1059 int priflag = 0; 1060 int limflag = 0; 1061 uint_t cnt; 1062 pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; 1063 1064 ASSERT(MUTEX_NOT_HELD(&curproc->p_lock)); 1065 1066 if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) 1067 return (EINVAL); 1068 1069 for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { 1070 1071 switch (vpp->pc_key) { 1072 case TS_KY_UPRILIM: 1073 if (limflag++) 1074 return (EINVAL); 1075 if (copyout(&tsprmsp->ts_uprilim, 1076 (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) 1077 return (EFAULT); 1078 break; 1079 1080 case TS_KY_UPRI: 1081 if (priflag++) 1082 return (EINVAL); 1083 if (copyout(&tsprmsp->ts_upri, 1084 (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) 1085 return (EFAULT); 1086 break; 1087 1088 default: 1089 return (EINVAL); 1090 } 1091 } 1092 1093 return (0); 1094 } 1095 1096 1097 /* 1098 * Copy all selected interactive class parameters to the user. 1099 * The parameters are specified by a key. 1100 */ 1101 static int 1102 ia_vaparmsout(void *prmsp, pc_vaparms_t *vaparmsp) 1103 { 1104 iaparms_t *iaprmsp = (iaparms_t *)prmsp; 1105 int priflag = 0; 1106 int limflag = 0; 1107 int mflag = 0; 1108 uint_t cnt; 1109 pc_vaparm_t *vpp = &vaparmsp->pc_parms[0]; 1110 1111 ASSERT(MUTEX_NOT_HELD(&curproc->p_lock)); 1112 1113 if (vaparmsp->pc_vaparmscnt > PC_VAPARMCNT) 1114 return (EINVAL); 1115 1116 for (cnt = 0; cnt < vaparmsp->pc_vaparmscnt; cnt++, vpp++) { 1117 1118 switch (vpp->pc_key) { 1119 case IA_KY_UPRILIM: 1120 if (limflag++) 1121 return (EINVAL); 1122 if (copyout(&iaprmsp->ia_uprilim, 1123 (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) 1124 return (EFAULT); 1125 break; 1126 1127 case IA_KY_UPRI: 1128 if (priflag++) 1129 return (EINVAL); 1130 if (copyout(&iaprmsp->ia_upri, 1131 (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (pri_t))) 1132 return (EFAULT); 1133 break; 1134 1135 case IA_KY_MODE: 1136 if (mflag++) 1137 return (EINVAL); 1138 if (copyout(&iaprmsp->ia_mode, 1139 (caddr_t)(uintptr_t)vpp->pc_parm, sizeof (int))) 1140 return (EFAULT); 1141 break; 1142 1143 default: 1144 return (EINVAL); 1145 } 1146 } 1147 return (0); 1148 } 1149 1150 1151 /* 1152 * Set the scheduling parameters of the thread pointed to by tsprocp 1153 * to those specified in the buffer pointed to by tsparmsp. 1154 * ts_parmsset() is called for TS threads, and ia_parmsset() is 1155 * called for IA threads. 1156 */ 1157 /* ARGSUSED */ 1158 static int 1159 ts_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp) 1160 { 1161 char nice; 1162 pri_t reqtsuprilim; 1163 pri_t reqtsupri; 1164 tsparms_t *tsparmsp = (tsparms_t *)parmsp; 1165 tsproc_t *tspp = (tsproc_t *)tx->t_cldata; 1166 1167 ASSERT(MUTEX_HELD(&(ttoproc(tx))->p_lock)); 1168 1169 if (tsparmsp->ts_uprilim == TS_NOCHANGE) 1170 reqtsuprilim = tspp->ts_uprilim; 1171 else 1172 reqtsuprilim = tsparmsp->ts_uprilim; 1173 1174 if (tsparmsp->ts_upri == TS_NOCHANGE) 1175 reqtsupri = tspp->ts_upri; 1176 else 1177 reqtsupri = tsparmsp->ts_upri; 1178 1179 /* 1180 * Make sure the user priority doesn't exceed the upri limit. 1181 */ 1182 if (reqtsupri > reqtsuprilim) 1183 reqtsupri = reqtsuprilim; 1184 1185 /* 1186 * Basic permissions enforced by generic kernel code 1187 * for all classes require that a thread attempting 1188 * to change the scheduling parameters of a target 1189 * thread be privileged or have a real or effective 1190 * UID matching that of the target thread. We are not 1191 * called unless these basic permission checks have 1192 * already passed. The time-sharing class requires in 1193 * addition that the calling thread be privileged if it 1194 * is attempting to raise the upri limit above its current 1195 * value This may have been checked previously but if our 1196 * caller passed us a non-NULL credential pointer we assume 1197 * it hasn't and we check it here. 1198 */ 1199 if (reqpcredp != NULL && 1200 reqtsuprilim > tspp->ts_uprilim && 1201 secpolicy_raisepriority(reqpcredp) != 0) 1202 return (EPERM); 1203 1204 /* 1205 * Set ts_nice to the nice value corresponding to the user 1206 * priority we are setting. Note that setting the nice field 1207 * of the parameter struct won't affect upri or nice. 1208 */ 1209 nice = NZERO - (reqtsupri * NZERO) / ts_maxupri; 1210 if (nice >= 2 * NZERO) 1211 nice = 2 * NZERO - 1; 1212 1213 thread_lock(tx); 1214 1215 tspp->ts_uprilim = reqtsuprilim; 1216 tspp->ts_upri = reqtsupri; 1217 TS_NEWUMDPRI(tspp); 1218 tspp->ts_nice = nice; 1219 1220 if ((tspp->ts_flags & TSKPRI) != 0) { 1221 thread_unlock(tx); 1222 return (0); 1223 } 1224 1225 tspp->ts_dispwait = 0; 1226 ts_change_priority(tx, tspp); 1227 thread_unlock(tx); 1228 return (0); 1229 } 1230 1231 1232 static int 1233 ia_parmsset(kthread_t *tx, void *parmsp, id_t reqpcid, cred_t *reqpcredp) 1234 { 1235 tsproc_t *tspp = (tsproc_t *)tx->t_cldata; 1236 iaparms_t *iaparmsp = (iaparms_t *)parmsp; 1237 proc_t *p; 1238 pid_t pid, pgid, sid; 1239 pid_t on, off; 1240 struct stdata *stp; 1241 int sess_held; 1242 1243 /* 1244 * Handle user priority changes 1245 */ 1246 if (iaparmsp->ia_mode == IA_NOCHANGE) 1247 return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp)); 1248 1249 /* 1250 * Check permissions for changing modes. 1251 */ 1252 1253 if (reqpcredp != NULL && !groupmember(IA_gid, reqpcredp) && 1254 secpolicy_raisepriority(reqpcredp) != 0) { 1255 /* 1256 * Silently fail in case this is just a priocntl 1257 * call with upri and uprilim set to IA_NOCHANGE. 1258 */ 1259 return (0); 1260 } 1261 1262 ASSERT(MUTEX_HELD(&pidlock)); 1263 if ((p = ttoproc(tx)) == NULL) { 1264 return (0); 1265 } 1266 ASSERT(MUTEX_HELD(&p->p_lock)); 1267 if (p->p_stat == SIDL) { 1268 return (0); 1269 } 1270 pid = p->p_pid; 1271 sid = p->p_sessp->s_sid; 1272 pgid = p->p_pgrp; 1273 if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) { 1274 /* 1275 * session leaders must be turned on now so all processes 1276 * in the group controlling the tty will be turned on or off. 1277 * if the ia_mode is off for the session leader, 1278 * ia_set_process_group will return without setting the 1279 * processes in the group controlling the tty on. 1280 */ 1281 thread_lock(tx); 1282 tspp->ts_flags |= TSIASET; 1283 thread_unlock(tx); 1284 } 1285 mutex_enter(&p->p_sessp->s_lock); 1286 sess_held = 1; 1287 if ((pid == sid) && (p->p_sessp->s_vp != NULL) && 1288 ((stp = p->p_sessp->s_vp->v_stream) != NULL)) { 1289 if ((stp->sd_pgidp != NULL) && (stp->sd_sidp != NULL)) { 1290 pgid = stp->sd_pgidp->pid_id; 1291 sess_held = 0; 1292 mutex_exit(&p->p_sessp->s_lock); 1293 if (iaparmsp->ia_mode == 1294 IA_SET_INTERACTIVE) { 1295 off = 0; 1296 on = pgid; 1297 } else { 1298 off = pgid; 1299 on = 0; 1300 } 1301 TRACE_3(TR_FAC_IA, TR_ACTIVE_CHAIN, 1302 "active chain:pid %d gid %d %p", 1303 pid, pgid, p); 1304 ia_set_process_group(sid, off, on); 1305 } 1306 } 1307 if (sess_held) 1308 mutex_exit(&p->p_sessp->s_lock); 1309 1310 thread_lock(tx); 1311 1312 if (iaparmsp->ia_mode == IA_SET_INTERACTIVE) { 1313 tspp->ts_flags |= TSIASET; 1314 tspp->ts_boost = ia_boost; 1315 } else { 1316 tspp->ts_flags &= ~TSIASET; 1317 tspp->ts_boost = -ia_boost; 1318 } 1319 thread_unlock(tx); 1320 1321 return (ts_parmsset(tx, parmsp, reqpcid, reqpcredp)); 1322 } 1323 1324 static void 1325 ts_exit(kthread_t *t) 1326 { 1327 tsproc_t *tspp; 1328 1329 if (CPUCAPS_ON()) { 1330 /* 1331 * A thread could be exiting in between clock ticks, 1332 * so we need to calculate how much CPU time it used 1333 * since it was charged last time. 1334 * 1335 * CPU caps are not enforced on exiting processes - it is 1336 * usually desirable to exit as soon as possible to free 1337 * resources. 1338 */ 1339 thread_lock(t); 1340 tspp = (tsproc_t *)t->t_cldata; 1341 (void) cpucaps_charge(t, &tspp->ts_caps, CPUCAPS_CHARGE_ONLY); 1342 thread_unlock(t); 1343 } 1344 } 1345 1346 /* 1347 * Return the global scheduling priority that would be assigned 1348 * to a thread entering the time-sharing class with the ts_upri. 1349 */ 1350 static pri_t 1351 ts_globpri(kthread_t *t) 1352 { 1353 tsproc_t *tspp; 1354 pri_t tspri; 1355 1356 ASSERT(MUTEX_HELD(&ttoproc(t)->p_lock)); 1357 tspp = (tsproc_t *)t->t_cldata; 1358 tspri = tsmedumdpri + tspp->ts_upri; 1359 if (tspri > ts_maxumdpri) 1360 tspri = ts_maxumdpri; 1361 else if (tspri < 0) 1362 tspri = 0; 1363 return (ts_dptbl[tspri].ts_globpri); 1364 } 1365 1366 /* 1367 * Arrange for thread to be placed in appropriate location 1368 * on dispatcher queue. 1369 * 1370 * This is called with the current thread in TS_ONPROC and locked. 1371 */ 1372 static void 1373 ts_preempt(kthread_t *t) 1374 { 1375 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1376 klwp_t *lwp = curthread->t_lwp; 1377 pri_t oldpri = t->t_pri; 1378 1379 ASSERT(t == curthread); 1380 ASSERT(THREAD_LOCK_HELD(curthread)); 1381 1382 /* 1383 * If preempted in the kernel, make sure the thread has 1384 * a kernel priority if needed. 1385 */ 1386 if (!(tspp->ts_flags & TSKPRI) && lwp != NULL && t->t_kpri_req) { 1387 tspp->ts_flags |= TSKPRI; 1388 THREAD_CHANGE_PRI(t, ts_kmdpris[0]); 1389 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 1390 t->t_trapret = 1; /* so ts_trapret will run */ 1391 aston(t); 1392 } 1393 1394 /* 1395 * This thread may be placed on wait queue by CPU Caps. In this case we 1396 * do not need to do anything until it is removed from the wait queue. 1397 * Do not enforce CPU caps on threads running at a kernel priority 1398 */ 1399 if (CPUCAPS_ON()) { 1400 (void) cpucaps_charge(t, &tspp->ts_caps, 1401 CPUCAPS_CHARGE_ENFORCE); 1402 if (!(tspp->ts_flags & TSKPRI) && CPUCAPS_ENFORCE(t)) 1403 return; 1404 } 1405 1406 /* 1407 * If thread got preempted in the user-land then we know 1408 * it isn't holding any locks. Mark it as swappable. 1409 */ 1410 ASSERT(t->t_schedflag & TS_DONT_SWAP); 1411 if (lwp != NULL && lwp->lwp_state == LWP_USER) 1412 t->t_schedflag &= ~TS_DONT_SWAP; 1413 1414 /* 1415 * Check to see if we're doing "preemption control" here. If 1416 * we are, and if the user has requested that this thread not 1417 * be preempted, and if preemptions haven't been put off for 1418 * too long, let the preemption happen here but try to make 1419 * sure the thread is rescheduled as soon as possible. We do 1420 * this by putting it on the front of the highest priority run 1421 * queue in the TS class. If the preemption has been put off 1422 * for too long, clear the "nopreempt" bit and let the thread 1423 * be preempted. 1424 */ 1425 if (t->t_schedctl && schedctl_get_nopreempt(t)) { 1426 if (tspp->ts_timeleft > -SC_MAX_TICKS) { 1427 DTRACE_SCHED1(schedctl__nopreempt, kthread_t *, t); 1428 if (!(tspp->ts_flags & TSKPRI)) { 1429 /* 1430 * If not already remembered, remember current 1431 * priority for restoration in ts_yield(). 1432 */ 1433 if (!(tspp->ts_flags & TSRESTORE)) { 1434 tspp->ts_scpri = t->t_pri; 1435 tspp->ts_flags |= TSRESTORE; 1436 } 1437 THREAD_CHANGE_PRI(t, ts_maxumdpri); 1438 t->t_schedflag |= TS_DONT_SWAP; 1439 } 1440 schedctl_set_yield(t, 1); 1441 setfrontdq(t); 1442 goto done; 1443 } else { 1444 if (tspp->ts_flags & TSRESTORE) { 1445 THREAD_CHANGE_PRI(t, tspp->ts_scpri); 1446 tspp->ts_flags &= ~TSRESTORE; 1447 } 1448 schedctl_set_nopreempt(t, 0); 1449 DTRACE_SCHED1(schedctl__preempt, kthread_t *, t); 1450 TNF_PROBE_2(schedctl_preempt, "schedctl TS ts_preempt", 1451 /* CSTYLED */, tnf_pid, pid, ttoproc(t)->p_pid, 1452 tnf_lwpid, lwpid, t->t_tid); 1453 /* 1454 * Fall through and be preempted below. 1455 */ 1456 } 1457 } 1458 1459 if ((tspp->ts_flags & (TSBACKQ|TSKPRI)) == TSBACKQ) { 1460 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 1461 tspp->ts_dispwait = 0; 1462 tspp->ts_flags &= ~TSBACKQ; 1463 setbackdq(t); 1464 } else if ((tspp->ts_flags & (TSBACKQ|TSKPRI)) == (TSBACKQ|TSKPRI)) { 1465 tspp->ts_flags &= ~TSBACKQ; 1466 setbackdq(t); 1467 } else { 1468 setfrontdq(t); 1469 } 1470 1471 done: 1472 TRACE_2(TR_FAC_DISP, TR_PREEMPT, 1473 "preempt:tid %p old pri %d", t, oldpri); 1474 } 1475 1476 static void 1477 ts_setrun(kthread_t *t) 1478 { 1479 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1480 1481 ASSERT(THREAD_LOCK_HELD(t)); /* t should be in transition */ 1482 1483 if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) { 1484 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret; 1485 TS_NEWUMDPRI(tspp); 1486 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 1487 tspp->ts_dispwait = 0; 1488 if ((tspp->ts_flags & TSKPRI) == 0) { 1489 THREAD_CHANGE_PRI(t, 1490 ts_dptbl[tspp->ts_umdpri].ts_globpri); 1491 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 1492 } 1493 } 1494 1495 tspp->ts_flags &= ~TSBACKQ; 1496 1497 if (tspp->ts_flags & TSIA) { 1498 if (tspp->ts_flags & TSIASET) 1499 setfrontdq(t); 1500 else 1501 setbackdq(t); 1502 } else { 1503 if (t->t_disp_time != ddi_get_lbolt()) 1504 setbackdq(t); 1505 else 1506 setfrontdq(t); 1507 } 1508 } 1509 1510 1511 /* 1512 * Prepare thread for sleep. We reset the thread priority so it will 1513 * run at the kernel priority level when it wakes up. 1514 */ 1515 static void 1516 ts_sleep(kthread_t *t) 1517 { 1518 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1519 int flags; 1520 pri_t old_pri = t->t_pri; 1521 1522 ASSERT(t == curthread); 1523 ASSERT(THREAD_LOCK_HELD(t)); 1524 1525 /* 1526 * Account for time spent on CPU before going to sleep. 1527 */ 1528 (void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE); 1529 1530 flags = tspp->ts_flags; 1531 if (t->t_kpri_req) { 1532 tspp->ts_flags = flags | TSKPRI; 1533 THREAD_CHANGE_PRI(t, ts_kmdpris[0]); 1534 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 1535 t->t_trapret = 1; /* so ts_trapret will run */ 1536 aston(t); 1537 } else if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) { 1538 /* 1539 * If thread has blocked in the kernel (as opposed to 1540 * being merely preempted), recompute the user mode priority. 1541 */ 1542 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret; 1543 TS_NEWUMDPRI(tspp); 1544 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 1545 tspp->ts_dispwait = 0; 1546 1547 THREAD_CHANGE_PRI(curthread, 1548 ts_dptbl[tspp->ts_umdpri].ts_globpri); 1549 ASSERT(curthread->t_pri >= 0 && 1550 curthread->t_pri <= ts_maxglobpri); 1551 tspp->ts_flags = flags & ~TSKPRI; 1552 1553 if (DISP_MUST_SURRENDER(curthread)) 1554 cpu_surrender(curthread); 1555 } else if (flags & TSKPRI) { 1556 THREAD_CHANGE_PRI(curthread, 1557 ts_dptbl[tspp->ts_umdpri].ts_globpri); 1558 ASSERT(curthread->t_pri >= 0 && 1559 curthread->t_pri <= ts_maxglobpri); 1560 tspp->ts_flags = flags & ~TSKPRI; 1561 1562 if (DISP_MUST_SURRENDER(curthread)) 1563 cpu_surrender(curthread); 1564 } 1565 t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */ 1566 TRACE_2(TR_FAC_DISP, TR_SLEEP, 1567 "sleep:tid %p old pri %d", t, old_pri); 1568 } 1569 1570 1571 /* 1572 * Return Values: 1573 * 1574 * -1 if the thread is loaded or is not eligible to be swapped in. 1575 * 1576 * effective priority of the specified thread based on swapout time 1577 * and size of process (epri >= 0 , epri <= SHRT_MAX). 1578 */ 1579 /* ARGSUSED */ 1580 static pri_t 1581 ts_swapin(kthread_t *t, int flags) 1582 { 1583 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1584 long epri = -1; 1585 proc_t *pp = ttoproc(t); 1586 1587 ASSERT(THREAD_LOCK_HELD(t)); 1588 1589 /* 1590 * We know that pri_t is a short. 1591 * Be sure not to overrun its range. 1592 */ 1593 if (t->t_state == TS_RUN && (t->t_schedflag & TS_LOAD) == 0) { 1594 time_t swapout_time; 1595 1596 swapout_time = (ddi_get_lbolt() - t->t_stime) / hz; 1597 if (INHERITED(t) || (tspp->ts_flags & (TSKPRI | TSIASET))) 1598 epri = (long)DISP_PRIO(t) + swapout_time; 1599 else { 1600 /* 1601 * Threads which have been out for a long time, 1602 * have high user mode priority and are associated 1603 * with a small address space are more deserving 1604 */ 1605 epri = ts_dptbl[tspp->ts_umdpri].ts_globpri; 1606 ASSERT(epri >= 0 && epri <= ts_maxumdpri); 1607 epri += swapout_time - pp->p_swrss / nz(maxpgio)/2; 1608 } 1609 /* 1610 * Scale epri so SHRT_MAX/2 represents zero priority. 1611 */ 1612 epri += SHRT_MAX/2; 1613 if (epri < 0) 1614 epri = 0; 1615 else if (epri > SHRT_MAX) 1616 epri = SHRT_MAX; 1617 } 1618 return ((pri_t)epri); 1619 } 1620 1621 /* 1622 * Return Values 1623 * -1 if the thread isn't loaded or is not eligible to be swapped out. 1624 * 1625 * effective priority of the specified thread based on if the swapper 1626 * is in softswap or hardswap mode. 1627 * 1628 * Softswap: Return a low effective priority for threads 1629 * sleeping for more than maxslp secs. 1630 * 1631 * Hardswap: Return an effective priority such that threads 1632 * which have been in memory for a while and are 1633 * associated with a small address space are swapped 1634 * in before others. 1635 * 1636 * (epri >= 0 , epri <= SHRT_MAX). 1637 */ 1638 time_t ts_minrun = 2; /* XXX - t_pri becomes 59 within 2 secs */ 1639 time_t ts_minslp = 2; /* min time on sleep queue for hardswap */ 1640 1641 static pri_t 1642 ts_swapout(kthread_t *t, int flags) 1643 { 1644 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1645 long epri = -1; 1646 proc_t *pp = ttoproc(t); 1647 time_t swapin_time; 1648 1649 ASSERT(THREAD_LOCK_HELD(t)); 1650 1651 if (INHERITED(t) || (tspp->ts_flags & (TSKPRI | TSIASET)) || 1652 (t->t_proc_flag & TP_LWPEXIT) || 1653 (t->t_state & (TS_ZOMB | TS_FREE | TS_STOPPED | 1654 TS_ONPROC | TS_WAIT)) || 1655 !(t->t_schedflag & TS_LOAD) || !SWAP_OK(t)) 1656 return (-1); 1657 1658 ASSERT(t->t_state & (TS_SLEEP | TS_RUN)); 1659 1660 /* 1661 * We know that pri_t is a short. 1662 * Be sure not to overrun its range. 1663 */ 1664 swapin_time = (ddi_get_lbolt() - t->t_stime) / hz; 1665 if (flags == SOFTSWAP) { 1666 if (t->t_state == TS_SLEEP && swapin_time > maxslp) { 1667 epri = 0; 1668 } else { 1669 return ((pri_t)epri); 1670 } 1671 } else { 1672 pri_t pri; 1673 1674 if ((t->t_state == TS_SLEEP && swapin_time > ts_minslp) || 1675 (t->t_state == TS_RUN && swapin_time > ts_minrun)) { 1676 pri = ts_dptbl[tspp->ts_umdpri].ts_globpri; 1677 ASSERT(pri >= 0 && pri <= ts_maxumdpri); 1678 epri = swapin_time - 1679 (rm_asrss(pp->p_as) / nz(maxpgio)/2) - (long)pri; 1680 } else { 1681 return ((pri_t)epri); 1682 } 1683 } 1684 1685 /* 1686 * Scale epri so SHRT_MAX/2 represents zero priority. 1687 */ 1688 epri += SHRT_MAX/2; 1689 if (epri < 0) 1690 epri = 0; 1691 else if (epri > SHRT_MAX) 1692 epri = SHRT_MAX; 1693 1694 return ((pri_t)epri); 1695 } 1696 1697 /* 1698 * Check for time slice expiration. If time slice has expired 1699 * move thread to priority specified in tsdptbl for time slice expiration 1700 * and set runrun to cause preemption. 1701 */ 1702 static void 1703 ts_tick(kthread_t *t) 1704 { 1705 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1706 klwp_t *lwp; 1707 boolean_t call_cpu_surrender = B_FALSE; 1708 pri_t oldpri = t->t_pri; 1709 1710 ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock)); 1711 1712 thread_lock(t); 1713 1714 /* 1715 * Keep track of thread's project CPU usage. Note that projects 1716 * get charged even when threads are running in the kernel. 1717 */ 1718 if (CPUCAPS_ON()) { 1719 call_cpu_surrender = cpucaps_charge(t, &tspp->ts_caps, 1720 CPUCAPS_CHARGE_ENFORCE) && !(tspp->ts_flags & TSKPRI); 1721 } 1722 1723 if ((tspp->ts_flags & TSKPRI) == 0) { 1724 if (--tspp->ts_timeleft <= 0) { 1725 pri_t new_pri; 1726 1727 /* 1728 * If we're doing preemption control and trying to 1729 * avoid preempting this thread, just note that 1730 * the thread should yield soon and let it keep 1731 * running (unless it's been a while). 1732 */ 1733 if (t->t_schedctl && schedctl_get_nopreempt(t)) { 1734 if (tspp->ts_timeleft > -SC_MAX_TICKS) { 1735 DTRACE_SCHED1(schedctl__nopreempt, 1736 kthread_t *, t); 1737 schedctl_set_yield(t, 1); 1738 thread_unlock_nopreempt(t); 1739 return; 1740 } 1741 1742 TNF_PROBE_2(schedctl_failsafe, 1743 "schedctl TS ts_tick", /* CSTYLED */, 1744 tnf_pid, pid, ttoproc(t)->p_pid, 1745 tnf_lwpid, lwpid, t->t_tid); 1746 } 1747 tspp->ts_flags &= ~TSRESTORE; 1748 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp; 1749 TS_NEWUMDPRI(tspp); 1750 tspp->ts_dispwait = 0; 1751 new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri; 1752 ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri); 1753 /* 1754 * When the priority of a thread is changed, 1755 * it may be necessary to adjust its position 1756 * on a sleep queue or dispatch queue. 1757 * The function thread_change_pri accomplishes 1758 * this. 1759 */ 1760 if (thread_change_pri(t, new_pri, 0)) { 1761 if ((t->t_schedflag & TS_LOAD) && 1762 (lwp = t->t_lwp) && 1763 lwp->lwp_state == LWP_USER) 1764 t->t_schedflag &= ~TS_DONT_SWAP; 1765 tspp->ts_timeleft = 1766 ts_dptbl[tspp->ts_cpupri].ts_quantum; 1767 } else { 1768 call_cpu_surrender = B_TRUE; 1769 } 1770 TRACE_2(TR_FAC_DISP, TR_TICK, 1771 "tick:tid %p old pri %d", t, oldpri); 1772 } else if (t->t_state == TS_ONPROC && 1773 t->t_pri < t->t_disp_queue->disp_maxrunpri) { 1774 call_cpu_surrender = B_TRUE; 1775 } 1776 } 1777 1778 if (call_cpu_surrender) { 1779 tspp->ts_flags |= TSBACKQ; 1780 cpu_surrender(t); 1781 } 1782 1783 thread_unlock_nopreempt(t); /* clock thread can't be preempted */ 1784 } 1785 1786 1787 /* 1788 * If thread is currently at a kernel mode priority (has slept) 1789 * we assign it the appropriate user mode priority and time quantum 1790 * here. If we are lowering the thread's priority below that of 1791 * other runnable threads we will normally set runrun via cpu_surrender() to 1792 * cause preemption. 1793 */ 1794 static void 1795 ts_trapret(kthread_t *t) 1796 { 1797 tsproc_t *tspp = (tsproc_t *)t->t_cldata; 1798 cpu_t *cp = CPU; 1799 pri_t old_pri = curthread->t_pri; 1800 1801 ASSERT(THREAD_LOCK_HELD(t)); 1802 ASSERT(t == curthread); 1803 ASSERT(cp->cpu_dispthread == t); 1804 ASSERT(t->t_state == TS_ONPROC); 1805 1806 t->t_kpri_req = 0; 1807 if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) { 1808 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret; 1809 TS_NEWUMDPRI(tspp); 1810 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 1811 tspp->ts_dispwait = 0; 1812 1813 /* 1814 * If thread has blocked in the kernel (as opposed to 1815 * being merely preempted), recompute the user mode priority. 1816 */ 1817 THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri); 1818 cp->cpu_dispatch_pri = DISP_PRIO(t); 1819 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 1820 tspp->ts_flags &= ~TSKPRI; 1821 1822 if (DISP_MUST_SURRENDER(t)) 1823 cpu_surrender(t); 1824 } else if (tspp->ts_flags & TSKPRI) { 1825 /* 1826 * If thread has blocked in the kernel (as opposed to 1827 * being merely preempted), recompute the user mode priority. 1828 */ 1829 THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri); 1830 cp->cpu_dispatch_pri = DISP_PRIO(t); 1831 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 1832 tspp->ts_flags &= ~TSKPRI; 1833 1834 if (DISP_MUST_SURRENDER(t)) 1835 cpu_surrender(t); 1836 } 1837 1838 /* 1839 * Swapout lwp if the swapper is waiting for this thread to 1840 * reach a safe point. 1841 */ 1842 if ((t->t_schedflag & TS_SWAPENQ) && !(tspp->ts_flags & TSIASET)) { 1843 thread_unlock(t); 1844 swapout_lwp(ttolwp(t)); 1845 thread_lock(t); 1846 } 1847 1848 TRACE_2(TR_FAC_DISP, TR_TRAPRET, 1849 "trapret:tid %p old pri %d", t, old_pri); 1850 } 1851 1852 1853 /* 1854 * Update the ts_dispwait values of all time sharing threads that 1855 * are currently runnable at a user mode priority and bump the priority 1856 * if ts_dispwait exceeds ts_maxwait. Called once per second via 1857 * timeout which we reset here. 1858 * 1859 * There are several lists of time sharing threads broken up by a hash on 1860 * the thread pointer. Each list has its own lock. This avoids blocking 1861 * all ts_enterclass, ts_fork, and ts_exitclass operations while ts_update 1862 * runs. ts_update traverses each list in turn. 1863 * 1864 * If multiple threads have their priorities updated to the same value, 1865 * the system implicitly favors the one that is updated first (since it 1866 * winds up first on the run queue). To avoid this unfairness, the 1867 * traversal of threads starts at the list indicated by a marker. When 1868 * threads in more than one list have their priorities updated, the marker 1869 * is moved. This changes the order the threads will be placed on the run 1870 * queue the next time ts_update is called and preserves fairness over the 1871 * long run. The marker doesn't need to be protected by a lock since it's 1872 * only accessed by ts_update, which is inherently single-threaded (only 1873 * one instance can be running at a time). 1874 */ 1875 static void 1876 ts_update(void *arg) 1877 { 1878 int i; 1879 int new_marker = -1; 1880 static int ts_update_marker; 1881 1882 /* 1883 * Start with the ts_update_marker list, then do the rest. 1884 */ 1885 i = ts_update_marker; 1886 do { 1887 /* 1888 * If this is the first list after the current marker to 1889 * have threads with priorities updated, advance the marker 1890 * to this list for the next time ts_update runs. 1891 */ 1892 if (ts_update_list(i) && new_marker == -1 && 1893 i != ts_update_marker) { 1894 new_marker = i; 1895 } 1896 } while ((i = TS_LIST_NEXT(i)) != ts_update_marker); 1897 1898 /* advance marker for next ts_update call */ 1899 if (new_marker != -1) 1900 ts_update_marker = new_marker; 1901 1902 (void) timeout(ts_update, arg, hz); 1903 } 1904 1905 /* 1906 * Updates priority for a list of threads. Returns 1 if the priority of 1907 * one of the threads was actually updated, 0 if none were for various 1908 * reasons (thread is no longer in the TS or IA class, isn't runnable, 1909 * hasn't waited long enough, has the preemption control no-preempt bit 1910 * set, etc.) 1911 */ 1912 static int 1913 ts_update_list(int i) 1914 { 1915 tsproc_t *tspp; 1916 kthread_t *tx; 1917 int updated = 0; 1918 1919 mutex_enter(&ts_list_lock[i]); 1920 for (tspp = ts_plisthead[i].ts_next; tspp != &ts_plisthead[i]; 1921 tspp = tspp->ts_next) { 1922 tx = tspp->ts_tp; 1923 /* 1924 * Lock the thread and verify state. 1925 */ 1926 thread_lock(tx); 1927 /* 1928 * Skip the thread if it is no longer in the TS (or IA) class. 1929 */ 1930 if (tx->t_clfuncs != &ts_classfuncs.thread && 1931 tx->t_clfuncs != &ia_classfuncs.thread) 1932 goto next; 1933 tspp->ts_dispwait++; 1934 if ((tspp->ts_flags & TSKPRI) != 0) 1935 goto next; 1936 if (tspp->ts_dispwait <= ts_dptbl[tspp->ts_umdpri].ts_maxwait) 1937 goto next; 1938 if (tx->t_schedctl && schedctl_get_nopreempt(tx)) 1939 goto next; 1940 if (tx->t_state != TS_RUN && tx->t_state != TS_WAIT && 1941 (tx->t_state != TS_SLEEP || !ts_sleep_promote)) { 1942 /* make next syscall/trap do CL_TRAPRET */ 1943 tx->t_trapret = 1; 1944 aston(tx); 1945 goto next; 1946 } 1947 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_lwait; 1948 TS_NEWUMDPRI(tspp); 1949 tspp->ts_dispwait = 0; 1950 updated = 1; 1951 1952 /* 1953 * Only dequeue it if needs to move; otherwise it should 1954 * just round-robin here. 1955 */ 1956 if (tx->t_pri != ts_dptbl[tspp->ts_umdpri].ts_globpri) { 1957 pri_t oldpri = tx->t_pri; 1958 ts_change_priority(tx, tspp); 1959 TRACE_2(TR_FAC_DISP, TR_UPDATE, 1960 "update:tid %p old pri %d", tx, oldpri); 1961 } 1962 next: 1963 thread_unlock(tx); 1964 } 1965 mutex_exit(&ts_list_lock[i]); 1966 1967 return (updated); 1968 } 1969 1970 /* 1971 * Processes waking up go to the back of their queue. We don't 1972 * need to assign a time quantum here because thread is still 1973 * at a kernel mode priority and the time slicing is not done 1974 * for threads running in the kernel after sleeping. The proper 1975 * time quantum will be assigned by ts_trapret before the thread 1976 * returns to user mode. 1977 */ 1978 static void 1979 ts_wakeup(kthread_t *t) 1980 { 1981 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 1982 1983 ASSERT(THREAD_LOCK_HELD(t)); 1984 1985 t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */ 1986 1987 if (tspp->ts_flags & TSKPRI) { 1988 tspp->ts_flags &= ~TSBACKQ; 1989 if (tspp->ts_flags & TSIASET) 1990 setfrontdq(t); 1991 else 1992 setbackdq(t); 1993 } else if (t->t_kpri_req) { 1994 /* 1995 * Give thread a priority boost if we were asked. 1996 */ 1997 tspp->ts_flags |= TSKPRI; 1998 THREAD_CHANGE_PRI(t, ts_kmdpris[0]); 1999 setbackdq(t); 2000 t->t_trapret = 1; /* so that ts_trapret will run */ 2001 aston(t); 2002 } else { 2003 if (tspp->ts_dispwait > ts_dptbl[tspp->ts_umdpri].ts_maxwait) { 2004 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_slpret; 2005 TS_NEWUMDPRI(tspp); 2006 tspp->ts_timeleft = 2007 ts_dptbl[tspp->ts_cpupri].ts_quantum; 2008 tspp->ts_dispwait = 0; 2009 THREAD_CHANGE_PRI(t, 2010 ts_dptbl[tspp->ts_umdpri].ts_globpri); 2011 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 2012 } 2013 2014 tspp->ts_flags &= ~TSBACKQ; 2015 2016 if (tspp->ts_flags & TSIA) { 2017 if (tspp->ts_flags & TSIASET) 2018 setfrontdq(t); 2019 else 2020 setbackdq(t); 2021 } else { 2022 if (t->t_disp_time != ddi_get_lbolt()) 2023 setbackdq(t); 2024 else 2025 setfrontdq(t); 2026 } 2027 } 2028 } 2029 2030 2031 /* 2032 * When a thread yields, put it on the back of the run queue. 2033 */ 2034 static void 2035 ts_yield(kthread_t *t) 2036 { 2037 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 2038 2039 ASSERT(t == curthread); 2040 ASSERT(THREAD_LOCK_HELD(t)); 2041 2042 /* 2043 * Collect CPU usage spent before yielding 2044 */ 2045 (void) CPUCAPS_CHARGE(t, &tspp->ts_caps, CPUCAPS_CHARGE_ENFORCE); 2046 2047 /* 2048 * Clear the preemption control "yield" bit since the user is 2049 * doing a yield. 2050 */ 2051 if (t->t_schedctl) 2052 schedctl_set_yield(t, 0); 2053 /* 2054 * If ts_preempt() artifically increased the thread's priority 2055 * to avoid preemption, restore the original priority now. 2056 */ 2057 if (tspp->ts_flags & TSRESTORE) { 2058 THREAD_CHANGE_PRI(t, tspp->ts_scpri); 2059 tspp->ts_flags &= ~TSRESTORE; 2060 } 2061 if (tspp->ts_timeleft <= 0) { 2062 /* 2063 * Time slice was artificially extended to avoid 2064 * preemption, so pretend we're preempting it now. 2065 */ 2066 DTRACE_SCHED1(schedctl__yield, int, -tspp->ts_timeleft); 2067 tspp->ts_cpupri = ts_dptbl[tspp->ts_cpupri].ts_tqexp; 2068 TS_NEWUMDPRI(tspp); 2069 tspp->ts_timeleft = ts_dptbl[tspp->ts_cpupri].ts_quantum; 2070 tspp->ts_dispwait = 0; 2071 THREAD_CHANGE_PRI(t, ts_dptbl[tspp->ts_umdpri].ts_globpri); 2072 ASSERT(t->t_pri >= 0 && t->t_pri <= ts_maxglobpri); 2073 } 2074 tspp->ts_flags &= ~TSBACKQ; 2075 setbackdq(t); 2076 } 2077 2078 2079 /* 2080 * Increment the nice value of the specified thread by incr and 2081 * return the new value in *retvalp. 2082 */ 2083 static int 2084 ts_donice(kthread_t *t, cred_t *cr, int incr, int *retvalp) 2085 { 2086 int newnice; 2087 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 2088 tsparms_t tsparms; 2089 2090 ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock)); 2091 2092 /* If there's no change to priority, just return current setting */ 2093 if (incr == 0) { 2094 if (retvalp) { 2095 *retvalp = tspp->ts_nice - NZERO; 2096 } 2097 return (0); 2098 } 2099 2100 if ((incr < 0 || incr > 2 * NZERO) && 2101 secpolicy_raisepriority(cr) != 0) 2102 return (EPERM); 2103 2104 /* 2105 * Specifying a nice increment greater than the upper limit of 2106 * 2 * NZERO - 1 will result in the thread's nice value being 2107 * set to the upper limit. We check for this before computing 2108 * the new value because otherwise we could get overflow 2109 * if a privileged process specified some ridiculous increment. 2110 */ 2111 if (incr > 2 * NZERO - 1) 2112 incr = 2 * NZERO - 1; 2113 2114 newnice = tspp->ts_nice + incr; 2115 if (newnice >= 2 * NZERO) 2116 newnice = 2 * NZERO - 1; 2117 else if (newnice < 0) 2118 newnice = 0; 2119 2120 tsparms.ts_uprilim = tsparms.ts_upri = 2121 -((newnice - NZERO) * ts_maxupri) / NZERO; 2122 /* 2123 * Reset the uprilim and upri values of the thread. 2124 * Call ts_parmsset even if thread is interactive since we're 2125 * not changing mode. 2126 */ 2127 (void) ts_parmsset(t, (void *)&tsparms, (id_t)0, (cred_t *)NULL); 2128 2129 /* 2130 * Although ts_parmsset already reset ts_nice it may 2131 * not have been set to precisely the value calculated above 2132 * because ts_parmsset determines the nice value from the 2133 * user priority and we may have truncated during the integer 2134 * conversion from nice value to user priority and back. 2135 * We reset ts_nice to the value we calculated above. 2136 */ 2137 tspp->ts_nice = (char)newnice; 2138 2139 if (retvalp) 2140 *retvalp = newnice - NZERO; 2141 return (0); 2142 } 2143 2144 /* 2145 * Increment the priority of the specified thread by incr and 2146 * return the new value in *retvalp. 2147 */ 2148 static int 2149 ts_doprio(kthread_t *t, cred_t *cr, int incr, int *retvalp) 2150 { 2151 int newpri; 2152 tsproc_t *tspp = (tsproc_t *)(t->t_cldata); 2153 tsparms_t tsparms; 2154 2155 ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock)); 2156 2157 /* If there's no change to the priority, just return current setting */ 2158 if (incr == 0) { 2159 *retvalp = tspp->ts_upri; 2160 return (0); 2161 } 2162 2163 newpri = tspp->ts_upri + incr; 2164 if (newpri > ts_maxupri || newpri < -ts_maxupri) 2165 return (EINVAL); 2166 2167 *retvalp = newpri; 2168 tsparms.ts_uprilim = tsparms.ts_upri = newpri; 2169 /* 2170 * Reset the uprilim and upri values of the thread. 2171 * Call ts_parmsset even if thread is interactive since we're 2172 * not changing mode. 2173 */ 2174 return (ts_parmsset(t, &tsparms, 0, cr)); 2175 } 2176 2177 /* 2178 * ia_set_process_group marks foreground processes as interactive 2179 * and background processes as non-interactive iff the session 2180 * leader is interactive. This routine is called from two places: 2181 * strioctl:SPGRP when a new process group gets 2182 * control of the tty. 2183 * ia_parmsset-when the process in question is a session leader. 2184 * ia_set_process_group assumes that pidlock is held by the caller, 2185 * either strioctl or priocntlsys. If the caller is priocntlsys 2186 * (via ia_parmsset) then the p_lock of the session leader is held 2187 * and the code needs to be careful about acquiring other p_locks. 2188 */ 2189 static void 2190 ia_set_process_group(pid_t sid, pid_t bg_pgid, pid_t fg_pgid) 2191 { 2192 proc_t *leader, *fg, *bg; 2193 tsproc_t *tspp; 2194 kthread_t *tx; 2195 int plocked = 0; 2196 2197 ASSERT(MUTEX_HELD(&pidlock)); 2198 2199 /* 2200 * see if the session leader is interactive AND 2201 * if it is currently "on" AND controlling a tty 2202 * iff it is then make the processes in the foreground 2203 * group interactive and the processes in the background 2204 * group non-interactive. 2205 */ 2206 if ((leader = (proc_t *)prfind(sid)) == NULL) { 2207 return; 2208 } 2209 if (leader->p_stat == SIDL) { 2210 return; 2211 } 2212 if ((tx = proctot(leader)) == NULL) { 2213 return; 2214 } 2215 /* 2216 * XXX do all the threads in the leader 2217 */ 2218 if (tx->t_cid != ia_cid) { 2219 return; 2220 } 2221 tspp = tx->t_cldata; 2222 /* 2223 * session leaders that are not interactive need not have 2224 * any processing done for them. They are typically shells 2225 * that do not have focus and are changing the process group 2226 * attatched to the tty, e.g. a process that is exiting 2227 */ 2228 mutex_enter(&leader->p_sessp->s_lock); 2229 if (!(tspp->ts_flags & TSIASET) || 2230 (leader->p_sessp->s_vp == NULL) || 2231 (leader->p_sessp->s_vp->v_stream == NULL)) { 2232 mutex_exit(&leader->p_sessp->s_lock); 2233 return; 2234 } 2235 mutex_exit(&leader->p_sessp->s_lock); 2236 2237 /* 2238 * If we're already holding the leader's p_lock, we should use 2239 * mutex_tryenter instead of mutex_enter to avoid deadlocks from 2240 * lock ordering violations. 2241 */ 2242 if (mutex_owned(&leader->p_lock)) 2243 plocked = 1; 2244 2245 if (fg_pgid == 0) 2246 goto skip; 2247 /* 2248 * now look for all processes in the foreground group and 2249 * make them interactive 2250 */ 2251 for (fg = (proc_t *)pgfind(fg_pgid); fg != NULL; fg = fg->p_pglink) { 2252 /* 2253 * if the process is SIDL it's begin forked, ignore it 2254 */ 2255 if (fg->p_stat == SIDL) { 2256 continue; 2257 } 2258 /* 2259 * sesssion leaders must be turned on/off explicitly 2260 * not implicitly as happens to other members of 2261 * the process group. 2262 */ 2263 if (fg->p_pid == fg->p_sessp->s_sid) { 2264 continue; 2265 } 2266 2267 TRACE_1(TR_FAC_IA, TR_GROUP_ON, 2268 "group on:proc %p", fg); 2269 2270 if (plocked) { 2271 if (mutex_tryenter(&fg->p_lock) == 0) 2272 continue; 2273 } else { 2274 mutex_enter(&fg->p_lock); 2275 } 2276 2277 if ((tx = proctot(fg)) == NULL) { 2278 mutex_exit(&fg->p_lock); 2279 continue; 2280 } 2281 do { 2282 thread_lock(tx); 2283 /* 2284 * if this thread is not interactive continue 2285 */ 2286 if (tx->t_cid != ia_cid) { 2287 thread_unlock(tx); 2288 continue; 2289 } 2290 tspp = tx->t_cldata; 2291 tspp->ts_flags |= TSIASET; 2292 tspp->ts_boost = ia_boost; 2293 TS_NEWUMDPRI(tspp); 2294 if ((tspp->ts_flags & TSKPRI) != 0) { 2295 thread_unlock(tx); 2296 continue; 2297 } 2298 tspp->ts_dispwait = 0; 2299 ts_change_priority(tx, tspp); 2300 thread_unlock(tx); 2301 } while ((tx = tx->t_forw) != fg->p_tlist); 2302 mutex_exit(&fg->p_lock); 2303 } 2304 skip: 2305 if (bg_pgid == 0) 2306 return; 2307 for (bg = (proc_t *)pgfind(bg_pgid); bg != NULL; bg = bg->p_pglink) { 2308 if (bg->p_stat == SIDL) { 2309 continue; 2310 } 2311 /* 2312 * sesssion leaders must be turned off explicitly 2313 * not implicitly as happens to other members of 2314 * the process group. 2315 */ 2316 if (bg->p_pid == bg->p_sessp->s_sid) { 2317 continue; 2318 } 2319 2320 TRACE_1(TR_FAC_IA, TR_GROUP_OFF, 2321 "group off:proc %p", bg); 2322 2323 if (plocked) { 2324 if (mutex_tryenter(&bg->p_lock) == 0) 2325 continue; 2326 } else { 2327 mutex_enter(&bg->p_lock); 2328 } 2329 2330 if ((tx = proctot(bg)) == NULL) { 2331 mutex_exit(&bg->p_lock); 2332 continue; 2333 } 2334 do { 2335 thread_lock(tx); 2336 /* 2337 * if this thread is not interactive continue 2338 */ 2339 if (tx->t_cid != ia_cid) { 2340 thread_unlock(tx); 2341 continue; 2342 } 2343 tspp = tx->t_cldata; 2344 tspp->ts_flags &= ~TSIASET; 2345 tspp->ts_boost = -ia_boost; 2346 TS_NEWUMDPRI(tspp); 2347 if ((tspp->ts_flags & TSKPRI) != 0) { 2348 thread_unlock(tx); 2349 continue; 2350 } 2351 2352 tspp->ts_dispwait = 0; 2353 ts_change_priority(tx, tspp); 2354 thread_unlock(tx); 2355 } while ((tx = tx->t_forw) != bg->p_tlist); 2356 mutex_exit(&bg->p_lock); 2357 } 2358 } 2359 2360 2361 static void 2362 ts_change_priority(kthread_t *t, tsproc_t *tspp) 2363 { 2364 pri_t new_pri; 2365 2366 ASSERT(THREAD_LOCK_HELD(t)); 2367 new_pri = ts_dptbl[tspp->ts_umdpri].ts_globpri; 2368 ASSERT(new_pri >= 0 && new_pri <= ts_maxglobpri); 2369 tspp->ts_flags &= ~TSRESTORE; 2370 t->t_cpri = tspp->ts_upri; 2371 if (t == curthread || t->t_state == TS_ONPROC) { 2372 /* curthread is always onproc */ 2373 cpu_t *cp = t->t_disp_queue->disp_cpu; 2374 THREAD_CHANGE_PRI(t, new_pri); 2375 if (t == cp->cpu_dispthread) 2376 cp->cpu_dispatch_pri = DISP_PRIO(t); 2377 if (DISP_MUST_SURRENDER(t)) { 2378 tspp->ts_flags |= TSBACKQ; 2379 cpu_surrender(t); 2380 } else { 2381 tspp->ts_timeleft = 2382 ts_dptbl[tspp->ts_cpupri].ts_quantum; 2383 } 2384 } else { 2385 int frontq; 2386 2387 frontq = (tspp->ts_flags & TSIASET) != 0; 2388 /* 2389 * When the priority of a thread is changed, 2390 * it may be necessary to adjust its position 2391 * on a sleep queue or dispatch queue. 2392 * The function thread_change_pri accomplishes 2393 * this. 2394 */ 2395 if (thread_change_pri(t, new_pri, frontq)) { 2396 /* 2397 * The thread was on a run queue. Reset 2398 * its CPU timeleft from the quantum 2399 * associated with the new priority. 2400 */ 2401 tspp->ts_timeleft = 2402 ts_dptbl[tspp->ts_cpupri].ts_quantum; 2403 } else { 2404 tspp->ts_flags |= TSBACKQ; 2405 } 2406 } 2407 } 2408 2409 static int 2410 ts_alloc(void **p, int flag) 2411 { 2412 void *bufp; 2413 bufp = kmem_alloc(sizeof (tsproc_t), flag); 2414 if (bufp == NULL) { 2415 return (ENOMEM); 2416 } else { 2417 *p = bufp; 2418 return (0); 2419 } 2420 } 2421 2422 static void 2423 ts_free(void *bufp) 2424 { 2425 if (bufp) 2426 kmem_free(bufp, sizeof (tsproc_t)); 2427 }