gator: Version 5.18DS-5.18

Signed-off-by: Jon Medhurst <tixy@linaro.org>

119 files changed, 4350 insertions, 1124 deletions

diff --git a/README_Streamline.txt b/README_Streamline.txt
index 744c33f..df3f923 100755
--- a/README_Streamline.txt
+++ b/README_Streamline.txt
@@ -2,18 +2,19 @@
 *** Purpose ***

 

 Instructions on setting up ARM Streamline on the target.

-The gator driver and gator daemon are required to run on the ARM linux target in order for ARM Streamline to operate.

+The gator driver and gator daemon are required to run on the ARM Linux target in order for ARM Streamline to operate. A new early access feature allows the gator daemon can run without the gator driver by using userspace APIs with reduced functionality when using Linux 3.12 or later.

 The driver should be built as a module and the daemon must run with root permissions on the target.

 

 *** Introduction ***

 

-A linux development environment with cross compiling tools is most likely required, depending on what is already created and provided.

+A Linux development environment with cross compiling tools is most likely required, depending on what is already created and provided.

 -For users, the ideal environment is to be given a BSP with gatord and gator.ko already running on a properly configured kernel. In such a scenario, a development environment is not needed, root permission may or may not be needed (gatord must be executed with root permissions but can be automatically started, see below), and the user can run Streamline and profile the system without any setup.

 -The ideal development environment has the kernel source code available to be rebuilt, usually by cross-compiling on a host machine. This environment allows the greatest flexibility in configuring the kernel and building the gator driver module.

 -However, it is possible that a user/developer has a kernel but does not have the source code. In this scenario it may or may not be possible to obtain a valid profile.

         -First, check if the kernel has the proper configuration options (see below). Profiling cannot occur using a kernel that is not configured properly, a new kernel must be created. See if /proc/config.gz exists on the target.

         -Second, given a properly configured kernel, check if the filesystem contains the kernel source/headers, which can be used to re-create the gator driver. These files may be located in different areas, but common locations are /lib/modules/ and /usr/src.

         -If the kernel is not properly configured or sources/headers are not available, the developer is on their own and kernel creation is beyond the scope of this document. Note: It is possible for a module to work when compiled against a similar kernel source code, though this is not guaranteed to work due to differences in kernel structures, exported symbols and incompatible configuration parameters.

+        -If the target is running Linux 3.12 or later the kernel driver is not required and userspace APIs will be used instead.

 

 *** Kernel configuration ***

 

