xnu-6153.121.1.tar.gz

[apple/xnu.git] / pexpert / gen / device_tree.c

diff --git a/pexpert/gen/device_tree.c b/pexpert/gen/device_tree.c
index fe8e6940cb3545babdf8be14caad479e82be3a85..ef57446886374b3634121f6da3a7d27a3263ff73 100644 (file)
--- a/pexpert/gen/device_tree.c
+++ b/pexpert/gen/device_tree.c
@@ -1,23 +1,29 @@
 /*
  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
  *
 /*
  * Copyright (c) 2000-2004 Apple Computer, Inc. All rights reserved.
  *

- * @APPLE_LICENSE_HEADER_START@
- * 
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
- * 
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * @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,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
- * 
- * @APPLE_LICENSE_HEADER_END@
+ * 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@

  */
 /*
  * @OSF_FREE_COPYRIGHT@
  */
 /*
  * @OSF_FREE_COPYRIGHT@


@@ -29,60 +35,35 @@
 
 #include <mach/mach_types.h>
 #include <mach/machine/vm_types.h>
 
 #include <mach/mach_types.h>
 #include <mach/machine/vm_types.h>

+#include <kern/debug.h>

 #include <kern/kern_types.h>
 #include <kern/kalloc.h>
 #include <kern/kern_types.h>
 #include <kern/kalloc.h>

+#include <os/overflow.h>

 
 #include <sys/types.h>
 
 #include <sys/types.h>

-#ifdef i386
-#include <i386/fakePPCStructs.h>
-#endif
-
-#ifndef NULL
-#define       NULL    ((void *) 0)
-#endif
-
-#define round_long(x)  (((x) + 3) & -4)
-#define next_prop(x)   ((DeviceTreeNodeProperty *) (((int)x) + sizeof(DeviceTreeNodeProperty) + round_long(x->length)))
-
-/* Entry*/
-typedef DeviceTreeNode *RealDTEntry;
-
-typedef struct DTSavedScope {
-       struct DTSavedScope * nextScope;
-       RealDTEntry scope;
-       RealDTEntry entry;
-       unsigned long index;            
-} *DTSavedScopePtr;
-
-/* Entry Iterator*/
-typedef struct OpaqueDTEntryIterator {
-       RealDTEntry outerScope;
-       RealDTEntry currentScope;
-       RealDTEntry currentEntry;
-       DTSavedScopePtr savedScope;
-       unsigned long currentIndex;             
-} *RealDTEntryIterator;
-
-/* Property Iterator*/
-typedef struct OpaqueDTPropertyIterator {
-       RealDTEntry entry;
-       DeviceTreeNodeProperty *currentProperty;
-       unsigned long currentIndex;
-} *RealDTPropertyIterator;

 
 static int DTInitialized;
 static RealDTEntry DTRootNode;
 
 
 static int DTInitialized;
 static RealDTEntry DTRootNode;
 

-void DTInit(void *base);
-

 /*
  * Support Routines
  */
 /*
  * Support Routines
  */

+static inline DeviceTreeNodeProperty*
+next_prop(DeviceTreeNodeProperty* prop)
+{
+       uintptr_t next_addr;
+       if (os_add3_overflow((uintptr_t)prop, prop->length, sizeof(DeviceTreeNodeProperty) + 3, &next_addr)) {
+               panic("Device tree property overflow: prop %p, length 0x%x\n", prop, prop->length);
+       }
+       next_addr &= ~(3ULL);
+       return (DeviceTreeNodeProperty*)next_addr;
+}
+

 static RealDTEntry
 skipProperties(RealDTEntry entry)
 {
        DeviceTreeNodeProperty *prop;
 static RealDTEntry
 skipProperties(RealDTEntry entry)
 {
        DeviceTreeNodeProperty *prop;

-       int k;
+       unsigned int k;

 
        if (entry == NULL || entry->nProperties == 0) {
                return NULL;
 
        if (entry == NULL || entry->nProperties == 0) {
                return NULL;


@@ -92,14 +73,14 @@ skipProperties(RealDTEntry entry)
                        prop = next_prop(prop);
                }
        }
                        prop = next_prop(prop);
                }
        }

