kernel/syscall/exacctsys.c

   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 }