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, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2003 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 #include <sys/acctctl.h>
30 #include <sys/cmn_err.h>
31 #include <sys/cred.h>
32 #include <sys/errno.h>
33 #include <sys/exacct.h>
34 #include <sys/modctl.h>
35 #include <sys/procset.h>
36 #include <sys/sysmacros.h>
37 #include <sys/systm.h>
38 #include <sys/task.h>
39 #include <sys/types.h>
40 #include <sys/user.h>
41 #include <sys/policy.h>
42
43 /*
44 * getacct(2), putacct(2), and wracct(2) system calls
45 *
46 * The extended accounting subsystem provides three root-privileged system
47 * calls for interacting with the actual resource data associated with each
48 * task or process. getacct() copies a packed exacct record reflecting the
49 * resource usage out to the buffer provided by the user. wracct() writes a
50 * record to the appropriate extended accounting file. putacct() takes the
51 * buffer provided by the user, and appends a "tag" record associated with the
52 * specified task or project that encapsulates the user data. All three of
53 * these functions exit early if extended accounting is not active for the
54 * requested entity type.
55 *
56 * Locking
57 * Under the terminology introduced in os/task.c, all three of these system
58 * calls are task observers, when executing on an existing task.
59 */
60
61 /*
62 * getacct_callback() is used to copyout the buffer with accounting records
63 * from the kernel back to the user. It also sets actual to the size of the
64 * kernel buffer--the required minimum size for a successful outbound copy.
65 */
66 /* ARGSUSED */
67 static int
68 getacct_callback(ac_info_t *unused, void *ubuf, size_t usize, void *kbuf,
69 size_t ksize, size_t *actual)
70 {
71 size_t size = MIN(usize, ksize);
72
73 if (ubuf != NULL && copyout(kbuf, ubuf, size) != 0)
74 return (EFAULT);
75 *actual = ksize;
76 return (0);
77 }
78
79 static int
80 getacct_task(ac_info_t *ac_task, taskid_t tkid, void *buf, size_t bufsize,
81 size_t *sizep)
82 {
83 task_t *tk;
84 int error;
85
86 mutex_enter(&ac_task->ac_lock);
87 if (ac_task->ac_state == AC_OFF) {
88 mutex_exit(&ac_task->ac_lock);
89 return (ENOTACTIVE);
90 }
91 mutex_exit(&ac_task->ac_lock);
92
93 if ((tk = task_hold_by_id(tkid)) == NULL)
94 return (ESRCH);
95 error = exacct_assemble_task_usage(ac_task, tk,
96 getacct_callback, buf, bufsize, sizep, EW_PARTIAL);
97 task_rele(tk);
98
99 return (error);
100 }
101
102 static int
103 getacct_proc(ac_info_t *ac_proc, pid_t pid, void *buf, size_t bufsize,
104 size_t *sizep)
105 {
106 proc_t *p;
107 proc_usage_t *pu;
108 ulong_t mask[AC_MASK_SZ];
109 ulong_t *ac_mask = &mask[0];
110 int error;
111
112 mutex_enter(&ac_proc->ac_lock);
113 if (ac_proc->ac_state == AC_OFF) {
114 mutex_exit(&ac_proc->ac_lock);
115 return (ENOTACTIVE);
116 }
117 bt_copy(&ac_proc->ac_mask[0], ac_mask, AC_MASK_SZ);
118 mutex_exit(&ac_proc->ac_lock);
119
120 pu = kmem_zalloc(sizeof (proc_usage_t), KM_SLEEP);
121 pu->pu_command = kmem_zalloc(MAXCOMLEN + 1, KM_SLEEP);
122
123 mutex_enter(&pidlock);
124 if ((p = prfind(pid)) == NULL) {
125 mutex_exit(&pidlock);
126 kmem_free(pu->pu_command, MAXCOMLEN + 1);
127 kmem_free(pu, sizeof (proc_usage_t));
128 return (ESRCH);
129 }
130 mutex_enter(&p->p_lock);
131 mutex_exit(&pidlock);
132
133 exacct_calculate_proc_usage(p, pu, ac_mask, EW_PARTIAL, 0);
134 mutex_exit(&p->p_lock);
135
136 error = exacct_assemble_proc_usage(ac_proc, pu,
137 getacct_callback, buf, bufsize, sizep, EW_PARTIAL);
138
139 kmem_free(pu->pu_command, MAXCOMLEN + 1);
140 kmem_free(pu, sizeof (proc_usage_t));
141
142 return (error);
143 }
144
145 static ssize_t
146 getacct(idtype_t idtype, id_t id, void *buf, size_t bufsize)
147 {
148 size_t size = 0;
149 int error;
150 struct exacct_globals *acg;
151
152 if (bufsize > EXACCT_MAX_BUFSIZE)
153 bufsize = EXACCT_MAX_BUFSIZE;
154
155 acg = zone_getspecific(exacct_zone_key, curproc->p_zone);
156 switch (idtype) {
157 case P_PID:
158 error = getacct_proc(&acg->ac_proc, id, buf, bufsize, &size);
159 break;
160 case P_TASKID:
161 error = getacct_task(&acg->ac_task, id, buf, bufsize, &size);
162 break;
163 default:
164 error = EINVAL;
165 break;
166 }
167 return (error == 0 ? (ssize_t)size : set_errno(error));
168 }
169
170 static int
171 putacct(idtype_t idtype, id_t id, void *buf, size_t bufsize, int flags)
172 {
173 int error;
174 taskid_t tkid;
175 proc_t *p;
176 task_t *tk;
177 void *kbuf;
178 struct exacct_globals *acg;
179
180 if (bufsize == 0 || bufsize > EXACCT_MAX_BUFSIZE)
181 return (set_errno(EINVAL));
182
183 kbuf = kmem_alloc(bufsize, KM_SLEEP);
184 if (copyin(buf, kbuf, bufsize) != 0) {
185 error = EFAULT;
186 goto out;
187 }
188
189 acg = zone_getspecific(exacct_zone_key, curproc->p_zone);
190 switch (idtype) {
191 case P_PID:
192 mutex_enter(&pidlock);
193 if ((p = prfind(id)) == NULL) {
194 mutex_exit(&pidlock);
195 error = ESRCH;
196 } else {
197 zone_t *zone = p->p_zone;
198
199 tkid = p->p_task->tk_tkid;
200 zone_hold(zone);
201 mutex_exit(&pidlock);
202
203 error = exacct_tag_proc(&acg->ac_proc, id, tkid, kbuf,
204 bufsize, flags, zone->zone_nodename);
205 zone_rele(zone);
206 }
207 break;
208 case P_TASKID:
209 if ((tk = task_hold_by_id(id)) != NULL) {
210 error = exacct_tag_task(&acg->ac_task, tk, kbuf,
211 bufsize, flags);
212 task_rele(tk);
213 } else {
214 error = ESRCH;
215 }
216 break;
217 default:
218 error = EINVAL;
219 break;
220 }
221 out:
222 kmem_free(kbuf, bufsize);
223 return (error == 0 ? error : set_errno(error));
224 }
225
226 static int
227 wracct_task(ac_info_t *ac_task, taskid_t tkid, int flag, size_t *sizep)
228 {
229 task_t *tk;
230 int error;
231
232 mutex_enter(&ac_task->ac_lock);
233 if (ac_task->ac_state == AC_OFF || ac_task->ac_vnode == NULL) {
234 mutex_exit(&ac_task->ac_lock);
235 return (ENOTACTIVE);
236 }
237 mutex_exit(&ac_task->ac_lock);
238
239 if ((tk = task_hold_by_id(tkid)) == NULL)
240 return (ESRCH);
241 error = exacct_assemble_task_usage(ac_task, tk, exacct_commit_callback,
242 NULL, 0, sizep, flag);
243 task_rele(tk);
244
245 return (error);
246 }
247
248 static int
249 wracct_proc(ac_info_t *ac_proc, pid_t pid, int flag, size_t *sizep)
250 {
251 proc_t *p;
252 proc_usage_t *pu;
253 ulong_t mask[AC_MASK_SZ];
254 ulong_t *ac_mask = &mask[0];
255 int error;
256
257 mutex_enter(&ac_proc->ac_lock);
258 if (ac_proc->ac_state == AC_OFF || ac_proc->ac_vnode == NULL) {
259 mutex_exit(&ac_proc->ac_lock);
260 return (ENOTACTIVE);
261 }
262 bt_copy(&ac_proc->ac_mask[0], ac_mask, AC_MASK_SZ);
263 mutex_exit(&ac_proc->ac_lock);
264
265 pu = kmem_zalloc(sizeof (proc_usage_t), KM_SLEEP);
266 pu->pu_command = kmem_zalloc(MAXCOMLEN + 1, KM_SLEEP);
267
268 mutex_enter(&pidlock);
269 if ((p = prfind(pid)) == NULL) {
270 mutex_exit(&pidlock);
271 kmem_free(pu->pu_command, MAXCOMLEN + 1);
272 kmem_free(pu, sizeof (proc_usage_t));
273 return (ESRCH);
274 }
275 mutex_enter(&p->p_lock);
276 mutex_exit(&pidlock);
277 exacct_calculate_proc_usage(p, pu, ac_mask, flag, 0);
278 mutex_exit(&p->p_lock);
279
280 error = exacct_assemble_proc_usage(ac_proc, pu,
281 exacct_commit_callback, NULL, 0, sizep, flag);
282
283 kmem_free(pu->pu_command, MAXCOMLEN + 1);
284 kmem_free(pu, sizeof (proc_usage_t));
285
286 return (error);
287 }
288
289 static int
290 wracct(idtype_t idtype, id_t id, int flags)
291 {
292 int error;
293 size_t size = 0;
294 struct exacct_globals *acg;
295
296 /*
297 * Validate flags.
298 */
299 switch (flags) {
300 case EW_PARTIAL:
301 case EW_INTERVAL:
302 break;
303 default:
304 return (set_errno(EINVAL));
305 }
306
307 acg = zone_getspecific(exacct_zone_key, curproc->p_zone);
308 switch (idtype) {
309 case P_PID:
310 if (flags == EW_INTERVAL)
311 return (set_errno(ENOTSUP));
312 error = wracct_proc(&acg->ac_proc, id, flags, &size);
313 break;
314 case P_TASKID:
315 error = wracct_task(&acg->ac_task, id, flags, &size);
316 break;
317 default:
318 error = EINVAL;
319 break;
320 }
321
322 return (error == 0 ? error : set_errno(error));
323 }
324
325 static long
326 exacct(int code, idtype_t idtype, id_t id, void *buf, size_t bufsize,
327 int flags)
328 {
329 if (secpolicy_acct(CRED()) != 0)
330 return (set_errno(EPERM));
331
332 if (exacct_zone_key == ZONE_KEY_UNINITIALIZED)
333 return (set_errno(ENOTACTIVE));
334
335 switch (code) {
336 case 0:
337 return (getacct(idtype, id, buf, bufsize));
338 case 1:
339 return (putacct(idtype, id, buf, bufsize, flags));
340 case 2:
341 return (wracct(idtype, id, flags));
342 default:
343 return (set_errno(EINVAL));
344 }
345 }
346
347 #if defined(_LP64)
348 #define SE_LRVAL SE_64RVAL
349 #else
350 #define SE_LRVAL SE_32RVAL1
351 #endif
352
353 static struct sysent exacctsys_sysent = {
354 6,
355 SE_NOUNLOAD | SE_ARGC | SE_LRVAL,
356 (int (*)())exacct
357 };
358
359 static struct modlsys modlsys = {
360 &mod_syscallops,
361 "extended accounting facility",
362 &exacctsys_sysent
363 };
364
365 #ifdef _SYSCALL32_IMPL
366
367 static struct sysent exacctsys_sysent32 = {
368 6,
369 SE_NOUNLOAD | SE_ARGC | SE_32RVAL1,
370 (int (*)())exacct
371 };
372
373 static struct modlsys modlsys32 = {
374 &mod_syscallops32,
375 "32-bit extended accounting facility",
376 &exacctsys_sysent32
377 };
378
379 #endif
380
381 static struct modlinkage modlinkage = {
382 MODREV_1,
383 &modlsys,
384 #ifdef _SYSCALL32_IMPL
385 &modlsys32,
386 #endif
387 NULL
388 };
389
390 int
391 _init(void)
392 {
393 return (mod_install(&modlinkage));
394 }
395
396 int
397 _fini(void)
398 {
399 return (mod_remove(&modlinkage));
400 }
401
402 int
403 _info(struct modinfo *mip)
404 {
405 return (mod_info(&modlinkage, mip));
406 }