xnu-2050.18.24.tar.gz

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

diff --git a/iokit/Kernel/IOLib.cpp b/iokit/Kernel/IOLib.cpp
index a5415e71cb12f573ee57695c3cf3ecc496030fb4..886176acf7b3510f54197c1e6642dce70316193c 100644 (file)
--- a/iokit/Kernel/IOLib.cpp
+++ b/iokit/Kernel/IOLib.cpp
@@ -55,6 +55,24 @@
 #include <sys/sysctl.h>
 #endif
 
+#include "libkern/OSAtomic.h"
+#include <libkern/c++/OSKext.h>
+#include <IOKit/IOStatisticsPrivate.h>
+#include <sys/msgbuf.h>
+
+#if IOKITSTATS
+
+#define IOStatisticsAlloc(type, size) \
+do { \
+       IOStatistics::countAlloc(type, size); \
+} while (0)
+
+#else
+
+#define IOStatisticsAlloc(type, size)
+
+#endif /* IOKITSTATS */
+
 extern "C"
 {
 
@@ -63,7 +81,7 @@ mach_timespec_t IOZeroTvalspec = { 0, 0 };
 
 extern ppnum_t pmap_find_phys(pmap_t pmap, addr64_t va);
 
-int
+extern int
 __doprnt(
        const char              *fmt,
        va_list                 argp,
@@ -71,7 +89,9 @@ __doprnt(
        void                    *arg,
        int                     radix);
 
-extern void conslog_putc(char);
+extern void cons_putc_locked(char);
+extern void bsd_log_lock(void);
+extern void bsd_log_unlock(void);
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -178,11 +198,13 @@ void * IOMalloc(vm_size_t size)
     void * address;
 
     address = (void *)kalloc(size);
+    if ( address ) {
 #if IOALLOCDEBUG
-    if (address) {
                debug_iomalloc_size += size;
-       }
 #endif
+               IOStatisticsAlloc(kIOStatisticsMalloc, size);
+    }
+
     return address;
 }
 
@@ -193,6 +215,7 @@ void IOFree(void * address, vm_size_t size)
 #if IOALLOCDEBUG
                debug_iomalloc_size -= size;
 #endif
+               IOStatisticsAlloc(kIOStatisticsFree, size);
     }
 }
 
@@ -214,7 +237,10 @@ void * IOMallocAligned(vm_size_t size, vm_size_t alignment)
     alignMask = alignment - 1;
     adjustedSize = size + sizeof(vm_size_t) + sizeof(vm_address_t);
 
-    if (adjustedSize >= page_size) {
+    if (size > adjustedSize) {
+           address = 0;    /* overflow detected */
+    }
+    else if (adjustedSize >= page_size) {
 
         kr = kernel_memory_allocate(kernel_map, &address,
                                        size, alignMask, 0);
@@ -250,11 +276,12 @@ void * IOMallocAligned(vm_size_t size, vm_size_t alignment)
 
     assert(0 == (address & alignMask));
 
-#if IOALLOCDEBUG
     if( address) {
+#if IOALLOCDEBUG
                debug_iomalloc_size += size;
-       }
 #endif
+       IOStatisticsAlloc(kIOStatisticsMallocAligned, size);
+       }
 
     return (void *) address;
 }
@@ -289,6 +316,8 @@ void IOFreeAligned(void * address, vm_size_t size)
 #if IOALLOCDEBUG
     debug_iomalloc_size -= size;
 #endif
+
+    IOStatisticsAlloc(kIOStatisticsFreeAligned, size);
 }
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -318,6 +347,7 @@ IOKernelFreePhysical(mach_vm_address_t address, mach_vm_size_t size)
        kfree((void *)allocationAddress, adjustedSize);
     }
 
+    IOStatisticsAlloc(kIOStatisticsFreeContiguous, size);
 #if IOALLOCDEBUG
     debug_iomalloc_size -= size;
 #endif