@@ -24,7 +25,7 @@ menuconfig options (depending on the kernel version, the location of these confi
   - [*] Profiling Support (enables CONFIG_PROFILING)

 - Kernel Features

   - [*] High Resolution Timer Support (enables CONFIG_HIGH_RES_TIMERS)

-  - [*] Use local timer interrupts (only required for SMP, enables CONFIG_LOCAL_TIMERS)

+  - [*] Use local timer interrupts (only required for SMP and for version before Linux 3.12, enables CONFIG_LOCAL_TIMERS)

   - [*] Enable hardware performance counter support for perf events (enables CONFIG_HW_PERF_EVENTS)

 - CPU Power Management

   - CPU Frequency scaling

@@ -46,8 +47,10 @@ CONFIG_DEBUG_INFO (optional, used for analyzing the kernel)
 CONFIG_CPU_FREQ (optional, provides frequency setting of the CPU)

 

 These may be verified on a running system using /proc/config.gz (if this file exists) by running 'zcat /proc/config.gz | grep <option>'. For example, confirming that CONFIG_PROFILING is enabled

-  > zcat /proc/config.gz | grep CONFIG_PROFILING

-  CONFIG_PROFILING=y

+        > zcat /proc/config.gz | grep CONFIG_PROFILING

+        CONFIG_PROFILING=y

+

+If a device tree is used it must include the pmu bindings, see Documentation/devicetree/bindings/arm/pmu.txt for details.

 

 *** Checking the gator requirements ***

 

@@ -64,6 +67,17 @@ for example when using the linaro-toolchain-binaries
         make -C /home/username/kernel_2.6.32/ M=`pwd` ARCH=arm CROSS_COMPILE=/home/username/gcc-linaro-arm-linux-gnueabihf-4.7-2013.01-20130125_linux/bin/arm-linux-gnueabihf- modules

 If successful, a gator.ko module should be generated

 

+It is also possible to integrate the gator.ko module into the kernel build system

+        cd /path/to/kernel/build/dir

+        cd drivers

+        mkdir gator

+        cp -r /path/to/gator/driver-src/* gator

+Edit Makefile in the kernel drivers folder and add this to the end

+        obj-$(CONFIG_GATOR)             += gator/

+Edit Kconfig in the kernel drivers folder and add this before the last endmenu

+        source "drivers/gator/Kconfig"

+You can now select gator when using menuconfig while configuring the kernel and rebuild as directed

+

 *** Building the gator daemon ***

 

 cd /path/to/gator/daemon-src

@@ -78,6 +92,9 @@ For Android targets (install the android ndk, see developer.android.com)
         ndk-build

                 or execute /path/to/ndk/ndk-build if the ndk is not on your path

         gatord should now be created and located in libs/armeabi

+        If you get an error like the following, upgrade to a more recent version of the android ndk

+                jni/PerfGroup.cpp: In function 'int sys_perf_event_open(perf_event_attr*, pid_t, int, int, long unsigned int)':

+                jni/PerfGroup.cpp:36:17: error: '__NR_perf_event_open' was not declared in this scope

 

 *** Running gator ***

 

@@ -88,6 +105,7 @@ gator.ko must be located in the same directory as gatord on the target or the lo
 With root privileges, run the daemon

         sudo ./gatord &

 Note: gatord requires libstdc++.so.6 which is usually supplied by the Linux distribution on the target. A copy of libstdc++.so.6 is available in the DS-5 Linux example distribution.

+If gator.ko is not loaded and is not in the same directory as gatord when using Linux 3.12 or later, gatord can run without gator.ko by using userspace APIs. Not all features are supported by userspace gator. If /dev/gator/version does not exist after starting gatord it is running userspace gator.

 

 *** Customizing the l2c-310 Counter ***

 

@@ -96,6 +114,10 @@ The l2c-310 counter in gator_events_l2c-310.c contains hard coded offsets where
 Further, the l2c-310 counter can be disabled by providing an offset of zero, ex:

         insmod gator.ko l2c310_addr=0

 

+*** CCN-504 ***

+

+CCN-504 is disabled by default. To enable CCN-504, insmod gator module with the ccn504_addr=<addr> parameter where addr is the base address of the CCN-504 configuration register space (PERIPHBASE), ex: insmod gator.ko ccn504_addr=0x2E000000.

+

 *** Compiling an application or shared library ***

 

 Recommended compiler settings:

@@ -113,18 +135,31 @@ Attempting to run an incompatible binary often results in the confusing error me
 *** Bugs ***

 

 There is a bug in some Linux kernels where perf misidentifies the CPU type. To see if you are affected by this, run ls /sys/bus/event_source/devices/ and verify the listed processor type matches what is expected. For example, an A9 should show the following.

-

-# ls /sys/bus/event_source/devices/

-ARMv7_Cortex_A9  breakpoint  software  tracepoint

-

+        # ls /sys/bus/event_source/devices/

+        ARMv7_Cortex_A9  breakpoint  software  tracepoint

 To work around the issue try upgrading to a later kernel or comment out the gator_events_perf_pmu_cpu_init(gator_cpu, type); call in gator_events_perf_pmu.c

 

+There is a bug in some Linux kernels where an Oops may occurs when using userspace gator and a core is offlined. The fix was merged into mainline in 3.14-rc5, see http://git.kernel.org/tip/e3703f8cdfcf39c25c4338c3ad8e68891cca3731, and as been backported to older kernels.

+

+If you see this error when using SELinux, ex: Android 4.4 or later

+        # ./gatord

+        Unable to load (insmod) gator.ko driver:

+          >>> gator.ko must be built against the current kernel version & configuration

+          >>> See dmesg for more details

+        # dmesg

+        ...

+        <7>[ 6745.475110] SELinux: initialized (dev gatorfs, type gatorfs), not configured for labeling

+        <5>[ 6745.477434] type=1400 audit(1393005053.336:10): avc:  denied  { mount } for  pid=1996 comm="gatord-main" name="/" dev="gatorfs" ino=8733 scontext=u:r:shell:s0 tcontext=u:object_r:unlabeled:s0 tclass=filesystem

+disable SELinux so that gatorfs can be mounted by running

+        # setenforce 0

+Once gator is started, SELinux can be reenabled

+

 *** Profiling the kernel (optional) ***

 

 CONFIG_DEBUG_INFO must be enabled, see "Kernel configuration" section above.

 Use vmlinux as the image for debug symbols in Streamline.

 Drivers may be profiled using this method by statically linking the driver into the kernel image or adding the driver as an image to Streamline.

-To perform kernel stack unwinding and module unwinding, edit the Makefile to enable GATOR_KERNEL_STACK_UNWINDING and rebuild gator.ko.

+To perform kernel stack unwinding and module unwinding, edit the Makefile to enable GATOR_KERNEL_STACK_UNWINDING and rebuild gator.ko or run "echo 1 > /sys/module/gator/parameters/kernel_stack_unwinding" as root on the target after gatord is started.

 

 *** Automatically start gator on boot (optional) ***

 

@@ -137,4 +172,3 @@ update-rc.d rungator.sh defaults
 *** GPL License ***

 

 For license information, please see the file LICENSE after unzipping driver-src/gator-driver.tar.gz.

-

diff --git a/daemon/Android.mk b/daemon/Android.mk
index a042971..045d028 100644
--- a/daemon/Android.mk
+++ b/daemon/Android.mk
@@ -1,7 +1,7 @@
 LOCAL_PATH := $(call my-dir)
 include $(CLEAR_VARS)
 
-XML_H := $(shell cd $(LOCAL_PATH) && make events_xml.h configuration_xml.h)
+XML_H := $(shell cd $(LOCAL_PATH) && make events_xml.h defaults_xml.h)
 
 LOCAL_CFLAGS += -Wall -O3 -mthumb-interwork -fno-exceptions -DETCDIR=\"/etc\" -Ilibsensors
 
@@ -9,22 +9,33 @@ LOCAL_SRC_FILES := \
         Buffer.cpp \
         CapturedXML.cpp \
         Child.cpp \
-        Collector.cpp \
         ConfigurationXML.cpp \
         Driver.cpp \
+        DriverSource.cpp \
+        DynBuf.cpp \
         EventsXML.cpp \
+        ExternalSource.cpp \
         Fifo.cpp \
         Hwmon.cpp \
         KMod.cpp \
         LocalCapture.cpp \
         Logging.cpp \
         main.cpp \
+        Monitor.cpp \
         OlySocket.cpp \
         OlyUtility.cpp \
+        PerfBuffer.cpp \
+        PerfDriver.cpp \
+        PerfGroup.cpp \
+        PerfSource.cpp \
+        Proc.cpp \
         Sender.cpp \
         SessionData.cpp \
         SessionXML.cpp \
+        Source.cpp \
         StreamlineSetup.cpp \
+        UEvent.cpp \
+        UserSpaceSource.cpp \
         libsensors/access.c \
         libsensors/conf-lex.c \
         libsensors/conf-parse.c \
diff --git a/daemon/Buffer.cpp b/daemon/Buffer.cpp
index 090a715..93557da 100644
--- a/daemon/Buffer.cpp
+++ b/daemon/Buffer.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -12,33 +12,60 @@
 #include "Sender.h"
 #include "SessionData.h"
 
-#define mask (size - 1)
-
-Buffer::Buffer (const int32_t core, const int32_t buftype, const int size, sem_t *const readerSem) : core(core), buftype(buftype), size(size), readPos(0), writePos(0), commitPos(0), available(true), done(false), buf(new char[size]), commitTime(gSessionData->mLiveRate), readerSem(readerSem) {
-        if ((size & mask) != 0) {
+#define mask (mSize - 1)
+
+enum {
+        CODE_PEA    = 1,
+        CODE_KEYS   = 2,
+        CODE_FORMAT = 3,
+        CODE_MAPS   = 4,
+        CODE_COMM   = 5,
+};
+
+// Summary Frame Messages
+enum {
+        MESSAGE_SUMMARY = 1,
+        MESSAGE_CORE_NAME = 3,
+};
+
+// From gator_marshaling.c
+#define NEWLINE_CANARY \
+        /* Unix */ \
+        "1\n" \
+        /* Windows */ \
+        "2\r\n" \
+        /* Mac OS */ \
+        "3\r" \
+        /* RISC OS */ \
+        "4\n\r" \
+        /* Add another character so the length isn't 0x0a bytes */ \
+        "5"
+
+Buffer::Buffer(const int32_t core, const int32_t buftype, const int size, sem_t *const readerSem) : mCore(core), mBufType(buftype), mSize(size), mReadPos(0), mWritePos(0), mCommitPos(0), mAvailable(true), mIsDone(false), mBuf(new char[mSize]), mCommitTime(gSessionData->mLiveRate), mReaderSem(readerSem) {
+        if ((mSize & mask) != 0) {
                 logg->logError(__FILE__, __LINE__, "Buffer size is not a power of 2");
                 handleException();
         }
         frame();
 }
 
-Buffer::~Buffer () {
-        delete [] buf;
+Buffer::~Buffer() {
+        delete [] mBuf;
 }
 
-void Buffer::write (Sender * const sender) {
+void Buffer::write(Sender *const sender) {
         if (!commitReady()) {
                 return;
         }
 
         // determine the size of two halves
-        int length1 = commitPos - readPos;
-        char * buffer1 = buf + readPos;
+        int length1 = mCommitPos - mReadPos;
+        char *buffer1 = mBuf + mReadPos;
         int length2 = 0;
-        char * buffer2 = buf;
+        char *buffer2 = mBuf;
         if (length1 < 0) {
-                length1 = size - readPos;
-                length2 = commitPos;
+                length1 = mSize - mReadPos;
+                length2 = mCommitPos;
         }
 
         logg->logMessage("Sending data length1: %i length2: %i", length1, length2);
@@ -53,22 +80,22 @@ void Buffer::write (Sender * const sender) {
                 sender->writeData(buffer2, length2, RESPONSE_APC_DATA);
         }
 
-        readPos = commitPos;
+        mReadPos = mCommitPos;
 }
 
-bool Buffer::commitReady () const {
-        return commitPos != readPos;
+bool Buffer::commitReady() const {
+        return mCommitPos != mReadPos;
 }
 
-int Buffer::bytesAvailable () const {
-        int filled = writePos - readPos;
+int Buffer::bytesAvailable() const {
+        int filled = mWritePos - mReadPos;
         if (filled < 0) {
-                filled += size;
+                filled += mSize;
         }
 
-        int remaining = size - filled;
+        int remaining = mSize - filled;
 
-        if (available) {
+        if (mAvailable) {
                 // Give some extra room; also allows space to insert the overflow error packet
                 remaining -= 200;
         } else {
@@ -79,58 +106,68 @@ int Buffer::bytesAvailable () const {
         return remaining;
 }
 
-bool Buffer::checkSpace (const int bytes) {
+bool Buffer::checkSpace(const int bytes) {
         const int remaining = bytesAvailable();
 
         if (remaining < bytes) {
-                available = false;
+                mAvailable = false;
         } else {
-                available = true;
+                mAvailable = true;
         }
 
-        return available;
+        return mAvailable;
+}
+
+int Buffer::contiguousSpaceAvailable() const {
+        int remaining = bytesAvailable();
+        int contiguous = mSize - mWritePos;
+        if (remaining < contiguous) {
+                return remaining;
+        } else {
+                return contiguous;
+        }
 }
 
-void Buffer::commit (const uint64_t time) {
+void Buffer::commit(const uint64_t time) {
         // post-populate the length, which does not include the response type length nor the length itself, i.e. only the length of the payload
         const int typeLength = gSessionData->mLocalCapture ? 0 : 1;
-        int length = writePos - commitPos;
+        int length = mWritePos - mCommitPos;
         if (length < 0) {
-                length += size;
+                length += mSize;
         }
         length = length - typeLength - sizeof(int32_t);
         for (size_t byte = 0; byte < sizeof(int32_t); byte++) {
-                buf[(commitPos + typeLength + byte) & mask] = (length >> byte * 8) & 0xFF;
+                mBuf[(mCommitPos + typeLength + byte) & mask] = (length >> byte * 8) & 0xFF;
         }
 
-        logg->logMessage("Committing data readPos: %i writePos: %i commitPos: %i", readPos, writePos, commitPos);
-        commitPos = writePos;
+        logg->logMessage("Committing data mReadPos: %i mWritePos: %i mCommitPos: %i", mReadPos, mWritePos, mCommitPos);
+        mCommitPos = mWritePos;
 
         if (gSessionData->mLiveRate > 0) {
-                while (time > commitTime) {
-                        commitTime += gSessionData->mLiveRate;
+                while (time > mCommitTime) {
+                        mCommitTime += gSessionData->mLiveRate;
                 }
         }
 
-        if (!done) {
+        if (!mIsDone) {
                 frame();
         }
 
         // send a notification that data is ready
-        sem_post(readerSem);
+        sem_post(mReaderSem);
 }
 
-void Buffer::check (const uint64_t time) {
-        int filled = writePos - commitPos;
+void Buffer::check(const uint64_t time) {
+        int filled = mWritePos - mCommitPos;
         if (filled < 0) {
-                filled += size;
+                filled += mSize;
         }
-        if (filled >= ((size * 3) / 4) || (gSessionData->mLiveRate > 0 && time >= commitTime)) {
+        if (filled >= ((mSize * 3) / 4) || (gSessionData->mLiveRate > 0 && time >= mCommitTime)) {
                 commit(time);
         }
 }
 
-void Buffer::packInt (int32_t x) {
+void Buffer::packInt(int32_t x) {
         int packedBytes = 0;
         int more = true;
         while (more) {
@@ -144,14 +181,14 @@ void Buffer::packInt (int32_t x) {
                         b |= 0x80;
                 }
 
-                buf[(writePos + packedBytes) & mask] = b;
+                mBuf[(mWritePos + packedBytes) & mask] = b;
                 packedBytes++;
         }
 
-        writePos = (writePos + packedBytes) & mask;
+        mWritePos = (mWritePos + packedBytes) & mask;
 }
 
-void Buffer::packInt64 (int64_t x) {
+void Buffer::packInt64(int64_t x) {
         int packedBytes = 0;
         int more = true;
         while (more) {
@@ -165,24 +202,61 @@ void Buffer::packInt64 (int64_t x) {
                         b |= 0x80;
                 }
 
-                buf[(writePos + packedBytes) & mask] = b;
+                mBuf[(mWritePos + packedBytes) & mask] = b;
                 packedBytes++;
         }
 
-        writePos = (writePos + packedBytes) & mask;
+        mWritePos = (mWritePos + packedBytes) & mask;
+}
+
+void Buffer::writeBytes(const void *const data, size_t count) {
+        size_t i;
+        for (i = 0; i < count; ++i) {
+                mBuf[(mWritePos + i) & mask] = static_cast<const char *>(data)[i];
+        }
+
+        mWritePos = (mWritePos + i) & mask;
 }
 
-void Buffer::frame () {
+void Buffer::writeString(const char *const str) {
+        const int len = strlen(str);
+        packInt(len);
+        writeBytes(str, len);
+}
+
+void Buffer::frame() {
         if (!gSessionData->mLocalCapture) {
                 packInt(RESPONSE_APC_DATA);
         }
         // Reserve space for the length
-        writePos += sizeof(int32_t);
-        packInt(buftype);
-        packInt(core);
+        mWritePos += sizeof(int32_t);
+        packInt(mBufType);
+        packInt(mCore);
 }
 
-bool Buffer::eventHeader (const uint64_t curr_time) {
+void Buffer::summary(const int64_t timestamp, const int64_t uptime, const int64_t monotonicDelta, const char *const uname) {
+        packInt(MESSAGE_SUMMARY);
+        writeString(NEWLINE_CANARY);
+        packInt64(timestamp);
+        packInt64(uptime);
+        packInt64(monotonicDelta);
+        writeString("uname");
+        writeString(uname);
+        writeString("");
+        check(1);
+}
+
+void Buffer::coreName(const int core, const int cpuid, const char *const name) {
+        if (checkSpace(3 * MAXSIZE_PACK32 + 0x100)) {
+                packInt(MESSAGE_CORE_NAME);
+                packInt(core);
+                packInt(cpuid);
+                writeString(name);
+        }
+        check(1);
+}
+
+bool Buffer::eventHeader(const uint64_t curr_time) {
         bool retval = false;
         if (checkSpace(MAXSIZE_PACK32 + MAXSIZE_PACK64)) {
                 packInt(0);     // key of zero indicates a timestamp
@@ -193,9 +267,9 @@ bool Buffer::eventHeader (const uint64_t curr_time) {
         return retval;
 }
 
-bool Buffer::eventTid (const int tid) {
+bool Buffer::eventTid(const int tid) {
         bool retval = false;
-        if (checkSpace(2*MAXSIZE_PACK32)) {
+        if (checkSpace(2 * MAXSIZE_PACK32)) {
                 packInt(1);     // key of 1 indicates a tid
                 packInt(tid);
                 retval = true;
@@ -204,25 +278,94 @@ bool Buffer::eventTid (const int tid) {
         return retval;
 }
 
-void Buffer::event (const int32_t key, const int32_t value) {
+void Buffer::event(const int32_t key, const int32_t value) {
         if (checkSpace(2 * MAXSIZE_PACK32)) {
                 packInt(key);
                 packInt(value);
         }
 }
 
-void Buffer::event64 (const int64_t key, const int64_t value) {
+void Buffer::event64(const int64_t key, const int64_t value) {
         if (checkSpace(2 * MAXSIZE_PACK64)) {
                 packInt64(key);
                 packInt64(value);
         }
 }
 
-void Buffer::setDone () {
-        done = true;
+void Buffer::pea(const struct perf_event_attr *const pea, int key) {
+        if (checkSpace(2 * MAXSIZE_PACK32 + pea->size)) {
+                packInt(CODE_PEA);
+                writeBytes(pea, pea->size);
+                packInt(key);
+        } else {
+                logg->logError(__FILE__, __LINE__, "Ran out of buffer space for perf attrs");
+                handleException();
+        }
+        // Don't know the real perf time so use 1 as it will work for now
+        check(1);
+}
+
+void Buffer::keys(const int count, const __u64 *const ids, const int *const keys) {
+        if (checkSpace(2 * MAXSIZE_PACK32 + count * (MAXSIZE_PACK32 + MAXSIZE_PACK64))) {
+                packInt(CODE_KEYS);
+                packInt(count);
+                for (int i = 0; i < count; ++i) {
+                        packInt64(ids[i]);
+                        packInt(keys[i]);
+                }
+        } else {
+                logg->logError(__FILE__, __LINE__, "Ran out of buffer space for perf attrs");
+                handleException();
+        }
+        check(1);
+}
+
+void Buffer::format(const int length, const char *const format) {
+        if (checkSpace(MAXSIZE_PACK32 + length + 1)) {
+                packInt(CODE_FORMAT);
+                writeBytes(format, length + 1);
+        } else {
+                logg->logError(__FILE__, __LINE__, "Ran out of buffer space for perf attrs");
+                handleException();
+        }
+        check(1);
+}
+
+void Buffer::maps(const int pid, const int tid, const char *const maps) {
+        const int mapsLen = strlen(maps) + 1;
+        if (checkSpace(3 * MAXSIZE_PACK32 + mapsLen)) {
+                packInt(CODE_MAPS);
+                packInt(pid);
+                packInt(tid);
+                writeBytes(maps, mapsLen);
+        } else {
+                logg->logError(__FILE__, __LINE__, "Ran out of buffer space for perf attrs");
+                handleException();
+        }
+        check(1);
+}
+
+void Buffer::comm(const int pid, const int tid, const char *const image, const char *const comm) {
+        const int imageLen = strlen(image) + 1;
+        const int commLen = strlen(comm) + 1;
+        if (checkSpace(3 * MAXSIZE_PACK32 + imageLen + commLen)) {
+                packInt(CODE_COMM);
+                packInt(pid);
+                packInt(tid);
+                writeBytes(image, imageLen);
+                writeBytes(comm, commLen);
+        } else {
+                logg->logError(__FILE__, __LINE__, "Ran out of buffer space for perf attrs");
+                handleException();
+        }
+        check(1);
+}
+
+void Buffer::setDone() {
+        mIsDone = true;
         commit(0);
 }
 
-bool Buffer::isDone () const {
-        return done && readPos == commitPos && commitPos == writePos;
+bool Buffer::isDone() const {
+        return mIsDone && mReadPos == mCommitPos && mCommitPos == mWritePos;
 }
diff --git a/daemon/Buffer.h b/daemon/Buffer.h
index b3c8d78..5023777 100644
--- a/daemon/Buffer.h
+++ b/daemon/Buffer.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,54 +9,89 @@
 #ifndef BUFFER_H
 #define BUFFER_H
 
-#include <stddef.h>
 #include <stdint.h>
 #include <semaphore.h>
 
+#include "k/perf_event.h"
+
 class Sender;
 
+enum {
+        FRAME_SUMMARY       =  1,
+        FRAME_BLOCK_COUNTER =  5,
+        FRAME_EXTERNAL      = 10,
+        FRAME_PERF_ATTRS    = 11,
+        FRAME_PERF          = 12,
+};
+
 class Buffer {
 public:
         static const size_t MAXSIZE_PACK32 = 5;
         static const size_t MAXSIZE_PACK64 = 10;
 
-        Buffer (int32_t core, int32_t buftype, const int size, sem_t *const readerSem);
-        ~Buffer ();
+        Buffer(int32_t core, int32_t buftype, const int size, sem_t *const readerSem);
+        ~Buffer();
+
+        void write(Sender *sender);
+
+        int bytesAvailable() const;
+        int contiguousSpaceAvailable() const;
+        void commit(const uint64_t time);
+        void check(const uint64_t time);
 
-        void write (Sender * sender);
+        void frame();
 
-        int bytesAvailable () const;
-        void commit (const uint64_t time);
-        void check (const uint64_t time);
+        // Summary messages
+        void summary(const int64_t timestamp, const int64_t uptime, const int64_t monotonicDelta, const char *const uname);
+        void coreName(const int core, const int cpuid, const char *const name);
 
-        void frame ();
+        // Block Counter messages
+        bool eventHeader(uint64_t curr_time);
+        bool eventTid(int tid);
+        void event(int32_t key, int32_t value);
+        void event64(int64_t key, int64_t value);
 
-        bool eventHeader (uint64_t curr_time);
-        bool eventTid (int tid);
-        void event (int32_t key, int32_t value);
-        void event64 (int64_t key, int64_t value);
+        // Perf Attrs messages
+        void pea(const struct perf_event_attr *const pea, int key);
+        void keys(const int count, const __u64 *const ids, const int *const keys);
+        void format(const int length, const char *const format);
+        void maps(const int pid, const int tid, const char *const maps);
+        void comm(const int pid, const int tid, const char *const image, const char *const comm);
 
-        void setDone ();
-        bool isDone () const;
+        void setDone();
+        bool isDone() const;
+
+        // Prefer a new member to using these functions if possible
+        char *getWritePos() { return mBuf + mWritePos; }
+        void advanceWrite(int bytes) { mWritePos = (mWritePos + bytes) & /*mask*/(mSize - 1); }
+
+        static void writeLEInt(unsigned char *buf, int v) {
+                buf[0] = (v >> 0) & 0xFF;
+                buf[1] = (v >> 8) & 0xFF;
+                buf[2] = (v >> 16) & 0xFF;
+                buf[3] = (v >> 24) & 0xFF;
+        }
 
 private:
-        bool commitReady () const;
-        bool checkSpace (int bytes);
-
-        void packInt (int32_t x);
-        void packInt64 (int64_t x);
-
-        const int32_t core;
-        const int32_t buftype;
-        const int size;
-        int readPos;
-        int writePos;
-        int commitPos;
-        bool available;
-        bool done;
-        char *const buf;
-        uint64_t commitTime;
-        sem_t *const readerSem;
+        bool commitReady() const;
+        bool checkSpace(int bytes);
+
+        void packInt(int32_t x);
+        void packInt64(int64_t x);
+        void writeBytes(const void *const data, size_t count);
+        void writeString(const char *const str);
+
+        const int32_t mCore;
+        const int32_t mBufType;
+        const int mSize;
+        int mReadPos;
+        int mWritePos;
+        int mCommitPos;
+        bool mAvailable;
+        bool mIsDone;
+        char *const mBuf;
+        uint64_t mCommitTime;
+        sem_t *const mReaderSem;
 
         // Intentionally unimplemented
         Buffer(const Buffer &);
diff --git a/daemon/CapturedXML.cpp b/daemon/CapturedXML.cpp
index 30c4c44..cf79b72 100644
--- a/daemon/CapturedXML.cpp
+++ b/daemon/CapturedXML.cpp
@@ -1,16 +1,18 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
+#include "CapturedXML.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <dirent.h>
+
 #include "SessionData.h"
-#include "CapturedXML.h"
 #include "Logging.h"
 #include "OlyUtility.h"
 
@@ -30,6 +32,9 @@ mxml_node_t* CapturedXML::getTree(bool includeTime) {
 
         captured = mxmlNewElement(xml, "captured");
         mxmlElementSetAttr(captured, "version", "1");
+        if (gSessionData->perf.isSetup()) {
+          mxmlElementSetAttr(captured, "type", "Perf");
+        }
         mxmlElementSetAttrf(captured, "protocol", "%d", PROTOCOL_VERSION);
         if (includeTime) { // Send the following only after the capture is complete
                 if (time(NULL) > 1267000000) { // If the time is reasonable (after Feb 23, 2010)
@@ -41,7 +46,7 @@ mxml_node_t* CapturedXML::getTree(bool includeTime) {
         mxmlElementSetAttr(target, "name", gSessionData->mCoreName);
         mxmlElementSetAttrf(target, "sample_rate", "%d", gSessionData->mSampleRate);
         mxmlElementSetAttrf(target, "cores", "%d", gSessionData->mCores);
-        mxmlElementSetAttrf(target, "cpuid", "0x%x", gSessionData->mCpuId);
+        mxmlElementSetAttrf(target, "cpuid", "0x%x", gSessionData->mMaxCpuId);
 
         if (!gSessionData->mOneShot && (gSessionData->mSampleRate > 0)) {
                 mxmlElementSetAttr(target, "supports_live", "yes");
diff --git a/daemon/CapturedXML.h b/daemon/CapturedXML.h
index b0482f5..efc1e52 100644
--- a/daemon/CapturedXML.h
+++ b/daemon/CapturedXML.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/Child.cpp b/daemon/Child.cpp
index 9ee2ef8..ca33561 100644
--- a/daemon/Child.cpp
+++ b/daemon/Child.cpp
@@ -1,38 +1,39 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
+#include "Child.h"
+
 #include <stdlib.h>
 #include <string.h>
 #include <signal.h>
 #include <unistd.h>
 #include <sys/prctl.h>
+
 #include "Logging.h"
 #include "CapturedXML.h"
 #include "SessionData.h"
-#include "Child.h"
 #include "LocalCapture.h"
-#include "Collector.h"
 #include "Sender.h"
 #include "OlyUtility.h"
+#include "OlySocket.h"
 #include "StreamlineSetup.h"
 #include "ConfigurationXML.h"
 #include "Driver.h"
-#include "Fifo.h"
-#include "Buffer.h"
-
-#define NS_PER_S ((uint64_t)1000000000)
-#define NS_PER_US 1000
+#include "PerfSource.h"
+#include "DriverSource.h"
+#include "UserSpaceSource.h"
+#include "ExternalSource.h"
 
 static sem_t haltPipeline, senderThreadStarted, startProfile, senderSem; // Shared by Child and spawned threads
-static Fifo* collectorFifo = NULL;   // Shared by Child.cpp and spawned threads
-static Buffer* buffer = NULL;
+static Source *primarySource = NULL;
+static Source *userSpaceSource = NULL;
+static Source *externalSource = NULL;
 static Sender* sender = NULL;        // Shared by Child.cpp and spawned threads
-static Collector* collector = NULL;
 Child* child = NULL;                 // shared by Child.cpp and main.cpp
 
 extern void cleanUp();
@@ -78,7 +79,7 @@ static void child_handler(int signum) {
         }
         beenHere = true;
         logg->logMessage("Gator is shutting down.");
-        if (signum == SIGALRM || !collector) {
+        if (signum == SIGALRM || !primarySource) {
                 exit(1);
         } else {
                 child->endSession();
@@ -139,77 +140,22 @@ static void *stopThread(void *) {
         return 0;
 }
 
-static void *countersThread(void *) {
-        prctl(PR_SET_NAME, (unsigned long)&"gatord-counters", 0, 0, 0);
-
-        gSessionData->hwmon.start();
-
-        int64_t monotonic_started = 0;
-        while (monotonic_started <= 0) {
-                usleep(10);
-
-                if (Collector::readInt64Driver("/dev/gator/started", &monotonic_started) == -1) {
-                        logg->logError(__FILE__, __LINE__, "Error reading gator driver start time");
-                        handleException();
-                }
-        }
-
-        uint64_t next_time = 0;
-        while (gSessionData->mSessionIsActive) {
-                struct timespec ts;
-#ifndef CLOCK_MONOTONIC_RAW
-                // Android doesn't have this defined but it was added in Linux 2.6.28
-#define CLOCK_MONOTONIC_RAW 4
-#endif
-                if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) != 0) {
-                        logg->logError(__FILE__, __LINE__, "Failed to get uptime");
-                        handleException();
-                }
-                const uint64_t curr_time = (NS_PER_S*ts.tv_sec + ts.tv_nsec) - monotonic_started;
-                // Sample ten times a second ignoring gSessionData->mSampleRate
-                next_time += NS_PER_S/10;//gSessionData->mSampleRate;
-                if (next_time < curr_time) {
-                        logg->logMessage("Too slow, curr_time: %lli next_time: %lli", curr_time, next_time);
-                        next_time = curr_time;
-                }
-
-                if (buffer->eventHeader(curr_time)) {
-                        gSessionData->hwmon.read(buffer);
-                        // Only check after writing all counters so that time and corresponding counters appear in the same frame
-                        buffer->check(curr_time);
-                }
-
-                if (buffer->bytesAvailable() <= 0) {
-                        logg->logMessage("One shot (counters)");
-                        child->endSession();
-                }
-
-                usleep((next_time - curr_time)/NS_PER_US);
-        }
-
-        buffer->setDone();
-
-        return NULL;
-}
-
 static void *senderThread(void *) {
-        int length = 1;
-        char* data;
         char end_sequence[] = {RESPONSE_APC_DATA, 0, 0, 0, 0};
 
         sem_post(&senderThreadStarted);
         prctl(PR_SET_NAME, (unsigned long)&"gatord-sender", 0, 0, 0);
         sem_wait(&haltPipeline);
 
-        while (length > 0 || !buffer->isDone()) {
+        while (!primarySource->isDone() || (userSpaceSource != NULL && !userSpaceSource->isDone()) || (externalSource != NULL && !externalSource->isDone())) {
                 sem_wait(&senderSem);
-                data = collectorFifo->read(&length);
-                if (data != NULL) {
-                        sender->writeData(data, length, RESPONSE_APC_DATA);
-                        collectorFifo->release();
+
+                primarySource->write(sender);
+                if (userSpaceSource != NULL) {
+                        userSpaceSource->write(sender);
                 }
-                if (!buffer->isDone()) {
-                        buffer->write(sender);
+                if (externalSource != NULL) {
+                        externalSource->write(sender);
                 }
         }
 
@@ -255,15 +201,13 @@ void Child::initialization() {
 
 void Child::endSession() {
         gSessionData->mSessionIsActive = false;
-        collector->stop();
+        primarySource->interrupt();
         sem_post(&haltPipeline);
 }
 
 void Child::run() {
-        char* collectBuffer;
-        int bytesCollected = 0;
         LocalCapture* localCapture = NULL;
-        pthread_t durationThreadID, stopThreadID, senderThreadID, countersThreadID;
+        pthread_t durationThreadID, stopThreadID, senderThreadID;
 
         prctl(PR_SET_NAME, (unsigned long)&"gatord-child", 0, 0, 0);
 
@@ -282,7 +226,11 @@ void Child::run() {
         { ConfigurationXML configuration; }
 
         // Set up the driver; must be done after gSessionData->mPerfCounterType[] is populated
-        collector = new Collector();
+        if (!gSessionData->perf.isSetup()) {
+          primarySource = new DriverSource(&senderSem, &startProfile);
+        } else {
+          primarySource = new PerfSource(&senderSem, &startProfile);
+        }
 
         // Initialize all drivers
         for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
@@ -317,15 +265,11 @@ void Child::run() {
                 free(xmlString);
         }
 
-        // Create user-space buffers, add 5 to the size to account for the 1-byte type and 4-byte length
-        logg->logMessage("Created %d MB collector buffer with a %d-byte ragged end", gSessionData->mTotalBufferSize, collector->getBufferSize());
-        collectorFifo = new Fifo(collector->getBufferSize() + 5, gSessionData->mTotalBufferSize*1024*1024, &senderSem);
-
-        // Get the initial pointer to the collect buffer
-        collectBuffer = collectorFifo->start();
-
-        // Create a new Block Counter Buffer
-        buffer = new Buffer(0, 5, gSessionData->mTotalBufferSize*1024*1024, &senderSem);
+        // Must be after session XML is parsed
+        if (!primarySource->prepare()) {
+                logg->logError(__FILE__, __LINE__, "Unable to prepare for capture");
+                handleException();
+        }
 
         // Sender thread shall be halted until it is signaled for one shot mode
         sem_init(&haltPipeline, 0, gSessionData->mOneShot ? 0 : 2);
@@ -340,14 +284,21 @@ void Child::run() {
                 thread_creation_success = false;
         }
 
-        bool startcountersThread = gSessionData->hwmon.countersEnabled();
-        if (startcountersThread) {
-                if (pthread_create(&countersThreadID, NULL, countersThread, this)) {
-                        thread_creation_success = false;
+        if (gSessionData->hwmon.countersEnabled()) {
+                userSpaceSource = new UserSpaceSource(&senderSem);
+                if (!userSpaceSource->prepare()) {
+                        logg->logError(__FILE__, __LINE__, "Unable to prepare for capture");
+                        handleException();
                 }
-        } else {
-                // Let senderThread know there is no buffer data to send
-                buffer->setDone();
+                userSpaceSource->start();
+        }
+        if (access("/tmp/gator", F_OK) == 0) {
+                externalSource = new ExternalSource(&senderSem);
+                if (!externalSource->prepare()) {
+                        logg->logError(__FILE__, __LINE__, "Unable to prepare for capture");
+                        handleException();
+                }
+                externalSource->start();
         }
 
         if (!thread_creation_success) {
@@ -359,28 +310,13 @@ void Child::run() {
         sem_wait(&senderThreadStarted);
 
         // Start profiling
-        logg->logMessage("********** Profiling started **********");
-        collector->start();
-        sem_post(&startProfile);
-
-        // Collect Data
-        do {
-                // This command will stall until data is received from the driver
-                bytesCollected = collector->collect(collectBuffer);
-
-                // In one shot mode, stop collection once all the buffers are filled
-                if (gSessionData->mOneShot && gSessionData->mSessionIsActive) {
-                        if (bytesCollected == -1 || collectorFifo->willFill(bytesCollected)) {
-                                logg->logMessage("One shot");
-                                endSession();
-                        }
-                }
-                collectBuffer = collectorFifo->write(bytesCollected);
-        } while (bytesCollected > 0);
-        logg->logMessage("Exit collect data loop");
+        primarySource->run();
 
-        if (startcountersThread) {
-                pthread_join(countersThreadID, NULL);
+        if (externalSource != NULL) {
+                externalSource->join();
+        }
+        if (userSpaceSource != NULL) {
+                userSpaceSource->join();
         }
 
         // Wait for the other threads to exit
@@ -401,9 +337,9 @@ void Child::run() {
 
         logg->logMessage("Profiling ended.");
 
-        delete buffer;
-        delete collectorFifo;
+        delete externalSource;
+        delete userSpaceSource;
+        delete primarySource;
         delete sender;
-        delete collector;
         delete localCapture;
 }
diff --git a/daemon/Child.h b/daemon/Child.h
index 0330e9d..9e206d7 100644
--- a/daemon/Child.h
+++ b/daemon/Child.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,8 +9,6 @@
 #ifndef __CHILD_H__
 #define __CHILD_H__
 
-#include <pthread.h>
-
 class OlySocket;
 
 class Child {
diff --git a/daemon/Collector.h b/daemon/Collector.h
deleted file mode 100644
index c5e9eac..0000000
--- a/daemon/Collector.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef __COLLECTOR_H__
-#define __COLLECTOR_H__
-
-#include <stdio.h>
-
-class Collector {
-public:
-        Collector();
-        ~Collector();
-        void start();
-        void stop();
-        int collect(char* buffer);
-        int getBufferSize() {return mBufferSize;}
-
-        static int readIntDriver(const char* path, int* value);
-        static int readInt64Driver(const char* path, int64_t* value);
-        static int writeDriver(const char* path, int value);
-        static int writeDriver(const char* path, int64_t value);
-        static int writeDriver(const char* path, const char* data);
-        static int writeReadDriver(const char* path, int* value);
-        static int writeReadDriver(const char* path, int64_t* value);
-
-private:
-        int mBufferSize;
-        int mBufferFD;
-
-        void checkVersion();
-};
-
-#endif  //__COLLECTOR_H__
diff --git a/daemon/Config.h b/daemon/Config.h
new file mode 100644
index 0000000..6f5e2aa
--- /dev/null
+++ b/daemon/Config.h
@@ -0,0 +1,17 @@
+/**
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#define ARRAY_LENGTH(A) static_cast<int>(sizeof(A)/sizeof((A)[0]))
+
+#define MAX_PERFORMANCE_COUNTERS 50
+#define NR_CPUS 16
+
+#endif // CONFIG_H
diff --git a/daemon/ConfigurationXML.cpp b/daemon/ConfigurationXML.cpp
index 2a5252a..fd479f2 100644
--- a/daemon/ConfigurationXML.cpp
+++ b/daemon/ConfigurationXML.cpp
@@ -1,15 +1,17 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
+#include "ConfigurationXML.h"
+
 #include <string.h>
 #include <stdlib.h>
 #include <dirent.h>
-#include "ConfigurationXML.h"
+
 #include "Driver.h"
 #include "Logging.h"
 #include "OlyUtility.h"
@@ -67,6 +69,7 @@ int ConfigurationXML::parse(const char* configurationXML) {
 
         // clear counter overflow
         gSessionData->mCounterOverflow = 0;
+        gSessionData->mIsEBS = false;
         mIndex = 0;
 
         // disable all counters prior to parsing the configuration xml
@@ -155,6 +158,9 @@ void ConfigurationXML::configurationTag(mxml_node_t *node) {
         if (mxmlElementGetAttr(node, ATTR_COUNTER)) counter.setType(mxmlElementGetAttr(node, ATTR_COUNTER));
         if (mxmlElementGetAttr(node, ATTR_EVENT)) counter.setEvent(strtol(mxmlElementGetAttr(node, ATTR_EVENT), NULL, 16));
         if (mxmlElementGetAttr(node, ATTR_COUNT)) counter.setCount(strtol(mxmlElementGetAttr(node, ATTR_COUNT), NULL, 10));
+        if (counter.getCount() > 0) {
+                gSessionData->mIsEBS = true;
+        }
         counter.setEnabled(true);
 
         // Associate a driver with each counter
@@ -181,9 +187,9 @@ void ConfigurationXML::configurationTag(mxml_node_t *node) {
 }
 
 void ConfigurationXML::getDefaultConfigurationXml(const char * & xml, unsigned int & len) {
-#include "configuration_xml.h" // defines and initializes char configuration_xml[] and int configuration_xml_len
-        xml = (const char *)configuration_xml;
-        len = configuration_xml_len;
+#include "defaults_xml.h" // defines and initializes char defaults_xml[] and int defaults_xml_len
+        xml = (const char *)defaults_xml;
+        len = defaults_xml_len;
 }
 
 void ConfigurationXML::getPath(char* path) {
diff --git a/daemon/ConfigurationXML.h b/daemon/ConfigurationXML.h
index 5650f48..efa415e 100644
--- a/daemon/ConfigurationXML.h
+++ b/daemon/ConfigurationXML.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/Counter.h b/daemon/Counter.h
index 231a85d..6891745 100644
--- a/daemon/Counter.h
+++ b/daemon/Counter.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -25,7 +25,7 @@ public:
         void clear () {
                 mType[0] = '\0';
                 mEnabled = false;
-                mEvent = 0;
+                mEvent = -1;
                 mCount = 0;
                 mKey = 0;
                 mDriver = NULL;
diff --git a/daemon/Driver.cpp b/daemon/Driver.cpp
index c262467..09e0401 100644
--- a/daemon/Driver.cpp
+++ b/daemon/Driver.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/Driver.h b/daemon/Driver.h
index f3a932f..e5ed7b6 100644
--- a/daemon/Driver.h
+++ b/daemon/Driver.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -27,7 +27,7 @@ public:
         virtual void setupCounter(Counter &counter) = 0;
 
         // Emits available counters
-        virtual void writeCounters(mxml_node_t *root) const = 0;
+        virtual int writeCounters(mxml_node_t *root) const = 0;
         // Emits possible dynamically generated events/counters
         virtual void writeEvents(mxml_node_t *) const {}
 
diff --git a/daemon/Collector.cpp b/daemon/DriverSource.cpp
index bf73534..f78ec6b 100644
--- a/daemon/Collector.cpp
+++ b/daemon/DriverSource.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -8,23 +8,47 @@
 
 #define __STDC_FORMAT_MACROS
 
+#include "DriverSource.h"
+
 #include <fcntl.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdlib.h>
-#include <errno.h>
-#include <sys/time.h>
 #include <inttypes.h>
-#include "Collector.h"
-#include "SessionData.h"
+#include <unistd.h>
+
+#include "Child.h"
+#include "Fifo.h"
 #include "Logging.h"
 #include "Sender.h"
+#include "SessionData.h"
+
+extern Child *child;
 
-// Driver initialization independent of session settings
-Collector::Collector() {
-        mBufferFD = 0;
+DriverSource::DriverSource(sem_t *senderSem, sem_t *startProfile) : mFifo(NULL), mSenderSem(senderSem), mStartProfile(startProfile), mBufferSize(0), mBufferFD(0), mLength(1) {
+        int driver_version = 0;
 
-        checkVersion();
+        if (readIntDriver("/dev/gator/version", &driver_version) == -1) {
+                logg->logError(__FILE__, __LINE__, "Error reading gator driver version");
+                handleException();
+        }
+
+        // Verify the driver version matches the daemon version
+        if (driver_version != PROTOCOL_VERSION) {
+                if ((driver_version > PROTOCOL_DEV) || (PROTOCOL_VERSION > PROTOCOL_DEV)) {
+                        // One of the mismatched versions is development version
+                        logg->logError(__FILE__, __LINE__,
+                                "DEVELOPMENT BUILD MISMATCH: gator driver version \"%d\" is not in sync with gator daemon version \"%d\".\n"
+                                ">> The following must be synchronized from engineering repository:\n"
+                                ">> * gator driver\n"
+                                ">> * gator daemon\n"
+                                ">> * Streamline", driver_version, PROTOCOL_VERSION);
+                        handleException();
+                } else {
+                        // Release version mismatch
+                        logg->logError(__FILE__, __LINE__, 
+                                "gator driver version \"%d\" is different than gator daemon version \"%d\".\n"
+                                ">> Please upgrade the driver and daemon to the latest versions.", driver_version, PROTOCOL_VERSION);
+                        handleException();
+                }
+        }
 
         int enable = -1;
         if (readIntDriver("/dev/gator/enable", &enable) != 0 || enable != 0) {
@@ -37,14 +61,15 @@ Collector::Collector() {
                 gSessionData->mCores = 1;
         }
 
-        mBufferSize = 0;
         if (readIntDriver("/dev/gator/buffer_size", &mBufferSize) || mBufferSize <= 0) {
                 logg->logError(__FILE__, __LINE__, "Unable to read the driver buffer size");
                 handleException();
         }
 }
 
-Collector::~Collector() {
+DriverSource::~DriverSource() {
+        delete mFifo;
+
         // Write zero for safety, as a zero should have already been written
         writeDriver("/dev/gator/enable", "0");
 
@@ -54,36 +79,21 @@ Collector::~Collector() {
         }
 }
 
-void Collector::checkVersion() {
-        int driver_version = 0;
-
-        if (readIntDriver("/dev/gator/version", &driver_version) == -1) {
-                logg->logError(__FILE__, __LINE__, "Error reading gator driver version");
-                handleException();
-        }
+bool DriverSource::prepare() {
+        // Create user-space buffers, add 5 to the size to account for the 1-byte type and 4-byte length
+        logg->logMessage("Created %d MB collector buffer with a %d-byte ragged end", gSessionData->mTotalBufferSize, mBufferSize);
+        mFifo = new Fifo(mBufferSize + 5, gSessionData->mTotalBufferSize*1024*1024, mSenderSem);
 
-        // Verify the driver version matches the daemon version
-        if (driver_version != PROTOCOL_VERSION) {
-                if ((driver_version > PROTOCOL_DEV) || (PROTOCOL_VERSION > PROTOCOL_DEV)) {
-                        // One of the mismatched versions is development version
-                        logg->logError(__FILE__, __LINE__,
-                                "DEVELOPMENT BUILD MISMATCH: gator driver version \"%d\" is not in sync with gator daemon version \"%d\".\n"
-                                ">> The following must be synchronized from engineering repository:\n"
-                                ">> * gator driver\n"
-                                ">> * gator daemon\n"
-                                ">> * Streamline", driver_version, PROTOCOL_VERSION);
-                        handleException();
-                } else {
-                        // Release version mismatch
-                        logg->logError(__FILE__, __LINE__, 
-                                "gator driver version \"%d\" is different than gator daemon version \"%d\".\n"
-                                ">> Please upgrade the driver and daemon to the latest versions.", driver_version, PROTOCOL_VERSION);
-                        handleException();
-                }
-        }
+        return true;
 }
 
-void Collector::start() {
+void DriverSource::run() {
+        // Get the initial pointer to the collect buffer
+        char *collectBuffer = mFifo->start();
+        int bytesCollected = 0;
+
+        logg->logMessage("********** Profiling started **********");
+
         // Set the maximum backtrace depth
         if (writeReadDriver("/dev/gator/backtrace_depth", &gSessionData->mBacktraceDepth)) {
                 logg->logError(__FILE__, __LINE__, "Unable to set the driver backtrace depth");
@@ -125,79 +135,112 @@ void Collector::start() {
         }
 
         lseek(mBufferFD, 0, SEEK_SET);
+
+        sem_post(mStartProfile);
+
+        // Collect Data
+        do {
+                // This command will stall until data is received from the driver
+                // Calls event_buffer_read in the driver
+                errno = 0;
+                bytesCollected = read(mBufferFD, collectBuffer, mBufferSize);
+
+                // If read() returned due to an interrupt signal, re-read to obtain the last bit of collected data
+                if (bytesCollected == -1 && errno == EINTR) {
+                        bytesCollected = read(mBufferFD, collectBuffer, mBufferSize);
+                }
+
+                // return the total bytes written
+                logg->logMessage("Driver read of %d bytes", bytesCollected);
+
+                // In one shot mode, stop collection once all the buffers are filled
+                if (gSessionData->mOneShot && gSessionData->mSessionIsActive) {
+                        if (bytesCollected == -1 || mFifo->willFill(bytesCollected)) {
+                                logg->logMessage("One shot");
+                                child->endSession();
+                        }
+                }
+                collectBuffer = mFifo->write(bytesCollected);
+        } while (bytesCollected > 0);
+
+        logg->logMessage("Exit collect data loop");
 }
 
-// These commands should cause the read() function in collect() to return
-void Collector::stop() {
-        // This will stop the driver from profiling
+void DriverSource::interrupt() {
+        // This command should cause the read() function in collect() to return and stop the driver from profiling
         if (writeDriver("/dev/gator/enable", "0") != 0) {
                 logg->logMessage("Stopping kernel failed");
         }
 }
 
-int Collector::collect(char* buffer) {
-        // Calls event_buffer_read in the driver
-        int bytesRead;
-
-        errno = 0;
-        bytesRead = read(mBufferFD, buffer, mBufferSize);
+bool DriverSource::isDone() {
+        return mLength <= 0;
+}
 
-        // If read() returned due to an interrupt signal, re-read to obtain the last bit of collected data
-        if (bytesRead == -1 && errno == EINTR) {
-                bytesRead = read(mBufferFD, buffer, mBufferSize);
+void DriverSource::write(Sender *sender) {
+        char *data = mFifo->read(&mLength);
+        if (data != NULL) {
+                sender->writeData(data, mLength, RESPONSE_APC_DATA);
+                mFifo->release();
         }
-
-        // return the total bytes written
-        logg->logMessage("Driver read of %d bytes", bytesRead);
-        return bytesRead;
 }
 
-int Collector::readIntDriver(const char* fullpath, int* value) {
-        FILE* file = fopen(fullpath, "r");
-        if (file == NULL) {
+int DriverSource::readIntDriver(const char *fullpath, int *value) {
+        char data[40]; // Sufficiently large to hold any integer
+        const int fd = open(fullpath, O_RDONLY);
+        if (fd < 0) {
+                return -1;
+        }
+
+        const ssize_t bytes = read(fd, data, sizeof(data) - 1);
+        close(fd);
+        if (bytes < 0) {
                 return -1;
         }
-        if (fscanf(file, "%u", value) != 1) {
-                fclose(file);
+        data[bytes] = '\0';
+
+        char *endptr;
+        errno = 0;
+        *value = strtol(data, &endptr, 10);
+        if (errno != 0 || *endptr != '\n') {
                 logg->logMessage("Invalid value in file %s", fullpath);
                 return -1;
         }
-        fclose(file);
+
         return 0;
 }
 
-int Collector::readInt64Driver(const char* fullpath, int64_t* value) {
-        FILE* file = fopen(fullpath, "r");
-        if (file == NULL) {
+int DriverSource::readInt64Driver(const char *fullpath, int64_t *value) {
+        char data[40]; // Sufficiently large to hold any integer
+        const int fd = open(fullpath, O_RDONLY);
+        if (fd < 0) {
                 return -1;
         }
-        if (fscanf(file, "%" SCNi64, value) != 1) {
-                fclose(file);
-                logg->logMessage("Invalid value in file %s", fullpath);
+
+        const ssize_t bytes = read(fd, data, sizeof(data) - 1);
+        close(fd);
+        if (bytes < 0) {
                 return -1;
         }
-        fclose(file);
-        return 0;
-}
+        data[bytes] = '\0';
 
-int Collector::writeDriver(const char* path, int value) {
-        char data[40]; // Sufficiently large to hold any integer
-        snprintf(data, sizeof(data), "%d", value);
-        return writeDriver(path, data);
-}
+        char *endptr;
+        errno = 0;
+        *value = strtoll(data, &endptr, 10);
+        if (errno != 0 || *endptr != '\n') {
+                logg->logMessage("Invalid value in file %s", fullpath);
+                return -1;
+        }
 
-int Collector::writeDriver(const char* path, int64_t value) {
-        char data[40]; // Sufficiently large to hold any integer
-        snprintf(data, sizeof(data), "%" PRIi64, value);
-        return writeDriver(path, data);
+        return 0;
 }
 
-int Collector::writeDriver(const char* fullpath, const char* data) {
+int DriverSource::writeDriver(const char *fullpath, const char *data) {
         int fd = open(fullpath, O_WRONLY);
         if (fd < 0) {
                 return -1;
         }
-        if (write(fd, data, strlen(data)) < 0) {
+        if (::write(fd, data, strlen(data)) < 0) {
                 close(fd);
                 logg->logMessage("Opened but could not write to %s", fullpath);
                 return -1;
@@ -206,14 +249,26 @@ int Collector::writeDriver(const char* fullpath, const char* data) {
         return 0;
 }
 
-int Collector::writeReadDriver(const char* path, int* value) {
+int DriverSource::writeDriver(const char *path, int value) {
+        char data[40]; // Sufficiently large to hold any integer
+        snprintf(data, sizeof(data), "%d", value);
+        return writeDriver(path, data);
+}
+
+int DriverSource::writeDriver(const char *path, int64_t value) {
+        char data[40]; // Sufficiently large to hold any integer
+        snprintf(data, sizeof(data), "%" PRIi64, value);
+        return writeDriver(path, data);
+}
+
+int DriverSource::writeReadDriver(const char *path, int *value) {
         if (writeDriver(path, *value) || readIntDriver(path, value)) {
                 return -1;
         }
         return 0;
 }
 
-int Collector::writeReadDriver(const char* path, int64_t* value) {
+int DriverSource::writeReadDriver(const char *path, int64_t *value) {
         if (writeDriver(path, *value) || readInt64Driver(path, value)) {
                 return -1;
         }
diff --git a/daemon/DriverSource.h b/daemon/DriverSource.h
new file mode 100644
index 0000000..dcf1078
--- /dev/null
+++ b/daemon/DriverSource.h
@@ -0,0 +1,52 @@
+/**
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef DRIVERSOURCE_H
+#define DRIVERSOURCE_H
+
+#include <semaphore.h>
+#include <stdint.h>
+
+#include "Source.h"
+
+class Fifo;
+
+class DriverSource : public Source {
+public:
+        DriverSource(sem_t *senderSem, sem_t *startProfile);
+        ~DriverSource();
+
+        bool prepare();
+        void run();
+        void interrupt();
+
+        bool isDone();
+        void write(Sender *sender);
+
+        static int readIntDriver(const char *fullpath, int *value);
+        static int readInt64Driver(const char *fullpath, int64_t *value);
+        static int writeDriver(const char *fullpath, const char *data);
+        static int writeDriver(const char *path, int value);
+        static int writeDriver(const char *path, int64_t value);
+        static int writeReadDriver(const char *path, int *value);
+        static int writeReadDriver(const char *path, int64_t *value);
+
+private:
+        Fifo *mFifo;
+        sem_t *const mSenderSem;
+        sem_t *const mStartProfile;
+        int mBufferSize;
+        int mBufferFD;
+        int mLength;
+
+        // Intentionally unimplemented
+        DriverSource(const DriverSource &);
+        DriverSource &operator=(const DriverSource &);
+};
+
+#endif // DRIVERSOURCE_H
diff --git a/daemon/DynBuf.cpp b/daemon/DynBuf.cpp
new file mode 100644
index 0000000..6f92b33
--- /dev/null
+++ b/daemon/DynBuf.cpp
@@ -0,0 +1,139 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "DynBuf.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "Logging.h"
+
+// Pick an aggressive size as buffer is primarily used for disk IO
+#define MIN_BUFFER_FREE (1 << 12)
+
+int DynBuf::resize(const size_t minCapacity) {
+        size_t scaledCapacity = 2 * capacity;
+        if (scaledCapacity < minCapacity) {
+                scaledCapacity = minCapacity;
+        }
+        if (scaledCapacity < 2 * MIN_BUFFER_FREE) {
+                scaledCapacity = 2 * MIN_BUFFER_FREE;
+        }
+        capacity = scaledCapacity;
+
+        buf = static_cast<char *>(realloc(buf, capacity));
+        if (buf == NULL) {
+                return -errno;
+        }
+
+        return 0;
+}
+
+bool DynBuf::read(const char *const path) {
+        int result = false;
+
+        const int fd = open(path, O_RDONLY);
+        if (fd < 0) {
+                logg->logMessage("%s(%s:%i): open failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        length = 0;
+
+        for (;;) {
+                const size_t minCapacity = length + MIN_BUFFER_FREE + 1;
+                if (capacity < minCapacity) {
+                        if (resize(minCapacity) != 0) {
+                                logg->logMessage("%s(%s:%i): DynBuf::resize failed", __FUNCTION__, __FILE__, __LINE__);
+                                goto fail;
+                        }
+                }
+
+                const ssize_t bytes = ::read(fd, buf + length, capacity - length - 1);
+                if (bytes < 0) {
+                        logg->logMessage("%s(%s:%i): read failed", __FUNCTION__, __FILE__, __LINE__);
+                        goto fail;
+                } else if (bytes == 0) {
+                        break;
+                }
+                length += bytes;
+        }
+
+        buf[length] = '\0';
+        result = true;
+
+ fail:
+        close(fd);
+
+        return result;
+}
+
+int DynBuf::readlink(const char *const path) {
+        ssize_t bytes = MIN_BUFFER_FREE;
+
+        for (;;) {
+                if (static_cast<size_t>(bytes) >= capacity) {
+                        const int err = resize(2 * bytes);
+                        if (err != 0) {
+                                return err;
+                        }
+                }
+                bytes = ::readlink(path, buf, capacity);
+                if (bytes < 0) {
+                        return -errno;
+                } else if (static_cast<size_t>(bytes) < capacity) {
+                        break;
+                }
+        }
+
+        length = bytes;
+        buf[bytes] = '\0';
+
+        return 0;
+}
+
+bool DynBuf::printf(const char *format, ...) {
+        va_list ap;
+
+        if (capacity <= 0) {
+                if (resize(2 * MIN_BUFFER_FREE) != 0) {
+                        logg->logMessage("%s(%s:%i): DynBuf::resize failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        }
+
+        va_start(ap, format);
+        int bytes = vsnprintf(buf, capacity, format, ap);
+        va_end(ap);
+        if (bytes < 0) {
+                logg->logMessage("%s(%s:%i): fsnprintf failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        if (static_cast<size_t>(bytes) > capacity) {
+                if (resize(bytes + 1) != 0) {
+                        logg->logMessage("%s(%s:%i): DynBuf::resize failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+
+                va_start(ap, format);
+                bytes = vsnprintf(buf, capacity, format, ap);
+                va_end(ap);
+                if (bytes < 0) {
+                        logg->logMessage("%s(%s:%i): fsnprintf failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        }
+
+        length = bytes;
+
+        return true;
+}
diff --git a/daemon/DynBuf.h b/daemon/DynBuf.h
new file mode 100644
index 0000000..2f4554a
--- /dev/null
+++ b/daemon/DynBuf.h
@@ -0,0 +1,52 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef DYNBUF_H
+#define DYNBUF_H
+
+#include <stdlib.h>
+
+class DynBuf {
+public:
+        DynBuf() : capacity(0), length(0), buf(NULL) {}
+        ~DynBuf() {
+                reset();
+        }
+
+        inline void reset() {
+                capacity = 0;
+                length = 0;
+                if (buf != NULL) {
+                        free(buf);
+                        buf = NULL;
+                }
+        }
+
+        bool read(const char *const path);
+        // On error instead of printing the error and returning false, this returns -errno
+        int readlink(const char *const path);
+        __attribute__ ((format(printf, 2, 3)))
+        bool printf(const char *format, ...);
+
+        size_t getLength() const { return length; }
+        const char *getBuf() const { return buf; }
+        char *getBuf() { return buf; }
+
+private:
+        int resize(const size_t minCapacity);
+
+        size_t capacity;
+        size_t length;
+        char *buf;
+
+        // Intentionally undefined
+        DynBuf(const DynBuf &);
+        DynBuf &operator=(const DynBuf &);
+};
+
+#endif // DYNBUF_H
diff --git a/daemon/EventsXML.cpp b/daemon/EventsXML.cpp
index 2a80482..a07a046 100644
--- a/daemon/EventsXML.cpp
+++ b/daemon/EventsXML.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -35,7 +35,7 @@ char* EventsXML::getXML() {
                 fclose(fl);
         } else {
                 logg->logMessage("Unable to locate events.xml, using default");
-                xml = mxmlLoadString(NULL, (char *)events_xml, MXML_NO_CALLBACK);
+                xml = mxmlLoadString(NULL, (const char *)events_xml, MXML_NO_CALLBACK);
         }
 
         // Add dynamic events from the drivers
diff --git a/daemon/EventsXML.h b/daemon/EventsXML.h
index 8e693ef..6cd1560 100644
--- a/daemon/EventsXML.h
+++ b/daemon/EventsXML.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/ExternalSource.cpp b/daemon/ExternalSource.cpp
new file mode 100644
index 0000000..fe5824b
--- /dev/null
+++ b/daemon/ExternalSource.cpp
@@ -0,0 +1,56 @@
+/**
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "ExternalSource.h"
+
+#include <sys/prctl.h>
+
+#include "Logging.h"
+#include "OlySocket.h"
+#include "SessionData.h"
+
+ExternalSource::ExternalSource(sem_t *senderSem) : mBuffer(0, FRAME_EXTERNAL, 1024, senderSem), mSock("/tmp/gator") {
+}
+
+ExternalSource::~ExternalSource() {
+}
+
+bool ExternalSource::prepare() {
+        return true;
+}
+
+void ExternalSource::run() {
+        prctl(PR_SET_NAME, (unsigned long)&"gatord-uds", 0, 0, 0);
+
+        while (gSessionData->mSessionIsActive) {
+                // Will be aborted when the socket is closed at the end of the capture
+                int length = mSock.receive(mBuffer.getWritePos(), mBuffer.contiguousSpaceAvailable());
+                if (length <= 0) {
+                        break;
+                }
+
+                mBuffer.advanceWrite(length);
+                mBuffer.check(0);
+        }
+
+        mBuffer.setDone();
+}
+
+void ExternalSource::interrupt() {
+        // Do nothing
+}
+
+bool ExternalSource::isDone() {
+        return mBuffer.isDone();
+}
+
+void ExternalSource::write(Sender *sender) {
+        if (!mBuffer.isDone()) {
+                mBuffer.write(sender);
+        }
+}
diff --git a/daemon/ExternalSource.h b/daemon/ExternalSource.h
new file mode 100644
index 0000000..2052bdf
--- /dev/null
+++ b/daemon/ExternalSource.h
@@ -0,0 +1,40 @@
+/**
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef EXTERNALSOURCE_H
+#define EXTERNALSOURCE_H
+
+#include <semaphore.h>
+
+#include "Buffer.h"
+#include "OlySocket.h"
+#include "Source.h"
+
+// Unix domain socket counters from external sources like graphics drivers
+class ExternalSource : public Source {
+public:
+        ExternalSource(sem_t *senderSem);
+        ~ExternalSource();
+
+        bool prepare();
+        void run();
+        void interrupt();
+
+        bool isDone();
+        void write(Sender *sender);
+
+private:
+        Buffer mBuffer;
+        OlySocket mSock;
+
+        // Intentionally unimplemented
+        ExternalSource(const ExternalSource &);
+        ExternalSource &operator=(const ExternalSource &);
+};
+
+#endif // EXTERNALSOURCE_H
diff --git a/daemon/Fifo.cpp b/daemon/Fifo.cpp
index 250a4d0..f672e92 100644
--- a/daemon/Fifo.cpp
+++ b/daemon/Fifo.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/Fifo.h b/daemon/Fifo.h
index d25cd68..7dd7426 100644
--- a/daemon/Fifo.h
+++ b/daemon/Fifo.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -12,7 +12,7 @@
 #ifdef WIN32
 #include <windows.h>
 #define sem_t HANDLE
-#define sem_init(sem, pshared, value) ((*(sem) = CreateSemaphore(NULL, value, INFINITE, NULL)) == NULL)
+#define sem_init(sem, pshared, value) ((*(sem) = CreateSemaphore(NULL, value, LONG_MAX, NULL)) == NULL)
 #define sem_wait(sem) WaitForSingleObject(*(sem), INFINITE)
 #define sem_post(sem) ReleaseSemaphore(*(sem), 1, NULL)
 #define sem_destroy(sem) CloseHandle(*(sem))
diff --git a/daemon/Hwmon.cpp b/daemon/Hwmon.cpp
index 1d7c0da..778f307 100644
--- a/daemon/Hwmon.cpp
+++ b/daemon/Hwmon.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -17,7 +17,7 @@
 
 class HwmonCounter {
 public:
-        HwmonCounter(HwmonCounter *next, int key, const sensors_chip_name *chip, const sensors_feature *feature);
+        HwmonCounter(HwmonCounter *next, const sensors_chip_name *chip, const sensors_feature *feature);
         ~HwmonCounter();
 
         HwmonCounter *getNext() const { return next; }
@@ -69,7 +69,7 @@ private:
         HwmonCounter &operator=(const HwmonCounter &);
 };
 
-HwmonCounter::HwmonCounter(HwmonCounter *next, int key, const sensors_chip_name *chip, const sensors_feature *feature) : next(next), key(key), polled(false), readable(false), enabled(false), duplicate(false), chip(chip), feature(feature) {
+HwmonCounter::HwmonCounter(HwmonCounter *next, const sensors_chip_name *chip, const sensors_feature *feature) : next(next), key(getEventKey()), polled(false), readable(false), enabled(false), duplicate(false), chip(chip), feature(feature) {
 
         int len = sensors_snprintf_chip_name(NULL, 0, chip) + 1;
         char *chip_name = new char[len];
@@ -205,6 +205,23 @@ bool HwmonCounter::canRead() {
 }
 
 Hwmon::Hwmon() : counters(NULL) {
+}
+
+Hwmon::~Hwmon() {
+        while (counters != NULL) {
+                HwmonCounter * counter = counters;
+                counters = counter->getNext();
+                delete counter;
+        }
+        sensors_cleanup();
+}
+
+void Hwmon::setup() {
+        // hwmon does not currently work with perf
+        if (gSessionData->perf.isSetup()) {
+                return;
+        }
+
         int err = sensors_init(NULL);
         if (err) {
                 logg->logMessage("Failed to initialize libsensors! (%d)", err);
@@ -218,20 +235,11 @@ Hwmon::Hwmon() : counters(NULL) {
                 int feature_nr = 0;
                 const sensors_feature *feature;
                 while ((feature = sensors_get_features(chip, &feature_nr))) {
-                        counters = new HwmonCounter(counters, getEventKey(), chip, feature);
+                        counters = new HwmonCounter(counters, chip, feature);
                 }
         }
 }
 
-Hwmon::~Hwmon() {
-        while (counters != NULL) {
-                HwmonCounter * counter = counters;
-                counters = counter->getNext();
-                delete counter;
-        }
-        sensors_cleanup();
-}
-
 HwmonCounter *Hwmon::findCounter(const Counter &counter) const {
         for (HwmonCounter * hwmonCounter = counters; hwmonCounter != NULL; hwmonCounter = hwmonCounter->getNext()) {
                 if (hwmonCounter->canRead() && strcmp(hwmonCounter->getName(), counter.getType()) == 0) {
@@ -271,14 +279,18 @@ void Hwmon::setupCounter(Counter &counter) {
         counter.setKey(hwmonCounter->getKey());
 }
 
-void Hwmon::writeCounters(mxml_node_t *root) const {
+int Hwmon::writeCounters(mxml_node_t *root) const {
+        int count = 0;
         for (HwmonCounter * counter = counters; counter != NULL; counter = counter->getNext()) {
                 if (!counter->canRead()) {
                         continue;
                 }
                 mxml_node_t *node = mxmlNewElement(root, "counter");
                 mxmlElementSetAttr(node, "name", counter->getName());
+                ++count;
         }
+
+        return count;
 }
 
 void Hwmon::writeEvents(mxml_node_t *root) const {
diff --git a/daemon/Hwmon.h b/daemon/Hwmon.h
index 46bb42e..a22a360 100644
--- a/daemon/Hwmon.h
+++ b/daemon/Hwmon.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -19,12 +19,14 @@ public:
         Hwmon();
         ~Hwmon();
 
+        void setup();
+
         bool claimCounter(const Counter &counter) const;
         bool countersEnabled() const;
         void resetCounters();
         void setupCounter(Counter &counter);
 
-        void writeCounters(mxml_node_t *root) const;
+        int writeCounters(mxml_node_t *root) const;
         void writeEvents(mxml_node_t *root) const;
 
         void start();
diff --git a/daemon/KMod.cpp b/daemon/KMod.cpp
index 559297f..9300002 100644
--- a/daemon/KMod.cpp
+++ b/daemon/KMod.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -12,9 +12,9 @@
 #include <dirent.h>
 #include <unistd.h>
 
-#include "Collector.h"
 #include "ConfigurationXML.h"
 #include "Counter.h"
+#include "DriverSource.h"
 #include "Logging.h"
 
 // Claim all the counters in /dev/gator/events
@@ -38,9 +38,9 @@ void KMod::resetCounters() {
                                 continue;
                         snprintf(base, sizeof(base), "/dev/gator/events/%s", ent->d_name);
                         snprintf(text, sizeof(text), "%s/enabled", base);
-                        Collector::writeDriver(text, 0);
+                        DriverSource::writeDriver(text, 0);
                         snprintf(text, sizeof(text), "%s/count", base);
-                        Collector::writeDriver(text, 0);
+                        DriverSource::writeDriver(text, 0);
                 }
                 closedir(dir);
         }
@@ -53,22 +53,22 @@ void KMod::setupCounter(Counter &counter) {
 
         snprintf(text, sizeof(text), "%s/enabled", base);
         int enabled = true;
-        if (Collector::writeReadDriver(text, &enabled) || !enabled) {
+        if (DriverSource::writeReadDriver(text, &enabled) || !enabled) {
                 counter.setEnabled(false);
                 return;
         }
 
         snprintf(text, sizeof(text), "%s/key", base);
         int key = 0;
-        Collector::readIntDriver(text, &key);
+        DriverSource::readIntDriver(text, &key);
         counter.setKey(key);
 
         snprintf(text, sizeof(text), "%s/event", base);
-        Collector::writeDriver(text, counter.getEvent());
+        DriverSource::writeDriver(text, counter.getEvent());
         snprintf(text, sizeof(text), "%s/count", base);
         if (access(text, F_OK) == 0) {
                 int count = counter.getCount();
-                if (Collector::writeReadDriver(text, &count) && counter.getCount() > 0) {
+                if (DriverSource::writeReadDriver(text, &count) && counter.getCount() > 0) {
                         logg->logError(__FILE__, __LINE__, "Cannot enable EBS for %s:%i with a count of %d\n", counter.getType(), counter.getEvent(), counter.getCount());
                         handleException();
                 }
@@ -80,23 +80,26 @@ void KMod::setupCounter(Counter &counter) {
         }
 }
 
-void KMod::writeCounters(mxml_node_t *root) const {
+int KMod::writeCounters(mxml_node_t *root) const {
         struct dirent *ent;
         mxml_node_t *counter;
 
         // counters.xml is simply a file listing of /dev/gator/events
         DIR* dir = opendir("/dev/gator/events");
         if (dir == NULL) {
-                logg->logError(__FILE__, __LINE__, "Cannot create counters.xml since unable to read /dev/gator/events");
-                handleException();
+                return 0;
         }
 
+        int count = 0;
         while ((ent = readdir(dir)) != NULL) {
                 // skip hidden files, current dir, and parent dir
                 if (ent->d_name[0] == '.')
                         continue;
                 counter = mxmlNewElement(root, "counter");
                 mxmlElementSetAttr(counter, "name", ent->d_name);
+                ++count;
         }
         closedir(dir);
+
+        return count;
 }
diff --git a/daemon/KMod.h b/daemon/KMod.h
index 7974262..fb7fc8a 100644
--- a/daemon/KMod.h
+++ b/daemon/KMod.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2013. All rights reserved.
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -21,7 +21,7 @@ public:
         void resetCounters();
         void setupCounter(Counter &counter);
 
-        void writeCounters(mxml_node_t *root) const;
+        int writeCounters(mxml_node_t *root) const;
 };
 
 #endif // KMOD_H
diff --git a/daemon/LocalCapture.cpp b/daemon/LocalCapture.cpp
index 3235a34..d2a4b79 100644
--- a/daemon/LocalCapture.cpp
+++ b/daemon/LocalCapture.cpp
@@ -1,18 +1,20 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
+#include "LocalCapture.h"
+
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include "LocalCapture.h"
+
 #include "SessionData.h"
 #include "Logging.h"
 #include "OlyUtility.h"
diff --git a/daemon/LocalCapture.h b/daemon/LocalCapture.h
index 8042d6a..aadecce 100644
--- a/daemon/LocalCapture.h
+++ b/daemon/LocalCapture.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/Logging.cpp b/daemon/Logging.cpp
index 5fd45b5..b8d3178 100644
--- a/daemon/Logging.cpp
+++ b/daemon/Logging.cpp
@@ -1,11 +1,13 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
 
+#include "Logging.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
@@ -23,8 +25,6 @@
 #define MUTEX_UNLOCK()  pthread_mutex_unlock(&mLoggingMutex)
 #endif
 
-#include "Logging.h"
-
 // Global thread-safe logging
 Logging* logg = NULL;
 
diff --git a/daemon/Logging.h b/daemon/Logging.h
index 8f960de..6ae3280 100644
--- a/daemon/Logging.h
+++ b/daemon/Logging.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,14 +9,7 @@
 #ifndef __LOGGING_H__
 #define __LOGGING_H__
 
-#include <stdio.h>
-#include <string.h>
-#include <limits.h>
-#ifdef WIN32
-#include <windows.h>
-#else
 #include <pthread.h>
-#endif
 
 #define DRIVER_ERROR "\n Driver issue:\n  >> gator.ko must be built against the current kernel version & configuration\n  >> gator.ko should be co-located with gatord in the same directory\n  >>   OR insmod gator.ko prior to launching gatord"
 
@@ -33,11 +26,7 @@ private:
         char    mErrBuf[4096]; // Arbitrarily large buffer to hold a string
         char    mLogBuf[4096]; // Arbitrarily large buffer to hold a string
         bool    mDebug;
-#ifdef WIN32
-        HANDLE  mLoggingMutex;
-#else
         pthread_mutex_t mLoggingMutex;
-#endif
 };
 
 extern Logging* logg;
diff --git a/daemon/Monitor.cpp b/daemon/Monitor.cpp
new file mode 100644
index 0000000..90d5c47
--- /dev/null
+++ b/daemon/Monitor.cpp
@@ -0,0 +1,61 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "Monitor.h"
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "Logging.h"
+
+Monitor::Monitor() : mFd(-1) {
+}
+
+Monitor::~Monitor() {
+        if (mFd >= -1) {
+                close(mFd);
+        }
+}
+
+bool Monitor::init() {
+        mFd = epoll_create(16);
+        if (mFd < 0) {
+                logg->logMessage("%s(%s:%i): epoll_create1 failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        return true;
+}
+
+bool Monitor::add(const int fd) {
+        struct epoll_event event;
+        memset(&event, 0, sizeof(event));
+        event.data.fd = fd;
+        event.events = EPOLLIN;
+        if (epoll_ctl(mFd, EPOLL_CTL_ADD, fd, &event) != 0) {
+                logg->logMessage("%s(%s:%i): epoll_ctl failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        return true;
+}
+
+int Monitor::wait(struct epoll_event *const events, int maxevents, int timeout) {
+        int result = epoll_wait(mFd, events, maxevents, timeout);
+        if (result < 0) {
+                // Ignore if the call was interrupted as this will happen when SIGINT is received
+                if (errno == EINTR) {
+                        result = 0;
+                } else {
+                        logg->logMessage("%s(%s:%i): epoll_wait failed", __FUNCTION__, __FILE__, __LINE__);
+                }
+        }
+
+        return result;
+}
diff --git a/daemon/Monitor.h b/daemon/Monitor.h
new file mode 100644
index 0000000..6e268b6
--- /dev/null
+++ b/daemon/Monitor.h
@@ -0,0 +1,32 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef MONITOR_H
+#define MONITOR_H
+
+#include <sys/epoll.h>
+
+class Monitor {
+public:
+        Monitor();
+        ~Monitor();
+
+        bool init();
+        bool add(const int fd);
+        int wait(struct epoll_event *const events, int maxevents, int timeout);
+
+private:
+
+        int mFd;
+
+        // Intentionally unimplemented
+        Monitor(const Monitor &);
+        Monitor &operator=(const Monitor &);
+};
+
+#endif // MONITOR_H
diff --git a/daemon/OlySocket.cpp b/daemon/OlySocket.cpp
index ab5c3c2..26e4768 100644
--- a/daemon/OlySocket.cpp
+++ b/daemon/OlySocket.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -15,6 +15,7 @@
 #else
 #include <netinet/in.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <unistd.h>
 #include <netdb.h>
 #endif
@@ -30,7 +31,7 @@
 #define SHUTDOWN_RX_TX SHUT_RDWR
 #endif
 
-OlySocket::OlySocket(int port, bool multiple) {
+OlyServerSocket::OlyServerSocket(int port) {
 #ifdef WIN32
   WSADATA wsaData;
   if (WSAStartup(0x0202, &wsaData) != 0) {
@@ -39,24 +40,82 @@ OlySocket::OlySocket(int port, bool multiple) {
   }
 #endif
 
-  if (multiple) {
-    createServerSocket(port);
-  } else {
-    createSingleServerConnection(port);
-  }
+  createServerSocket(port);
 }
 
-OlySocket::OlySocket(int port, char* host) {
-  mFDServer = 0;
+OlySocket::OlySocket(int port, const char* host) {
   createClientSocket(host, port);
 }
 
+OlySocket::OlySocket(int socketID) : mSocketID(socketID) {
+}
+
+#ifndef WIN32
+
+OlyServerSocket::OlyServerSocket(const char* path) {
+  // Create socket
+  mFDServer = socket(PF_UNIX, SOCK_STREAM, 0);
+  if (mFDServer < 0) {
+    logg->logError(__FILE__, __LINE__, "Error creating server socket");
+    handleException();
+  }
+
+  unlink(path);
+
+  // Create sockaddr_in structure, ensuring non-populated fields are zero
+  struct sockaddr_un sockaddr;
+  memset((void*)&sockaddr, 0, sizeof(sockaddr));
+  sockaddr.sun_family = AF_UNIX;
+  strncpy(sockaddr.sun_path, path, sizeof(sockaddr.sun_path) - 1);
+  sockaddr.sun_path[sizeof(sockaddr.sun_path) - 1] = '\0';
+
+  // Bind the socket to an address
+  if (bind(mFDServer, (const struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0) {
+    logg->logError(__FILE__, __LINE__, "Binding of server socket failed.");
+    handleException();
+  }
+
+  // Listen for connections on this socket
+  if (listen(mFDServer, 1) < 0) {
+    logg->logError(__FILE__, __LINE__, "Listening of server socket failed");
+    handleException();
+  }
+}
+
+OlySocket::OlySocket(const char* path) {
+  mSocketID = socket(PF_UNIX, SOCK_STREAM, 0);
+  if (mSocketID < 0) {
+    return;
+  }
+
+  // Create sockaddr_in structure, ensuring non-populated fields are zero
+  struct sockaddr_un sockaddr;
+  memset((void*)&sockaddr, 0, sizeof(sockaddr));
+  sockaddr.sun_family = AF_UNIX;
+  strncpy(sockaddr.sun_path, path, sizeof(sockaddr.sun_path) - 1);
+  sockaddr.sun_path[sizeof(sockaddr.sun_path) - 1] = '\0';
+
+  if (connect(mSocketID, (const struct sockaddr*)&sockaddr, sizeof(sockaddr)) < 0) {
+    close(mSocketID);
+    mSocketID = -1;
+    return;
+  }
+}
+
+#endif
+
 OlySocket::~OlySocket() {
   if (mSocketID > 0) {
     CLOSE_SOCKET(mSocketID);
   }
 }
 
+OlyServerSocket::~OlyServerSocket() {
+  if (mFDServer > 0) {
+    CLOSE_SOCKET(mFDServer);
+  }
+}
+
 void OlySocket::shutdownConnection() {
   // Shutdown is primarily used to unblock other threads that are blocking on send/receive functions
   shutdown(mSocketID, SHUTDOWN_RX_TX);
@@ -70,7 +129,7 @@ void OlySocket::closeSocket() {
   }
 }
 
-void OlySocket::closeServerSocket() {
+void OlyServerSocket::closeServerSocket() {
   if (CLOSE_SOCKET(mFDServer) != 0) {
     logg->logError(__FILE__, __LINE__, "Failed to close server socket.");
     handleException();
@@ -78,7 +137,7 @@ void OlySocket::closeServerSocket() {
   mFDServer = 0;
 }
 
-void OlySocket::createClientSocket(char* hostname, int portno) {
+void OlySocket::createClientSocket(const char* hostname, int portno) {
 #ifdef WIN32
   // TODO: Implement for Windows
 #else
@@ -119,14 +178,7 @@ void OlySocket::createClientSocket(char* hostname, int portno) {
 #endif
 }
 
-void OlySocket::createSingleServerConnection(int port) {
-  createServerSocket(port);
-
-  mSocketID = acceptConnection();
-  closeServerSocket();
-}
-
-void OlySocket::createServerSocket(int port) {
+void OlyServerSocket::createServerSocket(int port) {
   int family = AF_INET6;
 
   // Create socket
@@ -169,22 +221,23 @@ void OlySocket::createServerSocket(int port) {
 
 // mSocketID is always set to the most recently accepted connection
 // The user of this class should maintain the different socket connections, e.g. by forking the process
-int OlySocket::acceptConnection() {
+int OlyServerSocket::acceptConnection() {
+  int socketID;
   if (mFDServer <= 0) {
     logg->logError(__FILE__, __LINE__, "Attempting multiple connections on a single connection server socket or attempting to accept on a client socket");
     handleException();
   }
 
   // Accept a connection, note that this call blocks until a client connects
-  mSocketID = accept(mFDServer, NULL, NULL);
-  if (mSocketID < 0) {
+  socketID = accept(mFDServer, NULL, NULL);
+  if (socketID < 0) {
     logg->logError(__FILE__, __LINE__, "Socket acceptance failed");
     handleException();
   }
-  return mSocketID;
+  return socketID;
 }
 
-void OlySocket::send(char* buffer, int size) {
+void OlySocket::send(const char* buffer, int size) {
   if (size <= 0 || buffer == NULL) {
     return;
   }
diff --git a/daemon/OlySocket.h b/daemon/OlySocket.h
index 5bab7d1..eab786b 100644
--- a/daemon/OlySocket.h
+++ b/daemon/OlySocket.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -9,27 +9,44 @@
 #ifndef __OLY_SOCKET_H__
 #define __OLY_SOCKET_H__
 
-#include <string.h>
-
 class OlySocket {
 public:
-  OlySocket(int port, bool multipleConnections = false);
-  OlySocket(int port, char* hostname);
+  OlySocket(int port, const char* hostname);
+  OlySocket(int socketID);
+#ifndef WIN32
+  OlySocket(const char* path);
+#endif
   ~OlySocket();
-  int acceptConnection();
+
   void closeSocket();
-  void closeServerSocket();
   void shutdownConnection();
-  void send(char* buffer, int size);
-  void sendString(const char* string) {send((char*)string, strlen(string));}
+  void send(const char* buffer, int size);
   int receive(char* buffer, int size);
   int receiveNBytes(char* buffer, int size);
   int receiveString(char* buffer, int size);
-  int getSocketID() {return mSocketID;}
+
+  bool isValid() const { return mSocketID >= 0; }
+
+private:
+  int mSocketID;
+
+  void createClientSocket(const char* hostname, int port);
+};
+
+class OlyServerSocket {
+public:
+  OlyServerSocket(int port);
+#ifndef WIN32
+  OlyServerSocket(const char* path);
+#endif
+  ~OlyServerSocket();
+
+  int acceptConnection();
+  void closeServerSocket();
+
 private:
-  int mSocketID, mFDServer;
-  void createClientSocket(char* hostname, int port);
-  void createSingleServerConnection(int port);
+  int mFDServer;
+
   void createServerSocket(int port);
 };
 
diff --git a/daemon/OlyUtility.cpp b/daemon/OlyUtility.cpp
index 0b22d6e..45340a2 100644
--- a/daemon/OlyUtility.cpp
+++ b/daemon/OlyUtility.cpp
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/OlyUtility.h b/daemon/OlyUtility.h
index abab0a5..1d26beb 100644
--- a/daemon/OlyUtility.h
+++ b/daemon/OlyUtility.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) ARM Limited 2010-2013. All rights reserved.
+ * Copyright (C) ARM Limited 2010-2014. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/daemon/PerfBuffer.cpp b/daemon/PerfBuffer.cpp
new file mode 100644
index 0000000..5fad583
--- /dev/null
+++ b/daemon/PerfBuffer.cpp
@@ -0,0 +1,139 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "PerfBuffer.h"
+
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+#include "Buffer.h"
+#include "Logging.h"
+#include "Sender.h"
+#include "SessionData.h"
+
+PerfBuffer::PerfBuffer() {
+        for (int cpu = 0; cpu < ARRAY_LENGTH(mBuf); ++cpu) {
+                mBuf[cpu] = MAP_FAILED;
+                mDiscard[cpu] = false;
+        }
+}
+
+PerfBuffer::~PerfBuffer() {
+        for (int cpu = ARRAY_LENGTH(mBuf) - 1; cpu >= 0; --cpu) {
+                if (mBuf[cpu] != MAP_FAILED) {
+                        munmap(mBuf[cpu], gSessionData->mPageSize + BUF_SIZE);
+                }
+        }
+}
+
+bool PerfBuffer::useFd(const int cpu, const int fd, const int groupFd) {
+        if (fd == groupFd) {
+                if (mBuf[cpu] != MAP_FAILED) {
+                        logg->logMessage("%s(%s:%i): cpu %i already online or not correctly cleaned up", __FUNCTION__, __FILE__, __LINE__, cpu);
+                        return false;
+                }
+
+                // The buffer isn't mapped yet
+                mBuf[cpu] = mmap(NULL, gSessionData->mPageSize + BUF_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+                if (mBuf[cpu] == MAP_FAILED) {
+                        logg->logMessage("%s(%s:%i): mmap failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+
+                // Check the version
+                struct perf_event_mmap_page *pemp = static_cast<struct perf_event_mmap_page *>(mBuf[cpu]);
+                if (pemp->compat_version != 0) {
+                        logg->logMessage("%s(%s:%i): Incompatible perf_event_mmap_page compat_version", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        } else {
+                if (mBuf[cpu] == MAP_FAILED) {
+                        logg->logMessage("%s(%s:%i): cpu already online or not correctly cleaned up", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+
+                if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, groupFd) < 0) {
+                        logg->logMessage("%s(%s:%i): ioctl failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        }
+
+        return true;
+}
+
+void PerfBuffer::discard(const int cpu) {
+        if (mBuf[cpu] != MAP_FAILED) {
+                mDiscard[cpu] = true;
+        }
+}
+
+bool PerfBuffer::isEmpty() {
+        for (int cpu = 0; cpu < gSessionData->mCores; ++cpu) {
+                if (mBuf[cpu] != MAP_FAILED) {
+                        // Take a snapshot of the positions
+                        struct perf_event_mmap_page *pemp = static_cast<struct perf_event_mmap_page *>(mBuf[cpu]);
+                        const __u64 head = pemp->data_head;
+                        const __u64 tail = pemp->data_tail;
+
+                        if (head != tail) {
+                                return false;
+                        }
+                }
+        }
+
+        return true;
+}
+
+bool PerfBuffer::send(Sender *const sender) {
+        for (int cpu = 0; cpu < gSessionData->mCores; ++cpu) {
+                if (mBuf[cpu] == MAP_FAILED) {
+                        continue;
+                }
+
+                // Take a snapshot of the positions
+                struct perf_event_mmap_page *pemp = static_cast<struct perf_event_mmap_page *>(mBuf[cpu]);
+                const __u64 head = pemp->data_head;
+                const __u64 tail = pemp->data_tail;
+
+                if (head > tail) {
+                        const uint8_t *const b = static_cast<uint8_t *>(mBuf[cpu]) + gSessionData->mPageSize;
+                        const int offset = gSessionData->mLocalCapture ? 1 : 0;
+                        unsigned char header[7];
+                        header[0] = RESPONSE_APC_DATA;
+                        Buffer::writeLEInt(header + 1, head - tail + sizeof(header) - 5);
+                        // Should use real packing functions
+                        header[5] = FRAME_PERF;
+                        header[6] = cpu;
+
+                        // Write header
+                        sender->writeData(reinterpret_cast<const char *>(&header) + offset, sizeof(header) - offset, RESPONSE_APC_DATA);
+
+                        // Write data
+                        if ((head & ~BUF_MASK) == (tail & ~BUF_MASK)) {
+                                // Not wrapped
+                                sender->writeData(reinterpret_cast<const char *>(b + (tail & BUF_MASK)), head - tail, RESPONSE_APC_DATA);
+                        } else {
+                                // Wrapped
+                                sender->writeData(reinterpret_cast<const char *>(b + (tail & BUF_MASK)), BUF_SIZE - (tail & BUF_MASK), RESPONSE_APC_DATA);
+                                sender->writeData(reinterpret_cast<const char *>(b), head & BUF_MASK, RESPONSE_APC_DATA);
+                        }
+
+                        // Update tail with the data read
+                        pemp->data_tail = head;
+                }
+
+                if (mDiscard[cpu]) {
+                        munmap(mBuf[cpu], gSessionData->mPageSize + BUF_SIZE);
+                        mBuf[cpu] = MAP_FAILED;
+                        mDiscard[cpu] = false;
+                        logg->logMessage("%s(%s:%i): Unmaped cpu %i", __FUNCTION__, __FILE__, __LINE__, cpu);
+                }
+        }
+
+        return true;
+}
diff --git a/daemon/PerfBuffer.h b/daemon/PerfBuffer.h
new file mode 100644
index 0000000..278a3b9
--- /dev/null
+++ b/daemon/PerfBuffer.h
@@ -0,0 +1,39 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef PERF_BUFFER
+#define PERF_BUFFER
+
+#include "Config.h"
+
+#define BUF_SIZE (gSessionData->mTotalBufferSize * 1024 * 1024)
+#define BUF_MASK (BUF_SIZE - 1)
+
+class Sender;
+
+class PerfBuffer {
+public:
+        PerfBuffer();
+        ~PerfBuffer();
+
+        bool useFd(const int cpu, const int fd, const int groupFd);
+        void discard(const int cpu);
+        bool isEmpty();
+        bool send(Sender *const sender);
+
+private:
+        void *mBuf[NR_CPUS];
+        // After the buffer is flushed it should be unmaped
+        bool mDiscard[NR_CPUS];
+
+        // Intentionally undefined
+        PerfBuffer(const PerfBuffer &);
+        PerfBuffer &operator=(const PerfBuffer &);
+};
+
+#endif // PERF_BUFFER
diff --git a/daemon/PerfDriver.cpp b/daemon/PerfDriver.cpp
new file mode 100644
index 0000000..8e25c22
--- /dev/null
+++ b/daemon/PerfDriver.cpp
@@ -0,0 +1,355 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "PerfDriver.h"
+
+#include <dirent.h>
+#include <sys/utsname.h>
+#include <time.h>
+
+#include "Buffer.h"
+#include "Config.h"
+#include "ConfigurationXML.h"
+#include "Counter.h"
+#include "DriverSource.h"
+#include "DynBuf.h"
+#include "Logging.h"
+#include "PerfGroup.h"
+#include "SessionData.h"
+
+#define PERF_DEVICES "/sys/bus/event_source/devices"
+
+#define TYPE_DERIVED ~0U
+
+// From gator.h
+struct gator_cpu {
+        const int cpuid;
+        // Human readable name
+        const char core_name[32];
+        // gatorfs event and Perf PMU name
+        const char *const pmnc_name;
+        const int pmnc_counters;
+};
+
+// From gator_main.c
+static const struct gator_cpu gator_cpus[] = {
+        { 0xb36, "ARM1136",      "ARM_ARM11",        3 },
+        { 0xb56, "ARM1156",      "ARM_ARM11",        3 },
+        { 0xb76, "ARM1176",      "ARM_ARM11",        3 },
+        { 0xb02, "ARM11MPCore",  "ARM_ARM11MPCore",  3 },
+        { 0xc05, "Cortex-A5",    "ARMv7_Cortex_A5",  2 },
+        { 0xc07, "Cortex-A7",    "ARMv7_Cortex_A7",  4 },
+        { 0xc08, "Cortex-A8",    "ARMv7_Cortex_A8",  4 },
+        { 0xc09, "Cortex-A9",    "ARMv7_Cortex_A9",  6 },
+        { 0xc0d, "Cortex-A12",   "ARMv7_Cortex_A12", 6 },
+        { 0xc0f, "Cortex-A15",   "ARMv7_Cortex_A15", 6 },
+        { 0xc0e, "Cortex-A17",   "ARMv7_Cortex_A17", 6 },
+        { 0x00f, "Scorpion",     "Scorpion",         4 },
+        { 0x02d, "ScorpionMP",   "ScorpionMP",       4 },
+        { 0x049, "KraitSIM",     "Krait",            4 },
+        { 0x04d, "Krait",        "Krait",            4 },
+        { 0x06f, "Krait S4 Pro", "Krait",            4 },
+        { 0xd03, "Cortex-A53",   "ARM_Cortex-A53",   6 },
+        { 0xd07, "Cortex-A57",   "ARM_Cortex-A57",   6 },
+        { 0xd0f, "AArch64",      "ARM_AArch64",      6 },
+};
+
+static const char OLD_PMU_PREFIX[] = "ARMv7 Cortex-";
+static const char NEW_PMU_PREFIX[] = "ARMv7_Cortex_";
+
+class PerfCounter {
+public:
+        PerfCounter(PerfCounter *next, const char *name, uint32_t type, uint64_t config) : mNext(next), mName(name), mType(type), mCount(0), mKey(getEventKey()), mConfig(config), mEnabled(false) {}
+        ~PerfCounter() {
+                delete [] mName;
+        }
+
+        PerfCounter *getNext() const { return mNext; }
+        const char *getName() const { return mName; }
+        uint32_t getType() const { return mType; }
+        int getCount() const { return mCount; }
+        void setCount(const int count) { mCount = count; }
+        int getKey() const { return mKey; }
+        uint64_t getConfig() const { return mConfig; }
+        void setConfig(const uint64_t config) { mConfig = config; }
+        bool isEnabled() const { return mEnabled; }
+        void setEnabled(const bool enabled) { mEnabled = enabled; }
+
+private:
+        PerfCounter *const mNext;
+        const char *const mName;
+        const uint32_t mType;
+        int mCount;
+        const int mKey;
+        uint64_t mConfig;
+        bool mEnabled;
+};
+
+PerfDriver::PerfDriver() : mCounters(NULL), mIsSetup(false) {
+}
+
+PerfDriver::~PerfDriver() {
+        while (mCounters != NULL) {
+                PerfCounter *counter = mCounters;
+                mCounters = counter->getNext();
+                delete counter;
+        }
+}
+
+void PerfDriver::addCpuCounters(const char *const counterName, const int type, const int numCounters) {
+        int len = snprintf(NULL, 0, "%s_ccnt", counterName) + 1;
+        char *name = new char[len];
+        snprintf(name, len, "%s_ccnt", counterName);
+        mCounters = new PerfCounter(mCounters, name, type, -1);
+
+        for (int j = 0; j < numCounters; ++j) {
+                len = snprintf(NULL, 0, "%s_cnt%d", counterName, j) + 1;
+                name = new char[len];
+                snprintf(name, len, "%s_cnt%d", counterName, j);
+                mCounters = new PerfCounter(mCounters, name, type, -1);
+        }
+}
+
+// From include/generated/uapi/linux/version.h
+#define KERNEL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
+
+bool PerfDriver::setup() {
+        // Check the kernel version
+        struct utsname utsname;
+        if (uname(&utsname) != 0) {
+                logg->logMessage("%s(%s:%i): uname failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        int release[3] = { 0, 0, 0 };
+        int part = 0;
+        char *ch = utsname.release;
+        while (*ch >= '0' && *ch <= '9' && part < ARRAY_LENGTH(release)) {
+                release[part] = 10*release[part] + *ch - '0';
+
+                ++ch;
+                if (*ch == '.') {
+                        ++part;
+                        ++ch;
+                }
+        }
+
+        if (KERNEL_VERSION(release[0], release[1], release[2]) < KERNEL_VERSION(3, 12, 0)) {
+                logg->logMessage("%s(%s:%i): Unsupported kernel version", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        // Add supported PMUs
+        bool foundCpu = false;
+        DIR *dir = opendir(PERF_DEVICES);
+        if (dir == NULL) {
+                logg->logMessage("%s(%s:%i): opendif failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        struct dirent *dirent;
+        while ((dirent = readdir(dir)) != NULL) {
+                for (int i = 0; i < ARRAY_LENGTH(gator_cpus); ++i) {
+                        // Do the names match exactly?
+                        if (strcmp(dirent->d_name, gator_cpus[i].pmnc_name) != 0 &&
+                                        // Do these names match but have the old vs new prefix?
+                            (strncmp(dirent->d_name, OLD_PMU_PREFIX, sizeof(OLD_PMU_PREFIX) - 1) != 0 ||
+                             strncmp(gator_cpus[i].pmnc_name, NEW_PMU_PREFIX, sizeof(NEW_PMU_PREFIX) - 1) != 0 ||
+                             strcmp(dirent->d_name + sizeof(OLD_PMU_PREFIX) - 1, gator_cpus[i].pmnc_name + sizeof(NEW_PMU_PREFIX) - 1) != 0)) {
+                                continue;
+                        }
+
+                        int type;
+                        char buf[256];
+                        snprintf(buf, sizeof(buf), PERF_DEVICES "/%s/type", dirent->d_name);
+                        if (DriverSource::readIntDriver(buf, &type) != 0) {
+                                continue;
+                        }
+
+                        foundCpu = true;
+                        addCpuCounters(gator_cpus[i].pmnc_name, type, gator_cpus[i].pmnc_counters);
+                }
+        }
+        closedir(dir);
+
+        if (!foundCpu) {
+                // If no cpu was found based on pmu names, try by cpuid
+                for (int i = 0; i < ARRAY_LENGTH(gator_cpus); ++i) {
+                        if (gSessionData->mMaxCpuId != gator_cpus[i].cpuid) {
+                                continue;
+                        }
+
+                        foundCpu = true;
+                        addCpuCounters(gator_cpus[i].pmnc_name, PERF_TYPE_RAW, gator_cpus[i].pmnc_counters);
+                }
+        }
+
+        /*
+        if (!foundCpu) {
+                // If all else fails, use the perf architected counters
+                // 9 because that's how many are in events-Perf-Hardware.xml - assume they can all be enabled at once
+                addCpuCounters("Perf_Hardware", PERF_TYPE_HARDWARE, 9);
+        }
+        */
+
+        // Add supported software counters
+        long long id;
+        DynBuf printb;
+
+        id = getTracepointId("irq/softirq_exit", &printb);
+        if (id >= 0) {
+                mCounters = new PerfCounter(mCounters, "Linux_irq_softirq", PERF_TYPE_TRACEPOINT, id);
+        }
+
+        id = getTracepointId("irq/irq_handler_exit", &printb);
+        if (id >= 0) {
+                mCounters = new PerfCounter(mCounters, "Linux_irq_irq", PERF_TYPE_TRACEPOINT, id);
+        }
+
+        //Linux_block_rq_wr
+        //Linux_block_rq_rd
+        //Linux_net_rx
+        //Linux_net_tx
+
+        id = getTracepointId(SCHED_SWITCH, &printb);
+        if (id >= 0) {
+                mCounters = new PerfCounter(mCounters, "Linux_sched_switch", PERF_TYPE_TRACEPOINT, id);
+        }
+
+        //Linux_meminfo_memused
+        //Linux_meminfo_memfree
+        //Linux_meminfo_bufferram
+        //Linux_power_cpu_freq
+        //Linux_power_cpu_idle
+
+        mCounters = new PerfCounter(mCounters, "Linux_cpu_wait_contention", TYPE_DERIVED, -1);
+
+        //Linux_cpu_wait_io
+
+        mIsSetup = true;
+        return true;
+}
+
+bool PerfDriver::summary(Buffer *const buffer) {
+        struct utsname utsname;
+        if (uname(&utsname) != 0) {
+                logg->logMessage("%s(%s:%i): uname failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        char buf[512];
+        snprintf(buf, sizeof(buf), "%s %s %s %s %s GNU/Linux", utsname.sysname, utsname.nodename, utsname.release, utsname.version, utsname.machine);
+
+        struct timespec ts;
+        if (clock_gettime(CLOCK_REALTIME, &ts) != 0) {
+                logg->logMessage("%s(%s:%i): clock_gettime failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+        const int64_t timestamp = (int64_t)ts.tv_sec * 1000000000L + ts.tv_nsec;
+
+        if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
+                logg->logMessage("%s(%s:%i): clock_gettime failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+        const int64_t uptime = (int64_t)ts.tv_sec * 1000000000L + ts.tv_nsec;
+
+        buffer->summary(timestamp, uptime, 0, buf);
+
+        for (int i = 0; i < gSessionData->mCores; ++i) {
+                int j;
+                for (j = 0; j < ARRAY_LENGTH(gator_cpus); ++j) {
+                        if (gator_cpus[j].cpuid == gSessionData->mCpuIds[i]) {
+                                break;
+                        }
+                }
+                if (gator_cpus[j].cpuid == gSessionData->mCpuIds[i]) {
+                        buffer->coreName(i, gSessionData->mCpuIds[i], gator_cpus[j].core_name);
+                } else {
+                        snprintf(buf, sizeof(buf), "Unknown (0x%.3x)", gSessionData->mCpuIds[i]);
+                        buffer->coreName(i, gSessionData->mCpuIds[i], buf);
+                }
+        }
+        buffer->commit(1);
+
+        return true;
+}
+
+PerfCounter *PerfDriver::findCounter(const Counter &counter) const {
+        for (PerfCounter * perfCounter = mCounters; perfCounter != NULL; perfCounter = perfCounter->getNext()) {
+                if (strcmp(perfCounter->getName(), counter.getType()) == 0) {
+                        return perfCounter;
+                }
+        }
+
+        return NULL;
+}
+
+bool PerfDriver::claimCounter(const Counter &counter) const {
+        return findCounter(counter) != NULL;
+}
+
+void PerfDriver::resetCounters() {
+        for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) {
+                counter->setEnabled(false);
+        }
+}
+
+void PerfDriver::setupCounter(Counter &counter) {
+        PerfCounter *const perfCounter = findCounter(counter);
+        if (perfCounter == NULL) {
+                counter.setEnabled(false);
+                return;
+        }
+
+        // Don't use the config from counters XML if it's not set, ex: software counters
+        if (counter.getEvent() != -1) {
+                perfCounter->setConfig(counter.getEvent());
+        }
+        perfCounter->setCount(counter.getCount());
+        perfCounter->setEnabled(true);
+        counter.setKey(perfCounter->getKey());
+}
+
+int PerfDriver::writeCounters(mxml_node_t *root) const {
+        int count = 0;
+        for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) {
+                mxml_node_t *node = mxmlNewElement(root, "counter");
+                mxmlElementSetAttr(node, "name", counter->getName());
+                ++count;
+        }
+
+        return count;
+}
+
+bool PerfDriver::enable(PerfGroup *group, Buffer *const buffer) const {
+        for (PerfCounter * counter = mCounters; counter != NULL; counter = counter->getNext()) {
+                if (counter->isEnabled() && (counter->getType() != TYPE_DERIVED)) {
+                        if (!group->add(buffer, counter->getKey(), counter->getType(), counter->getConfig(), counter->getCount(), 0, 0)) {
+                                logg->logMessage("%s(%s:%i): PerfGroup::add failed", __FUNCTION__, __FILE__, __LINE__);
+                                return false;
+                        }
+                }
+        }
+
+        return true;
+}
+
+long long PerfDriver::getTracepointId(const char *const name, DynBuf *const printb) {
+        if (!printb->printf(EVENTS_PATH "/%s/id", name)) {
+                logg->logMessage("%s(%s:%i): DynBuf::printf failed", __FUNCTION__, __FILE__, __LINE__);
+                return -1;
+        }
+
+        int64_t result;
+        if (DriverSource::readInt64Driver(printb->getBuf(), &result) != 0) {
+                logg->logMessage("%s(%s:%i): DriverSource::readInt64Driver failed", __FUNCTION__, __FILE__, __LINE__);
+                return -1;
+        }
+
+        return result;
+}
diff --git a/daemon/PerfDriver.h b/daemon/PerfDriver.h
new file mode 100644
index 0000000..3181b74
--- /dev/null
+++ b/daemon/PerfDriver.h
@@ -0,0 +1,56 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef PERFDRIVER_H
+#define PERFDRIVER_H
+
+#include "Driver.h"
+
+// If debugfs is not mounted at /sys/kernel/debug, update DEBUGFS_PATH
+#define DEBUGFS_PATH "/sys/kernel/debug"
+#define EVENTS_PATH DEBUGFS_PATH "/tracing/events"
+
+#define SCHED_SWITCH "sched/sched_switch"
+
+class Buffer;
+class DynBuf;
+class PerfCounter;
+class PerfGroup;
+
+class PerfDriver : public Driver {
+public:
+        PerfDriver();
+        ~PerfDriver();
+
+        bool setup();
+        bool summary(Buffer *const buffer);
+        bool isSetup() const { return mIsSetup; }
+
+        bool claimCounter(const Counter &counter) const;
+        void resetCounters();
+        void setupCounter(Counter &counter);
+
+        int writeCounters(mxml_node_t *root) const;
+
+        bool enable(PerfGroup *group, Buffer *const buffer) const;
+
+        static long long getTracepointId(const char *const name, DynBuf *const printb);
+
+private:
+        PerfCounter *findCounter(const Counter &counter) const;
+        void addCpuCounters(const char *const counterName, const int type, const int numCounters);
+
+        PerfCounter *mCounters;
+        bool mIsSetup;
+
+        // Intentionally undefined
+        PerfDriver(const PerfDriver &);
+        PerfDriver &operator=(const PerfDriver &);
+};
+
+#endif // PERFDRIVER_H
diff --git a/daemon/PerfGroup.cpp b/daemon/PerfGroup.cpp
new file mode 100644
index 0000000..faf5fca
--- /dev/null
+++ b/daemon/PerfGroup.cpp
@@ -0,0 +1,206 @@
+/**
+ * Copyright (C) ARM Limited 2013-2014. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include "PerfGroup.h"
+
+#include <errno.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#include "Buffer.h"
+#include "Logging.h"
+#include "Monitor.h"
+#include "PerfBuffer.h"
+#include "SessionData.h"
+
+#define DEFAULT_PEA_ARGS(pea, additionalSampleType) \
+        pea.size = sizeof(pea); \
+        /* Emit time, read_format below, group leader id, and raw tracepoint info */ \
+        pea.sample_type = PERF_SAMPLE_TIME | PERF_SAMPLE_READ | PERF_SAMPLE_IDENTIFIER | additionalSampleType; \
+        /* Emit emit value in group format */ \
+        pea.read_format = PERF_FORMAT_ID | PERF_FORMAT_GROUP; \
+        /* start out disabled */ \
+        pea.disabled = 1; \
+        /* have a sampling interrupt happen when we cross the wakeup_watermark boundary */ \
+        pea.watermark = 1; \
+        /* Be conservative in flush size as only one buffer set is monitored */ \
+        pea.wakeup_watermark = 3 * BUF_SIZE / 4
+
+static int sys_perf_event_open(struct perf_event_attr *const attr, const pid_t pid, const int cpu, const int group_fd, const unsigned long flags) {
+        return syscall(__NR_perf_event_open, attr, pid, cpu, group_fd, flags);
+}
+
+PerfGroup::PerfGroup(PerfBuffer *const pb) : mPb(pb) {
+        memset(&mAttrs, 0, sizeof(mAttrs));
+        memset(&mKeys, -1, sizeof(mKeys));
+        memset(&mFds, -1, sizeof(mFds));
+}
+
+PerfGroup::~PerfGroup() {
+        for (int pos = ARRAY_LENGTH(mFds) - 1; pos >= 0; --pos) {
+                if (mFds[pos] >= 0) {
+                        close(mFds[pos]);
+                }
+        }
+}
+
+bool PerfGroup::add(Buffer *const buffer, const int key, const __u32 type, const __u64 config, const __u64 sample, const __u64 sampleType, const int flags) {
+        int i;
+        for (i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                if (mKeys[i] < 0) {
+                        break;
+                }
+        }
+
+        if (i >= ARRAY_LENGTH(mKeys)) {
+                logg->logMessage("%s(%s:%i): Too many counters", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        DEFAULT_PEA_ARGS(mAttrs[i], sampleType);
+        mAttrs[i].type = type;
+        mAttrs[i].config = config;
+        mAttrs[i].sample_period = sample;
+        // always be on the CPU but only a group leader can be pinned
+        mAttrs[i].pinned = (i == 0 ? 1 : 0);
+        mAttrs[i].mmap = (flags & PERF_GROUP_MMAP ? 1 : 0);
+        mAttrs[i].comm = (flags & PERF_GROUP_COMM ? 1 : 0);
+        mAttrs[i].freq = (flags & PERF_GROUP_FREQ ? 1 : 0);
+        mAttrs[i].task = (flags & PERF_GROUP_TASK ? 1 : 0);
+        mAttrs[i].sample_id_all = (flags & PERF_GROUP_SAMPLE_ID_ALL ? 1 : 0);
+
+        mKeys[i] = key;
+
+        buffer->pea(&mAttrs[i], key);
+
+        return true;
+}
+
+bool PerfGroup::prepareCPU(const int cpu) {
+        logg->logMessage("%s(%s:%i): Onlining cpu %i", __FUNCTION__, __FILE__, __LINE__, cpu);
+
+        for (int i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                if (mKeys[i] < 0) {
+                        continue;
+                }
+
+                const int offset = i * gSessionData->mCores;
+                if (mFds[cpu + offset] >= 0) {
+                        logg->logMessage("%s(%s:%i): cpu already online or not correctly cleaned up", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+
+                logg->logMessage("%s(%s:%i): perf_event_open cpu: %i type: %lli config: %lli sample: %lli sample_type: %lli", __FUNCTION__, __FILE__, __LINE__, cpu, (long long)mAttrs[i].type, (long long)mAttrs[i].config, (long long)mAttrs[i].sample_period, (long long)mAttrs[i].sample_type);
+                mFds[cpu + offset] = sys_perf_event_open(&mAttrs[i], -1, cpu, i == 0 ? -1 : mFds[cpu], i == 0 ? 0 : PERF_FLAG_FD_OUTPUT);
+                if (mFds[cpu + offset] < 0) {
+                        logg->logMessage("%s(%s:%i): failed %s", __FUNCTION__, __FILE__, __LINE__, strerror(errno));
+                        continue;
+                }
+
+                if (!mPb->useFd(cpu, mFds[cpu + offset], mFds[cpu])) {
+                        logg->logMessage("%s(%s:%i): PerfBuffer::useFd failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        }
+
+        return true;
+}
+
+int PerfGroup::onlineCPU(const int cpu, const bool start, Buffer *const buffer, Monitor *const monitor) {
+        __u64 ids[ARRAY_LENGTH(mKeys)];
+        int coreKeys[ARRAY_LENGTH(mKeys)];
+        int idCount = 0;
+
+        for (int i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                const int fd = mFds[cpu + i * gSessionData->mCores];
+                if (fd < 0) {
+                        continue;
+                }
+
+                coreKeys[idCount] = mKeys[i];
+                if (ioctl(fd, PERF_EVENT_IOC_ID, &ids[idCount]) != 0) {
+                        logg->logMessage("%s(%s:%i): ioctl failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+                ++idCount;
+        }
+
+        if (!monitor->add(mFds[cpu])) {
+                logg->logMessage("%s(%s:%i): Monitor::add failed", __FUNCTION__, __FILE__, __LINE__);
+                return false;
+        }
+
+        buffer->keys(idCount, ids, coreKeys);
+
+        if (start) {
+                for (int i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                        int offset = i * gSessionData->mCores + cpu;
+                        if (mFds[offset] >= 0 && ioctl(mFds[offset], PERF_EVENT_IOC_ENABLE) < 0) {
+                                logg->logMessage("%s(%s:%i): ioctl failed", __FUNCTION__, __FILE__, __LINE__);
+                                return false;
+                        }
+                }
+        }
+
+        return idCount;
+}
+
+bool PerfGroup::offlineCPU(const int cpu) {
+        logg->logMessage("%s(%s:%i): Offlining cpu %i", __FUNCTION__, __FILE__, __LINE__, cpu);
+
+        for (int i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                int offset = i * gSessionData->mCores + cpu;
+                if (mFds[offset] >= 0 && ioctl(mFds[offset], PERF_EVENT_IOC_DISABLE) < 0) {
+                        logg->logMessage("%s(%s:%i): ioctl failed", __FUNCTION__, __FILE__, __LINE__);
+                        return false;
+                }
+        }
+
+        // Mark the buffer so that it will be released next time it's read
+        mPb->discard(cpu);
+
+        for (int i = 0; i < ARRAY_LENGTH(mKeys); ++i) {
+                if (mKeys[i] < 0) {
+                        continue;
+                }
+
+                int offset = i * gSessionData->mCores + cpu;
+                if (mFds[offset] >= 0) {
+                        close(mFds[offset]);
+                        mFds[offset] = -1;
+                }
+        }
+
+        return true;
+}
+
+bool PerfGroup::start() {
+        for (int pos = 0; pos < ARRAY_LENGTH(mFds); ++pos) {
+                if (mFds[pos] >= 0 && ioctl(mFds[pos], PERF_EVENT_IOC_ENABLE) < 0) {
+                        logg->logMessage("%s(%s:%i): ioctl failed", __FUNCTION__, __FILE__, __LINE__);
+                        goto fail;
+                }
+        }
+
+        return true;
+
+ fail:
+        stop();
+
+        return false;
+}
+
+void PerfGroup::stop() {
+        for (int pos = ARRAY_LENGTH(mFds) - 1; pos >= 0; --pos) {
+                if (mFds[pos] >= 0) {
+                        ioctl(mFds[pos], PERF_EVENT_IOC_DISABLE);