[apple/xnu.git] / iokit / Kernel / IOKitDebug.cpp

/*
 * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * Copyright (c) 1998 Apple Computer, Inc.  All rights reserved. 
 *
 * HISTORY
 *
 */

#include <sys/sysctl.h>

#include <IOKit/IOKitDebug.h>
#include <IOKit/IOLib.h>
#include <IOKit/assert.h>
#include <IOKit/IODeviceTreeSupport.h>
#include <IOKit/IOService.h>

#include <libkern/c++/OSContainers.h>
#include <libkern/c++/OSCPPDebug.h>

#ifdef IOKITDEBUG
#define DEBUG_INIT_VALUE IOKITDEBUG
#else
#define DEBUG_INIT_VALUE 0
#endif

SInt64		gIOKitDebug = DEBUG_INIT_VALUE;
SYSCTL_QUAD(_debug, OID_AUTO, iokit, CTLFLAG_RW, &gIOKitDebug, "boot_arg io");


int 		debug_malloc_size;
int		debug_iomalloc_size;

vm_size_t	debug_iomallocpageable_size;
int 		debug_container_malloc_size;
// int 		debug_ivars_size; // in OSObject.cpp

extern "C" {


void IOPrintPlane( const IORegistryPlane * plane )
{
    IORegistryEntry *		next;
    IORegistryIterator * 	iter;
    OSOrderedSet *		all;
    char			format[] = "%xxxs";
    IOService *			service;

    iter = IORegistryIterator::iterateOver( plane );
    assert( iter );
    all = iter->iterateAll();
    if( all) {
        IOLog("Count %d\n", all->getCount() );
        all->release();
    } else
	IOLog("Empty\n");

    iter->reset();
    while( (next = iter->getNextObjectRecursive())) {
	snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane ));
	IOLog( format, "");
	IOLog( "\033[33m%s", next->getName( plane ));
	if( (next->getLocation( plane )))
            IOLog("@%s", next->getLocation( plane ));
	IOLog("\033[0m <class %s", next->getMetaClass()->getClassName());
        if( (service = OSDynamicCast(IOService, next)))
            IOLog(", busy %ld", service->getBusyState());
	IOLog( ">\n");
	IOSleep(250);
    }
    iter->release();
}

void dbugprintf(char *fmt, ...);
void db_dumpiojunk( const IORegistryPlane * plane );

void db_piokjunk(void) {

	dbugprintf("\nDT plane:\n");
	db_dumpiojunk( gIODTPlane );
	dbugprintf("\n\nService plane:\n");
	db_dumpiojunk( gIOServicePlane );
    dbugprintf("\n\n"
	    "ivar kalloc()       0x%08x\n"
	    "malloc()            0x%08x\n"
            "containers kalloc() 0x%08x\n"
	    "IOMalloc()          0x%08x\n"
            "----------------------------------------\n",
	    debug_ivars_size,
            debug_malloc_size,
            debug_container_malloc_size,
            debug_iomalloc_size
            );

}


void db_dumpiojunk( const IORegistryPlane * plane )
{
    IORegistryEntry *		next;
    IORegistryIterator * 	iter;
    OSOrderedSet *		all;
    char			format[] = "%xxxs";
    IOService *			service;

    iter = IORegistryIterator::iterateOver( plane );

    all = iter->iterateAll();
    if( all) {
        dbugprintf("Count %d\n", all->getCount() );
        all->release();
    } else dbugprintf("Empty\n");

    iter->reset();
    while( (next = iter->getNextObjectRecursive())) {
		snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane ));
		dbugprintf( format, "");
		dbugprintf( "%s", next->getName( plane ));
		if( (next->getLocation( plane )))
				dbugprintf("@%s", next->getLocation( plane ));
		dbugprintf(" <class %s", next->getMetaClass()->getClassName());
			if( (service = OSDynamicCast(IOService, next)))
				dbugprintf(", busy %ld", service->getBusyState());
		dbugprintf( ">\n");
    }
    iter->release();
}

void IOPrintMemory( void )
{

//    OSMetaClass::printInstanceCounts();

    IOLog("\n"
	    "ivar kalloc()       0x%08x\n"
	    "malloc()            0x%08x\n"
            "containers kalloc() 0x%08x\n"
	    "IOMalloc()          0x%08x\n"
            "----------------------------------------\n",
	    debug_ivars_size,
            debug_malloc_size,
            debug_container_malloc_size,
            debug_iomalloc_size
            );
}

} /* extern "C" */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#define super OSObject
OSDefineMetaClassAndStructors(IOKitDiagnostics, OSObject)

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