@@ -325,7 +355,7 @@ IOKernelFreePhysical(mach_vm_address_t address, mach_vm_size_t size)
 
 mach_vm_address_t
 IOKernelAllocateWithPhysicalRestrict(mach_vm_size_t size, mach_vm_address_t maxPhys, 
-                                    mach_vm_size_t alignment, bool contiguous)
+                                       mach_vm_size_t alignment, bool contiguous)
 {
     kern_return_t      kr;
     mach_vm_address_t  address;
@@ -353,12 +383,18 @@ IOKernelAllocateWithPhysicalRestrict(mach_vm_size_t size, mach_vm_address_t maxP
         contiguous = (contiguous && (adjustedSize > page_size))
                            || (alignment > page_size);
 
-        if ((!contiguous) && (maxPhys <= 0xFFFFFFFF))
-        {
-            maxPhys = 0;
-            options |= KMA_LOMEM;
-        }
-
+       if (!contiguous)
+       {
+           if (maxPhys <= 0xFFFFFFFF)
+           {
+               maxPhys = 0;
+               options |= KMA_LOMEM;
+           }
+           else if (gIOLastPage && (atop_64(maxPhys) > gIOLastPage))
+           {
+               maxPhys = 0;
+           }
+       }
        if (contiguous || maxPhys)
        {
            kr = kmem_alloc_contig(kernel_map, &virt, size,
@@ -396,15 +432,17 @@ IOKernelAllocateWithPhysicalRestrict(mach_vm_size_t size, mach_vm_address_t maxP
            address = 0;
     }
 
-#if IOALLOCDEBUG
     if (address) {
+    IOStatisticsAlloc(kIOStatisticsMallocContiguous, size);
+#if IOALLOCDEBUG
        debug_iomalloc_size += size;
-    }
 #endif
+    }
 
     return (address);
 }
 
+
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 struct _IOMallocContiguousEntry
@@ -603,10 +641,12 @@ void * IOMallocPageable(vm_size_t size, vm_size_t alignment)
     if( kIOReturnSuccess != kr)
         ref.address = 0;
 
+       if( ref.address) {
 #if IOALLOCDEBUG
-    if( ref.address)
        debug_iomallocpageable_size += round_page(size);
 #endif
+       IOStatisticsAlloc(kIOStatisticsMallocPageable, size);
+       }
 
     return( (void *) ref.address );
 }
@@ -640,6 +680,8 @@ void IOFreePageable(void * address, vm_size_t size)
 #if IOALLOCDEBUG
     debug_iomallocpageable_size -= round_page(size);
 #endif
+
+    IOStatisticsAlloc(kIOStatisticsFreePageable, size);
 }
     
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -727,23 +769,36 @@ void IOPause(unsigned nanoseconds)
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-static void _iolog_putc(int ch, void *arg __unused)
+static void _iolog_consputc(int ch, void *arg __unused)
+{
+    cons_putc_locked(ch);
+}
+
+static void _iolog_logputc(int ch, void *arg __unused)
 {
-       conslog_putc(ch);
+    log_putc_locked(ch);
 }
 
 void IOLog(const char *format, ...)
 {
-       va_list ap;
+    va_list ap;
 
-       va_start(ap, format);
-       __doprnt(format, ap, _iolog_putc, NULL, 16);
-       va_end(ap);
+    va_start(ap, format);
+    IOLogv(format, ap);
+    va_end(ap);
 }
 
 void IOLogv(const char *format, va_list ap)
 {
-       __doprnt(format, ap, _iolog_putc, NULL, 16);
+    va_list ap2;
+
+    va_copy(ap2, ap);
+
+    bsd_log_lock();
+    __doprnt(format, ap, _iolog_logputc, NULL, 16);
+    bsd_log_unlock();
+
+    __doprnt(format, ap2, _iolog_consputc, NULL, 16);
 }
 
 #if !__LP64__