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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Implement fast getrusage call
28 */
29
30 #include <sys/types.h>
31 #include <sys/systm.h>
32 #include <sys/time.h>
33 #include <sys/errno.h>
34 #include <sys/resource.h>
35 #include <sys/vm_usage.h>
36
37 static int
38 getrusage(void *user_rusage)
39 {
40 struct rusage r;
41 kthread_t *t = curthread;
42 proc_t *p = ttoproc(t);
43 hrtime_t snsecs, unsecs;
44 klwp_t *lwp;
45
46 bzero(&r, sizeof (struct rusage));
47
48 mutex_enter(&p->p_lock);
49
50 if (p->p_defunct > 0) {
51 r.ru_majflt = p->p_ru.majflt;
52 r.ru_minflt = p->p_ru.minflt;
53 r.ru_nswap = p->p_ru.nswap;
54 r.ru_inblock = p->p_ru.inblock;
55 r.ru_oublock = p->p_ru.oublock;
56 r.ru_msgsnd = p->p_ru.msgsnd;
57 r.ru_msgrcv = p->p_ru.msgrcv;
58 r.ru_nsignals = p->p_ru.nsignals;
59 r.ru_nvcsw = p->p_ru.nvcsw;
60 r.ru_nivcsw = p->p_ru.nivcsw;
61 }
62
63 unsecs = mstate_aggr_state(p, LMS_USER);
64 snsecs = mstate_aggr_state(p, LMS_SYSTEM);
65
66 do {
67 if (t->t_proc_flag & TP_LWPEXIT)
68 continue;
69
70 lwp = ttolwp(t);
71
72 r.ru_majflt += lwp->lwp_ru.majflt;
73 r.ru_minflt += lwp->lwp_ru.minflt;
74 r.ru_nswap += lwp->lwp_ru.nswap;
75 r.ru_inblock += lwp->lwp_ru.inblock;
76 r.ru_oublock += lwp->lwp_ru.oublock;
77 r.ru_msgsnd += lwp->lwp_ru.msgsnd;
78 r.ru_msgrcv += lwp->lwp_ru.msgrcv;
79 r.ru_nsignals += lwp->lwp_ru.nsignals;
80 r.ru_nvcsw += lwp->lwp_ru.nvcsw;
81 r.ru_nivcsw += lwp->lwp_ru.nivcsw;
82
83 } while ((t = t->t_forw) != curthread);
84
85 mutex_exit(&p->p_lock);
86
87 hrt2tv(unsecs, &r.ru_utime);
88 hrt2tv(snsecs, &r.ru_stime);
89
90 #ifdef _SYSCALL32_IMPL
91 if (get_udatamodel() == DATAMODEL_ILP32) {
92 struct rusage32 r32;
93
94 bzero(&r32, sizeof (struct rusage32));
95
96 r32.ru_utime.tv_sec = r.ru_utime.tv_sec;
97 r32.ru_utime.tv_usec = r.ru_utime.tv_usec;
98 r32.ru_stime.tv_sec = r.ru_stime.tv_sec;
99 r32.ru_stime.tv_usec = r.ru_stime.tv_usec;
100
101 r32.ru_majflt = (int32_t)r.ru_majflt;
102 r32.ru_minflt = (int32_t)r.ru_minflt;
103 r32.ru_nswap = (int32_t)r.ru_nswap;
104 r32.ru_inblock = (int32_t)r.ru_inblock;
105 r32.ru_oublock = (int32_t)r.ru_oublock;
106 r32.ru_msgsnd = (int32_t)r.ru_msgsnd;
107 r32.ru_msgrcv = (int32_t)r.ru_msgrcv;
108 r32.ru_nsignals = (int32_t)r.ru_nsignals;
109 r32.ru_nvcsw = (int32_t)r.ru_nvcsw;
110 r32.ru_nivcsw = (int32_t)r.ru_nivcsw;
111 if (copyout(&r32, user_rusage, sizeof (r32)) != 0)
112 return (set_errno(EFAULT));
113 } else
114 #endif /* _SYSCALL32_IMPL */
115
116 if (copyout(&r, user_rusage, sizeof (r)) != 0)
117 return (set_errno(EFAULT));
118
119 return (0);
120 }
121
122 static int
123 getrusage_chld(void *user_rusage)
124 {
125 struct rusage r;
126 kthread_t *t = curthread;
127 proc_t *p = ttoproc(t);
128 hrtime_t snsecs, unsecs;
129
130 bzero(&r, sizeof (struct rusage));
131
132 mutex_enter(&p->p_lock);
133
134 unsecs = p->p_cacct[LMS_USER];
135 snsecs = p->p_cacct[LMS_SYSTEM] + p->p_cacct[LMS_TRAP];
136
137 r.ru_majflt = p->p_cru.majflt;
138 r.ru_minflt = p->p_cru.minflt;
139 r.ru_nswap = p->p_cru.nswap;
140 r.ru_inblock = p->p_cru.inblock;
141 r.ru_oublock = p->p_cru.oublock;
142 r.ru_msgsnd = p->p_cru.msgsnd;
143 r.ru_msgrcv = p->p_cru.msgrcv;
144 r.ru_nsignals = p->p_cru.nsignals;
145 r.ru_nvcsw = p->p_cru.nvcsw;
146 r.ru_nivcsw = p->p_cru.nivcsw;
147
148 mutex_exit(&p->p_lock);
149
150 hrt2tv(unsecs, &r.ru_utime);
151 hrt2tv(snsecs, &r.ru_stime);
152 #ifdef _SYSCALL32_IMPL
153 if (get_udatamodel() == DATAMODEL_ILP32) {
154 struct rusage32 r32;
155
156 bzero(&r32, sizeof (struct rusage32));
157
158 r32.ru_utime.tv_sec = r.ru_utime.tv_sec;
159 r32.ru_utime.tv_usec = r.ru_utime.tv_usec;
160 r32.ru_stime.tv_sec = r.ru_stime.tv_sec;
161 r32.ru_stime.tv_usec = r.ru_stime.tv_usec;
162
163 r32.ru_majflt = (int32_t)r.ru_majflt;
164 r32.ru_minflt = (int32_t)r.ru_minflt;
165 r32.ru_nswap = (int32_t)r.ru_nswap;
166 r32.ru_inblock = (int32_t)r.ru_inblock;
167 r32.ru_oublock = (int32_t)r.ru_oublock;
168 r32.ru_msgsnd = (int32_t)r.ru_msgsnd;
169 r32.ru_msgrcv = (int32_t)r.ru_msgrcv;
170 r32.ru_nsignals = (int32_t)r.ru_nsignals;
171 r32.ru_nvcsw = (int32_t)r.ru_nvcsw;
172 r32.ru_nivcsw = (int32_t)r.ru_nivcsw;
173 if (copyout(&r32, user_rusage, sizeof (r32)) != 0)
174 return (set_errno(EFAULT));
175 } else
176 #endif /* _SYSCALL32_IMPL */
177
178 if (copyout(&r, user_rusage, sizeof (r)) != 0)
179 return (set_errno(EFAULT));
180
181 return (0);
182 }
183
184 static int
185 getrusage_lwp(void *user_rusage)
186 {
187 struct rusage r;
188 kthread_t *t = curthread;
189 klwp_t *lwp;
190 hrtime_t snsecs, unsecs;
191 struct mstate *ms;
192
193 bzero(&r, sizeof (struct rusage));
194
195 lwp = ttolwp(t);
196 ms = &lwp->lwp_mstate;
197 unsecs = ms->ms_acct[LMS_USER];
198 snsecs = ms->ms_acct[LMS_SYSTEM] + ms->ms_acct[LMS_TRAP];
199 scalehrtime(&unsecs);
200 scalehrtime(&snsecs);
201 r.ru_majflt = lwp->lwp_ru.majflt;
202 r.ru_minflt = lwp->lwp_ru.minflt;
203 r.ru_nswap = lwp->lwp_ru.nswap;
204 r.ru_inblock = lwp->lwp_ru.inblock;
205 r.ru_oublock = lwp->lwp_ru.oublock;
206 r.ru_msgsnd = lwp->lwp_ru.msgsnd;
207 r.ru_msgrcv = lwp->lwp_ru.msgrcv;
208 r.ru_nsignals = lwp->lwp_ru.nsignals;
209 r.ru_nvcsw = lwp->lwp_ru.nvcsw;
210 r.ru_nivcsw = lwp->lwp_ru.nivcsw;
211
212 hrt2tv(unsecs, &r.ru_utime);
213 hrt2tv(snsecs, &r.ru_stime);
214 #ifdef _SYSCALL32_IMPL
215 if (get_udatamodel() == DATAMODEL_ILP32) {
216 struct rusage32 r32;
217
218 bzero(&r32, sizeof (struct rusage32));
219
220 r32.ru_utime.tv_sec = r.ru_utime.tv_sec;
221 r32.ru_utime.tv_usec = r.ru_utime.tv_usec;
222 r32.ru_stime.tv_sec = r.ru_stime.tv_sec;
223 r32.ru_stime.tv_usec = r.ru_stime.tv_usec;
224
225 r32.ru_majflt = (int32_t)r.ru_majflt;
226 r32.ru_minflt = (int32_t)r.ru_minflt;
227 r32.ru_nswap = (int32_t)r.ru_nswap;
228 r32.ru_inblock = (int32_t)r.ru_inblock;
229 r32.ru_oublock = (int32_t)r.ru_oublock;
230 r32.ru_msgsnd = (int32_t)r.ru_msgsnd;
231 r32.ru_msgrcv = (int32_t)r.ru_msgrcv;
232 r32.ru_nsignals = (int32_t)r.ru_nsignals;
233 r32.ru_nvcsw = (int32_t)r.ru_nvcsw;
234 r32.ru_nivcsw = (int32_t)r.ru_nivcsw;
235 if (copyout(&r32, user_rusage, sizeof (r32)) != 0)
236 return (set_errno(EFAULT));
237 } else
238 #endif /* _SYSCALL32_IMPL */
239
240 if (copyout(&r, user_rusage, sizeof (r)) != 0)
241 return (set_errno(EFAULT));
242
243 return (0);
244 }
245
246 int
247 rusagesys(int code, void *arg1, void *arg2, void *arg3, void *arg4)
248 {
249 switch (code) {
250
251 case _RUSAGESYS_GETRUSAGE:
252 return (getrusage(arg1));
253 case _RUSAGESYS_GETRUSAGE_CHLD:
254 return (getrusage_chld(arg1));
255 case _RUSAGESYS_GETRUSAGE_LWP:
256 return (getrusage_lwp(arg1));
257 case _RUSAGESYS_GETVMUSAGE:
258 return (vm_getusage((uint_t)(uintptr_t)arg1, (time_t)arg2,
259 (vmusage_t *)arg3, (size_t *)arg4, 0));
260 default:
261 return (set_errno(EINVAL));
262 }
263 }