OSObject * IOKitDiagnostics::diagnostics( void )
{
    IOKitDiagnostics * diags;

    diags = new IOKitDiagnostics;
    if( diags && !diags->init()) {
	diags->release();
	diags = 0;
    }

    return( diags );
}

void IOKitDiagnostics::updateOffset( OSDictionary * dict,
			UInt32 value, const char * name )
{
    OSNumber * off;

    off = OSNumber::withNumber( value, 32 );
    if( !off)
	return;

    dict->setObject( name, off );
    off->release();
}

bool IOKitDiagnostics::serialize(OSSerialize *s) const
{
    OSDictionary * 	dict;
    bool		ok;

    dict = OSDictionary::withCapacity( 5 );
    if( !dict)
	return( false );

    updateOffset( dict, debug_ivars_size, "Instance allocation" );
    updateOffset( dict, debug_container_malloc_size, "Container allocation" );
    updateOffset( dict, debug_iomalloc_size, "IOMalloc allocation" );
    updateOffset( dict, debug_iomallocpageable_size, "Pageable allocation" );

    OSMetaClass::serializeClassDictionary(dict);

    ok = dict->serialize( s );

    dict->release();

    return( ok );
}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
Commit	Line	Data
1c79356b	1	/*
2d21ac55	2	* Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
1c79356b	3	*
2d21ac55	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
2d21ac55 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
8f6c56a5	14	*
2d21ac55 A	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
8f6c56a5 A	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
8f6c56a5 A	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
2d21ac55 A	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
8f6c56a5	25	*
2d21ac55	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	* Copyright (c) 1998 Apple Computer, Inc. All rights reserved.
	30	*
	31	* HISTORY
	32	*
	33	*/
	34
91447636 A	35	#include <sys/sysctl.h>
91447636 A	36
1c79356b A	37	#include <IOKit/IOKitDebug.h>
	38	#include <IOKit/IOLib.h>
	39	#include <IOKit/assert.h>
	40	#include <IOKit/IODeviceTreeSupport.h>
	41	#include <IOKit/IOService.h>
	42
	43	#include <libkern/c++/OSContainers.h>
	44	#include <libkern/c++/OSCPPDebug.h>
	45
1c79356b	46	#ifdef IOKITDEBUG
91447636 A	47	#define DEBUG_INIT_VALUE IOKITDEBUG
	48	#else
	49	#define DEBUG_INIT_VALUE 0
1c79356b	50	#endif
91447636 A	51
	52	SInt64 gIOKitDebug = DEBUG_INIT_VALUE;
	53	SYSCTL_QUAD(_debug, OID_AUTO, iokit, CTLFLAG_RW, &gIOKitDebug, "boot_arg io");
	54
1c79356b A	55
	56	int debug_malloc_size;
	57	int debug_iomalloc_size;
2d21ac55	58
91447636	59	vm_size_t debug_iomallocpageable_size;
1c79356b A	60	int debug_container_malloc_size;
	61	// int debug_ivars_size; // in OSObject.cpp
	62
91447636 A	63	extern "C" {
	64
	65
1c79356b A	66	void IOPrintPlane( const IORegistryPlane * plane )
	67	{
	68	IORegistryEntry * next;
	69	IORegistryIterator * iter;
	70	OSOrderedSet * all;
	71	char format[] = "%xxxs";
	72	IOService * service;
	73
	74	iter = IORegistryIterator::iterateOver( plane );
	75	assert( iter );
	76	all = iter->iterateAll();
	77	if( all) {
	78	IOLog("Count %d\n", all->getCount() );
	79	all->release();
	80	} else
	81	IOLog("Empty\n");
	82
	83	iter->reset();
	84	while( (next = iter->getNextObjectRecursive())) {
2d21ac55	85	snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane ));
1c79356b	86	IOLog( format, "");
0b4e3aa0 A	87	IOLog( "\033[33m%s", next->getName( plane ));
	88	if( (next->getLocation( plane )))
	89	IOLog("@%s", next->getLocation( plane ));
	90	IOLog("\033[0m <class %s", next->getMetaClass()->getClassName());
1c79356b	91	if( (service = OSDynamicCast(IOService, next)))
0b4e3aa0 A	92	IOLog(", busy %ld", service->getBusyState());
	93	IOLog( ">\n");
	94	IOSleep(250);
1c79356b A	95	}
	96	iter->release();
	97	}
	98
