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 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * Routines to support shuttle synchronization objects
31 */
32
33 #include <sys/types.h>
34 #include <sys/proc.h>
35 #include <sys/thread.h>
36 #include <sys/class.h>
37 #include <sys/debug.h>
38 #include <sys/sobject.h>
39 #include <sys/cpuvar.h>
40 #include <sys/schedctl.h>
41 #include <sys/sdt.h>
42
43 static disp_lock_t shuttle_lock; /* lock on shuttle objects */
44
45 /*
46 * Place the thread in question on the run q.
47 */
48 static void
shuttle_unsleep(kthread_t * t)49 shuttle_unsleep(kthread_t *t)
50 {
51 ASSERT(THREAD_LOCK_HELD(t));
52
53 /* Waiting on a shuttle */
54 ASSERT(t->t_wchan0 == (caddr_t)1 && t->t_wchan == NULL);
55 t->t_flag &= ~T_WAKEABLE;
56 t->t_wchan0 = NULL;
57 t->t_sobj_ops = NULL;
58 THREAD_TRANSITION(t);
59 CL_SETRUN(t);
60 }
61
62 static kthread_t *
shuttle_owner()63 shuttle_owner()
64 {
65 return (NULL);
66 }
67
68 /*ARGSUSED*/
69 static void
shuttle_change_pri(kthread_t * t,pri_t p,pri_t * t_prip)70 shuttle_change_pri(kthread_t *t, pri_t p, pri_t *t_prip)
71 {
72 ASSERT(THREAD_LOCK_HELD(t));
73 *t_prip = p;
74 }
75
76 static sobj_ops_t shuttle_sobj_ops = {
77 SOBJ_SHUTTLE, shuttle_owner, shuttle_unsleep, shuttle_change_pri
78 };
79
80 /*
81 * Mark the current thread as sleeping on a shuttle object, and
82 * resume the specified thread. The 't' thread must be marked as ONPROC.
83 *
84 * No locks other than 'l' should be held at this point.
85 */
86 void
shuttle_resume(kthread_t * t,kmutex_t * l)87 shuttle_resume(kthread_t *t, kmutex_t *l)
88 {
89 klwp_t *lwp = ttolwp(curthread);
90 cpu_t *cp;
91 disp_lock_t *oldtlp;
92
93 thread_lock(curthread);
94 disp_lock_enter_high(&shuttle_lock);
95 if (lwp != NULL) {
96 lwp->lwp_asleep = 1; /* /proc */
97 lwp->lwp_sysabort = 0; /* /proc */
98 lwp->lwp_ru.nvcsw++;
99 }
100 curthread->t_flag |= T_WAKEABLE;
101 curthread->t_sobj_ops = &shuttle_sobj_ops;
102 /*
103 * setting cpu_dispthread before changing thread state
104 * so that kernel preemption will be deferred to after swtch_to()
105 */
106 cp = CPU;
107 cp->cpu_dispthread = t;
108 cp->cpu_dispatch_pri = DISP_PRIO(t);
109 /*
110 * Set the wchan0 field so that /proc won't just do a setrun
111 * on this thread when trying to stop a process. Instead,
112 * /proc will mark the thread as VSTOPPED similar to threads
113 * that are blocked on user level condition variables.
114 */
115 curthread->t_wchan0 = (caddr_t)1;
116 CL_INACTIVE(curthread);
117 DTRACE_SCHED1(wakeup, kthread_t *, t);
118 DTRACE_SCHED(sleep);
119 THREAD_SLEEP(curthread, &shuttle_lock);
120 disp_lock_exit_high(&shuttle_lock);
121
122 /*
123 * Update ustate records (there is no waitrq obviously)
124 */
125 (void) new_mstate(curthread, LMS_SLEEP);
126
127 thread_lock_high(t);
128 oldtlp = t->t_lockp;
129
130 t->t_flag &= ~T_WAKEABLE;
131 t->t_wchan0 = NULL;
132 t->t_sobj_ops = NULL;
133
134 /*
135 * Make sure we end up on the right CPU if we are dealing with bound
136 * CPU's or processor partitions.
137 */
138 if (t->t_bound_cpu != NULL || t->t_cpupart != cp->cpu_part) {
139 aston(t);
140 cp->cpu_runrun = 1;
141 }
142
143 /*
144 * We re-assign t_disp_queue and t_lockp of 't' here because
145 * 't' could have been preempted.
146 */
147 if (t->t_disp_queue != cp->cpu_disp) {
148 t->t_disp_queue = cp->cpu_disp;
149 thread_onproc(t, cp);
150 }
151
152 /*
153 * We can't call thread_unlock_high() here because t's thread lock
154 * could have changed by thread_onproc() call above to point to
155 * CPU->cpu_thread_lock.
156 */
157 disp_lock_exit_high(oldtlp);
158
159 mutex_exit(l);
160 /*
161 * Make sure we didn't receive any important events while
162 * we weren't looking
163 */
164 if (lwp && (ISSIG(curthread, JUSTLOOKING) ||
165 MUSTRETURN(curproc, curthread) || schedctl_cancel_pending()))
166 setrun(curthread);
167
168 swtch_to(t);
169 /*
170 * Caller must check for ISSIG/lwp_sysabort conditions
171 * and clear lwp->lwp_asleep/lwp->lwp_sysabort
172 */
173 }
174
175 /*
176 * Mark the current thread as sleeping on a shuttle object, and
177 * switch to a new thread.
178 * No locks other than 'l' should be held at this point.
179 */
180 void
shuttle_swtch(kmutex_t * l)181 shuttle_swtch(kmutex_t *l)
182 {
183 klwp_t *lwp = ttolwp(curthread);
184
185 thread_lock(curthread);
186 disp_lock_enter_high(&shuttle_lock);
187 lwp->lwp_asleep = 1; /* /proc */
188 lwp->lwp_sysabort = 0; /* /proc */
189 lwp->lwp_ru.nvcsw++;
190 curthread->t_flag |= T_WAKEABLE;
191 curthread->t_sobj_ops = &shuttle_sobj_ops;
192 curthread->t_wchan0 = (caddr_t)1;
193 CL_INACTIVE(curthread);
194 DTRACE_SCHED(sleep);
195 THREAD_SLEEP(curthread, &shuttle_lock);
196 (void) new_mstate(curthread, LMS_SLEEP);
197 disp_lock_exit_high(&shuttle_lock);
198 mutex_exit(l);
199 if (ISSIG(curthread, JUSTLOOKING) ||
200 MUSTRETURN(curproc, curthread) || schedctl_cancel_pending())
201 setrun(curthread);
202 swtch();
203 /*
204 * Caller must check for ISSIG/lwp_sysabort conditions
205 * and clear lwp->lwp_asleep/lwp->lwp_sysabort
206 */
207 }
208
209 /*
210 * Mark the specified thread as once again sleeping on a shuttle object. This
211 * routine is called to put a server thread -- one that was dequeued but for
212 * which shuttle_resume() was _not_ called -- back to sleep on a shuttle
213 * object. Because we don't hit the sched:::wakeup DTrace probe until
214 * shuttle_resume(), we do _not_ have a sched:::sleep probe here.
215 */
216 void
shuttle_sleep(kthread_t * t)217 shuttle_sleep(kthread_t *t)
218 {
219 klwp_t *lwp = ttolwp(t);
220 proc_t *p = ttoproc(t);
221
222 thread_lock(t);
223 disp_lock_enter_high(&shuttle_lock);
224 if (lwp != NULL) {
225 lwp->lwp_asleep = 1; /* /proc */
226 lwp->lwp_sysabort = 0; /* /proc */
227 lwp->lwp_ru.nvcsw++;
228 }
229 t->t_flag |= T_WAKEABLE;
230 t->t_sobj_ops = &shuttle_sobj_ops;
231 t->t_wchan0 = (caddr_t)1;
232 CL_INACTIVE(t);
233 ASSERT(t->t_mstate == LMS_SLEEP);
234 THREAD_SLEEP(t, &shuttle_lock);
235 disp_lock_exit_high(&shuttle_lock);
236 if (lwp && (ISSIG(t, JUSTLOOKING) || MUSTRETURN(p, t)))
237 setrun(t);
238 }
239