Exemplo n.º 1
0
void
DT__PrintFlattenedNode(DTEntry entry, int level)
{
	char spaces[10], *cp = spaces;
	DTPropertyIterator	                propIter;
	char *name;
	void *prop;
	int propSize;

	if (level > 9) level = 9;
	while (level--) *cp++ = ' ';
		*cp = '\0';

	printf("%s===Entry %p===\n", spaces, entry);
		if (kSuccess != DTCreatePropertyIterator(entry, &propIter))
		{
			printf("Couldn't create property iterator\n");
			return;
		}
		while( kSuccess == DTIterateProperties( propIter, &name))
		{
			if(  kSuccess != DTGetProperty( entry, name, &prop, &propSize ))
				continue;
		printf("%s Property %s = %s\n", spaces, name, prop);
	}
	DTDisposePropertyIterator(propIter);

	printf("%s==========\n", spaces);
}
Exemplo n.º 2
0
//
// Iterates over kexts loaded by booter
// and calls PatchKext() for each.
//
VOID
PatchLoadedKexts (
    VOID
)
{
    DTEntry             MMEntry;
    _BooterKextFileInfo *KextFileInfo;
    CHAR8               *PropName;
    _DeviceTreeBuffer   *PropEntry;
    CHAR8               SavedValue;
    CHAR8               *InfoPlist;

    struct OpaqueDTPropertyIterator OPropIter;
    DTPropertyIterator	PropIter = &OPropIter;

    if (!dtRoot) {
        return;
    }

    DTInit(dtRoot);

    if (DTLookupEntry(NULL,"/chosen/memory-map", &MMEntry) == kSuccess)
    {
        if (DTCreatePropertyIteratorNoAlloc(MMEntry, PropIter) == kSuccess)
        {
            while (DTIterateProperties(PropIter, &PropName) == kSuccess)
            {
                if (AsciiStrStr(PropName,"Driver-"))
                {
                    PropEntry = (_DeviceTreeBuffer*)(((UINT8*)PropIter->currentProperty) + sizeof(DeviceTreeNodeProperty));
                    KextFileInfo = (_BooterKextFileInfo *)(UINTN)PropEntry->paddr;
                    // Info.plist should be terminated with 0, but will also do it just in case
                    InfoPlist = (CHAR8*)(UINTN)KextFileInfo->infoDictPhysAddr;
                    SavedValue = InfoPlist[KextFileInfo->infoDictLength];
                    InfoPlist[KextFileInfo->infoDictLength] = '\0';

                    PatchKext(
                        (UINT8*)(UINTN)KextFileInfo->executablePhysAddr,
                        KextFileInfo->executableLength,
                        InfoPlist,
                        KextFileInfo->infoDictLength
                    );

                    InfoPlist[KextFileInfo->infoDictLength] = SavedValue;
                }
            }
        }
    }
}
Exemplo n.º 3
0
int
main(int argc, char **argv)
{
	DTEntry			dtEntry;
	DTPropertyIterator	propIter;
	DTEntryIterator		entryIter;
	void			*prop;
	int			propSize;
	char			*name;
	void			*flatTree;
	uint32_t		flatSize;

	Node *node;

	node = AddChild(NULL, "device-tree");
	AddProperty(node, "potato", 4, "foo");
	AddProperty(node, "chemistry", 4, "bar");
	AddProperty(node, "physics", 4, "baz");

	node = AddChild(node, "dev");
	AddProperty(node, "one", 4, "one");
	AddProperty(node, "two", 4, "two");
	AddProperty(node, "three", 6, "three");

	node = AddChild(rootNode, "foo");
	AddProperty(node, "aaa", 4, "aab");
	AddProperty(node, "bbb", 4, "bbc");
	AddProperty(node, "cccc", 6, "ccccd");

	node = FindNode("/this/is/a/test", 1);
	AddProperty(node, "dddd", 12, "abcdefghijk");

	printf("In-memory tree:\n\n");

	PrintTree(rootNode);

	FlattenDeviceTree(&flatTree, &flatSize);

	printf("Flat tree = %p, size %d\n", flatTree, flatSize);

	dtEntry = (DTEntry)flatTree;

	printf("\n\nPrinting flat tree\n\n");

	DTInit(dtEntry);

	PrintFlattenedTree((DTEntry)flatTree);
#if 0
	printf("=== Entry %p ===\n", dtEntry);
	if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter))
	{
		printf("Couldn't create property iterator\n");
		return 1;
	}
	while( kSuccess == DTIterateProperties( propIter, &name))
	{
		if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
			continue;
		printf(" Property %s = %s\n", name, prop);
        }
	DTDisposePropertyIterator(propIter);
	printf("========\n");

	if (kSuccess != DTCreateEntryIterator(dtEntry, &entryIter))
	{
		printf("Couldn't create entry iterator\n");
		return 1;
	}
	while (kSuccess == DTIterateEntries( entryIter, &dtEntry ))
	{
		printf("=== Entry %p ===\n", dtEntry);

	if (kSuccess != DTCreatePropertyIterator(dtEntry, &propIter))
	{
		printf("Couldn't create property iterator\n");
		return 1;
	}
		while( kSuccess == DTIterateProperties( propIter, &name))
		{
			if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
				continue;
			printf(" Property %s = %s\n", name, prop);
		}
		DTDisposePropertyIterator(propIter);
		printf("========\n");
	}
	DTDisposeEntryIterator(entryIter);