55e303ae A	99	void dbugprintf(char *fmt, ...);
	100	void db_dumpiojunk( const IORegistryPlane * plane );
	101
	102	void db_piokjunk(void) {
	103
	104	dbugprintf("\nDT plane:\n");
	105	db_dumpiojunk( gIODTPlane );
	106	dbugprintf("\n\nService plane:\n");
	107	db_dumpiojunk( gIOServicePlane );
	108	dbugprintf("\n\n"
	109	"ivar kalloc() 0x%08x\n"
	110	"malloc() 0x%08x\n"
	111	"containers kalloc() 0x%08x\n"
	112	"IOMalloc() 0x%08x\n"
	113	"----------------------------------------\n",
	114	debug_ivars_size,
	115	debug_malloc_size,
	116	debug_container_malloc_size,
	117	debug_iomalloc_size
	118	);
	119
	120	}
	121
	122
	123	void db_dumpiojunk( const IORegistryPlane * plane )
	124	{
	125	IORegistryEntry * next;
	126	IORegistryIterator * iter;
	127	OSOrderedSet * all;
	128	char format[] = "%xxxs";
	129	IOService * service;
	130
	131	iter = IORegistryIterator::iterateOver( plane );
	132
	133	all = iter->iterateAll();
	134	if( all) {
	135	dbugprintf("Count %d\n", all->getCount() );
	136	all->release();
	137	} else dbugprintf("Empty\n");
	138
	139	iter->reset();
	140	while( (next = iter->getNextObjectRecursive())) {
2d21ac55	141	snprintf(format + 1, sizeof(format) - 1, "%ds", 2 * next->getDepth( plane ));
55e303ae A	142	dbugprintf( format, "");
	143	dbugprintf( "%s", next->getName( plane ));
	144	if( (next->getLocation( plane )))
	145	dbugprintf("@%s", next->getLocation( plane ));
	146	dbugprintf(" <class %s", next->getMetaClass()->getClassName());
	147	if( (service = OSDynamicCast(IOService, next)))
	148	dbugprintf(", busy %ld", service->getBusyState());
	149	dbugprintf( ">\n");
	150	}
	151	iter->release();
	152	}
	153
1c79356b A	154	void IOPrintMemory( void )
	155	{
	156
	157	// OSMetaClass::printInstanceCounts();
	158
	159	IOLog("\n"
	160	"ivar kalloc() 0x%08x\n"
	161	"malloc() 0x%08x\n"
	162	"containers kalloc() 0x%08x\n"
	163	"IOMalloc() 0x%08x\n"
	164	"----------------------------------------\n",
	165	debug_ivars_size,
	166	debug_malloc_size,
	167	debug_container_malloc_size,
	168	debug_iomalloc_size
	169	);
	170	}
	171
	172	} /* extern "C" */
	173
	174	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	175
	176	#define super OSObject
	177	OSDefineMetaClassAndStructors(IOKitDiagnostics, OSObject)
	178
	179	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	180
	181	OSObject * IOKitDiagnostics::diagnostics( void )
	182	{
	183	IOKitDiagnostics * diags;
	184
	185	diags = new IOKitDiagnostics;
	186	if( diags && !diags->init()) {
	187	diags->release();
	188	diags = 0;
	189	}
	190
	191	return( diags );
	192	}
	193
	194	void IOKitDiagnostics::updateOffset( OSDictionary * dict,
	195	UInt32 value, const char * name )
	196	{
	197	OSNumber * off;
	198
	199	off = OSNumber::withNumber( value, 32 );
	200	if( !off)
	201	return;
	202
	203	dict->setObject( name, off );
	204	off->release();
	205	}
	206
1c79356b A	207	bool IOKitDiagnostics::serialize(OSSerialize *s) const
	208	{
	209	OSDictionary * dict;
	210	bool ok;
	211
	212	dict = OSDictionary::withCapacity( 5 );
	213	if( !dict)
	214	return( false );
	215
	216	updateOffset( dict, debug_ivars_size, "Instance allocation" );
	217	updateOffset( dict, debug_container_malloc_size, "Container allocation" );
	218	updateOffset( dict, debug_iomalloc_size, "IOMalloc allocation" );
91447636	219	updateOffset( dict, debug_iomallocpageable_size, "Pageable allocation" );
1c79356b	220
55e303ae	221	OSMetaClass::serializeClassDictionary(dict);
1c79356b A	222
	223	ok = dict->serialize( s );
	224
	225	dict->release();
	226
	227	return( ok );
	228	}
	229
	230	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */