Home | History | Annotate | Download | only in os
      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 2007 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
     27 /*	  All Rights Reserved  	*/
     28 
     29 
     30 #pragma ident	"@(#)acct.c	1.50	07/10/25 SMI"
     31 
     32 #include <sys/types.h>
     33 #include <sys/sysmacros.h>
     34 #include <sys/param.h>
     35 #include <sys/systm.h>
     36 #include <sys/acct.h>
     37 #include <sys/cred.h>
     38 #include <sys/user.h>
     39 #include <sys/errno.h>
     40 #include <sys/file.h>
     41 #include <sys/vnode.h>
     42 #include <sys/debug.h>
     43 #include <sys/proc.h>
     44 #include <sys/resource.h>
     45 #include <sys/session.h>
     46 #include <sys/modctl.h>
     47 #include <sys/syscall.h>
     48 #include <sys/policy.h>
     49 #include <sys/list.h>
     50 #include <sys/time.h>
     51 #include <sys/msacct.h>
     52 #include <sys/zone.h>
     53 
     54 /*
     55  * Each zone has its own accounting settings (on or off) and associated
     56  * file.  The global zone is not special in this aspect; it will only
     57  * generate records for processes that ran in the global zone.  We could
     58  * allow the global zone to record all activity on the system, but there
     59  * would be no way of knowing the zone in which the processes executed.
     60  * sysacct() is thus virtualized to only act on the caller's zone.
     61  */
     62 struct acct_globals {
     63 	struct acct	acctbuf;
     64 	kmutex_t	aclock;
     65 	struct vnode	*acctvp;
     66 	list_node_t	aclink;
     67 };
     68 
     69 /*
     70  * We need a list of all accounting settings for all zones, so we can
     71  * accurately determine if a file is in use for accounting (possibly by
     72  * another zone).
     73  */
     74 static zone_key_t acct_zone_key;
     75 static list_t acct_list;
     76 kmutex_t acct_list_lock;
     77 
     78 static struct sysent acctsysent = {
     79 	1,
     80 	SE_NOUNLOAD | SE_ARGC | SE_32RVAL1,
     81 	sysacct
     82 };
     83 
     84 static struct modlsys modlsys = {
     85 	&mod_syscallops, "acct(2) syscall", &acctsysent
     86 };
     87 
     88 #ifdef _SYSCALL32_IMPL
     89 static struct modlsys modlsys32 = {
     90 	&mod_syscallops32, "32-bit acct(2) syscall", &acctsysent
     91 };
     92 #endif
     93 
     94 static struct modlinkage modlinkage = {
     95 	MODREV_1,
     96 	&modlsys,
     97 #ifdef _SYSCALL32_IMPL
     98 	&modlsys32,
     99 #endif
    100 	NULL
    101 };
    102 
    103 /*ARGSUSED*/
    104 static void *
    105 acct_init(zoneid_t zoneid)
    106 {
    107 	struct acct_globals *ag;
    108 
    109 	ag = kmem_alloc(sizeof (*ag), KM_SLEEP);
    110 	bzero(&ag->acctbuf, sizeof (ag->acctbuf));
    111 	mutex_init(&ag->aclock, NULL, MUTEX_DEFAULT, NULL);
    112 	ag->acctvp = NULL;
    113 
    114 	mutex_enter(&acct_list_lock);
    115 	list_insert_tail(&acct_list, ag);
    116 	mutex_exit(&acct_list_lock);
    117 	return (ag);
    118 }
    119 
    120 /* ARGSUSED */
    121 static void
    122 acct_shutdown(zoneid_t zoneid, void *arg)
    123 {
    124 	struct acct_globals *ag = arg;
    125 
    126 	mutex_enter(&ag->aclock);
    127 	if (ag->acctvp) {
    128 		/*
    129 		 * This needs to be done as a shutdown callback, otherwise this
    130 		 * held vnode may cause filesystems to be busy, and the zone
    131 		 * shutdown operation to fail.
    132 		 */
    133 		(void) VOP_CLOSE(ag->acctvp, FWRITE, 1, (offset_t)0, kcred,
    134 		    NULL);
    135 		VN_RELE(ag->acctvp);
    136 	}
    137 	ag->acctvp = NULL;
    138 	mutex_exit(&ag->aclock);
    139 }
    140 
    141 /*ARGSUSED*/
    142 static void
    143 acct_fini(zoneid_t zoneid, void *arg)
    144 {
    145 	struct acct_globals *ag = arg;
    146 
    147 	mutex_enter(&acct_list_lock);
    148 	list_remove(&acct_list, ag);
    149 	mutex_exit(&acct_list_lock);
    150 
    151 	mutex_destroy(&ag->aclock);
    152 	kmem_free(ag, sizeof (*ag));
    153 }
    154 
    155 int
    156 _init(void)
    157 {
    158 	int error;
    159 
    160 	mutex_init(&acct_list_lock, NULL, MUTEX_DEFAULT, NULL);
    161 	list_create(&acct_list, sizeof (struct acct_globals),
    162 	    offsetof(struct acct_globals, aclink));
    163 	/*
    164 	 * Using an initializer here wastes a bit of memory for zones that
    165 	 * don't use accounting, but vastly simplifies the locking.
    166 	 */
    167 	zone_key_create(&acct_zone_key, acct_init, acct_shutdown, acct_fini);
    168 	if ((error = mod_install(&modlinkage)) != 0) {
    169 		(void) zone_key_delete(acct_zone_key);
    170 		list_destroy(&acct_list);
    171 		mutex_destroy(&acct_list_lock);
    172 	}
    173 	return (error);
    174 }
    175 
    176 int
    177 _info(struct modinfo *modinfop)
    178 {
    179 	return (mod_info(&modlinkage, modinfop));
    180 }
    181 
    182 /*
    183  * acct() is a "weak stub" routine called from exit().
    184  * Once this module has been loaded, we refuse to allow
    185  * it to unload - otherwise accounting would quietly
    186  * cease.  See 1211661.  It's possible to make this module
    187  * unloadable but it's substantially safer not to bother.
    188  */
    189 int
    190 _fini(void)
    191 {
    192 	return (EBUSY);
    193 }
    194 
    195 /*
    196  * See if vp is in use by the accounting system on any zone.  This does a deep
    197  * comparison of vnodes such that a file and a lofs "shadow" node of it will
    198  * appear to be the same.
    199  *
    200  * If 'compare_vfs' is true, the function will do a comparison of vfs_t's
    201  * instead (ie, is the vfs_t on which the vnode resides in use by the
    202  * accounting system in any zone).
    203  *
    204  * Returns 1 if found (in use), 0 otherwise.
    205  */
    206 static int
    207 acct_find(vnode_t *vp, boolean_t compare_vfs)
    208 {
    209 	struct acct_globals *ag;
    210 	vnode_t *realvp;
    211 
    212 	ASSERT(MUTEX_HELD(&acct_list_lock));
    213 	ASSERT(vp != NULL);
    214 
    215 	if (VOP_REALVP(vp, &realvp, NULL))
    216 		realvp = vp;
    217 	for (ag = list_head(&acct_list); ag != NULL;
    218 	    ag = list_next(&acct_list, ag)) {
    219 		vnode_t *racctvp;
    220 		boolean_t found = B_FALSE;
    221 
    222 		mutex_enter(&ag->aclock);
    223 		if (ag->acctvp == NULL) {
    224 			mutex_exit(&ag->aclock);
    225 			continue;
    226 		}
    227 		if (VOP_REALVP(ag->acctvp, &racctvp, NULL))
    228 			racctvp = ag->acctvp;
    229 		if (compare_vfs) {
    230 			if (racctvp->v_vfsp == realvp->v_vfsp)
    231 				found = B_TRUE;
    232 		} else {
    233 			if (VN_CMP(realvp, racctvp))
    234 				found = B_TRUE;
    235 		}
    236 		mutex_exit(&ag->aclock);
    237 		if (found)
    238 			return (1);
    239 	}
    240 	return (0);
    241 }
    242 
    243 /*
    244  * Returns 1 if the vfs that vnode resides on is in use for the accounting
    245  * subsystem, 0 otherwise.
    246  */
    247 int
    248 acct_fs_in_use(vnode_t *vp)
    249 {
    250 	int found;
    251 
    252 	if (vp == NULL)
    253 		return (0);
    254 	mutex_enter(&acct_list_lock);
    255 	found = acct_find(vp, B_TRUE);
    256 	mutex_exit(&acct_list_lock);
    257 	return (found);
    258 }
    259 
    260 /*
    261  * Perform process accounting functions.
    262  */
    263 int
    264 sysacct(char *fname)
    265 {
    266 	struct acct_globals *ag;
    267 	struct vnode *vp;
    268 	int error = 0;
    269 
    270 	if (secpolicy_acct(CRED()) != 0)
    271 		return (set_errno(EPERM));
    272 
    273 	ag = zone_getspecific(acct_zone_key, curproc->p_zone);
    274 	ASSERT(ag != NULL);
    275 
    276 	if (fname == NULL) {
    277 		/*
    278 		 * Close the file and stop accounting.
    279 		 */
    280 		mutex_enter(&ag->aclock);
    281 		vp = ag->acctvp;
    282 		ag->acctvp = NULL;
    283 		mutex_exit(&ag->aclock);
    284 		if (vp) {
    285 			error = VOP_CLOSE(vp, FWRITE, 1, (offset_t)0, CRED(),
    286 			    NULL);
    287 			VN_RELE(vp);
    288 		}
    289 		return (error == 0 ? 0 : set_errno(error));
    290 	}
    291 
    292 	/*
    293 	 * Either (a) open a new file and begin accounting -or- (b)
    294 	 * switch accounting from an old to a new file.
    295 	 *
    296 	 * (Open the file without holding aclock in case it
    297 	 * sleeps (holding the lock prevents process exit).)
    298 	 */
    299 	if ((error = vn_open(fname, UIO_USERSPACE, FWRITE,
    300 	    0, &vp, (enum create)0, 0)) != 0) {
    301 		/* SVID  compliance */
    302 		if (error == EISDIR)
    303 			error = EACCES;
    304 		return (set_errno(error));
    305 	}
    306 
    307 	if (vp->v_type != VREG) {
    308 		error = EACCES;
    309 	} else {
    310 		mutex_enter(&acct_list_lock);
    311 		if (acct_find(vp, B_FALSE)) {
    312 			error = EBUSY;
    313 		} else {
    314 			mutex_enter(&ag->aclock);
    315 			if (ag->acctvp) {
    316 				vnode_t *oldvp;
    317 
    318 				/*
    319 				 * close old acctvp, and point acct()
    320 				 * at new file by swapping vp and acctvp
    321 				 */
    322 				oldvp = ag->acctvp;
    323 				ag->acctvp = vp;
    324 				vp = oldvp;
    325 			} else {
    326 				/*
    327 				 * no existing file, start accounting ..
    328 				 */
    329 				ag->acctvp = vp;
    330 				vp = NULL;
    331 			}
    332 			mutex_exit(&ag->aclock);
    333 		}
    334 		mutex_exit(&acct_list_lock);
    335 	}
    336 
    337 	if (vp) {
    338 		(void) VOP_CLOSE(vp, FWRITE, 1, (offset_t)0, CRED(), NULL);
    339 		VN_RELE(vp);
    340 	}
    341 	return (error == 0 ? 0 : set_errno(error));
    342 }
    343 
    344 /*
    345  * Produce a pseudo-floating point representation
    346  * with 3 bits base-8 exponent, 13 bits fraction.
    347  */
    348 static comp_t
    349 acct_compress(ulong_t t)
    350 {
    351 	int exp = 0, round = 0;
    352 
    353 	while (t >= 8192) {
    354 		exp++;
    355 		round = t & 04;
    356 		t >>= 3;
    357 	}
    358 	if (round) {
    359 		t++;
    360 		if (t >= 8192) {
    361 			t >>= 3;
    362 			exp++;
    363 		}
    364 	}
    365 #ifdef _LP64
    366 	if (exp > 7) {
    367 		/* prevent wraparound */
    368 		t = 8191;
    369 		exp = 7;
    370 	}
    371 #endif
    372 	return ((exp << 13) + t);
    373 }
    374 
    375 /*
    376  * On exit, write a record on the accounting file.
    377  */
    378 void
    379 acct(char st)
    380 {
    381 	struct vnode *vp;
    382 	struct cred *cr;
    383 	struct proc *p;
    384 	user_t *ua;
    385 	struct vattr va;
    386 	ssize_t resid = 0;
    387 	int error;
    388 	struct acct_globals *ag;
    389 
    390 	ag = zone_getspecific(acct_zone_key, curproc->p_zone);
    391 
    392 	mutex_enter(&ag->aclock);
    393 	if ((vp = ag->acctvp) == NULL) {
    394 		mutex_exit(&ag->aclock);
    395 		return;
    396 	}
    397 
    398 	/*
    399 	 * This only gets called from exit after all lwp's have exited so no
    400 	 * cred locking is needed.
    401 	 */
    402 	p = curproc;
    403 	ua = PTOU(p);
    404 	bcopy(ua->u_comm, ag->acctbuf.ac_comm, sizeof (ag->acctbuf.ac_comm));
    405 	ag->acctbuf.ac_btime = ua->u_start.tv_sec;
    406 	ag->acctbuf.ac_utime = acct_compress(NSEC_TO_TICK(p->p_acct[LMS_USER]));
    407 	ag->acctbuf.ac_stime = acct_compress(
    408 	    NSEC_TO_TICK(p->p_acct[LMS_SYSTEM] + p->p_acct[LMS_TRAP]));
    409 	ag->acctbuf.ac_etime = acct_compress(lbolt - ua->u_ticks);
    410 	ag->acctbuf.ac_mem = acct_compress((ulong_t)ua->u_mem);
    411 	ag->acctbuf.ac_io = acct_compress((ulong_t)p->p_ru.ioch);
    412 	ag->acctbuf.ac_rw = acct_compress((ulong_t)(p->p_ru.inblock +
    413 	    p->p_ru.oublock));
    414 	cr = CRED();
    415 	ag->acctbuf.ac_uid = crgetruid(cr);
    416 	ag->acctbuf.ac_gid = crgetrgid(cr);
    417 	(void) cmpldev(&ag->acctbuf.ac_tty, cttydev(p));
    418 	ag->acctbuf.ac_stat = st;
    419 	ag->acctbuf.ac_flag = (ua->u_acflag | AEXPND);
    420 
    421 	/*
    422 	 * Save the size. If the write fails, reset the size to avoid
    423 	 * corrupted acct files.
    424 	 *
    425 	 * Large Files: We deliberately prevent accounting files from
    426 	 * exceeding the 2GB limit as none of the accounting commands are
    427 	 * currently large file aware.
    428 	 */
    429 	va.va_mask = AT_SIZE;
    430 	if (VOP_GETATTR(vp, &va, 0, kcred, NULL) == 0) {
    431 		error = vn_rdwr(UIO_WRITE, vp, (caddr_t)&ag->acctbuf,
    432 		    sizeof (ag->acctbuf), 0LL, UIO_SYSSPACE, FAPPEND,
    433 		    (rlim64_t)MAXOFF32_T, kcred, &resid);
    434 		if (error || resid)
    435 			(void) VOP_SETATTR(vp, &va, 0, kcred, NULL);
    436 	}
    437 	mutex_exit(&ag->aclock);
    438 }
    439