xref: /illumos-gate/usr/src/cmd/lastcomm/lc_exacct.c (revision 2a8bcb4efb45d99ac41c94a75c396b362c414f7f)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/time.h>
#include <errno.h>
#include "lastcomm.h"

/* ARGSUSED1 */
static void
skip_group(ea_file_t *ef, uint_t nobjs)
{
	ea_object_t curr_obj;

	if (ea_previous_object(ef, &curr_obj) == -1) {
		(void) fprintf(stderr, gettext("lastcomm: "
		    "corrupted exacct file\n"));
		exit(1);
	}
}

static int
ok(int argc, char *argv[], int index, uid_t uid, dev_t tty, char *command)
{
	int j;

	for (j = index; j < argc; j++)
		if (strcmp(getname(uid), argv[j]) &&
		    strcmp(getdev(tty), argv[j]) &&
		    strncmp(command, argv[j], fldsiz(acct, ac_comm)))
			break;
	return (j == argc);
}

static void
disp_group(ea_file_t *ef, uint_t nobjs, int argc, char *argv[], int index)
{
	uint_t i;
	char *command = NULL;
	double cpu_usr_secs = 0.;
	double cpu_usr_nsecs = 0.;
	double cpu_sys_secs = 0.;
	double cpu_sys_nsecs = 0.;
	double totalsecs;
	dev_t tty = 0;
	major_t tty_major = 0;
	minor_t tty_minor = 0;
	uid_t uid = 0;
	time_t time = 0;
	uint32_t flag = 0;

	for (i = 0; i < nobjs; i++) {
		ea_object_t curr_obj;

		if (ea_get_object(ef, &curr_obj) == -1) {
			(void) fprintf(stderr, gettext("lastcomm: "
			    "corrupted exacct file\n"));
			exit(1);
		}

		switch (curr_obj.eo_catalog) {
			case EXT_STRING | EXC_DEFAULT | EXD_PROC_COMMAND:
				command = curr_obj.eo_item.ei_string;
				break;
			case EXT_UINT32 | EXC_DEFAULT | EXD_PROC_UID:
				uid = curr_obj.eo_item.ei_uint32;
				break;
			case EXT_UINT64 | EXC_DEFAULT | EXD_PROC_CPU_SYS_SEC:
				cpu_sys_secs = curr_obj.eo_item.ei_uint64;
				break;
			case EXT_UINT64 | EXC_DEFAULT | EXD_PROC_CPU_USER_SEC:
				cpu_usr_secs = curr_obj.eo_item.ei_uint64;
				break;
			case EXT_UINT64 | EXC_DEFAULT | EXD_PROC_CPU_SYS_NSEC:
				cpu_sys_nsecs = curr_obj.eo_item.ei_uint64;
				break;
			case EXT_UINT64 | EXC_DEFAULT | EXD_PROC_CPU_USER_NSEC:
				cpu_usr_nsecs = curr_obj.eo_item.ei_uint64;
				break;
			case EXT_UINT32 | EXC_DEFAULT | EXD_PROC_TTY_MAJOR:
				tty_major = curr_obj.eo_item.ei_uint32;
				break;
			case EXT_UINT32 | EXC_DEFAULT | EXD_PROC_TTY_MINOR:
				tty_minor = curr_obj.eo_item.ei_uint32;
				break;
			case EXT_UINT32 | EXC_DEFAULT | EXD_PROC_ACCT_FLAGS:
				flag = curr_obj.eo_item.ei_uint32;
				break;
			case EXT_UINT64 | EXC_DEFAULT | EXD_PROC_START_SEC:
				time = (uint32_t)curr_obj.eo_item.ei_uint64;
				break;
			default:
				break;
		}

		if (curr_obj.eo_type == EO_GROUP)
			disp_group(ef, curr_obj.eo_group.eg_nobjs,
			    argc, argv, index);
	}

	if (command == NULL) {
		(void) fprintf(stderr, gettext("lastcomm: "
		    "corrupted exacct file\n"));
		exit(1);
	}

	/*
	 * If a 64-bit kernel returns a major or minor value that would exceed
	 * the capacity of a 32-bit dev_t (and these also become visible in the
	 * filesystem), then the 32-bit makedev may be inaccurate and return
	 * NODEV.  When this occurs, we can remedy the problem by providing
	 * either a function which returns "dev64_t"'s or by providing an LP64
	 * version of lastcomm.
	 */
	tty = makedev(tty_major, tty_minor);

	/*
	 * If this record doesn't match the optional arguments, go on to the
	 * next record.
	 */
	if (argc > index && !ok(argc, argv, index, uid, tty, command))
		return;

	totalsecs =
	    cpu_usr_secs + cpu_usr_nsecs / NANOSEC +
	    cpu_sys_secs + cpu_sys_nsecs / NANOSEC;

	(void) printf("%-*.*s %s %-*s %-*s %6.2f secs %.16s\n",
	    fldsiz(acct, ac_comm), fldsiz(acct, ac_comm), command,
	    flagbits(flag), NMAX, getname(uid), LMAX, getdev(tty),
	    totalsecs, ctime(&time));
}

int
lc_exacct(char *filename, int argc, char *argv[], int index)
{
	ea_file_t ef;
	ea_object_t curr_obj;

	if (ea_open(&ef, filename, EXACCT_CREATOR,
		    EO_TAIL | EO_VALID_HDR, O_RDONLY, 0) < 0) {
		switch (ea_error()) {
			case EXR_CORRUPT_FILE:
				(void) fprintf(stderr, gettext("lastcomm: "
				    "exacct file corrupted\n"));
				break;
			case EXR_SYSCALL_FAIL:
				(void) fprintf(stderr, gettext("lastcomm: "
				    "cannot open %s: %s\n"), filename,
				    strerror(errno));
				break;
			default:
				break;
		}

		return (1);
	}

	while (ea_previous_object(&ef, &curr_obj) != -1) {
		if (ea_get_object(&ef, &curr_obj) == -1) {
			(void) fprintf(stderr, gettext("lastcomm: "
			    "exacct file corrupted\n"));
			exit(1);
		}

		/*
		 * lc_exacct(), in parsing the extended process accounting file,
		 * has knowledge of the fact that process records are top-level
		 * records.
		 */
		if ((curr_obj.eo_catalog & EXT_TYPE_MASK) == EXT_GROUP) {
			if (curr_obj.eo_catalog ==
			    (EXT_GROUP | EXC_DEFAULT | EXD_GROUP_PROC))
				disp_group(&ef, curr_obj.eo_group.eg_nobjs,
				    argc, argv, index);
			else
				skip_group(&ef, curr_obj.eo_group.eg_nobjs);
		}

		/*
		 * Back up to the head of the object we just consumed.
		 */
		if (ea_previous_object(&ef, &curr_obj) == -1) {
			if (ea_error() == EXR_EOF)
				break;

			(void) fprintf(stderr, gettext("lastcomm: "
			    "exacct file corrupted\n"));
			exit(1);
		}
	}

	if (ea_error() != EXR_EOF) {
		(void) fprintf(stderr, gettext("lastcomm: "
		    "exacct file corrupted\n"));
		exit(1);
	}

	(void) ea_close(&ef);

	return (0);
}