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.
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.
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]
22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
25 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
28 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
29 /* All Rights Reserved */
35 #include <sys/priocntl.h>
36 #include <sys/thread.h>
37 #include <sys/class.h>
44 * The following is the format of a dispatcher queue entry.
46 typedef struct dispq
{
47 kthread_t
*dq_first
; /* first thread on queue or NULL */
48 kthread_t
*dq_last
; /* last thread on queue or NULL */
49 int dq_sruncnt
; /* number of loaded, runnable */
50 /* threads on queue */
54 * Dispatch queue structure.
56 typedef struct _disp
{
57 disp_lock_t disp_lock
; /* protects dispatching fields */
58 pri_t disp_npri
; /* # of priority levels in queue */
59 dispq_t
*disp_q
; /* the dispatch queue */
60 dispq_t
*disp_q_limit
; /* ptr past end of dispatch queue */
61 ulong_t
*disp_qactmap
; /* bitmap of active dispatch queues */
65 * disp_maxrunpri is the maximum run priority of runnable threads
66 * on this queue. It is -1 if nothing is runnable.
68 * disp_max_unbound_pri is the maximum run priority of threads on
69 * this dispatch queue but runnable by any CPU. This may be left
70 * artificially high, then corrected when some CPU tries to take
71 * an unbound thread. It is -1 if nothing is runnable.
73 pri_t disp_maxrunpri
; /* maximum run priority */
74 pri_t disp_max_unbound_pri
; /* max pri of unbound threads */
76 volatile int disp_nrunnable
; /* runnable threads in cpu dispq */
78 struct cpu
*disp_cpu
; /* cpu owning this queue or NULL */
79 hrtime_t disp_steal
; /* time when threads become stealable */
82 #if defined(_KERNEL) || defined(_FAKE_KERNEL)
84 #define MAXCLSYSPRI 99
85 #define MINCLSYSPRI 60
89 * Global scheduling variables.
90 * - See sys/cpuvar.h for CPU-local variables.
92 extern int nswapped
; /* number of swapped threads */
93 /* nswapped protected by swap_lock */
95 extern pri_t minclsyspri
; /* minimum level of any system class */
96 extern pri_t maxclsyspri
; /* maximum level of any system class */
97 extern pri_t intr_pri
; /* interrupt thread priority base level */
99 #endif /* _KERNEL || _FAKE_KERNEL */
103 * Minimum amount of time that a thread can remain runnable before it can
104 * be stolen by another CPU (in nanoseconds).
106 extern hrtime_t nosteal_nsec
;
109 * Kernel preemption occurs if a higher-priority thread is runnable with
110 * a priority at or above kpreemptpri.
112 * So that other processors can watch for such threads, a separate
113 * dispatch queue with unbound work above kpreemptpri is maintained.
114 * This is part of the CPU partition structure (cpupart_t).
116 extern pri_t kpreemptpri
; /* level above which preemption takes place */
118 extern void disp_kp_alloc(disp_t
*, pri_t
); /* allocate kp queue */
119 extern void disp_kp_free(disp_t
*); /* free kp queue */
122 * Macro for use by scheduling classes to decide whether the thread is about
123 * to be scheduled or not. This returns the maximum run priority.
125 #define DISP_MAXRUNPRI(t) ((t)->t_disp_queue->disp_maxrunpri)
128 * Platform callbacks for various dispatcher operations
130 * idle_cpu() is invoked when a cpu goes idle, and has nothing to do.
131 * disp_enq_thread() is invoked when a thread is placed on a run queue.
133 extern void (*idle_cpu
)();
134 extern void (*disp_enq_thread
)(struct cpu
*, int);
137 extern int dispdeq(kthread_t
*);
138 extern void dispinit(void);
139 extern void disp_add(sclass_t
*);
140 extern int intr_active(struct cpu
*, int);
141 extern int servicing_interrupt(void);
142 extern void preempt(void);
143 extern void setbackdq(kthread_t
*);
144 extern void setfrontdq(kthread_t
*);
145 extern void swtch(void);
146 extern void swtch_to(kthread_t
*);
147 extern void swtch_from_zombie(void)
149 extern void dq_sruninc(kthread_t
*);
150 extern void dq_srundec(kthread_t
*);
151 extern void cpu_rechoose(kthread_t
*);
152 extern void cpu_surrender(kthread_t
*);
153 extern void kpreempt(int);
154 extern struct cpu
*disp_lowpri_cpu(struct cpu
*, struct lgrp_ld
*, pri_t
,
156 extern int disp_bound_threads(struct cpu
*, int);
157 extern int disp_bound_anythreads(struct cpu
*, int);
158 extern int disp_bound_partition(struct cpu
*, int);
159 extern void disp_cpu_init(struct cpu
*);
160 extern void disp_cpu_fini(struct cpu
*);
161 extern void disp_cpu_inactive(struct cpu
*);
162 extern void disp_adjust_unbound_pri(kthread_t
*);
163 extern void resume(kthread_t
*);
164 extern void resume_from_intr(kthread_t
*);
165 extern void resume_from_zombie(kthread_t
*)
167 extern void disp_swapped_enq(kthread_t
*);
168 extern int disp_anywork(void);
170 #define KPREEMPT_SYNC (-1)
171 #define kpreempt_disable() \
173 curthread->t_preempt++; \
174 ASSERT(curthread->t_preempt >= 1); \
176 #define kpreempt_enable() \
178 ASSERT(curthread->t_preempt >= 1); \
179 if (--curthread->t_preempt == 0 && \
181 kpreempt(KPREEMPT_SYNC); \
190 #endif /* _SYS_DISP_H */