modules/ipp/ipp.c

/*
 * 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 2001-2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/time.h>
#include <ipp/ipp.h>
#include <ipp/ipp_impl.h>
#include <mdb/mdb_modapi.h>

static uintptr_t	ipp_mod_byid;
static uintptr_t	ipp_action_byid;

static int	byid_walk_init(mdb_walk_state_t *);
static int	byid_walk_step(mdb_walk_state_t *);
static void	byid_walk_fini(mdb_walk_state_t *);

static int	action(uintptr_t, uint_t, int, const mdb_arg_t *);
static int	action_format(uintptr_t, const void *, void *);
static int	action_dump(uintptr_t, ipp_action_t *, boolean_t);
static int	action_summary(uintptr_t, ipp_action_t *, boolean_t);

static int	cfglock(uintptr_t, uint_t, int, const mdb_arg_t *);

static int	mod(uintptr_t, uint_t, int, const mdb_arg_t *);
static int	mod_format(uintptr_t, const void *, void *);
static int	mod_dump(uintptr_t, ipp_mod_t *, boolean_t);
static int	mod_summary(uintptr_t, ipp_mod_t *, boolean_t);
static int	cfglock(uintptr_t, uint_t, int, const mdb_arg_t *);

static int	ippops(uintptr_t, uint_t, int, const mdb_arg_t *);

static int	packet(uintptr_t, uint_t, int, const mdb_arg_t *);
static void	dump_classes(uintptr_t, uint_t);
static void	dump_log(uintptr_t, uint_t);
static void	aid2aname(ipp_action_id_t, char *);

static int	ref_walk_init(mdb_walk_state_t *);
static int	ref_walk_step(mdb_walk_state_t *);
static void	ref_walk_fini(mdb_walk_state_t *);

typedef	struct afdata {
	boolean_t	af_banner;
	uint_t		af_flags;
} afdata_t;

#define	AF_VERBOSE	1

typedef	struct mfdata {
	boolean_t	mf_banner;
	uint_t		mf_flags;
} mfdata_t;

#define	MF_VERBOSE	1

/*
 * walker. Skips entries that are NULL.
 */

static int
byid_walk_init(
	mdb_walk_state_t *wsp)
{
	uintptr_t	start;

	if (mdb_vread(&start, sizeof (uintptr_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read from address %p", wsp->walk_addr);
		return (WALK_ERR);
	}

	wsp->walk_addr = start;

	return (WALK_NEXT);
}

static int
byid_walk_step(
	mdb_walk_state_t *wsp)
{
	int		status;
	void 		*ptr;

	if (mdb_vread(&ptr, sizeof (void *), wsp->walk_addr) == -1) {
		mdb_warn("failed to read from address %p", wsp->walk_addr);
		return (WALK_ERR);
	}

	if (ptr == (void *)-1) {
		status = WALK_DONE;
	} else if (ptr == NULL) {
		status = WALK_NEXT;
	} else {
		status = wsp->walk_callback((uintptr_t)ptr, NULL,
		    wsp->walk_cbdata);
	}

	wsp->walk_addr += sizeof (void *);

	return (status);
}

/*ARGSUSED*/
static void
byid_walk_fini(
	mdb_walk_state_t *wsp)
{
}


/*ARGSUSED*/
static int
action(
	uintptr_t	addr,
	uint_t		flags,
	int		argc,
	const mdb_arg_t	*argv)
{
	int		status;
	int		rc = DCMD_OK;
	afdata_t	*afp;

	afp = mdb_zalloc(sizeof (afdata_t), UM_SLEEP);

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, AF_VERBOSE, &afp->af_flags,
	    NULL) != argc)
		return (DCMD_USAGE);

	if ((flags & DCMD_LOOPFIRST) || !(flags & DCMD_LOOP))
		afp->af_banner = B_TRUE;

	if (flags & DCMD_ADDRSPEC) {
		status = action_format(addr, NULL, afp);
		rc = (status == WALK_NEXT) ? DCMD_OK : DCMD_ERR;
		goto cleanup;
	}

	if (mdb_pwalk("ipp_byid", action_format, afp,
	    ipp_action_byid) == -1) {
		mdb_warn("failed to execute ipp_byid walk");
		rc = DCMD_ERR;
	}

cleanup:
	mdb_free(afp, sizeof (afdata_t));

	return (rc);
}