-       return ((RealDTEntry) prop);
+       return (RealDTEntry) prop;

 }
 
 static RealDTEntry
 skipTree(RealDTEntry root)
 {
        RealDTEntry entry;
 }
 
 static RealDTEntry
 skipTree(RealDTEntry root)
 {
        RealDTEntry entry;

-       int k;
+       unsigned int k;

 
        entry = skipProperties(root);
        if (entry == NULL) {
 
        entry = skipProperties(root);
        if (entry == NULL) {


@@ -126,11 +107,18 @@ GetNextChild(RealDTEntry sibling)
 static const char *
 GetNextComponent(const char *cp, char *bp)
 {
 static const char *
 GetNextComponent(const char *cp, char *bp)
 {

+       size_t length = 0;
+       char *origbp = bp;
+

        while (*cp != 0) {
                if (*cp == kDTPathNameSeparator) {
                        cp++;
                        break;
                }
        while (*cp != 0) {
                if (*cp == kDTPathNameSeparator) {
                        cp++;
                        break;
                }

+               if (++length > kDTMaxEntryNameLength) {
+                       *origbp = '\0';
+                       return cp;
+               }

                *bp++ = *cp++;
        }
        *bp = 0;
                *bp++ = *cp++;
        }
        *bp = 0;


@@ -140,10 +128,10 @@ GetNextComponent(const char *cp, char *bp)
 static RealDTEntry
 FindChild(RealDTEntry cur, char *buf)
 {
 static RealDTEntry
 FindChild(RealDTEntry cur, char *buf)
 {

-       RealDTEntry     child;
-       unsigned long   index;
-       char *          str;
-       int             dummy;
+       RealDTEntry     child;
+       unsigned long   index;
+       char *                  str;
+       unsigned int    dummy;

 
        if (cur->nChildren == 0) {
                return NULL;
 
        if (cur->nChildren == 0) {
                return NULL;


@@ -181,60 +169,63 @@ int
 DTEntryIsEqual(const DTEntry ref1, const DTEntry ref2)
 {
        /* equality of pointers */
 DTEntryIsEqual(const DTEntry ref1, const DTEntry ref2)
 {
        /* equality of pointers */

-       return (ref1 == ref2);
+       return ref1 == ref2;

 }
 
 }
 

-static char *startingP;                // needed for find_entry
+static char *startingP;         // needed for find_entry

 int find_entry(const char *propName, const char *propValue, DTEntry *entryH);
 
 int find_entry(const char *propName, const char *propValue, DTEntry *entryH);
 

-int DTFindEntry(const char *propName, const char *propValue, DTEntry *entryH)
+int
+DTFindEntry(const char *propName, const char *propValue, DTEntry *entryH)

 {
        if (!DTInitialized) {
                return kError;
        }
 
        startingP = (char *)DTRootNode;
 {
        if (!DTInitialized) {
                return kError;
        }
 
        startingP = (char *)DTRootNode;

-       return(find_entry(propName, propValue, entryH));
+       return find_entry(propName, propValue, entryH);

 }
 
 }
 

-int find_entry(const char *propName, const char *propValue, DTEntry *entryH)
+int
+find_entry(const char *propName, const char *propValue, DTEntry *entryH)

 {
 {

-       DeviceTreeNode *nodeP = (DeviceTreeNode *) startingP;
-       int k;
+       DeviceTreeNode *nodeP = (DeviceTreeNode *) (void *) startingP;
+       unsigned int k;

 
 

-       if (nodeP->nProperties == 0) return(kError);    // End of the list of nodes
+       if (nodeP->nProperties == 0) {
+               return kError;                        // End of the list of nodes
+       }

        startingP = (char *) (nodeP + 1);
 
        // Search current entry
        for (k = 0; k < nodeP->nProperties; ++k) {
        startingP = (char *) (nodeP + 1);
 
        // Search current entry
        for (k = 0; k < nodeP->nProperties; ++k) {

-               DeviceTreeNodeProperty *propP = (DeviceTreeNodeProperty *) startingP;
+               DeviceTreeNodeProperty *propP = (DeviceTreeNodeProperty *) (void *) startingP;

 
 

-               startingP += sizeof (*propP) + ((propP->length + 3) & -4);
+               startingP += sizeof(*propP) + ((propP->length + 3) & -4);

 
 

-               if (strcmp (propP->name, propName) == 0) {
-                       if (strcmp( (char *)(propP + 1), propValue) == 0)
-                       {
+               if (strcmp(propP->name, propName) == 0) {
+                       if (propValue == NULL || strcmp((char *)(propP + 1), propValue) == 0) {

                                *entryH = (DTEntry)nodeP;
                                *entryH = (DTEntry)nodeP;

-                               return(kSuccess);
+                               return kSuccess;

                        }
                }
        }
 
        // Search child nodes
                        }
                }
        }
 
        // Search child nodes

-       for (k = 0; k < nodeP->nChildren; ++k)
-       {
-               if (find_entry(propName, propValue, entryH) == kSuccess)
-                       return(kSuccess);
+       for (k = 0; k < nodeP->nChildren; ++k) {
+               if (find_entry(propName, propValue, entryH) == kSuccess) {
+                       return kSuccess;
+               }

        }
        }

-       return(kError);
+       return kError;

 }
 
 int
 DTLookupEntry(const DTEntry searchPoint, const char *pathName, DTEntry *foundEntry)
 {
 }
 
 int
 DTLookupEntry(const DTEntry searchPoint, const char *pathName, DTEntry *foundEntry)
 {

-       DTEntryNameBuf  buf;
-       RealDTEntry     cur;
-       const char *    cp;
+       DTEntryNameBuf  buf;
+       RealDTEntry     cur;
+       const char *    cp;

 
        if (!DTInitialized) {
                return kError;
 
        if (!DTInitialized) {
                return kError;


@@ -265,22 +256,18 @@ DTLookupEntry(const DTEntry searchPoint, const char *pathName, DTEntry *foundEnt
                }
 
                cur = FindChild(cur, buf);
                }
 
                cur = FindChild(cur, buf);

-

        } while (cur != NULL);
 
        return kError;
 }
 
 int
        } while (cur != NULL);
 
        return kError;
 }
 
 int

-DTCreateEntryIterator(const DTEntry startEntry, DTEntryIterator *iterator)
+DTInitEntryIterator(const DTEntry startEntry, DTEntryIterator iter)

 {
 {

-       RealDTEntryIterator iter;
-

        if (!DTInitialized) {
                return kError;
        }
 
        if (!DTInitialized) {
                return kError;
        }
 

-       iter = (RealDTEntryIterator) kalloc(sizeof(struct OpaqueDTEntryIterator));

        if (startEntry != NULL) {
                iter->outerScope = (RealDTEntry) startEntry;
                iter->currentScope = (RealDTEntry) startEntry;
        if (startEntry != NULL) {
                iter->outerScope = (RealDTEntry) startEntry;
                iter->currentScope = (RealDTEntry) startEntry;


@@ -292,28 +279,12 @@ DTCreateEntryIterator(const DTEntry startEntry, DTEntryIterator *iterator)
        iter->savedScope = NULL;
        iter->currentIndex = 0;
 
        iter->savedScope = NULL;
        iter->currentIndex = 0;
 

-       *iterator = iter;
-       return kSuccess;
-}
-
-int
-DTDisposeEntryIterator(DTEntryIterator iterator)
-{
-       RealDTEntryIterator iter = iterator;
-       DTSavedScopePtr scope;
-
-       while ((scope = iter->savedScope) != NULL) {
-               iter->savedScope = scope->nextScope;
-               kfree(scope, sizeof(struct DTSavedScope));
-       }
-       kfree(iterator, sizeof(struct OpaqueDTEntryIterator));

        return kSuccess;
 }
 
 int
        return kSuccess;
 }
 
 int

-DTEnterEntry(DTEntryIterator iterator, DTEntry childEntry)
+DTEnterEntry(DTEntryIterator iter, DTEntry childEntry)

 {
 {

-       RealDTEntryIterator iter = iterator;

        DTSavedScopePtr newScope;
 
        if (childEntry == NULL) {
        DTSavedScopePtr newScope;
 
        if (childEntry == NULL) {


@@ -323,7 +294,7 @@ DTEnterEntry(DTEntryIterator iterator, DTEntry childEntry)
        newScope->nextScope = iter->savedScope;
        newScope->scope = iter->currentScope;
        newScope->entry = iter->currentEntry;
        newScope->nextScope = iter->savedScope;
        newScope->scope = iter->currentScope;
        newScope->entry = iter->currentEntry;

-       newScope->index = iter->currentIndex;           
+       newScope->index = iter->currentIndex;

 
        iter->currentScope = childEntry;
        iter->currentEntry = NULL;
 
        iter->currentScope = childEntry;
        iter->currentEntry = NULL;


@@ -334,9 +305,8 @@ DTEnterEntry(DTEntryIterator iterator, DTEntry childEntry)
 }
 
 int
 }
 
 int

-DTExitEntry(DTEntryIterator iterator, DTEntry *currentPosition)
+DTExitEntry(DTEntryIterator iter, DTEntry *currentPosition)

 {
 {

-       RealDTEntryIterator iter = iterator;

        DTSavedScopePtr newScope;
 
        newScope = iter->savedScope;
        DTSavedScopePtr newScope;
 
        newScope = iter->savedScope;


@@ -355,10 +325,8 @@ DTExitEntry(DTEntryIterator iterator, DTEntry *currentPosition)
 }
 
 int
 }
 
 int

-DTIterateEntries(DTEntryIterator iterator, DTEntry *nextEntry)
+DTIterateEntries(DTEntryIterator iter, DTEntry *nextEntry)

 {
 {

-       RealDTEntryIterator iter = iterator;
-

        if (iter->currentIndex >= iter->currentScope->nChildren) {
                *nextEntry = NULL;
                return kIterationDone;
        if (iter->currentIndex >= iter->currentScope->nChildren) {
                *nextEntry = NULL;
                return kIterationDone;


@@ -375,9 +343,8 @@ DTIterateEntries(DTEntryIterator iterator, DTEntry *nextEntry)
 }
 
 int
 }
 
 int

-DTRestartEntryIteration(DTEntryIterator iterator)
+DTRestartEntryIteration(DTEntryIterator iter)

 {
 {

-       RealDTEntryIterator iter = iterator;

 #if 0
        // This commented out code allows a second argument (outer)
        // which (if true) causes restarting at the outer scope
 #if 0
        // This commented out code allows a second argument (outer)
        // which (if true) causes restarting at the outer scope


@@ -398,10 +365,10 @@ DTRestartEntryIteration(DTEntryIterator iterator)
 }
 
 int
 }
 
 int

-DTGetProperty(const DTEntry entry, const char *propertyName, void **propertyValue, int *propertySize)
+DTGetProperty(const DTEntry entry, const char *propertyName, void **propertyValue, unsigned int *propertySize)

 {
        DeviceTreeNodeProperty *prop;
 {
        DeviceTreeNodeProperty *prop;

-       int k;
+       unsigned int k;

 
        if (entry == NULL || entry->nProperties == 0) {
                return kError;
 
        if (entry == NULL || entry->nProperties == 0) {
                return kError;


@@ -409,8 +376,8 @@ DTGetProperty(const DTEntry entry, const char *propertyName, void **propertyValu
                prop = (DeviceTreeNodeProperty *) (entry + 1);
                for (k = 0; k < entry->nProperties; k++) {
                        if (strcmp(prop->name, propertyName) == 0) {
                prop = (DeviceTreeNodeProperty *) (entry + 1);
                for (k = 0; k < entry->nProperties; k++) {
                        if (strcmp(prop->name, propertyName) == 0) {

-                               *propertyValue = (void *) (((int)prop)
-                                               + sizeof(DeviceTreeNodeProperty));
+                               *propertyValue = (void *) (((uintptr_t)prop)
+                                   + sizeof(DeviceTreeNodeProperty));

                                *propertySize = prop->length;
                                return kSuccess;
                        }
                                *propertySize = prop->length;
                                return kSuccess;
                        }


@@ -421,31 +388,17 @@ DTGetProperty(const DTEntry entry, const char *propertyName, void **propertyValu
 }
 
 int
 }
 
 int

-DTCreatePropertyIterator(const DTEntry entry, DTPropertyIterator *iterator)
+DTInitPropertyIterator(const DTEntry entry, DTPropertyIterator iter)

 {
 {

-       RealDTPropertyIterator iter;
-
-       iter = (RealDTPropertyIterator) kalloc(sizeof(struct OpaqueDTPropertyIterator));

        iter->entry = entry;
        iter->currentProperty = NULL;
        iter->currentIndex = 0;
        iter->entry = entry;
        iter->currentProperty = NULL;
        iter->currentIndex = 0;

-
-       *iterator = iter;

        return kSuccess;
 }
 
 int
        return kSuccess;
 }
 
 int

-DTDisposePropertyIterator(DTPropertyIterator iterator)
+DTIterateProperties(DTPropertyIterator iter, char **foundProperty)

 {
 {

-       kfree(iterator, sizeof(struct OpaqueDTPropertyIterator));
-       return kSuccess;
-}
-
-int
-DTIterateProperties(DTPropertyIterator iterator, char **foundProperty)
-{
-       RealDTPropertyIterator iter = iterator;
-

        if (iter->currentIndex >= iter->entry->nProperties) {
                *foundProperty = NULL;
                return kIterationDone;
        if (iter->currentIndex >= iter->entry->nProperties) {
                *foundProperty = NULL;
                return kIterationDone;


@@ -462,12 +415,9 @@ DTIterateProperties(DTPropertyIterator iterator, char **foundProperty)
 }
 
 int
 }
 
 int

-DTRestartPropertyIteration(DTPropertyIterator iterator)
+DTRestartPropertyIteration(DTPropertyIterator iter)

 {
 {

-       RealDTPropertyIterator iter = iterator;
-

        iter->currentProperty = NULL;
        iter->currentIndex = 0;
        return kSuccess;
 }
        iter->currentProperty = NULL;
        iter->currentIndex = 0;
        return kSuccess;
 }

-