xref: /illumos-gate/usr/src/cmd/modload/modinfo.c (revision 2e107de7)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/types.h>
#include <inttypes.h>
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/modctl.h>
#include <sys/errno.h>

static int wide;
static int count = 0;
static int first_mod = 1;

/*
 * When printing module load addresses on 32-bit kernels, the 8 hex
 * character field width is obviously adequate. On sparcv9 kernels
 * solely by virtue of the choice of code model enabled by the separate
 * kernel context, the text addresses are currently in the lower 4G
 * address range, and so -still- fit in 8 hex characters.
 *
 * However, amd64 kernels live at the top of the 64-bit address space, and
 * so as to be honest about the addresses (and since this is a tool for
 * humans to parse), we have to print out a 16 hex character address.
 *
 * We assume that we will print out all 16 hex characters on future
 * 64-bit kernel ports too.
 */
static const char header[] =
	" Id "
#if defined(_LP64) && !defined(__sparcv9)
	"        "
#endif
	"Loadaddr   Size Info Rev Module Name\n";

static char *cheader  =
	" Id    Loadcnt Module Name                            State\n";


static void usage();
static void print_info(struct modinfo *mi);
static void print_cinfo(struct modinfo *mi);

/*
 * These functions are in modsubr.c
 */
void fatal(char *fmt, ...);
void error(char *fmt, ...);

/*
 * Display information of all loaded modules
 */
int
main(int argc, char *argv[])
{
	struct modinfo modinfo;
	int info_all = 1;
	int id;
	int opt;

	id = -1;	/* assume we're getting all loaded modules */

	while ((opt = getopt(argc, argv, "i:wc")) != EOF) {
		switch (opt) {
		case 'i':
			if (sscanf(optarg, "%d", &id) != 1)
				fatal("Invalid id %s\n", optarg);
			if (id == -1)
				id = 0;
			info_all = 0;
			break;
		case 'w':
			wide++;
			break;
		case 'c':
			count++;
			break;
		case '?':
		default:
			usage();
			break;
		}
	}


	/*
	 * Next id of -1 means we're getting info on all modules.
	 */
	modinfo.mi_id = modinfo.mi_nextid = id;
	modinfo.mi_info = (info_all) ? MI_INFO_ALL : MI_INFO_ONE;

	if (count)
		modinfo.mi_info |= MI_INFO_CNT;

	do {
		/*
		 * Get module information.
		 * If modinfo.mi_nextid == -1, get info about the
		 * next installed module with id > "id."
		 * Otherwise, get info about the module with id == "id."
		 */
		if (modctl(MODINFO, id, &modinfo) < 0) {
			if (!info_all)
				error("can't get module information");
			break;
		}

		if (first_mod) {
			first_mod = 0;
			(void) printf("%s", count ? cheader : header);
		}
		if (count)
			print_cinfo(&modinfo);
		else
			print_info(&modinfo);
		/*
		 * If we're getting info about all modules, the next one
		 * we want is the one with an id greater than this one.
		 */
		id = modinfo.mi_id;
	} while (info_all);

	return (0);
}

/*
 * Display loadcounts.
 */
static void
print_cinfo(struct modinfo *mi)
{
	(void) printf("%3d %10d %-32s", mi->mi_id, mi->mi_loadcnt, mi->mi_name);
	(void) printf(" %s/%s\n",
	    mi->mi_state & MI_LOADED ? "LOADED" : "UNLOADED",
	    mi->mi_state & MI_INSTALLED ? "INSTALLED" : "UNINSTALLED");
}

/*
 * Display info about a loaded module.
 *
 * The sparc kernel resides in its own address space, with modules
 * loaded at low addresses.  The low 32-bits of a module's base
 * address is sufficient but does put a cap at 4gb here.
 * The x86 64-bit kernel is loaded in high memory with the full
 * address provided.
 */
static void
print_info(struct modinfo *mi)
{
	int n, p0;
	char namebuf[256];

	for (n = 0; n < MODMAXLINK; n++) {
		if (n > 0 && mi->mi_msinfo[n].msi_linkinfo[0] == '\0')
			break;

		(void) printf("%3d ", mi->mi_id);
#if defined(_LP64) && !defined(__sparcv9)
		(void) printf("%16lx ", (uintptr_t)mi->mi_base);
#elif defined(_LP64)
		(void) printf("%8lx ", (uintptr_t)mi->mi_base);
#else
		(void) printf("%8x ", (uintptr_t)mi->mi_base);
#endif
#if defined(_LP64)
		(void) printf("%6lx ", mi->mi_size);
#else
		(void) printf("%6x ", mi->mi_size);
#endif

		p0 = mi->mi_msinfo[n].msi_p0;

		if (p0 != -1)
			(void) printf("%3d ", p0);
		else
			(void) printf("  - ");

		(void) printf("  %d  ", mi->mi_rev);

		mi->mi_name[MODMAXNAMELEN - 1] = '\0';
		mi->mi_msinfo[n].msi_linkinfo[MODMAXNAMELEN - 1] = '\0';

		if (wide) {
			(void) printf("%s (%s)\n", mi->mi_name,
			    mi->mi_msinfo[n].msi_linkinfo);
		} else {
			/* snprintf(3c) will always append a null character */
			(void) snprintf(namebuf, sizeof (namebuf), "%s (%s)",
			    mi->mi_name, mi->mi_msinfo[n].msi_linkinfo);
#if defined(_LP64) && !defined(__sparcv9)
			(void) printf("%.43s\n", namebuf);
#else
			(void) printf("%.51s\n", namebuf);
#endif
		}
	}
}

static void
usage()
{
	fatal("usage:  modinfo [-w] [-c] [-i module-id]\n");
}