#endif

	return 0;
}
Exemplo n.º 4
0
static IORegistryEntry *
MakeReferenceTable( DTEntry dtEntry, bool copy )
{
    IORegistryEntry		*regEntry;
    OSDictionary		*propTable;
    const OSSymbol		*nameKey;
    OSData				*data;
    const OSSymbol		*sym;
    DTPropertyIterator	dtIter;
    void				*prop;
    unsigned int		propSize;
    char				*name;
    char				location[ 32 ];
    bool				noLocation = true;

    regEntry = new IOService;

    if( regEntry && (false == regEntry->init())) {
        regEntry->release();
        regEntry = 0;
    }

    if( regEntry &&
      (kSuccess == DTCreatePropertyIterator( dtEntry, &dtIter))) {

        propTable = regEntry->getPropertyTable();

        while( kSuccess == DTIterateProperties( dtIter, &name)) {

            if(  kSuccess != DTGetProperty( dtEntry, name, &prop, &propSize ))
                continue;

            if( copy) {
                nameKey = OSSymbol::withCString(name);
                data = OSData::withBytes(prop, propSize);
            } else {
                nameKey = OSSymbol::withCStringNoCopy(name);
                data = OSData::withBytesNoCopy(prop, propSize);
            }
            assert( nameKey && data );

            propTable->setObject( nameKey, data);
            data->release();
            nameKey->release();

            if( nameKey == gIODTNameKey ) {
                if( copy)
                    sym = OSSymbol::withCString( (const char *) prop);
                else
                    sym = OSSymbol::withCStringNoCopy( (const char *) prop);
                regEntry->setName( sym );
                sym->release();

            } else if( nameKey == gIODTUnitKey ) {
                // all OF strings are null terminated... except this one
                if( propSize >= (int) sizeof(location))
                    propSize = sizeof(location) - 1;
                strncpy( location, (const char *) prop, propSize );
                location[ propSize ] = 0;
                regEntry->setLocation( location );
                propTable->removeObject( gIODTUnitKey );
                noLocation = false;
    
            } else if(noLocation && (!strncmp(name, "reg", sizeof("reg")))) {
                // default location - override later
                snprintf(location, sizeof(location), "%X", *((uint32_t *) prop));
                regEntry->setLocation( location );
            }
        }
        DTDisposePropertyIterator( dtIter);
    }

    return( regEntry);
}