/*ARGSUSED*/
static int
action_format(
	uintptr_t	addr,
	const void	*data,
	void		*arg)
{
	afdata_t	*afp = (afdata_t *)arg;
	ipp_action_t	*ap;
	int		rc;

	ap = mdb_alloc(sizeof (ipp_action_t), UM_SLEEP);
	if (mdb_vread(ap, sizeof (ipp_action_t), addr) == -1) {
		mdb_warn("failed to read ipp_action_t at %p", addr);
		rc = WALK_ERR;
		goto done;
	}

	if (afp->af_flags & AF_VERBOSE)
		rc = action_dump(addr, ap, afp->af_banner);
	else
		rc = action_summary(addr, ap, afp->af_banner);

	afp->af_banner = B_FALSE;
done:
	mdb_free(ap, sizeof (ipp_action_t));
	return (rc);
}

/*ARGSUSED*/
static int
action_dump(
	uintptr_t	addr,
	ipp_action_t	*ap,
	boolean_t	banner)
{
	mdb_printf("%?p: %20s = %d\n", addr, "id", ap->ippa_id);
	if (!ap->ippa_nameless) {
		mdb_printf("%?s  %20s = %s\n", "", "name", ap->ippa_name);
	}
	mdb_printf("%?s  %20s = 0x%p\n", "", "mod", ap->ippa_mod);
	mdb_printf("%?s  %20s = 0x%p\n", "", "ref", ap->ippa_ref);
	mdb_printf("%?s  %20s = 0x%p\n", "", "refby", ap->ippa_refby);
	mdb_printf("%?s  %20s = 0x%p\n", "", "ptr", ap->ippa_ptr);

	mdb_printf("%?s  %20s = ", "", "state");
	switch (ap->ippa_state) {
	case IPP_ASTATE_PROTO:
		mdb_printf("%s\n", "PROTO");
		break;
	case IPP_ASTATE_CONFIG_PENDING:
		mdb_printf("%s\n", "CONFIG_PENDING");
		break;
	case IPP_ASTATE_AVAILABLE:
		mdb_printf("%s\n", "AVAILABLE");
		break;
	default:
		mdb_printf("%s\n", "<unknown>");
		break;
	}

	mdb_printf("%?s  %20s = %d\n", "", "packets", ap->ippa_packets);
	mdb_printf("%?s  %20s = %d\n", "", "hold_count", ap->ippa_hold_count);
	mdb_printf("%?s  %20s = %s\n", "", "destruct_pending",
	    (ap->ippa_destruct_pending) ? "TRUE" : "FALSE");
	mdb_printf("%?s  %20s = 0x%p\n", "", "lock",
	    addr + ((uintptr_t)ap->ippa_lock - (uintptr_t)ap));
	mdb_printf("%?s  %20s = 0x%p\n", "", "config_lock",
	    addr + ((uintptr_t)ap->ippa_config_lock - (uintptr_t)ap));
	mdb_printf("\n");

	return (WALK_NEXT);
}

static int
action_summary(
	uintptr_t	addr,
	ipp_action_t	*ap,
	boolean_t	banner)
{
	ipp_mod_t	*imp;
	uintptr_t	ptr;

	if (banner)
		mdb_printf("%?s %<u>%20s %5s %20s%</u>\n",
		    "", "NAME", "ID", "MODNAME");

	imp = mdb_alloc(sizeof (ipp_mod_t), UM_SLEEP);
	ptr = (uintptr_t)ap->ippa_mod;
	if (mdb_vread(imp, sizeof (ipp_mod_t), ptr) == -1) {
		mdb_warn("failed to read ipp_mod_t at %p", ptr);
		mdb_free(imp, sizeof (ipp_mod_t));
		return (WALK_ERR);
	}

	mdb_printf("%?p:%20s %5d %20s\n", addr, ap->ippa_name, ap->ippa_id,
	    imp->ippm_name);

	mdb_free(imp, sizeof (ipp_mod_t));
	return (WALK_NEXT);
}

/*ARGSUSED*/
static int
cfglock(
	uintptr_t	addr,
	uint_t		flags,
	int		argc,
	const mdb_arg_t	*argv)
{
	cfglock_t	*clp;

	if ((flags & DCMD_ADDRSPEC) == 0)
		return (DCMD_ERR);

	clp = mdb_alloc(sizeof (cfglock_t), UM_SLEEP);
	if (mdb_vread(clp, sizeof (cfglock_t), addr) == -1) {
		mdb_warn("failed to read cfglock_t at %p", addr);
		mdb_free(clp, sizeof (cfglock_t));
		return (WALK_ERR);
	}

	mdb_printf("%?p: %20s = %p\n", addr, "owner", clp->cl_owner);
	mdb_printf("%?s  %20s = %s\n", "", "reader",
	    clp->cl_reader ? "TRUE" : "FALSE");
	mdb_printf("%?s  %20s = %d\n", "", "writers", clp->cl_writers);
	mdb_printf("%?s  %20s = 0x%p\n", "", "mutex",
	    addr + ((uintptr_t)clp->cl_mutex - (uintptr_t)clp));
	mdb_printf("%?s  %20s = 0x%p\n", "", "cv",
	    addr + ((uintptr_t)clp->cl_cv - (uintptr_t)clp));
	mdb_printf("\n");

	mdb_free(clp, sizeof (cfglock_t));

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
mod(
	uintptr_t	addr,
	uint_t		flags,
	int		argc,
	const mdb_arg_t	*argv)
{
	int		status;
	int		rc = DCMD_OK;
	mfdata_t	*mfp;

	mfp = mdb_zalloc(sizeof (mfdata_t), UM_SLEEP);

	if (mdb_getopts(argc, argv,
	    'v', MDB_OPT_SETBITS, MF_VERBOSE, &mfp->mf_flags,
	    NULL) != argc)
		return (DCMD_USAGE);

	if ((flags & DCMD_LOOPFIRST) || !(flags & DCMD_LOOP))
		mfp->mf_banner = B_TRUE;

	if (flags & DCMD_ADDRSPEC) {
		status = mod_format(addr, NULL, mfp);
		rc = (status == WALK_NEXT) ? DCMD_OK : DCMD_ERR;
		goto cleanup;
	}

	if (mdb_pwalk("ipp_byid", mod_format, mfp,
	    ipp_mod_byid) == -1) {
		mdb_warn("failed to execute ipp_byid walk");
		rc = DCMD_ERR;
	}

cleanup:
	mdb_free(mfp, sizeof (mfdata_t));

	return (rc);
}

/*ARGSUSED*/
static int
mod_format(
	uintptr_t	addr,
	const void	*data,
	void		*arg)
{
	mfdata_t	*mfp = (mfdata_t *)arg;
	ipp_mod_t	*imp;
	int		rc;

	imp = mdb_alloc(sizeof (ipp_mod_t), UM_SLEEP);
	if (mdb_vread(imp, sizeof (ipp_mod_t), addr) == -1) {
		mdb_warn("failed to read ipp_mod_t at %p", addr);
		rc = WALK_ERR;
		goto done;
	}

	if (mfp->mf_flags & MF_VERBOSE)
		rc = mod_dump(addr, imp, mfp->mf_banner);
	else
		rc = mod_summary(addr, imp, mfp->mf_banner);

	mfp->mf_banner = B_FALSE;
done:
	mdb_free(imp, sizeof (ipp_mod_t));
	return (rc);
}

/*ARGSUSED*/
static int
mod_dump(
	uintptr_t	addr,
	ipp_mod_t	*imp,
	boolean_t	banner)
{
	mdb_printf("%?p: %20s = %d\n", addr, "id", imp->ippm_id);
	mdb_printf("%?s  %20s = %s\n", "", "name", imp->ippm_name);
	mdb_printf("%?s  %20s = 0x%p\n", "", "ops", imp->ippm_ops);
	mdb_printf("%?s  %20s = 0x%p\n", "", "action", imp->ippm_action);

	mdb_printf("%?s  %20s = ", "", "state");
	switch (imp->ippm_state) {
	case IPP_MODSTATE_PROTO:
		mdb_printf("%s\n", "PROTO");
		break;
	case IPP_MODSTATE_AVAILABLE:
		mdb_printf("%s\n", "AVAILABLE");
		break;
	default:
		mdb_printf("%s\n", "<unknown>");
		break;
	}

	mdb_printf("%?s  %20s = %d\n", "", "hold_count", imp->ippm_hold_count);
	mdb_printf("%?s  %20s = %s\n", "", "destruct_pending",
	    (imp->ippm_destruct_pending) ? "TRUE" : "FALSE");
	mdb_printf("%?s  %20s = 0x%p\n", "", "lock",
	    addr + ((uintptr_t)imp->ippm_lock - (uintptr_t)imp));
	mdb_printf("\n");

	return (WALK_NEXT);
}

static int
mod_summary(
	uintptr_t	addr,
	ipp_mod_t	*imp,
	boolean_t	banner)
{
	if (banner)
		mdb_printf("%?s %<u>%20s %5s%</u>\n",
		    "", "NAME", "ID");

	mdb_printf("%?p:%20s %5d\n", addr, imp->ippm_name, imp->ippm_id);

	return (WALK_NEXT);
}

/*ARGSUSED*/
static int
ippops(
	uintptr_t	addr,
	uint_t		flags,
	int		argc,
	const mdb_arg_t	*argv)
{
	ipp_ops_t	*ippo;
	GElf_Sym	sym;
	char		buf[MDB_SYM_NAMLEN];

	if ((flags & DCMD_ADDRSPEC) == 0)
		return (DCMD_ERR);

	ippo = mdb_alloc(sizeof (ipp_ops_t), UM_SLEEP);
	if (mdb_vread(ippo, sizeof (ipp_ops_t), addr) == -1) {
		mdb_warn("failed to read ipp_ops_t at %p", addr);
		mdb_free(ippo, sizeof (ipp_ops_t));
		return (DCMD_ERR);
	}

	mdb_printf("%?p: %20s = %d\n", addr, "rev", ippo->ippo_rev);

	if (mdb_lookup_by_addr((uintptr_t)ippo->ippo_action_create,
	    MDB_SYM_EXACT, buf, MDB_SYM_NAMLEN, &sym) == 0)
		mdb_printf("%?s  %20s = %s\n", "", "action_create", buf);
	else
		mdb_printf("%?s  %20s = 0x%p\n", "", "action_create",
		    ippo->ippo_action_create);

	if (mdb_lookup_by_addr((uintptr_t)ippo->ippo_action_modify,
	    MDB_SYM_EXACT, buf, MDB_SYM_NAMLEN, &sym) == 0)
		mdb_printf("%?s  %20s = %s\n", "", "action_modify", buf);
	else
		mdb_printf("%?s  %20s = 0x%p\n", "", "action_modify",
		    ippo->ippo_action_modify);

	if (mdb_lookup_by_addr((uintptr_t)ippo->ippo_action_destroy,
	    MDB_SYM_EXACT, buf, MDB_SYM_NAMLEN, &sym) == 0)
		mdb_printf("%?s  %20s = %s\n", "", "action_destroy", buf);
	else
		mdb_printf("%?s  %20s = 0x%p\n", "", "action_destroy",
		    ippo->ippo_action_destroy);

	if (mdb_lookup_by_addr((uintptr_t)ippo->ippo_action_info,
	    MDB_SYM_EXACT, buf, MDB_SYM_NAMLEN, &sym) == 0)
		mdb_printf("%?s  %20s = %s\n", "", "action_info", buf);
	else
		mdb_printf("%?s  %20s = 0x%p\n", "", "action_info",
		    ippo->ippo_action_info);

	if (mdb_lookup_by_addr((uintptr_t)ippo->ippo_action_invoke,
	    MDB_SYM_EXACT, buf, MDB_SYM_NAMLEN, &sym) == 0)
		mdb_printf("%?s  %20s = %s\n", "", "action_invoke", buf);
	else
		mdb_printf("%?s  %20s = 0x%p\n", "", "action_invoke",
		    ippo->ippo_action_invoke);

	mdb_printf("\n");

	mdb_free(ippo, sizeof (ipp_ops_t));
	return (DCMD_OK);
}

static int
ref_walk_init(
	mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	return (WALK_NEXT);
}

static int
ref_walk_step(
	mdb_walk_state_t *wsp)
{
	ipp_ref_t	*rp;
	int		status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	rp = mdb_alloc(sizeof (ipp_ref_t), UM_SLEEP);

	if (mdb_vread(rp, sizeof (ipp_ref_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read ipp_ref_t at %p", wsp->walk_addr);
		mdb_free(rp, sizeof (ipp_ref_t));
		return (WALK_ERR);
	}

	status = wsp->walk_callback((uintptr_t)rp->ippr_ptr, NULL,
	    wsp->walk_cbdata);

	wsp->walk_addr = (uintptr_t)(rp->ippr_nextp);

	mdb_free(rp, sizeof (ipp_ref_t));
	return (status);
}

/*ARGSUSED*/
static void
ref_walk_fini(
	mdb_walk_state_t *wsp)
{
}

/*ARGSUSED*/
static int
packet(
	uintptr_t	addr,
	uint_t		flags,
	int		argc,
	const mdb_arg_t	*argv)
{
	ipp_packet_t	*pp;

	if ((flags & DCMD_ADDRSPEC) == 0)
		return (DCMD_ERR);

	pp = mdb_alloc(sizeof (ipp_packet_t), UM_SLEEP);
	if (mdb_vread(pp, sizeof (ipp_packet_t), addr) == -1) {
		mdb_warn("failed to read ipp_packet_t at %p", addr);
		mdb_free(pp, sizeof (ipp_packet_t));
		return (DCMD_ERR);
	}

	mdb_printf("%?p: %20s = 0x%p\n", addr, "data", pp->ippp_data);
	mdb_printf("%?s  %20s = 0x%p\n", "", "private", pp->ippp_private);
	dump_classes((uintptr_t)pp->ippp_class_array, pp->ippp_class_windex);
	dump_log((uintptr_t)pp->ippp_log, pp->ippp_log_windex);

	mdb_free(pp, sizeof (ipp_packet_t));
	return (DCMD_OK);
}

static void
dump_classes(
	uintptr_t	ptr,
	uint_t		nelt)
{
	ipp_class_t	*array;
	ipp_class_t	*cp;
	uint_t		i;
	boolean_t	first_time = B_TRUE;
	char		buf[MAXNAMELEN];

	array = mdb_alloc(sizeof (ipp_class_t) * nelt, UM_SLEEP);
	if (mdb_vread(array, sizeof (ipp_class_t) * nelt, ptr) == -1) {
		mdb_warn("failed to read ipp_class_t array at %p", ptr);
		return;
	}

	for (i = 0; i < nelt; i++) {
		if (first_time) {
			mdb_printf("%20s  %?s   %<u>%15s %15s%</u>\n", "",
			    "classes", "NAME", "ACTION");
			first_time = B_FALSE;
		}

		cp = &(array[i]);
		aid2aname(cp->ippc_aid, buf);
		mdb_printf("%20s  %?p:  %15s %15s%\n", "",
		    ptr + (i * sizeof (ipp_class_t)), cp->ippc_name, buf);
	}

	mdb_free(cp, sizeof (ipp_class_t) * nelt);
}

static void
dump_log(
	uintptr_t	ptr,
	uint_t		nelt)
{
	ipp_log_t	*array;
	ipp_log_t	*lp;
	uint_t		i;
	boolean_t	first_time = B_TRUE;
	char		buf[MAXNAMELEN];

	array = mdb_alloc(sizeof (ipp_log_t) * nelt, UM_SLEEP);
	if (mdb_vread(array, sizeof (ipp_log_t) * nelt, ptr) == -1) {
		mdb_warn("failed to read ipp_log_t array at %p", ptr);
		return;
	}

	for (i = 0; i < nelt; i++) {
		if (first_time) {
			mdb_printf("%20s  %?s   %<u>%15s %15s%</u>\n", "",
			    "log", "CLASS NAME", "ACTION");
			first_time = B_FALSE;
		}

		lp = &(array[i]);
		aid2aname(lp->ippl_aid, buf);
		mdb_printf("%20s  %?p:  %15s %15s\n", "",
		    ptr + (i * sizeof (ipp_class_t)), lp->ippl_name, buf);
	}

	mdb_free(lp, sizeof (ipp_log_t) * nelt);
}

static void
aid2aname(
	ipp_action_id_t	aid,
	char		*buf)
{
	uintptr_t	addr;
	uintptr_t	ptr;
	ipp_action_t	*ap;

	switch (aid) {
	case IPP_ACTION_INVAL:
		strcpy(buf, "invalid");
		break;
	case IPP_ACTION_CONT:
		strcpy(buf, "continue");
		break;
	case IPP_ACTION_DEFER:
		strcpy(buf, "defer");
		break;
	case IPP_ACTION_DROP:
		strcpy(buf, "drop");
		break;
	default:
		if (mdb_vread(&addr, sizeof (uintptr_t),
		    ipp_action_byid) == -1) {
			mdb_warn("failed to read from address %p",
			    ipp_action_byid);
			strcpy(buf, "???");
			break;
		}

		addr += ((int32_t)aid * sizeof (void *));
		if (mdb_vread(&ptr, sizeof (uintptr_t), addr) == -1) {
			mdb_warn("failed to read from address %p", addr);
			strcpy(buf, "???");
			break;
		}

		ap = mdb_alloc(sizeof (ipp_action_t), UM_SLEEP);
		if (mdb_vread(ap, sizeof (ipp_action_t), ptr) == -1) {
			mdb_warn("failed to read ipp_action_t at %p", ptr);
			mdb_free(ap, sizeof (ipp_action_t));
			strcpy(buf, "???");
			break;
		}

		if (ap->ippa_id != aid) {
			mdb_warn("corrupt action at %p", ptr);
			mdb_free(ap, sizeof (ipp_action_t));
			strcpy(buf, "???");
			break;
		}

		strcpy(buf, ap->ippa_name);
	}
}

static const mdb_dcmd_t dcmds[] = {
	{ "ipp_action", "?[-v]",
	    "display ipp_action structure", action },
	{ "ipp_mod", "?[-v]",
	    "display ipp_mod structure", mod },
	{ "cfglock", ":",
	    "display cfglock structure", cfglock },
	{ "ippops", ":",
	    "display ipp_ops structure", ippops },
	{ "ipp_packet", ":",
	    "display ipp_packet structure", packet },
	{ NULL }
};

static const mdb_walker_t walkers[] = {
	{ "ipp_byid", "walk byid array", byid_walk_init, byid_walk_step,
	    byid_walk_fini },
	{ "ipp_ref", "walk reference list", ref_walk_init, ref_walk_step,
	    ref_walk_fini },
	{ NULL }
};

static const mdb_modinfo_t ipp_modinfo = { MDB_API_VERSION, dcmds, walkers };

const mdb_modinfo_t *
_mdb_init(void)
{
	GElf_Sym sym;

	if (mdb_lookup_by_name("ipp_action_byid", &sym) == -1) {
		mdb_warn("failed to lookup 'ipp_action_byid'");
		return (NULL);
	}

	ipp_action_byid = (uintptr_t)sym.st_value;

	if (mdb_lookup_by_name("ipp_mod_byid", &sym) == -1) {
		mdb_warn("failed to lookup 'ipp_mod_byid'");
		return (NULL);
	}

	ipp_mod_byid = (uintptr_t)sym.st_value;

	return (&ipp_modinfo);
}