120 files changed, 5566 insertions, 1402 deletions
diff --git a/tools/Makefile b/tools/Makefile
index 6bf68fe7dd29..f10b64d8c674 100644
--- a/tools/Makefile
+++ b/tools/Makefile
@@ -16,6 +16,7 @@ help:
        @echo '  gpio                   - GPIO tools'
        @echo '  hv                     - tools used when in Hyper-V clients'
        @echo '  iio                    - IIO tools'
+        @echo '  kvm_stat               - top-like utility for displaying kvm statistics'
        @echo '  lguest                 - a minimal 32-bit x86 hypervisor'
        @echo '  net                    - misc networking tools'
        @echo '  perf                   - Linux performance measurement and analysis tool'
@@ -110,10 +111,13 @@ tmon_install:
 freefall_install:
        $(call descend,laptop/$(@:_install=),install)
+kvm_stat_install:
+        $(call descend,kvm/$(@:_install=),install)
 install: acpi_install cgroup_install cpupower_install hv_install firewire_install lguest_install \
                perf_install selftests_install turbostat_install usb_install \
                virtio_install vm_install net_install x86_energy_perf_policy_install \
-                tmon_install freefall_install objtool_install
+                tmon_install freefall_install objtool_install kvm_stat_install
 acpi_clean:
        $(call descend,power/acpi,clean)
diff --git a/tools/build/Makefile.build b/tools/build/Makefile.build
index ee566e8bd1cf..27f3583193e6 100644
--- a/tools/build/Makefile.build
+++ b/tools/build/Makefile.build
@@ -58,8 +58,8 @@ quiet_cmd_mkdir = MKDIR    $(dir $@)
 quiet_cmd_cc_o_c = CC       $@
      cmd_cc_o_c = $(CC) $(c_flags) -c -o $@ $<
-quiet_cmd_cc_i_c = CPP      $@
+quiet_cmd_cpp_i_c = CPP      $@
-      cmd_cc_i_c = $(CC) $(c_flags) -E -o $@ $<
+      cmd_cpp_i_c = $(CC) $(c_flags) -E -o $@ $<
 quiet_cmd_cc_s_c = AS       $@
      cmd_cc_s_c = $(CC) $(c_flags) -S -o $@ $<
@@ -83,11 +83,11 @@ $(OUTPUT)%.o: %.S FORCE
 $(OUTPUT)%.i: %.c FORCE
        $(call rule_mkdir)
-        $(call if_changed_dep,cc_i_c)
+        $(call if_changed_dep,cpp_i_c)
 $(OUTPUT)%.s: %.S FORCE
        $(call rule_mkdir)
-        $(call if_changed_dep,cc_i_c)
+        $(call if_changed_dep,cpp_i_c)
 $(OUTPUT)%.s: %.c FORCE
        $(call rule_mkdir)
diff --git a/tools/gpio/Makefile b/tools/gpio/Makefile
index 4d198d5c4203..c155d6bc47a7 100644
--- a/tools/gpio/Makefile
+++ b/tools/gpio/Makefile
@@ -1,5 +1,5 @@
 CC = $(CROSS_COMPILE)gcc
-CFLAGS += -Wall -g -D_GNU_SOURCE
+CFLAGS += -O2 -Wall -g -D_GNU_SOURCE
 all: lsgpio
diff --git a/tools/gpio/lsgpio.c b/tools/gpio/lsgpio.c
index 1124da375942..eb3f56efd215 100644
--- a/tools/gpio/lsgpio.c
+++ b/tools/gpio/lsgpio.c
@@ -147,7 +147,7 @@ void print_usage(void)
 int main(int argc, char **argv)
 {
-        const char *device_name;
+        const char *device_name = NULL;
        int ret;
        int c;
diff --git a/tools/hv/lsvmbus b/tools/hv/lsvmbus
index 162a3784d80e..e8fecd61871f 100644
--- a/tools/hv/lsvmbus
+++ b/tools/hv/lsvmbus
@@ -35,6 +35,7 @@ vmbus_dev_dict = {
        '{ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}' : 'Synthetic SCSI Controller',
        '{2f9bcc4a-0069-4af3-b76b-6fd0be528cda}' : 'Synthetic fiber channel adapter',
        '{8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501}' : 'Synthetic RDMA adapter',
+        '{44c4f61d-4444-4400-9d52-802e27ede19f}' : 'PCI Express pass-through',
        '{276aacf4-ac15-426c-98dd-7521ad3f01fe}' : '[Reserved system device]',
        '{f8e65716-3cb3-4a06-9a60-1889c5cccab5}' : '[Reserved system device]',
        '{3375baf4-9e15-4b30-b765-67acb10d607b}' : '[Reserved system device]',
diff --git a/tools/iio/generic_buffer.c b/tools/iio/generic_buffer.c
index 01c4f67801e0..2429c78de940 100644
--- a/tools/iio/generic_buffer.c
+++ b/tools/iio/generic_buffer.c
@@ -35,6 +35,15 @@
 #include "iio_utils.h"
 /**
+ * enum autochan - state for the automatic channel enabling mechanism
+ */
+enum autochan {
+        AUTOCHANNELS_DISABLED,
+        AUTOCHANNELS_ENABLED,
+        AUTOCHANNELS_ACTIVE,
+};
+/**
 * size_from_channelarray() - calculate the storage size of a scan
 * @channels:           the channel info array
 * @num_channels:       number of channels
@@ -191,10 +200,51 @@ void process_scan(char *data,
        printf("\n");
 }
+static int enable_disable_all_channels(char *dev_dir_name, int enable)
+{
+        const struct dirent *ent;
+        char scanelemdir[256];
+        DIR *dp;
+        int ret;
+        snprintf(scanelemdir, sizeof(scanelemdir),
+                 FORMAT_SCAN_ELEMENTS_DIR, dev_dir_name);
+        scanelemdir[sizeof(scanelemdir)-1] = '\0';
+        dp = opendir(scanelemdir);
+        if (!dp) {
+                fprintf(stderr, "Enabling/disabling channels: can't open %s\n",
+                        scanelemdir);
+                return -EIO;
+        }
+        ret = -ENOENT;
+        while (ent = readdir(dp), ent) {
+                if (iioutils_check_suffix(ent->d_name, "_en")) {
+                        printf("%sabling: %s\n",
+                               enable ? "En" : "Dis",
+                               ent->d_name);
+                        ret = write_sysfs_int(ent->d_name, scanelemdir,
+                                              enable);
+                        if (ret < 0)
+                                fprintf(stderr, "Failed to enable/disable %s\n",
+                                        ent->d_name);
+                }
+        }
+        if (closedir(dp) == -1) {
+                perror("Enabling/disabling channels: "
+                       "Failed to close directory");
+                return -errno;
+        }
+        return 0;
+}
 void print_usage(void)
 {
        fprintf(stderr, "Usage: generic_buffer [options]...\n"
                "Capture, convert and output data from IIO device buffer\n"
+                "  -a         Auto-activate all available channels\n"
                "  -c <n>     Do n conversions\n"
                "  -e         Disable wait for event (new data)\n"
                "  -g         Use trigger-less mode\n"
@@ -225,12 +275,16 @@ int main(int argc, char **argv)
        int scan_size;
        int noevents = 0;
        int notrigger = 0;
+        enum autochan autochannels = AUTOCHANNELS_DISABLED;
        char *dummy;
        struct iio_channel_info *channels;
-        while ((c = getopt(argc, argv, "c:egl:n:t:w:")) != -1) {
+        while ((c = getopt(argc, argv, "ac:egl:n:t:w:")) != -1) {
                switch (c) {
+                case 'a':
+                        autochannels = AUTOCHANNELS_ENABLED;
+                        break;
                case 'c':
                        errno = 0;
                        num_loops = strtoul(optarg, &dummy, 10);
@@ -304,7 +358,19 @@ int main(int argc, char **argv)
                        }
                }
-                /* Verify the trigger exists */
+                /* Look for this "-devN" trigger */
+                trig_num = find_type_by_name(trigger_name, "trigger");
+                if (trig_num < 0) {
+                        /* OK try the simpler "-trigger" suffix instead */
+                        free(trigger_name);
+                        ret = asprintf(&trigger_name,
+                                       "%s-trigger", device_name);
+                        if (ret < 0) {
+                                ret = -ENOMEM;
+                                goto error_free_dev_dir_name;
+                        }
+                }
                trig_num = find_type_by_name(trigger_name, "trigger");
                if (trig_num < 0) {
                        fprintf(stderr, "Failed to find the trigger %s\n",
@@ -328,12 +394,47 @@ int main(int argc, char **argv)
                        "diag %s\n", dev_dir_name);
                goto error_free_triggername;
        }
-        if (!num_channels) {
+        if (num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr, "Auto-channels selected but some channels "
+                        "are already activated in sysfs\n");
+                fprintf(stderr, "Proceeding without activating any channels\n");
+        }
+        if (!num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr,
+                        "No channels are enabled, enabling all channels\n");
+                ret = enable_disable_all_channels(dev_dir_name, 1);
+                if (ret) {
+                        fprintf(stderr, "Failed to enable all channels\n");
+                        goto error_free_triggername;
+                }
+                /* This flags that we need to disable the channels again */
+                autochannels = AUTOCHANNELS_ACTIVE;
+                ret = build_channel_array(dev_dir_name, &channels,
+                                          &num_channels);
+                if (ret) {
+                        fprintf(stderr, "Problem reading scan element "
+                                "information\n"
+                                "diag %s\n", dev_dir_name);
+                        goto error_disable_channels;
+                }
+                if (!num_channels) {
+                        fprintf(stderr, "Still no channels after "
+                                "auto-enabling, giving up\n");
+                        goto error_disable_channels;
+                }
+        }
+        if (!num_channels && autochannels == AUTOCHANNELS_DISABLED) {
                fprintf(stderr,
                        "No channels are enabled, we have nothing to scan.\n");
                fprintf(stderr, "Enable channels manually in "
                        FORMAT_SCAN_ELEMENTS_DIR
-                        "/*_en and try again.\n", dev_dir_name);
+                        "/*_en or pass -a to autoenable channels and "
+                        "try again.\n", dev_dir_name);
                ret = -ENOENT;
                goto error_free_triggername;
        }
@@ -467,7 +568,12 @@ error_free_channels:
 error_free_triggername:
        if (datardytrigger)
                free(trigger_name);
+error_disable_channels:
+        if (autochannels == AUTOCHANNELS_ACTIVE) {
+                ret = enable_disable_all_channels(dev_dir_name, 0);
+                if (ret)
+                        fprintf(stderr, "Failed to disable all channels\n");
+        }
 error_free_dev_dir_name:
        free(dev_dir_name);
diff --git a/tools/iio/iio_event_monitor.c b/tools/iio/iio_event_monitor.c
index d51eb04202e9..d9b7e0f306c6 100644
--- a/tools/iio/iio_event_monitor.c
+++ b/tools/iio/iio_event_monitor.c
@@ -53,6 +53,10 @@ static const char * const iio_chan_type_name_spec[] = {
        [IIO_ENERGY] = "energy",
        [IIO_DISTANCE] = "distance",
        [IIO_VELOCITY] = "velocity",
+        [IIO_CONCENTRATION] = "concentration",
+        [IIO_RESISTANCE] = "resistance",
+        [IIO_PH] = "ph",
+        [IIO_UVINDEX] = "uvindex",
 };
 static const char * const iio_ev_type_text[] = {
@@ -90,6 +94,7 @@ static const char * const iio_modifier_names[] = {
        [IIO_MOD_LIGHT_RED] = "red",
        [IIO_MOD_LIGHT_GREEN] = "green",
        [IIO_MOD_LIGHT_BLUE] = "blue",
+        [IIO_MOD_LIGHT_UV] = "uv",
        [IIO_MOD_QUATERNION] = "quaternion",
        [IIO_MOD_TEMP_AMBIENT] = "ambient",
        [IIO_MOD_TEMP_OBJECT] = "object",
@@ -102,6 +107,10 @@ static const char * const iio_modifier_names[] = {
        [IIO_MOD_WALKING] = "walking",
        [IIO_MOD_STILL] = "still",
        [IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)",
+        [IIO_MOD_I] = "i",
+        [IIO_MOD_Q] = "q",
+        [IIO_MOD_CO2] = "co2",
+        [IIO_MOD_VOC] = "voc",
 };
 static bool event_is_known(struct iio_event_data *event)
@@ -136,6 +145,10 @@ static bool event_is_known(struct iio_event_data *event)
        case IIO_ENERGY:
        case IIO_DISTANCE:
        case IIO_VELOCITY:
+        case IIO_CONCENTRATION:
+        case IIO_RESISTANCE:
+        case IIO_PH:
+        case IIO_UVINDEX:
                break;
        default:
                return false;
@@ -162,6 +175,7 @@ static bool event_is_known(struct iio_event_data *event)
        case IIO_MOD_LIGHT_RED:
        case IIO_MOD_LIGHT_GREEN:
        case IIO_MOD_LIGHT_BLUE:
+        case IIO_MOD_LIGHT_UV:
        case IIO_MOD_QUATERNION:
        case IIO_MOD_TEMP_AMBIENT:
        case IIO_MOD_TEMP_OBJECT:
@@ -174,6 +188,10 @@ static bool event_is_known(struct iio_event_data *event)
        case IIO_MOD_WALKING:
        case IIO_MOD_STILL:
        case IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z:
+        case IIO_MOD_I:
+        case IIO_MOD_Q:
+        case IIO_MOD_CO2:
+        case IIO_MOD_VOC:
                break;
        default:
                return false;
diff --git a/tools/iio/iio_utils.h b/tools/iio/iio_utils.h
index e3503bfe538b..780f2014f8fa 100644
--- a/tools/iio/iio_utils.h
+++ b/tools/iio/iio_utils.h
@@ -52,6 +52,13 @@ struct iio_channel_info {
        unsigned location;
 };
+static inline int iioutils_check_suffix(const char *str, const char *suffix)
+{
+        return strlen(str) >= strlen(suffix) &&
+                strncmp(str+strlen(str)-strlen(suffix),
+                        suffix, strlen(suffix)) == 0;
+}
 int iioutils_break_up_name(const char *full_name, char **generic_name);
 int iioutils_get_type(unsigned *is_signed, unsigned *bytes, unsigned *bits_used,
                      unsigned *shift, uint64_t *mask, unsigned *be,
diff --git a/tools/kvm/kvm_stat/Makefile b/tools/kvm/kvm_stat/Makefile
new file mode 100644
index 000000000000..5b1cba57e3b3
--- /dev/null
+++ b/tools/kvm/kvm_stat/Makefile
@@ -0,0 +1,41 @@
+include ../../scripts/Makefile.include
+include ../../scripts/utilities.mak
+BINDIR=usr/bin
+MANDIR=usr/share/man
+MAN1DIR=$(MANDIR)/man1
+MAN1=kvm_stat.1
+A2X=a2x
+a2x_path := $(call get-executable,$(A2X))
+all: man
+ifneq ($(findstring $(MAKEFLAGS),s),s)
+  ifneq ($(V),1)
+     QUIET_A2X = @echo '  A2X     '$@;
+  endif
+endif
+%.1: %.txt
+ifeq ($(a2x_path),)
+        $(error "You need to install asciidoc for man pages")
+else
+        $(QUIET_A2X)$(A2X) --doctype manpage --format manpage $<
+endif
+clean:
+        rm -f $(MAN1)
+man: $(MAN1)
+install-man: man
+        install -d -m 755 $(INSTALL_ROOT)/$(MAN1DIR)
+        install -m 644 kvm_stat.1 $(INSTALL_ROOT)/$(MAN1DIR)
+install-tools:
+        install -d -m 755 $(INSTALL_ROOT)/$(BINDIR)
+        install -m 755 -p "kvm_stat" "$(INSTALL_ROOT)/$(BINDIR)/$(TARGET)"
+install: install-tools install-man
+.PHONY: all clean man install-tools install-man install
diff --git a/tools/kvm/kvm_stat/kvm_stat b/tools/kvm/kvm_stat/kvm_stat
new file mode 100755
index 000000000000..581278c58488
--- /dev/null
+++ b/tools/kvm/kvm_stat/kvm_stat
@@ -0,0 +1,1127 @@
+#!/usr/bin/python
+#
+# top-like utility for displaying kvm statistics
+#
+# Copyright 2006-2008 Qumranet Technologies
+# Copyright 2008-2011 Red Hat, Inc.
+#
+# Authors:
+#  Avi Kivity <avi@redhat.com>
+#
+# This work is licensed under the terms of the GNU GPL, version 2.  See
+# the COPYING file in the top-level directory.
+"""The kvm_stat module outputs statistics about running KVM VMs
+Three different ways of output formatting are available:
+- as a top-like text ui
+- in a key -> value format
+- in an all keys, all values format
+The data is sampled from the KVM's debugfs entries and its perf events.
+"""
+import curses
+import sys
+import os
+import time
+import optparse
+import ctypes
+import fcntl
+import resource
+import struct
+import re
+from collections import defaultdict
+from time import sleep
+VMX_EXIT_REASONS = {
+    'EXCEPTION_NMI':        0,
+    'EXTERNAL_INTERRUPT':   1,
+    'TRIPLE_FAULT':         2,
+    'PENDING_INTERRUPT':    7,
+    'NMI_WINDOW':           8,
+    'TASK_SWITCH':          9,
+    'CPUID':                10,
+    'HLT':                  12,
+    'INVLPG':               14,
+    'RDPMC':                15,
+    'RDTSC':                16,
+    'VMCALL':               18,
+    'VMCLEAR':              19,
+    'VMLAUNCH':             20,
+    'VMPTRLD':              21,
+    'VMPTRST':              22,
+    'VMREAD':               23,
+    'VMRESUME':             24,
+    'VMWRITE':              25,
+    'VMOFF':                26,
+    'VMON':                 27,
+    'CR_ACCESS':            28,
+    'DR_ACCESS':            29,
+    'IO_INSTRUCTION':       30,
+    'MSR_READ':             31,
+    'MSR_WRITE':            32,
+    'INVALID_STATE':        33,
+    'MWAIT_INSTRUCTION':    36,
+    'MONITOR_INSTRUCTION':  39,
+    'PAUSE_INSTRUCTION':    40,
+    'MCE_DURING_VMENTRY':   41,
+    'TPR_BELOW_THRESHOLD':  43,
+    'APIC_ACCESS':          44,
+    'EPT_VIOLATION':        48,
+    'EPT_MISCONFIG':        49,
+    'WBINVD':               54,
+    'XSETBV':               55,
+    'APIC_WRITE':           56,
+    'INVPCID':              58,
+}
+SVM_EXIT_REASONS = {
+    'READ_CR0':       0x000,
+    'READ_CR3':       0x003,
+    'READ_CR4':       0x004,
+    'READ_CR8':       0x008,
+    'WRITE_CR0':      0x010,
+    'WRITE_CR3':      0x013,
+    'WRITE_CR4':      0x014,
+    'WRITE_CR8':      0x018,
+    'READ_DR0':       0x020,
+    'READ_DR1':       0x021,
+    'READ_DR2':       0x022,
+    'READ_DR3':       0x023,
+    'READ_DR4':       0x024,
+    'READ_DR5':       0x025,
+    'READ_DR6':       0x026,
+    'READ_DR7':       0x027,
+    'WRITE_DR0':      0x030,
+    'WRITE_DR1':      0x031,
+    'WRITE_DR2':      0x032,
+    'WRITE_DR3':      0x033,
+    'WRITE_DR4':      0x034,
+    'WRITE_DR5':      0x035,
+    'WRITE_DR6':      0x036,
+    'WRITE_DR7':      0x037,
+    'EXCP_BASE':      0x040,
+    'INTR':           0x060,
+    'NMI':            0x061,
+    'SMI':            0x062,
+    'INIT':           0x063,
+    'VINTR':          0x064,
+    'CR0_SEL_WRITE':  0x065,
+    'IDTR_READ':      0x066,
+    'GDTR_READ':      0x067,
+    'LDTR_READ':      0x068,
+    'TR_READ':        0x069,
+    'IDTR_WRITE':     0x06a,
+    'GDTR_WRITE':     0x06b,
+    'LDTR_WRITE':     0x06c,
+    'TR_WRITE':       0x06d,
+    'RDTSC':          0x06e,
+    'RDPMC':          0x06f,
+    'PUSHF':          0x070,
+    'POPF':           0x071,
+    'CPUID':          0x072,
+    'RSM':            0x073,
+    'IRET':           0x074,
+    'SWINT':          0x075,
+    'INVD':           0x076,
+    'PAUSE':          0x077,
+    'HLT':            0x078,
+    'INVLPG':         0x079,
+    'INVLPGA':        0x07a,
+    'IOIO':           0x07b,
+    'MSR':            0x07c,
+    'TASK_SWITCH':    0x07d,
+    'FERR_FREEZE':    0x07e,
+    'SHUTDOWN':       0x07f,
+    'VMRUN':          0x080,
+    'VMMCALL':        0x081,
+    'VMLOAD':         0x082,
+    'VMSAVE':         0x083,
+    'STGI':           0x084,
+    'CLGI':           0x085,
+    'SKINIT':         0x086,
+    'RDTSCP':         0x087,
+    'ICEBP':          0x088,
+    'WBINVD':         0x089,
+    'MONITOR':        0x08a,
+    'MWAIT':          0x08b,
+    'MWAIT_COND':     0x08c,
+    'XSETBV':         0x08d,
+    'NPF':            0x400,
+}
+# EC definition of HSR (from arch/arm64/include/asm/kvm_arm.h)
+AARCH64_EXIT_REASONS = {
+    'UNKNOWN':      0x00,
+    'WFI':          0x01,
+    'CP15_32':      0x03,
+    'CP15_64':      0x04,
+    'CP14_MR':      0x05,
+    'CP14_LS':      0x06,
+    'FP_ASIMD':     0x07,
+    'CP10_ID':      0x08,
+    'CP14_64':      0x0C,
+    'ILL_ISS':      0x0E,
+    'SVC32':        0x11,
+    'HVC32':        0x12,
+    'SMC32':        0x13,
+    'SVC64':        0x15,
+    'HVC64':        0x16,
+    'SMC64':        0x17,
+    'SYS64':        0x18,
+    'IABT':         0x20,
+    'IABT_HYP':     0x21,
+    'PC_ALIGN':     0x22,
+    'DABT':         0x24,
+    'DABT_HYP':     0x25,
+    'SP_ALIGN':     0x26,
+    'FP_EXC32':     0x28,
+    'FP_EXC64':     0x2C,
+    'SERROR':       0x2F,
+    'BREAKPT':      0x30,
+    'BREAKPT_HYP':  0x31,
+    'SOFTSTP':      0x32,
+    'SOFTSTP_HYP':  0x33,
+    'WATCHPT':      0x34,
+    'WATCHPT_HYP':  0x35,
+    'BKPT32':       0x38,
+    'VECTOR32':     0x3A,
+    'BRK64':        0x3C,
+}
+# From include/uapi/linux/kvm.h, KVM_EXIT_xxx
+USERSPACE_EXIT_REASONS = {
+    'UNKNOWN':          0,
+    'EXCEPTION':        1,
+    'IO':               2,
+    'HYPERCALL':        3,
+    'DEBUG':            4,
+    'HLT':              5,
+    'MMIO':             6,
+    'IRQ_WINDOW_OPEN':  7,
+    'SHUTDOWN':         8,
+    'FAIL_ENTRY':       9,
+    'INTR':             10,
+    'SET_TPR':          11,
+    'TPR_ACCESS':       12,
+    'S390_SIEIC':       13,
+    'S390_RESET':       14,
+    'DCR':              15,
+    'NMI':              16,
+    'INTERNAL_ERROR':   17,
+    'OSI':              18,
+    'PAPR_HCALL':       19,
+    'S390_UCONTROL':    20,
+    'WATCHDOG':         21,
+    'S390_TSCH':        22,
+    'EPR':              23,
+    'SYSTEM_EVENT':     24,
+}
+IOCTL_NUMBERS = {
+    'SET_FILTER':  0x40082406,
+    'ENABLE':      0x00002400,
+    'DISABLE':     0x00002401,
+    'RESET':       0x00002403,
+}
+class Arch(object):
+    """Encapsulates global architecture specific data.
+    Contains the performance event open syscall and ioctl numbers, as
+    well as the VM exit reasons for the architecture it runs on.
+    """
+    @staticmethod
+    def get_arch():
+        machine = os.uname()[4]
+        if machine.startswith('ppc'):
+            return ArchPPC()
+        elif machine.startswith('aarch64'):
+            return ArchA64()
+        elif machine.startswith('s390'):
+            return ArchS390()
+        else:
+            # X86_64
+            for line in open('/proc/cpuinfo'):
+                if not line.startswith('flags'):
+                    continue
+                flags = line.split()
+                if 'vmx' in flags:
+                    return ArchX86(VMX_EXIT_REASONS)
+                if 'svm' in flags:
+                    return ArchX86(SVM_EXIT_REASONS)
+                return
+class ArchX86(Arch):
+    def __init__(self, exit_reasons):
+        self.sc_perf_evt_open = 298
+        self.ioctl_numbers = IOCTL_NUMBERS
+        self.exit_reasons = exit_reasons
+class ArchPPC(Arch):
+    def __init__(self):
+        self.sc_perf_evt_open = 319
+        self.ioctl_numbers = IOCTL_NUMBERS
+        self.ioctl_numbers['ENABLE'] = 0x20002400
+        self.ioctl_numbers['DISABLE'] = 0x20002401
+        self.ioctl_numbers['RESET'] = 0x20002403
+        # PPC comes in 32 and 64 bit and some generated ioctl
+        # numbers depend on the wordsize.
+        char_ptr_size = ctypes.sizeof(ctypes.c_char_p)
+        self.ioctl_numbers['SET_FILTER'] = 0x80002406 | char_ptr_size << 16
+        self.exit_reasons = {}
+class ArchA64(Arch):
+    def __init__(self):
+        self.sc_perf_evt_open = 241
+        self.ioctl_numbers = IOCTL_NUMBERS
+        self.exit_reasons = AARCH64_EXIT_REASONS
+class ArchS390(Arch):
+    def __init__(self):
+        self.sc_perf_evt_open = 331
+        self.ioctl_numbers = IOCTL_NUMBERS
+        self.exit_reasons = None
+ARCH = Arch.get_arch()
+def walkdir(path):
+    """Returns os.walk() data for specified directory.
+    As it is only a wrapper it returns the same 3-tuple of (dirpath,
+    dirnames, filenames).
+    """
+    return next(os.walk(path))
+def parse_int_list(list_string):
+    """Returns an int list from a string of comma separated integers and
+    integer ranges."""
+    integers = []
+    members = list_string.split(',')
+    for member in members:
+        if '-' not in member:
+            integers.append(int(member))
+        else:
+            int_range = member.split('-')
+            integers.extend(range(int(int_range[0]),
+                                  int(int_range[1]) + 1))
+    return integers
+def get_online_cpus():
+    """Returns a list of cpu id integers."""
+    with open('/sys/devices/system/cpu/online') as cpu_list:
+        cpu_string = cpu_list.readline()
+        return parse_int_list(cpu_string)
+def get_filters():
+    """Returns a dict of trace events, their filter ids and
+    the values that can be filtered.
+    Trace events can be filtered for special values by setting a
+    filter string via an ioctl. The string normally has the format
+    identifier==value. For each filter a new event will be created, to
+    be able to distinguish the events.
+    """
+    filters = {}
+    filters['kvm_userspace_exit'] = ('reason', USERSPACE_EXIT_REASONS)
+    if ARCH.exit_reasons:
+        filters['kvm_exit'] = ('exit_reason', ARCH.exit_reasons)
+    return filters
+libc = ctypes.CDLL('libc.so.6', use_errno=True)
+syscall = libc.syscall
+class perf_event_attr(ctypes.Structure):
+    """Struct that holds the necessary data to set up a trace event.
+    For an extensive explanation see perf_event_open(2) and
+    include/uapi/linux/perf_event.h, struct perf_event_attr
+    All fields that are not initialized in the constructor are 0.
+    """
+    _fields_ = [('type', ctypes.c_uint32),
+                ('size', ctypes.c_uint32),
+                ('config', ctypes.c_uint64),
+                ('sample_freq', ctypes.c_uint64),
+                ('sample_type', ctypes.c_uint64),
+                ('read_format', ctypes.c_uint64),
+                ('flags', ctypes.c_uint64),
+                ('wakeup_events', ctypes.c_uint32),
+                ('bp_type', ctypes.c_uint32),
+                ('bp_addr', ctypes.c_uint64),
+                ('bp_len', ctypes.c_uint64),
+                ]
+    def __init__(self):
+        super(self.__class__, self).__init__()
+        self.type = PERF_TYPE_TRACEPOINT
+        self.size = ctypes.sizeof(self)
+        self.read_format = PERF_FORMAT_GROUP
+def perf_event_open(attr, pid, cpu, group_fd, flags):
+    """Wrapper for the sys_perf_evt_open() syscall.
+    Used to set up performance events, returns a file descriptor or -1
+    on error.
+    Attributes are:
+    - syscall number
+    - struct perf_event_attr *
+    - pid or -1 to monitor all pids
+    - cpu number or -1 to monitor all cpus
+    - The file descriptor of the group leader or -1 to create a group.
+    - flags
+    """
+    return syscall(ARCH.sc_perf_evt_open, ctypes.pointer(attr),
+                   ctypes.c_int(pid), ctypes.c_int(cpu),
+                   ctypes.c_int(group_fd), ctypes.c_long(flags))
+PERF_TYPE_TRACEPOINT = 2
+PERF_FORMAT_GROUP = 1 << 3
+PATH_DEBUGFS_TRACING = '/sys/kernel/debug/tracing'
+PATH_DEBUGFS_KVM = '/sys/kernel/debug/kvm'
+class Group(object):
+    """Represents a perf event group."""
+    def __init__(self):
+        self.events = []
+    def add_event(self, event):
+        self.events.append(event)
+    def read(self):
+        """Returns a dict with 'event name: value' for all events in the
+        group.
+        Values are read by reading from the file descriptor of the
+        event that is the group leader. See perf_event_open(2) for
+        details.
+        Read format for the used event configuration is:
+        struct read_format {
+            u64 nr; /* The number of events */
+            struct {
+                u64 value; /* The value of the event */
+            } values[nr];
+        };
+        """
+        length = 8 * (1 + len(self.events))
+        read_format = 'xxxxxxxx' + 'Q' * len(self.events)
+        return dict(zip([event.name for event in self.events],
+                        struct.unpack(read_format,
+                                      os.read(self.events[0].fd, length))))
+class Event(object):
+    """Represents a performance event and manages its life cycle."""
+    def __init__(self, name, group, trace_cpu, trace_pid, trace_point,
+                 trace_filter, trace_set='kvm'):
+        self.name = name
+        self.fd = None
+        self.setup_event(group, trace_cpu, trace_pid, trace_point,
+                         trace_filter, trace_set)
+    def __del__(self):
+        """Closes the event's file descriptor.
+        As no python file object was created for the file descriptor,
+        python will not reference count the descriptor and will not
+        close it itself automatically, so we do it.
+        """
+        if self.fd:
+            os.close(self.fd)
+    def setup_event_attribute(self, trace_set, trace_point):
+        """Returns an initialized ctype perf_event_attr struct."""
+        id_path = os.path.join(PATH_DEBUGFS_TRACING, 'events', trace_set,
+                               trace_point, 'id')
+        event_attr = perf_event_attr()
+        event_attr.config = int(open(id_path).read())
+        return event_attr
+    def setup_event(self, group, trace_cpu, trace_pid, trace_point,
+                    trace_filter, trace_set):
+        """Sets up the perf event in Linux.
+        Issues the syscall to register the event in the kernel and
+        then sets the optional filter.
+        """
+        event_attr = self.setup_event_attribute(trace_set, trace_point)
+        # First event will be group leader.
+        group_leader = -1
+        # All others have to pass the leader's descriptor instead.
+        if group.events:
+            group_leader = group.events[0].fd
+        fd = perf_event_open(event_attr, trace_pid,
+                             trace_cpu, group_leader, 0)
+        if fd == -1:
+            err = ctypes.get_errno()
+            raise OSError(err, os.strerror(err),
+                          'while calling sys_perf_event_open().')
+        if trace_filter:
+            fcntl.ioctl(fd, ARCH.ioctl_numbers['SET_FILTER'],
+                        trace_filter)
+        self.fd = fd
+    def enable(self):
+        """Enables the trace event in the kernel.
+        Enabling the group leader makes reading counters from it and the
+        events under it possible.
+        """
+        fcntl.ioctl(self.fd, ARCH.ioctl_numbers['ENABLE'], 0)
+    def disable(self):
+        """Disables the trace event in the kernel.
+        Disabling the group leader makes reading all counters under it
+        impossible.
+        """
+        fcntl.ioctl(self.fd, ARCH.ioctl_numbers['DISABLE'], 0)
+    def reset(self):
+        """Resets the count of the trace event in the kernel."""
+        fcntl.ioctl(self.fd, ARCH.ioctl_numbers['RESET'], 0)
+class TracepointProvider(object):
+    """Data provider for the stats class.
+    Manages the events/groups from which it acquires its data.
+    """
+    def __init__(self):
+        self.group_leaders = []
+        self.filters = get_filters()
+        self._fields = self.get_available_fields()
+        self._pid = 0
+    def get_available_fields(self):
+        """Returns a list of available event's of format 'event name(filter
+        name)'.
+        All available events have directories under
+        /sys/kernel/debug/tracing/events/ which export information
+        about the specific event. Therefore, listing the dirs gives us
+        a list of all available events.
+        Some events like the vm exit reasons can be filtered for
+        specific values. To take account for that, the routine below
+        creates special fields with the following format:
+        event name(filter name)
+        """
+        path = os.path.join(PATH_DEBUGFS_TRACING, 'events', 'kvm')
+        fields = walkdir(path)[1]
+        extra = []
+        for field in fields:
+            if field in self.filters:
+                filter_name_, filter_dicts = self.filters[field]
+                for name in filter_dicts:
+                    extra.append(field + '(' + name + ')')
+        fields += extra
+        return fields
+    def setup_traces(self):
+        """Creates all event and group objects needed to be able to retrieve
+        data."""
+        if self._pid > 0:
+            # Fetch list of all threads of the monitored pid, as qemu
+            # starts a thread for each vcpu.
+            path = os.path.join('/proc', str(self._pid), 'task')
+            groupids = walkdir(path)[1]
+        else:
+            groupids = get_online_cpus()
+        # The constant is needed as a buffer for python libs, std
+        # streams and other files that the script opens.
+        newlim = len(groupids) * len(self._fields) + 50
+        try:
+            softlim_, hardlim = resource.getrlimit(resource.RLIMIT_NOFILE)
+            if hardlim < newlim:
+                # Now we need CAP_SYS_RESOURCE, to increase the hard limit.
+                resource.setrlimit(resource.RLIMIT_NOFILE, (newlim, newlim))
+            else:
+                # Raising the soft limit is sufficient.
+                resource.setrlimit(resource.RLIMIT_NOFILE, (newlim, hardlim))
+        except ValueError:
+            sys.exit("NOFILE rlimit could not be raised to {0}".format(newlim))
+        for groupid in groupids:
+            group = Group()
+            for name in self._fields:
+                tracepoint = name
+                tracefilter = None
+                match = re.match(r'(.*)\((.*)\)', name)
+                if match:
+                    tracepoint, sub = match.groups()
+                    tracefilter = ('%s==%d\0' %
+                                   (self.filters[tracepoint][0],
+                                    self.filters[tracepoint][1][sub]))
+                # From perf_event_open(2):
+                # pid > 0 and cpu == -1
+                # This measures the specified process/thread on any CPU.
+                #
+                # pid == -1 and cpu >= 0
+                # This measures all processes/threads on the specified CPU.
+                trace_cpu = groupid if self._pid == 0 else -1
+                trace_pid = int(groupid) if self._pid != 0 else -1
+                group.add_event(Event(name=name,
+                                      group=group,
+                                      trace_cpu=trace_cpu,
+                                      trace_pid=trace_pid,
+                                      trace_point=tracepoint,
+                                      trace_filter=tracefilter))
+            self.group_leaders.append(group)
+    def available_fields(self):
+        return self.get_available_fields()
+    @property
+    def fields(self):
+        return self._fields
+    @fields.setter
+    def fields(self, fields):
+        """Enables/disables the (un)wanted events"""
+        self._fields = fields
+        for group in self.group_leaders:
+            for index, event in enumerate(group.events):
+                if event.name in fields:
+                    event.reset()
+                    event.enable()
+                else:
+                    # Do not disable the group leader.
+                    # It would disable all of its events.
+                    if index != 0:
+                        event.disable()
+    @property
+    def pid(self):
+        return self._pid
+    @pid.setter
+    def pid(self, pid):
+        """Changes the monitored pid by setting new traces."""
+        self._pid = pid
+        # The garbage collector will get rid of all Event/Group
+        # objects and open files after removing the references.
+        self.group_leaders = []
+        self.setup_traces()
+        self.fields = self._fields
+    def read(self):
+        """Returns 'event name: current value' for all enabled events."""
+        ret = defaultdict(int)
+        for group in self.group_leaders:
+            for name, val in group.read().iteritems():
+                if name in self._fields:
+                    ret[name] += val
+        return ret
+class DebugfsProvider(object):
+    """Provides data from the files that KVM creates in the kvm debugfs
+    folder."""
+    def __init__(self):
+        self._fields = self.get_available_fields()
+        self._pid = 0
+        self.do_read = True
+    def get_available_fields(self):
+        """"Returns a list of available fields.
+        The fields are all available KVM debugfs files
+        """
+        return walkdir(PATH_DEBUGFS_KVM)[2]
+    @property
+    def fields(self):
+        return self._fields
+    @fields.setter
+    def fields(self, fields):
+        self._fields = fields
+    @property
+    def pid(self):
+        return self._pid
+    @pid.setter
+    def pid(self, pid):
+        if pid != 0:
+            self._pid = pid
+            vms = walkdir(PATH_DEBUGFS_KVM)[1]
+            if len(vms) == 0:
+                self.do_read = False
+            self.paths = filter(lambda x: "{}-".format(pid) in x, vms)
+        else:
+            self.paths = ['']
+            self.do_read = True
+    def read(self):
+        """Returns a dict with format:'file name / field -> current value'."""
+        results = {}
+        # If no debugfs filtering support is available, then don't read.
+        if not self.do_read:
+            return results
+        for path in self.paths:
+            for field in self._fields:
+                results[field] = results.get(field, 0) \
+                                 + self.read_field(field, path)
+        return results
+    def read_field(self, field, path):
+        """Returns the value of a single field from a specific VM."""
+        try:
+            return int(open(os.path.join(PATH_DEBUGFS_KVM,
+                                         path,
+                                         field))
+                       .read())
+        except IOError:
+            return 0
+class Stats(object):
+    """Manages the data providers and the data they provide.
+    It is used to set filters on the provider's data and collect all
+    provider data.
+    """
+    def __init__(self, providers, pid, fields=None):
+        self.providers = providers
+        self._pid_filter = pid
+        self._fields_filter = fields
+        self.values = {}
+        self.update_provider_pid()
+        self.update_provider_filters()
+    def update_provider_filters(self):
+        """Propagates fields filters to providers."""
+        def wanted(key):
+            if not self._fields_filter:
+                return True
+            return re.match(self._fields_filter, key) is not None
+        # As we reset the counters when updating the fields we can
+        # also clear the cache of old values.
+        self.values = {}
+        for provider in self.providers:
+            provider_fields = [key for key in provider.get_available_fields()
+                               if wanted(key)]
+            provider.fields = provider_fields
+    def update_provider_pid(self):
+        """Propagates pid filters to providers."""
+        for provider in self.providers:
+            provider.pid = self._pid_filter
+    @property
+    def fields_filter(self):
+        return self._fields_filter
+    @fields_filter.setter
+    def fields_filter(self, fields_filter):
+        self._fields_filter = fields_filter
+        self.update_provider_filters()
+    @property
+    def pid_filter(self):
+        return self._pid_filter
+    @pid_filter.setter
+    def pid_filter(self, pid):
+        self._pid_filter = pid
+        self.values = {}
+        self.update_provider_pid()
+    def get(self):
+        """Returns a dict with field -> (value, delta to last value) of all
+        provider data."""
+        for provider in self.providers:
+            new = provider.read()
+            for key in provider.fields:
+                oldval = self.values.get(key, (0, 0))
+                newval = new.get(key, 0)
+                newdelta = None
+                if oldval is not None:
+                    newdelta = newval - oldval[0]
+                self.values[key] = (newval, newdelta)
+        return self.values
+LABEL_WIDTH = 40
+NUMBER_WIDTH = 10
+class Tui(object):
+    """Instruments curses to draw a nice text ui."""
+    def __init__(self, stats):
+        self.stats = stats
+        self.screen = None
+        self.drilldown = False
+        self.update_drilldown()
+    def __enter__(self):
+        """Initialises curses for later use.  Based on curses.wrapper
+           implementation from the Python standard library."""
+        self.screen = curses.initscr()
+        curses.noecho()
+        curses.cbreak()
+        # The try/catch works around a minor bit of
+        # over-conscientiousness in the curses module, the error
+        # return from C start_color() is ignorable.
+        try:
+            curses.start_color()
+        except:
+            pass
+        curses.use_default_colors()
+        return self
+    def __exit__(self, *exception):
+        """Resets the terminal to its normal state.  Based on curses.wrappre
+           implementation from the Python standard library."""
+        if self.screen:
+            self.screen.keypad(0)
+            curses.echo()
+            curses.nocbreak()
+            curses.endwin()
+    def update_drilldown(self):
+        """Sets or removes a filter that only allows fields without braces."""
+        if not self.stats.fields_filter:
+            self.stats.fields_filter = r'^[^\(]*$'
+        elif self.stats.fields_filter == r'^[^\(]*$':
+            self.stats.fields_filter = None
+    def update_pid(self, pid):
+        """Propagates pid selection to stats object."""
+        self.stats.pid_filter = pid
+    def refresh(self, sleeptime):
+        """Refreshes on-screen data."""
+        self.screen.erase()
+        if self.stats.pid_filter > 0:
+            self.screen.addstr(0, 0, 'kvm statistics - pid {0}'
+                               .format(self.stats.pid_filter),
+                               curses.A_BOLD)
+        else:
+            self.screen.addstr(0, 0, 'kvm statistics - summary', curses.A_BOLD)
+        self.screen.addstr(2, 1, 'Event')
+        self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH -
+                           len('Total'), 'Total')
+        self.screen.addstr(2, 1 + LABEL_WIDTH + NUMBER_WIDTH + 8 -
+                           len('Current'), 'Current')
+        row = 3
+        stats = self.stats.get()
+        def sortkey(x):
+            if stats[x][1]:
+                return (-stats[x][1], -stats[x][0])
+            else:
+                return (0, -stats[x][0])
+        for key in sorted(stats.keys(), key=sortkey):
+            if row >= self.screen.getmaxyx()[0]:
+                break
+            values = stats[key]
+            if not values[0] and not values[1]:
+                break
+            col = 1
+            self.screen.addstr(row, col, key)
+            col += LABEL_WIDTH
+            self.screen.addstr(row, col, '%10d' % (values[0],))
+            col += NUMBER_WIDTH
+            if values[1] is not None:
+                self.screen.addstr(row, col, '%8d' % (values[1] / sleeptime,))
+            row += 1
+        self.screen.refresh()
+    def show_filter_selection(self):
+        """Draws filter selection mask.
+        Asks for a valid regex and sets the fields filter accordingly.
+        """
+        while True:
+            self.screen.erase()
+            self.screen.addstr(0, 0,
+                               "Show statistics for events matching a regex.",
+                               curses.A_BOLD)
+            self.screen.addstr(2, 0,
+                               "Current regex: {0}"
+                               .format(self.stats.fields_filter))
+            self.screen.addstr(3, 0, "New regex: ")
+            curses.echo()
+            regex = self.screen.getstr()
+            curses.noecho()
+            if len(regex) == 0:
+                return
+            try:
+                re.compile(regex)
+                self.stats.fields_filter = regex
+                return
+            except re.error:
+                continue
+    def show_vm_selection(self):
+        """Draws PID selection mask.
+        Asks for a pid until a valid pid or 0 has been entered.
+        """
+        while True:
+            self.screen.erase()
+            self.screen.addstr(0, 0,
+                               'Show statistics for specific pid.',
+                               curses.A_BOLD)
+            self.screen.addstr(1, 0,
+                               'This might limit the shown data to the trace '
+                               'statistics.')
+            curses.echo()
+            self.screen.addstr(3, 0, "Pid [0 or pid]: ")
+            pid = self.screen.getstr()
+            curses.noecho()
+            try:
+                pid = int(pid)
+                if pid == 0:
+                    self.update_pid(pid)
+                    break
+                else:
+                    if not os.path.isdir(os.path.join('/proc/', str(pid))):
+                        continue
+                    else:
+                        self.update_pid(pid)
+                        break
+            except ValueError:
+                continue
+    def show_stats(self):
+        """Refreshes the screen and processes user input."""
+        sleeptime = 0.25
+        while True:
+            self.refresh(sleeptime)
+            curses.halfdelay(int(sleeptime * 10))
+            sleeptime = 3
+            try:
+                char = self.screen.getkey()
+                if char == 'x':
+                    self.drilldown = not self.drilldown
+                    self.update_drilldown()
+                if char == 'q':
+                    break
+                if char == 'f':
+                    self.show_filter_selection()
+                if char == 'p':
+                    self.show_vm_selection()
+            except KeyboardInterrupt:
+                break
+            except curses.error:
+                continue
+def batch(stats):
+    """Prints statistics in a key, value format."""
+    s = stats.get()
+    time.sleep(1)
+    s = stats.get()
+    for key in sorted(s.keys()):
+        values = s[key]
+        print '%-42s%10d%10d' % (key, values[0], values[1])
+def log(stats):
+    """Prints statistics as reiterating key block, multiple value blocks."""
+    keys = sorted(stats.get().iterkeys())
+    def banner():
+        for k in keys:
+            print '%s' % k,
+        print
+    def statline():
+        s = stats.get()
+        for k in keys:
+            print ' %9d' % s[k][1],
+        print
+    line = 0
+    banner_repeat = 20
+    while True:
+        time.sleep(1)
+        if line % banner_repeat == 0:
+            banner()
+        statline()
+        line += 1
+def get_options():
+    """Returns processed program arguments."""
+    description_text = """
+This script displays various statistics about VMs running under KVM.
+The statistics are gathered from the KVM debugfs entries and / or the
+currently available perf traces.
+The monitoring takes additional cpu cycles and might affect the VM's
+performance.
+Requirements:
+- Access to:
+    /sys/kernel/debug/kvm
+    /sys/kernel/debug/trace/events/*
+    /proc/pid/task
+- /proc/sys/kernel/perf_event_paranoid < 1 if user has no
+  CAP_SYS_ADMIN and perf events are used.
+- CAP_SYS_RESOURCE if the hard limit is not high enough to allow
+  the large number of files that are possibly opened.
+"""
+    class PlainHelpFormatter(optparse.IndentedHelpFormatter):
+        def format_description(self, description):
+            if description:
+                return description + "\n"
+            else:
+                return ""
+    optparser = optparse.OptionParser(description=description_text,
+                                      formatter=PlainHelpFormatter())
+    optparser.add_option('-1', '--once', '--batch',
+                         action='store_true',
+                         default=False,
+                         dest='once',
+                         help='run in batch mode for one second',
+                         )
+    optparser.add_option('-l', '--log',
+                         action='store_true',
+                         default=False,
+                         dest='log',
+                         help='run in logging mode (like vmstat)',
+                         )
+    optparser.add_option('-t', '--tracepoints',
+                         action='store_true',
+                         default=False,
+                         dest='tracepoints',
+                         help='retrieve statistics from tracepoints',
+                         )
+    optparser.add_option('-d', '--debugfs',
+                         action='store_true',
+                         default=False,
+                         dest='debugfs',
+                         help='retrieve statistics from debugfs',
+                         )
+    optparser.add_option('-f', '--fields',
+                         action='store',
+                         default=None,
+                         dest='fields',
+                         help='fields to display (regex)',
+                         )
+    optparser.add_option('-p', '--pid',
+                        action='store',
+                        default=0,
+                        type=int,
+                        dest='pid',
+                        help='restrict statistics to pid',
+                        )
+    (options, _) = optparser.parse_args(sys.argv)
+    return options
+def get_providers(options):
+    """Returns a list of data providers depending on the passed options."""
+    providers = []
+    if options.tracepoints:
+        providers.append(TracepointProvider())
+    if options.debugfs:
+        providers.append(DebugfsProvider())
+    if len(providers) == 0:
+        providers.append(TracepointProvider())
+    return providers
+def check_access(options):
+    """Exits if the current user can't access all needed directories."""
+    if not os.path.exists('/sys/kernel/debug'):
+        sys.stderr.write('Please enable CONFIG_DEBUG_FS in your kernel.')
+        sys.exit(1)
+    if not os.path.exists(PATH_DEBUGFS_KVM):
+        sys.stderr.write("Please make sure, that debugfs is mounted and "
+                         "readable by the current user:\n"
+                         "('mount -t debugfs debugfs /sys/kernel/debug')\n"
+                         "Also ensure, that the kvm modules are loaded.\n")
+        sys.exit(1)
+    if not os.path.exists(PATH_DEBUGFS_TRACING) and (options.tracepoints
+                                                     or not options.debugfs):
+        sys.stderr.write("Please enable CONFIG_TRACING in your kernel "
+                         "when using the option -t (default).\n"
+                         "If it is enabled, make {0} readable by the "
+                         "current user.\n"
+                         .format(PATH_DEBUGFS_TRACING))
+        if options.tracepoints:
+            sys.exit(1)
+        sys.stderr.write("Falling back to debugfs statistics!\n")
+        options.debugfs = True
+        sleep(5)
+    return options
+def main():
+    options = get_options()
+    options = check_access(options)
+    if (options.pid > 0 and
+        not os.path.isdir(os.path.join('/proc/',
+                                       str(options.pid)))):
+        sys.stderr.write('Did you use a (unsupported) tid instead of a pid?\n')
+        sys.exit('Specified pid does not exist.')
+    providers = get_providers(options)
+    stats = Stats(providers, options.pid, fields=options.fields)
+    if options.log:
+        log(stats)
+    elif not options.once:
+        with Tui(stats) as tui:
+            tui.show_stats()
+    else:
+        batch(stats)
+if __name__ == "__main__":
+    main()
diff --git a/tools/kvm/kvm_stat/kvm_stat.txt b/tools/kvm/kvm_stat/kvm_stat.txt
new file mode 100644
index 000000000000..b92a153d7115
--- /dev/null
+++ b/tools/kvm/kvm_stat/kvm_stat.txt
@@ -0,0 +1,63 @@
+kvm_stat(1)
+===========
+NAME
+----
+kvm_stat - Report KVM kernel module event counters
+SYNOPSIS
+--------
+[verse]
+'kvm_stat' [OPTION]...
+DESCRIPTION
+-----------
+kvm_stat prints counts of KVM kernel module trace events.  These events signify
+state transitions such as guest mode entry and exit.
+This tool is useful for observing guest behavior from the host perspective.
+Often conclusions about performance or buggy behavior can be drawn from the
+output.
+The set of KVM kernel module trace events may be specific to the kernel version
+or architecture.  It is best to check the KVM kernel module source code for the
+meaning of events.
+OPTIONS
+-------
+-1::
+--once::
+--batch::
+        run in batch mode for one second
+-l::
+--log::
+        run in logging mode (like vmstat)
+-t::
+--tracepoints::
+        retrieve statistics from tracepoints
+-d::
+--debugfs::
+        retrieve statistics from debugfs
+-p<pid>::
+--pid=<pid>::
+        limit statistics to one virtual machine (pid)
+-f<fields>::
+--fields=<fields>::
+        fields to display (regex)
+-h::
+--help::
+        show help message
+SEE ALSO
+--------
+'perf'(1), 'trace-cmd'(1)
+AUTHOR
+------
+Stefan Hajnoczi <stefanha@redhat.com>
diff --git a/tools/objtool/Makefile b/tools/objtool/Makefile
index 6765c7e949f3..f094f3c4ed84 100644
--- a/tools/objtool/Makefile
+++ b/tools/objtool/Makefile
@@ -30,6 +30,10 @@ INCLUDES := -I$(srctree)/tools/include
 CFLAGS   += -Wall -Werror $(EXTRA_WARNINGS) -fomit-frame-pointer -O2 -g $(INCLUDES)
 LDFLAGS  += -lelf $(LIBSUBCMD)
+# Allow old libelf to be used:
+elfshdr := $(shell echo '\#include <libelf.h>' | $(CC) $(CFLAGS) -x c -E - | grep elf_getshdr)
+CFLAGS += $(if $(elfshdr),,-DLIBELF_USE_DEPRECATED)
 AWK = awk
 export srctree OUTPUT CFLAGS ARCH AWK
 include $(srctree)/tools/build/Makefile.include
diff --git a/tools/objtool/elf.h b/tools/objtool/elf.h
index 7f3e00a2f907..aa1ff6596684 100644
--- a/tools/objtool/elf.h
+++ b/tools/objtool/elf.h
@@ -23,6 +23,11 @@
 #include <linux/list.h>
 #include <linux/hashtable.h>
+#ifdef LIBELF_USE_DEPRECATED
+# define elf_getshdrnum    elf_getshnum
+# define elf_getshdrstrndx elf_getshstrndx
+#endif
 struct section {
        struct list_head list;
        GElf_Shdr sh;
diff --git a/tools/perf/arch/powerpc/include/perf_regs.h b/tools/perf/arch/powerpc/include/perf_regs.h
new file mode 100644
index 000000000000..75de0e92e71e
--- /dev/null
+++ b/tools/perf/arch/powerpc/include/perf_regs.h
@@ -0,0 +1,69 @@
+#ifndef ARCH_PERF_REGS_H
+#define ARCH_PERF_REGS_H
+#include <stdlib.h>
+#include <linux/types.h>
+#include <asm/perf_regs.h>
+#define PERF_REGS_MASK  ((1ULL << PERF_REG_POWERPC_MAX) - 1)
+#define PERF_REGS_MAX   PERF_REG_POWERPC_MAX
+#ifdef __powerpc64__
+        #define PERF_SAMPLE_REGS_ABI    PERF_SAMPLE_REGS_ABI_64
+#else
+        #define PERF_SAMPLE_REGS_ABI    PERF_SAMPLE_REGS_ABI_32
+#endif
+#define PERF_REG_IP     PERF_REG_POWERPC_NIP
+#define PERF_REG_SP     PERF_REG_POWERPC_R1
+static const char *reg_names[] = {
+        [PERF_REG_POWERPC_R0] = "r0",
+        [PERF_REG_POWERPC_R1] = "r1",
+        [PERF_REG_POWERPC_R2] = "r2",
+        [PERF_REG_POWERPC_R3] = "r3",
+        [PERF_REG_POWERPC_R4] = "r4",
+        [PERF_REG_POWERPC_R5] = "r5",
+        [PERF_REG_POWERPC_R6] = "r6",
+        [PERF_REG_POWERPC_R7] = "r7",
+        [PERF_REG_POWERPC_R8] = "r8",
+        [PERF_REG_POWERPC_R9] = "r9",
+        [PERF_REG_POWERPC_R10] = "r10",
+        [PERF_REG_POWERPC_R11] = "r11",
+        [PERF_REG_POWERPC_R12] = "r12",
+        [PERF_REG_POWERPC_R13] = "r13",
+        [PERF_REG_POWERPC_R14] = "r14",
+        [PERF_REG_POWERPC_R15] = "r15",
+        [PERF_REG_POWERPC_R16] = "r16",
+        [PERF_REG_POWERPC_R17] = "r17",
+        [PERF_REG_POWERPC_R18] = "r18",
+        [PERF_REG_POWERPC_R19] = "r19",
+        [PERF_REG_POWERPC_R20] = "r20",
+        [PERF_REG_POWERPC_R21] = "r21",
+        [PERF_REG_POWERPC_R22] = "r22",
+        [PERF_REG_POWERPC_R23] = "r23",
+        [PERF_REG_POWERPC_R24] = "r24",
+        [PERF_REG_POWERPC_R25] = "r25",
+        [PERF_REG_POWERPC_R26] = "r26",
+        [PERF_REG_POWERPC_R27] = "r27",
+        [PERF_REG_POWERPC_R28] = "r28",
+        [PERF_REG_POWERPC_R29] = "r29",
+        [PERF_REG_POWERPC_R30] = "r30",
+        [PERF_REG_POWERPC_R31] = "r31",
+        [PERF_REG_POWERPC_NIP] = "nip",
+        [PERF_REG_POWERPC_MSR] = "msr",
+        [PERF_REG_POWERPC_ORIG_R3] = "orig_r3",
+        [PERF_REG_POWERPC_CTR] = "ctr",
+        [PERF_REG_POWERPC_LINK] = "link",
+        [PERF_REG_POWERPC_XER] = "xer",
+        [PERF_REG_POWERPC_CCR] = "ccr",
+        [PERF_REG_POWERPC_SOFTE] = "softe",
+        [PERF_REG_POWERPC_TRAP] = "trap",
+        [PERF_REG_POWERPC_DAR] = "dar",
+        [PERF_REG_POWERPC_DSISR] = "dsisr"
+};
+static inline const char *perf_reg_name(int id)
+{
+        return reg_names[id];
+}
+#endif /* ARCH_PERF_REGS_H */
diff --git a/tools/perf/arch/powerpc/util/Build b/tools/perf/arch/powerpc/util/Build
index c8fe2074d217..90ad64b231cd 100644
--- a/tools/perf/arch/powerpc/util/Build
+++ b/tools/perf/arch/powerpc/util/Build
@@ -1,6 +1,8 @@
 libperf-y += header.o
 libperf-y += sym-handling.o
 libperf-y += kvm-stat.o
+libperf-y += perf_regs.o
 libperf-$(CONFIG_DWARF) += dwarf-regs.o
 libperf-$(CONFIG_DWARF) += skip-callchain-idx.o
+libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
diff --git a/tools/perf/arch/powerpc/util/perf_regs.c b/tools/perf/arch/powerpc/util/perf_regs.c
new file mode 100644
index 000000000000..a3c3e1ce6807
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/perf_regs.c
@@ -0,0 +1,49 @@
+#include "../../perf.h"
+#include "../../util/perf_regs.h"
+const struct sample_reg sample_reg_masks[] = {
+        SMPL_REG(r0, PERF_REG_POWERPC_R0),
+        SMPL_REG(r1, PERF_REG_POWERPC_R1),
+        SMPL_REG(r2, PERF_REG_POWERPC_R2),
+        SMPL_REG(r3, PERF_REG_POWERPC_R3),
+        SMPL_REG(r4, PERF_REG_POWERPC_R4),
+        SMPL_REG(r5, PERF_REG_POWERPC_R5),
+        SMPL_REG(r6, PERF_REG_POWERPC_R6),
+        SMPL_REG(r7, PERF_REG_POWERPC_R7),
+        SMPL_REG(r8, PERF_REG_POWERPC_R8),
+        SMPL_REG(r9, PERF_REG_POWERPC_R9),
+        SMPL_REG(r10, PERF_REG_POWERPC_R10),
+        SMPL_REG(r11, PERF_REG_POWERPC_R11),
+        SMPL_REG(r12, PERF_REG_POWERPC_R12),
+        SMPL_REG(r13, PERF_REG_POWERPC_R13),
+        SMPL_REG(r14, PERF_REG_POWERPC_R14),
+        SMPL_REG(r15, PERF_REG_POWERPC_R15),
+        SMPL_REG(r16, PERF_REG_POWERPC_R16),
+        SMPL_REG(r17, PERF_REG_POWERPC_R17),
+        SMPL_REG(r18, PERF_REG_POWERPC_R18),
+        SMPL_REG(r19, PERF_REG_POWERPC_R19),
+        SMPL_REG(r20, PERF_REG_POWERPC_R20),
+        SMPL_REG(r21, PERF_REG_POWERPC_R21),
+        SMPL_REG(r22, PERF_REG_POWERPC_R22),
+        SMPL_REG(r23, PERF_REG_POWERPC_R23),
+        SMPL_REG(r24, PERF_REG_POWERPC_R24),
+        SMPL_REG(r25, PERF_REG_POWERPC_R25),
+        SMPL_REG(r26, PERF_REG_POWERPC_R26),
+        SMPL_REG(r27, PERF_REG_POWERPC_R27),
+        SMPL_REG(r28, PERF_REG_POWERPC_R28),
+        SMPL_REG(r29, PERF_REG_POWERPC_R29),
+        SMPL_REG(r30, PERF_REG_POWERPC_R30),
+        SMPL_REG(r31, PERF_REG_POWERPC_R31),
+        SMPL_REG(nip, PERF_REG_POWERPC_NIP),
+        SMPL_REG(msr, PERF_REG_POWERPC_MSR),
+        SMPL_REG(orig_r3, PERF_REG_POWERPC_ORIG_R3),
+        SMPL_REG(ctr, PERF_REG_POWERPC_CTR),
+        SMPL_REG(link, PERF_REG_POWERPC_LINK),
+        SMPL_REG(xer, PERF_REG_POWERPC_XER),
+        SMPL_REG(ccr, PERF_REG_POWERPC_CCR),
+        SMPL_REG(softe, PERF_REG_POWERPC_SOFTE),
+        SMPL_REG(trap, PERF_REG_POWERPC_TRAP),
+        SMPL_REG(dar, PERF_REG_POWERPC_DAR),
+        SMPL_REG(dsisr, PERF_REG_POWERPC_DSISR),
+        SMPL_REG_END
+};
diff --git a/tools/perf/arch/powerpc/util/unwind-libunwind.c b/tools/perf/arch/powerpc/util/unwind-libunwind.c
new file mode 100644
index 000000000000..9e15f92ae49f
--- /dev/null
+++ b/tools/perf/arch/powerpc/util/unwind-libunwind.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2016 Chandan Kumar, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+#include <errno.h>
+#include <libunwind.h>
+#include <asm/perf_regs.h>
+#include "../../util/unwind.h"
+#include "../../util/debug.h"
+int libunwind__arch_reg_id(int regnum)
+{
+        switch (regnum) {
+        case UNW_PPC64_R0:
+                return PERF_REG_POWERPC_R0;
+        case UNW_PPC64_R1:
+                return PERF_REG_POWERPC_R1;
+        case UNW_PPC64_R2:
+                return PERF_REG_POWERPC_R2;
+        case UNW_PPC64_R3:
+                return PERF_REG_POWERPC_R3;
+        case UNW_PPC64_R4:
+                return PERF_REG_POWERPC_R4;
+        case UNW_PPC64_R5:
+                return PERF_REG_POWERPC_R5;
+        case UNW_PPC64_R6:
+                return PERF_REG_POWERPC_R6;
+        case UNW_PPC64_R7:
+                return PERF_REG_POWERPC_R7;
+        case UNW_PPC64_R8:
+                return PERF_REG_POWERPC_R8;
+        case UNW_PPC64_R9:
+                return PERF_REG_POWERPC_R9;
+        case UNW_PPC64_R10:
+                return PERF_REG_POWERPC_R10;
+        case UNW_PPC64_R11:
+                return PERF_REG_POWERPC_R11;
+        case UNW_PPC64_R12:
+                return PERF_REG_POWERPC_R12;
+        case UNW_PPC64_R13:
+                return PERF_REG_POWERPC_R13;
+        case UNW_PPC64_R14:
+                return PERF_REG_POWERPC_R14;
+        case UNW_PPC64_R15:
+                return PERF_REG_POWERPC_R15;
+        case UNW_PPC64_R16:
+                return PERF_REG_POWERPC_R16;
+        case UNW_PPC64_R17:
+                return PERF_REG_POWERPC_R17;
+        case UNW_PPC64_R18:
+                return PERF_REG_POWERPC_R18;
+        case UNW_PPC64_R19:
+                return PERF_REG_POWERPC_R19;
+        case UNW_PPC64_R20:
+                return PERF_REG_POWERPC_R20;
+        case UNW_PPC64_R21:
+                return PERF_REG_POWERPC_R21;
+        case UNW_PPC64_R22:
+                return PERF_REG_POWERPC_R22;
+        case UNW_PPC64_R23:
+                return PERF_REG_POWERPC_R23;
+        case UNW_PPC64_R24:
+                return PERF_REG_POWERPC_R24;
+        case UNW_PPC64_R25:
+                return PERF_REG_POWERPC_R25;
+        case UNW_PPC64_R26:
+                return PERF_REG_POWERPC_R26;
+        case UNW_PPC64_R27:
+                return PERF_REG_POWERPC_R27;
+        case UNW_PPC64_R28:
+                return PERF_REG_POWERPC_R28;
+        case UNW_PPC64_R29:
+                return PERF_REG_POWERPC_R29;
+        case UNW_PPC64_R30:
+                return PERF_REG_POWERPC_R30;
+        case UNW_PPC64_R31:
+                return PERF_REG_POWERPC_R31;
+        case UNW_PPC64_LR:
+                return PERF_REG_POWERPC_LINK;
+        case UNW_PPC64_CTR:
+                return PERF_REG_POWERPC_CTR;
+        case UNW_PPC64_XER:
+                return PERF_REG_POWERPC_XER;
+        case UNW_PPC64_NIP:
+                return PERF_REG_POWERPC_NIP;
+        default:
+                pr_err("unwind: invalid reg id %d\n", regnum);
+                return -EINVAL;
+        }
+        return -EINVAL;
+}
diff --git a/tools/perf/config/Makefile b/tools/perf/config/Makefile
index 1e46277286c2..5ad0255f8756 100644
--- a/tools/perf/config/Makefile
+++ b/tools/perf/config/Makefile
@@ -23,6 +23,12 @@ $(call detected_var,ARCH)
 NO_PERF_REGS := 1
+# Additional ARCH settings for ppc
+ifeq ($(ARCH),powerpc)
+  NO_PERF_REGS := 0
+  LIBUNWIND_LIBS := -lunwind -lunwind-ppc64
+endif
 # Additional ARCH settings for x86
 ifeq ($(ARCH),x86)
  $(call detected,CONFIG_X86)
diff --git a/tools/perf/tests/openat-syscall-all-cpus.c b/tools/perf/tests/openat-syscall-all-cpus.c
index 53c2273e8859..ad1cb63139a7 100644
--- a/tools/perf/tests/openat-syscall-all-cpus.c
+++ b/tools/perf/tests/openat-syscall-all-cpus.c
@@ -73,7 +73,7 @@ int test__openat_syscall_event_on_all_cpus(int subtest __maybe_unused)
        }
        /*
-         * Here we need to explicitely preallocate the counts, as if
+         * Here we need to explicitly preallocate the counts, as if
         * we use the auto allocation it will allocate just for 1 cpu,
         * as we start by cpu 0.
         */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 02c177d14c8d..5d7037ef7d3b 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -828,7 +828,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct record_opts *opts,
                perf_evsel__set_sample_bit(evsel, PERIOD);
        /*
-         * When the user explicitely disabled time don't force it here.
+         * When the user explicitly disabled time don't force it here.
         */
        if (opts->sample_time &&
            (!perf_missing_features.sample_id_all &&
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 205d27017361..b1772180c820 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -363,7 +363,7 @@ out_err:
 }
 /*
- * Caller must eventually drop thread->refcnt returned with a successfull
+ * Caller must eventually drop thread->refcnt returned with a successful
 * lookup/new thread inserted.
 */
 static struct thread *____machine__findnew_thread(struct machine *machine,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index bcbc983d4b12..c6fd0479f4cd 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1649,7 +1649,7 @@ static void parse_events_print_error(struct parse_events_error *err,
                buf = _buf;
-                /* We're cutting from the beggining. */
+                /* We're cutting from the beginning. */
                if (err->idx > max_err_idx)
                        cut = err->idx - max_err_idx;
diff --git a/tools/perf/util/perf_regs.c b/tools/perf/util/perf_regs.c
index 6b8eb13e14e4..c4023f22f287 100644
--- a/tools/perf/util/perf_regs.c
+++ b/tools/perf/util/perf_regs.c
@@ -12,18 +12,18 @@ int perf_reg_value(u64 *valp, struct regs_dump *regs, int id)
        int i, idx = 0;
        u64 mask = regs->mask;
-        if (regs->cache_mask & (1 << id))
+        if (regs->cache_mask & (1ULL << id))
                goto out;
-        if (!(mask & (1 << id)))
+        if (!(mask & (1ULL << id)))
                return -EINVAL;
        for (i = 0; i < id; i++) {
-                if (mask & (1 << i))
+                if (mask & (1ULL << i))
                        idx++;
        }
-        regs->cache_mask |= (1 << id);
+        regs->cache_mask |= (1ULL << id);
        regs->cache_regs[id] = regs->regs[idx];
 out:
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 2335b2824d8a..5214974e841a 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -557,7 +557,7 @@ static u8 revbyte(u8 b)
 /*
 * XXX this is hack in attempt to carry flags bitfield
- * throught endian village. ABI says:
+ * through endian village. ABI says:
 *
 * Bit-fields are allocated from right to left (least to most significant)
 * on little-endian implementations and from left to right (most to least
diff --git a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
index d0e6b857d8d1..546cf4a503b7 100644
--- a/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
+++ b/tools/power/acpi/os_specific/service_layers/oslinuxtbl.c
@@ -91,7 +91,7 @@ osl_get_customized_table(char *pathname,
                         char *signature,
                         u32 instance,
                         struct acpi_table_header **table,
-                         acpi_physical_address * address);
+                         acpi_physical_address *address);
 static acpi_status osl_list_bios_tables(void);
@@ -99,7 +99,7 @@ static acpi_status
 osl_get_bios_table(char *signature,
                   u32 instance,
                   struct acpi_table_header **table,
-                   acpi_physical_address * address);
+                   acpi_physical_address *address);
 static acpi_status osl_get_last_status(acpi_status default_status);
@@ -187,7 +187,7 @@ static acpi_status osl_get_last_status(acpi_status default_status)
 acpi_status
 acpi_os_get_table_by_address(acpi_physical_address address,
-                             struct acpi_table_header ** table)
+                             struct acpi_table_header **table)
 {
        u32 table_length;
        struct acpi_table_header *mapped_table;
@@ -252,8 +252,8 @@ exit:
 acpi_status
 acpi_os_get_table_by_name(char *signature,
                          u32 instance,
-                          struct acpi_table_header ** table,
+                          struct acpi_table_header **table,
-                          acpi_physical_address * address)
+                          acpi_physical_address *address)
 {
        acpi_status status;
@@ -380,8 +380,8 @@ static acpi_status osl_add_table_to_list(char *signature, u32 instance)
 acpi_status
 acpi_os_get_table_by_index(u32 index,
-                           struct acpi_table_header ** table,
+                           struct acpi_table_header **table,
-                           u32 *instance, acpi_physical_address * address)
+                           u32 *instance, acpi_physical_address *address)
 {
        struct osl_table_info *info;
        acpi_status status;
@@ -447,7 +447,7 @@ osl_find_rsdp_via_efi_by_keyword(FILE * file, const char *keyword)
                }
        }
-        return ((acpi_physical_address) (address));
+        return ((acpi_physical_address)(address));
 }
 /******************************************************************************
@@ -751,10 +751,10 @@ static acpi_status osl_list_bios_tables(void)
        for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
                if (osl_can_use_xsdt()) {
                        table_address =
-                            (acpi_physical_address) (*ACPI_CAST64(table_data));
+                            (acpi_physical_address)(*ACPI_CAST64(table_data));
                } else {
                        table_address =
-                            (acpi_physical_address) (*ACPI_CAST32(table_data));
+                            (acpi_physical_address)(*ACPI_CAST32(table_data));
                }
                /* Skip NULL entries in RSDT/XSDT */
@@ -800,7 +800,7 @@ static acpi_status
 osl_get_bios_table(char *signature,
                   u32 instance,
                   struct acpi_table_header **table,
-                   acpi_physical_address * address)
+                   acpi_physical_address *address)
 {
        struct acpi_table_header *local_table = NULL;
        struct acpi_table_header *mapped_table = NULL;
@@ -833,38 +833,37 @@ osl_get_bios_table(char *signature,
                        if ((gbl_fadt->header.length >= MIN_FADT_FOR_XDSDT) &&
                            gbl_fadt->Xdsdt) {
                                table_address =
-                                    (acpi_physical_address) gbl_fadt->Xdsdt;
+                                    (acpi_physical_address)gbl_fadt->Xdsdt;
                        } else
                            if ((gbl_fadt->header.length >= MIN_FADT_FOR_DSDT)
                                && gbl_fadt->dsdt) {
                                table_address =
-                                    (acpi_physical_address) gbl_fadt->dsdt;
+                                    (acpi_physical_address)gbl_fadt->dsdt;
                        }
                } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_FACS)) {
                        if ((gbl_fadt->header.length >= MIN_FADT_FOR_XFACS) &&
                            gbl_fadt->Xfacs) {
                                table_address =
-                                    (acpi_physical_address) gbl_fadt->Xfacs;
+                                    (acpi_physical_address)gbl_fadt->Xfacs;
                        } else
                            if ((gbl_fadt->header.length >= MIN_FADT_FOR_FACS)
                                && gbl_fadt->facs) {
                                table_address =
-                                    (acpi_physical_address) gbl_fadt->facs;
+                                    (acpi_physical_address)gbl_fadt->facs;
                        }
                } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_XSDT)) {
                        if (!gbl_revision) {
                                return (AE_BAD_SIGNATURE);
                        }
                        table_address =
-                            (acpi_physical_address) gbl_rsdp.
+                            (acpi_physical_address)gbl_rsdp.
                            xsdt_physical_address;
                } else if (ACPI_COMPARE_NAME(signature, ACPI_SIG_RSDT)) {
                        table_address =
-                            (acpi_physical_address) gbl_rsdp.
+                            (acpi_physical_address)gbl_rsdp.
                            rsdt_physical_address;
                } else {
-                        table_address =
+                        table_address = (acpi_physical_address)gbl_rsdp_address;
-                            (acpi_physical_address) gbl_rsdp_address;
                        signature = ACPI_SIG_RSDP;
                }
@@ -904,12 +903,12 @@ osl_get_bios_table(char *signature,
                for (i = 0; i < number_of_tables; ++i, table_data += item_size) {
                        if (osl_can_use_xsdt()) {
                                table_address =
-                                    (acpi_physical_address) (*ACPI_CAST64
+                                    (acpi_physical_address)(*ACPI_CAST64
-                                                             (table_data));
+                                                            (table_data));
                        } else {
                                table_address =
-                                    (acpi_physical_address) (*ACPI_CAST32
+                                    (acpi_physical_address)(*ACPI_CAST32
-                                                             (table_data));
+                                                            (table_data));
                        }
                        /* Skip NULL entries in RSDT/XSDT */
@@ -1301,7 +1300,7 @@ osl_get_customized_table(char *pathname,
                         char *signature,
                         u32 instance,
                         struct acpi_table_header **table,
-                         acpi_physical_address * address)
+                         acpi_physical_address *address)
 {
        void *table_dir;
        u32 current_instance = 0;
diff --git a/tools/power/acpi/os_specific/service_layers/osunixmap.c b/tools/power/acpi/os_specific/service_layers/osunixmap.c
index 3818fd07e50f..cbfbce18783d 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixmap.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixmap.c
@@ -54,7 +54,7 @@ ACPI_MODULE_NAME("osunixmap")
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
-#if defined(_dragon_fly) || defined(_free_BSD)
+#if defined(_dragon_fly) || defined(_free_BSD) || defined(_QNX)
 #define MMAP_FLAGS          MAP_SHARED
 #else
 #define MMAP_FLAGS          MAP_PRIVATE
diff --git a/tools/power/acpi/os_specific/service_layers/osunixxf.c b/tools/power/acpi/os_specific/service_layers/osunixxf.c
index 08cb8b2035f2..88aa66ef4ad5 100644
--- a/tools/power/acpi/os_specific/service_layers/osunixxf.c
+++ b/tools/power/acpi/os_specific/service_layers/osunixxf.c
@@ -246,8 +246,8 @@ acpi_physical_address acpi_os_get_root_pointer(void)
 *****************************************************************************/
 acpi_status
-acpi_os_predefined_override(const struct acpi_predefined_names * init_val,
+acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
-                            acpi_string * new_val)
+                            acpi_string *new_val)
 {
        if (!init_val || !new_val) {
@@ -274,8 +274,8 @@ acpi_os_predefined_override(const struct acpi_predefined_names * init_val,
 *****************************************************************************/
 acpi_status
-acpi_os_table_override(struct acpi_table_header * existing_table,
+acpi_os_table_override(struct acpi_table_header *existing_table,
-                       struct acpi_table_header ** new_table)
+                       struct acpi_table_header **new_table)
 {
        if (!existing_table || !new_table) {
@@ -311,8 +311,8 @@ acpi_os_table_override(struct acpi_table_header * existing_table,
 *****************************************************************************/
 acpi_status
-acpi_os_physical_table_override(struct acpi_table_header * existing_table,
+acpi_os_physical_table_override(struct acpi_table_header *existing_table,
-                                acpi_physical_address * new_address,
+                                acpi_physical_address *new_address,
                                u32 *new_table_length)
 {
@@ -506,7 +506,7 @@ acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read)
 void *acpi_os_map_memory(acpi_physical_address where, acpi_size length)
 {
-        return (ACPI_TO_POINTER((acpi_size) where));
+        return (ACPI_TO_POINTER((acpi_size)where));
 }
 /******************************************************************************
@@ -603,9 +603,9 @@ void acpi_os_free(void *mem)
 acpi_status
 acpi_os_create_semaphore(u32 max_units,
-                         u32 initial_units, acpi_handle * out_handle)
+                         u32 initial_units, acpi_handle *out_handle)
 {
-        *out_handle = (acpi_handle) 1;
+        *out_handle = (acpi_handle)1;
        return (AE_OK);
 }
@@ -640,7 +640,7 @@ acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units)
 acpi_status
 acpi_os_create_semaphore(u32 max_units,
-                         u32 initial_units, acpi_handle * out_handle)
+                         u32 initial_units, acpi_handle *out_handle)
 {
        sem_t *sem;
@@ -672,7 +672,7 @@ acpi_os_create_semaphore(u32 max_units,
        }
 #endif
-        *out_handle = (acpi_handle) sem;
+        *out_handle = (acpi_handle)sem;
        return (AE_OK);
 }
@@ -1035,7 +1035,7 @@ acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
 *****************************************************************************/
 acpi_status
-acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id,
+acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id,
                                u32 pci_register, u64 value, u32 width)
 {
diff --git a/tools/power/acpi/tools/acpidbg/acpidbg.c b/tools/power/acpi/tools/acpidbg/acpidbg.c
index d070fccdba6d..a88ac45b7756 100644
--- a/tools/power/acpi/tools/acpidbg/acpidbg.c
+++ b/tools/power/acpi/tools/acpidbg/acpidbg.c
@@ -375,7 +375,7 @@ void usage(FILE *file, char *progname)
 int main(int argc, char **argv)
 {
-        int fd = 0;
+        int fd = -1;
        int ch;
        int len;
        int ret = EXIT_SUCCESS;
@@ -430,7 +430,7 @@ int main(int argc, char **argv)
        acpi_aml_loop(fd);
 exit:
-        if (fd < 0)
+        if (fd >= 0)
                close(fd);
        if (acpi_aml_batch_cmd)
                free(acpi_aml_batch_cmd);
diff --git a/tools/power/acpi/tools/acpidump/Makefile b/tools/power/acpi/tools/acpidump/Makefile
index 8d761576e91b..2942cdced2ad 100644
--- a/tools/power/acpi/tools/acpidump/Makefile
+++ b/tools/power/acpi/tools/acpidump/Makefile
@@ -31,6 +31,7 @@ TOOL_OBJS = \
        osunixxf.o\
        tbprint.o\
        tbxfroot.o\
+        utascii.o\
        utbuffer.o\
        utdebug.o\
        utexcep.o\
diff --git a/tools/power/acpi/tools/acpidump/apdump.c b/tools/power/acpi/tools/acpidump/apdump.c
index da44458d3b6c..fb8f1d9e3b1b 100644
--- a/tools/power/acpi/tools/acpidump/apdump.c
+++ b/tools/power/acpi/tools/acpidump/apdump.c
@@ -68,7 +68,7 @@ u8 ap_is_valid_header(struct acpi_table_header *table)
                /* Make sure signature is all ASCII and a valid ACPI name */
-                if (!acpi_ut_valid_acpi_name(table->signature)) {
+                if (!acpi_ut_valid_nameseg(table->signature)) {
                        acpi_log_error("Table signature (0x%8.8X) is invalid\n",
                                       *(u32 *)table->signature);
                        return (FALSE);
@@ -286,14 +286,15 @@ int ap_dump_table_by_address(char *ascii_address)
        /* Convert argument to an integer physical address */
-        status = acpi_ut_strtoul64(ascii_address, 0, &long_address);
+        status = acpi_ut_strtoul64(ascii_address, ACPI_ANY_BASE,
+                                   ACPI_MAX64_BYTE_WIDTH, &long_address);
        if (ACPI_FAILURE(status)) {
                acpi_log_error("%s: Could not convert to a physical address\n",
                               ascii_address);
                return (-1);
        }
-        address = (acpi_physical_address) long_address;
+        address = (acpi_physical_address)long_address;
        status = acpi_os_get_table_by_address(address, &table);
        if (ACPI_FAILURE(status)) {
                acpi_log_error("Could not get table at 0x%8.8X%8.8X, %s\n",
@@ -406,6 +407,12 @@ int ap_dump_table_from_file(char *pathname)
                return (-1);
        }
+        if (!acpi_ut_valid_nameseg(table->signature)) {
+                acpi_log_error
+                    ("No valid ACPI signature was found in input file %s\n",
+                     pathname);
+        }
        /* File must be at least as long as the table length */
        if (table->length > file_size) {
diff --git a/tools/power/acpi/tools/acpidump/apmain.c b/tools/power/acpi/tools/acpidump/apmain.c
index c3c09152fac6..7692e6b887e1 100644
--- a/tools/power/acpi/tools/acpidump/apmain.c
+++ b/tools/power/acpi/tools/acpidump/apmain.c
@@ -209,7 +209,8 @@ static int ap_do_options(int argc, char **argv)
                case 'r':       /* Dump tables from specified RSDP */
                        status =
-                            acpi_ut_strtoul64(acpi_gbl_optarg, 0,
+                            acpi_ut_strtoul64(acpi_gbl_optarg, ACPI_ANY_BASE,
+                                              ACPI_MAX64_BYTE_WIDTH,
                                              &gbl_rsdp_base);
                        if (ACPI_FAILURE(status)) {
                                acpi_log_error
diff --git a/tools/power/cpupower/Makefile b/tools/power/cpupower/Makefile
index 0adaf0c7c03a..8358863259c5 100644
--- a/tools/power/cpupower/Makefile
+++ b/tools/power/cpupower/Makefile
@@ -63,7 +63,7 @@ DESTDIR ?=
 # and _should_ modify the PACKAGE_BUGREPORT definition
 VERSION=                        $(shell ./utils/version-gen.sh)
-LIB_MAJ=                        0.0.0
+LIB_MAJ=                        0.0.1
 LIB_MIN=                        0
 PACKAGE =                       cpupower
@@ -129,7 +129,7 @@ WARNINGS += -Wshadow
 CFLAGS += -DVERSION=\"$(VERSION)\" -DPACKAGE=\"$(PACKAGE)\" \
                -DPACKAGE_BUGREPORT=\"$(PACKAGE_BUGREPORT)\" -D_GNU_SOURCE
-UTIL_OBJS =  utils/helpers/amd.o utils/helpers/topology.o utils/helpers/msr.o \
+UTIL_OBJS =  utils/helpers/amd.o utils/helpers/msr.o \
        utils/helpers/sysfs.o utils/helpers/misc.o utils/helpers/cpuid.o \
        utils/helpers/pci.o utils/helpers/bitmask.o \
        utils/idle_monitor/nhm_idle.o utils/idle_monitor/snb_idle.o \
@@ -148,9 +148,9 @@ UTIL_HEADERS = utils/helpers/helpers.h utils/idle_monitor/cpupower-monitor.h \
        utils/helpers/bitmask.h \
        utils/idle_monitor/idle_monitors.h utils/idle_monitor/idle_monitors.def
-LIB_HEADERS =   lib/cpufreq.h lib/sysfs.h
+LIB_HEADERS =   lib/cpufreq.h lib/cpupower.h lib/cpuidle.h
-LIB_SRC =       lib/cpufreq.c lib/sysfs.c
+LIB_SRC =       lib/cpufreq.c lib/cpupower.c lib/cpuidle.c
-LIB_OBJS =      lib/cpufreq.o lib/sysfs.o
+LIB_OBJS =      lib/cpufreq.o lib/cpupower.o lib/cpuidle.o
 LIB_OBJS :=     $(addprefix $(OUTPUT),$(LIB_OBJS))
 CFLAGS +=       -pipe
@@ -280,6 +280,7 @@ install-lib:
        $(CP) $(OUTPUT)libcpupower.so* $(DESTDIR)${libdir}/
        $(INSTALL) -d $(DESTDIR)${includedir}
        $(INSTALL_DATA) lib/cpufreq.h $(DESTDIR)${includedir}/cpufreq.h
+        $(INSTALL_DATA) lib/cpuidle.h $(DESTDIR)${includedir}/cpuidle.h
 install-tools:
        $(INSTALL) -d $(DESTDIR)${bindir}
@@ -315,6 +316,7 @@ endif
 uninstall:
        - rm -f $(DESTDIR)${libdir}/libcpupower.*
        - rm -f $(DESTDIR)${includedir}/cpufreq.h
+        - rm -f $(DESTDIR)${includedir}/cpuidle.h
        - rm -f $(DESTDIR)${bindir}/utils/cpupower
        - rm -f $(DESTDIR)${mandir}/man1/cpupower.1
        - rm -f $(DESTDIR)${mandir}/man1/cpupower-frequency-set.1
diff --git a/tools/power/cpupower/bench/Makefile b/tools/power/cpupower/bench/Makefile
index d0f879b223fc..3e59f1aa3947 100644
--- a/tools/power/cpupower/bench/Makefile
+++ b/tools/power/cpupower/bench/Makefile
@@ -22,7 +22,7 @@ $(OUTPUT)%.o : %.c
 $(OUTPUT)cpufreq-bench: $(OBJS)
        $(ECHO) "  CC      " $@
-        $(QUIET) $(CC) -o $@ $(CFLAGS) $(OBJS) $(LIBS)
+        $(QUIET) $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS)
 all: $(OUTPUT)cpufreq-bench
diff --git a/tools/power/cpupower/bench/README-BENCH b/tools/power/cpupower/bench/README-BENCH
index 8093ec738170..97727aed61cc 100644
--- a/tools/power/cpupower/bench/README-BENCH
+++ b/tools/power/cpupower/bench/README-BENCH
@@ -113,7 +113,7 @@ cpufreq-bench Command Usage
 -c, --cpu=<unsigned int>        CPU Number to use, starting at 0
 -p, --prio=<priority>           scheduler priority, HIGH, LOW or DEFAULT
 -g, --governor=<governor>       cpufreq governor to test
-n, --cycles=<int>              load/sleep cycles to get an avarage value to compare
+-n, --cycles=<int>              load/sleep cycles to get an average value to compare
 -r, --rounds<int>               load/sleep rounds
 -f, --file=<configfile>         config file to use
 -o, --output=<dir>              output dir, must exist
diff --git a/tools/power/cpupower/bench/benchmark.c b/tools/power/cpupower/bench/benchmark.c
index 81b1c48607d9..429d51ab8031 100644
--- a/tools/power/cpupower/bench/benchmark.c
+++ b/tools/power/cpupower/bench/benchmark.c
@@ -130,7 +130,7 @@ void start_benchmark(struct config *config)
                        _round, load_time, sleep_time);
                if (config->verbose)
-                        printf("avarage: %lius, rps:%li\n",
+                        printf("average: %lius, rps:%li\n",
                                load_time / calculations,
                                1000000 * calculations / load_time);
@@ -177,7 +177,7 @@ void start_benchmark(struct config *config)
                progress_time += sleep_time + load_time;
-                /* compare the avarage sleep/load cycles  */
+                /* compare the average sleep/load cycles  */
                fprintf(config->output, "%li ",
                        powersave_time / config->cycles);
                fprintf(config->output, "%.3f\n",
diff --git a/tools/power/cpupower/bench/parse.c b/tools/power/cpupower/bench/parse.c
index f503fb53824e..9b65f052081f 100644
--- a/tools/power/cpupower/bench/parse.c
+++ b/tools/power/cpupower/bench/parse.c
@@ -65,7 +65,7 @@ FILE *prepare_output(const char *dirname)
 {
        FILE *output = NULL;
        int len;
-        char *filename;
+        char *filename, *filename_tmp;
        struct utsname sysdata;
        DIR *dir;
@@ -81,16 +81,22 @@ FILE *prepare_output(const char *dirname)
        len = strlen(dirname) + 30;
        filename = malloc(sizeof(char) * len);
+        if (!filename) {
+                perror("malloc");
+                goto out_dir;
+        }
        if (uname(&sysdata) == 0) {
                len += strlen(sysdata.nodename) + strlen(sysdata.release);
-                filename = realloc(filename, sizeof(char) * len);
+                filename_tmp = realloc(filename, sizeof(*filename) * len);
-                if (filename == NULL) {
+                if (filename_tmp == NULL) {
+                        free(filename);
                        perror("realloc");
-                        return NULL;
+                        goto out_dir;
                }
+                filename = filename_tmp;
                snprintf(filename, len - 1, "%s/benchmark_%s_%s_%li.log",
                        dirname, sysdata.nodename, sysdata.release, time(NULL));
        } else {
@@ -104,12 +110,16 @@ FILE *prepare_output(const char *dirname)
        if (output == NULL) {
                perror("fopen");
                fprintf(stderr, "error: unable to open logfile\n");
+                goto out;
        }
        fprintf(stdout, "Logfile: %s\n", filename);
-        free(filename);
        fprintf(output, "#round load sleep performance powersave percentage\n");
+out:
+        free(filename);
+out_dir:
+        closedir(dir);
        return output;
 }
diff --git a/tools/power/cpupower/bench/system.c b/tools/power/cpupower/bench/system.c
index f01e3f4be84c..c25a74ae51ba 100644
--- a/tools/power/cpupower/bench/system.c
+++ b/tools/power/cpupower/bench/system.c
@@ -26,6 +26,7 @@
 #include <sched.h>
 #include <cpufreq.h>
+#include <cpupower.h>
 #include "config.h"
 #include "system.h"
@@ -60,7 +61,7 @@ int set_cpufreq_governor(char *governor, unsigned int cpu)
        dprintf("set %s as cpufreq governor\n", governor);
-        if (cpufreq_cpu_exists(cpu) != 0) {
+        if (cpupower_is_cpu_online(cpu) != 0) {
                perror("cpufreq_cpu_exists");
                fprintf(stderr, "error: cpu %u does not exist\n", cpu);
                return -1;
diff --git a/tools/power/cpupower/lib/cpufreq.c b/tools/power/cpupower/lib/cpufreq.c
index d961101d1cea..1b993fe1ce23 100644
--- a/tools/power/cpupower/lib/cpufreq.c
+++ b/tools/power/cpupower/lib/cpufreq.c
@@ -9,28 +9,190 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include "cpufreq.h"
-#include "sysfs.h"
+#include "cpupower_intern.h"
-int cpufreq_cpu_exists(unsigned int cpu)
+/* CPUFREQ sysfs access **************************************************/
+/* helper function to read file from /sys into given buffer */
+/* fname is a relative path under "cpuX/cpufreq" dir */
+static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname,
+                                            char *buf, size_t buflen)
 {
-        return sysfs_cpu_exists(cpu);
+        char path[SYSFS_PATH_MAX];
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
+                         cpu, fname);
+        return sysfs_read_file(path, buf, buflen);
 }
+/* helper function to write a new value to a /sys file */
+/* fname is a relative path under "cpuX/cpufreq" dir */
+static unsigned int sysfs_cpufreq_write_file(unsigned int cpu,
+                                             const char *fname,
+                                             const char *value, size_t len)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numwrite;
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
+                         cpu, fname);
+        fd = open(path, O_WRONLY);
+        if (fd == -1)
+                return 0;
+        numwrite = write(fd, value, len);
+        if (numwrite < 1) {
+                close(fd);
+                return 0;
+        }
+        close(fd);
+        return (unsigned int) numwrite;
+}
+/* read access to files which contain one numeric value */
+enum cpufreq_value {
+        CPUINFO_CUR_FREQ,
+        CPUINFO_MIN_FREQ,
+        CPUINFO_MAX_FREQ,
+        CPUINFO_LATENCY,
+        SCALING_CUR_FREQ,
+        SCALING_MIN_FREQ,
+        SCALING_MAX_FREQ,
+        STATS_NUM_TRANSITIONS,
+        MAX_CPUFREQ_VALUE_READ_FILES
+};
+static const char *cpufreq_value_files[MAX_CPUFREQ_VALUE_READ_FILES] = {
+        [CPUINFO_CUR_FREQ] = "cpuinfo_cur_freq",
+        [CPUINFO_MIN_FREQ] = "cpuinfo_min_freq",
+        [CPUINFO_MAX_FREQ] = "cpuinfo_max_freq",
+        [CPUINFO_LATENCY]  = "cpuinfo_transition_latency",
+        [SCALING_CUR_FREQ] = "scaling_cur_freq",
+        [SCALING_MIN_FREQ] = "scaling_min_freq",
+        [SCALING_MAX_FREQ] = "scaling_max_freq",
+        [STATS_NUM_TRANSITIONS] = "stats/total_trans"
+};
+static unsigned long sysfs_cpufreq_get_one_value(unsigned int cpu,
+                                                 enum cpufreq_value which)
+{
+        unsigned long value;
+        unsigned int len;
+        char linebuf[MAX_LINE_LEN];
+        char *endp;
+        if (which >= MAX_CPUFREQ_VALUE_READ_FILES)
+                return 0;
+        len = sysfs_cpufreq_read_file(cpu, cpufreq_value_files[which],
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return 0;
+        value = strtoul(linebuf, &endp, 0);
+        if (endp == linebuf || errno == ERANGE)
+                return 0;
+        return value;
+}
+/* read access to files which contain one string */
+enum cpufreq_string {
+        SCALING_DRIVER,
+        SCALING_GOVERNOR,
+        MAX_CPUFREQ_STRING_FILES
+};
+static const char *cpufreq_string_files[MAX_CPUFREQ_STRING_FILES] = {
+        [SCALING_DRIVER] = "scaling_driver",
+        [SCALING_GOVERNOR] = "scaling_governor",
+};
+static char *sysfs_cpufreq_get_one_string(unsigned int cpu,
+                                           enum cpufreq_string which)
+{
+        char linebuf[MAX_LINE_LEN];
+        char *result;
+        unsigned int len;
+        if (which >= MAX_CPUFREQ_STRING_FILES)
+                return NULL;
+        len = sysfs_cpufreq_read_file(cpu, cpufreq_string_files[which],
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        result = strdup(linebuf);
+        if (result == NULL)
+                return NULL;
+        if (result[strlen(result) - 1] == '\n')
+                result[strlen(result) - 1] = '\0';
+        return result;
+}
+/* write access */
+enum cpufreq_write {
+        WRITE_SCALING_MIN_FREQ,
+        WRITE_SCALING_MAX_FREQ,
+        WRITE_SCALING_GOVERNOR,
+        WRITE_SCALING_SET_SPEED,
+        MAX_CPUFREQ_WRITE_FILES
+};
+static const char *cpufreq_write_files[MAX_CPUFREQ_WRITE_FILES] = {
+        [WRITE_SCALING_MIN_FREQ] = "scaling_min_freq",
+        [WRITE_SCALING_MAX_FREQ] = "scaling_max_freq",
+        [WRITE_SCALING_GOVERNOR] = "scaling_governor",
+        [WRITE_SCALING_SET_SPEED] = "scaling_setspeed",
+};
+static int sysfs_cpufreq_write_one_value(unsigned int cpu,
+                                         enum cpufreq_write which,
+                                         const char *new_value, size_t len)
+{
+        if (which >= MAX_CPUFREQ_WRITE_FILES)
+                return 0;
+        if (sysfs_cpufreq_write_file(cpu, cpufreq_write_files[which],
+                                        new_value, len) != len)
+                return -ENODEV;
+        return 0;
+};
 unsigned long cpufreq_get_freq_kernel(unsigned int cpu)
 {
-        return sysfs_get_freq_kernel(cpu);
+        return sysfs_cpufreq_get_one_value(cpu, SCALING_CUR_FREQ);
 }
 unsigned long cpufreq_get_freq_hardware(unsigned int cpu)
 {
-        return sysfs_get_freq_hardware(cpu);
+        return sysfs_cpufreq_get_one_value(cpu, CPUINFO_CUR_FREQ);
 }
 unsigned long cpufreq_get_transition_latency(unsigned int cpu)
 {
-        return sysfs_get_freq_transition_latency(cpu);
+        return sysfs_cpufreq_get_one_value(cpu, CPUINFO_LATENCY);
 }
 int cpufreq_get_hardware_limits(unsigned int cpu,
@@ -39,12 +201,21 @@ int cpufreq_get_hardware_limits(unsigned int cpu,
 {
        if ((!min) || (!max))
                return -EINVAL;
-        return sysfs_get_freq_hardware_limits(cpu, min, max);
+        *min = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MIN_FREQ);
+        if (!*min)
+                return -ENODEV;
+        *max = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MAX_FREQ);
+        if (!*max)
+                return -ENODEV;
+        return 0;
 }
 char *cpufreq_get_driver(unsigned int cpu)
 {
-        return sysfs_get_freq_driver(cpu);
+        return sysfs_cpufreq_get_one_string(cpu, SCALING_DRIVER);
 }
 void cpufreq_put_driver(char *ptr)
@@ -56,7 +227,26 @@ void cpufreq_put_driver(char *ptr)
 struct cpufreq_policy *cpufreq_get_policy(unsigned int cpu)
 {
-        return sysfs_get_freq_policy(cpu);
+        struct cpufreq_policy *policy;
+        policy = malloc(sizeof(struct cpufreq_policy));
+        if (!policy)
+                return NULL;
+        policy->governor = sysfs_cpufreq_get_one_string(cpu, SCALING_GOVERNOR);
+        if (!policy->governor) {
+                free(policy);
+                return NULL;
+        }
+        policy->min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
+        policy->max = sysfs_cpufreq_get_one_value(cpu, SCALING_MAX_FREQ);
+        if ((!policy->min) || (!policy->max)) {
+                free(policy->governor);
+                free(policy);
+                return NULL;
+        }
+        return policy;
 }
 void cpufreq_put_policy(struct cpufreq_policy *policy)
@@ -72,7 +262,57 @@ void cpufreq_put_policy(struct cpufreq_policy *policy)
 struct cpufreq_available_governors *cpufreq_get_available_governors(unsigned
                                                                int cpu)
 {
-        return sysfs_get_freq_available_governors(cpu);
+        struct cpufreq_available_governors *first = NULL;
+        struct cpufreq_available_governors *current = NULL;
+        char linebuf[MAX_LINE_LEN];
+        unsigned int pos, i;
+        unsigned int len;
+        len = sysfs_cpufreq_read_file(cpu, "scaling_available_governors",
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        pos = 0;
+        for (i = 0; i < len; i++) {
+                if (linebuf[i] == ' ' || linebuf[i] == '\n') {
+                        if (i - pos < 2)
+                                continue;
+                        if (current) {
+                                current->next = malloc(sizeof(*current));
+                                if (!current->next)
+                                        goto error_out;
+                                current = current->next;
+                        } else {
+                                first = malloc(sizeof(*first));
+                                if (!first)
+                                        goto error_out;
+                                current = first;
+                        }
+                        current->first = first;
+                        current->next = NULL;
+                        current->governor = malloc(i - pos + 1);
+                        if (!current->governor)
+                                goto error_out;
+                        memcpy(current->governor, linebuf + pos, i - pos);
+                        current->governor[i - pos] = '\0';
+                        pos = i + 1;
+                }
+        }
+        return first;
+ error_out:
+        while (first) {
+                current = first->next;
+                if (first->governor)
+                        free(first->governor);
+                free(first);
+                first = current;
+        }
+        return NULL;
 }
 void cpufreq_put_available_governors(struct cpufreq_available_governors *any)
@@ -96,7 +336,57 @@ void cpufreq_put_available_governors(struct cpufreq_available_governors *any)
 struct cpufreq_available_frequencies
 *cpufreq_get_available_frequencies(unsigned int cpu)
 {
-        return sysfs_get_available_frequencies(cpu);
+        struct cpufreq_available_frequencies *first = NULL;
+        struct cpufreq_available_frequencies *current = NULL;
+        char one_value[SYSFS_PATH_MAX];
+        char linebuf[MAX_LINE_LEN];
+        unsigned int pos, i;
+        unsigned int len;
+        len = sysfs_cpufreq_read_file(cpu, "scaling_available_frequencies",
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        pos = 0;
+        for (i = 0; i < len; i++) {
+                if (linebuf[i] == ' ' || linebuf[i] == '\n') {
+                        if (i - pos < 2)
+                                continue;
+                        if (i - pos >= SYSFS_PATH_MAX)
+                                goto error_out;
+                        if (current) {
+                                current->next = malloc(sizeof(*current));
+                                if (!current->next)
+                                        goto error_out;
+                                current = current->next;
+                        } else {
+                                first = malloc(sizeof(*first));
+                                if (!first)
+                                        goto error_out;
+                                current = first;
+                        }
+                        current->first = first;
+                        current->next = NULL;
+                        memcpy(one_value, linebuf + pos, i - pos);
+                        one_value[i - pos] = '\0';
+                        if (sscanf(one_value, "%lu", &current->frequency) != 1)
+                                goto error_out;
+                        pos = i + 1;
+                }
+        }
+        return first;
+ error_out:
+        while (first) {
+                current = first->next;
+                free(first);
+                first = current;
+        }
+        return NULL;
 }
 void cpufreq_put_available_frequencies(struct cpufreq_available_frequencies
@@ -114,10 +404,65 @@ void cpufreq_put_available_frequencies(struct cpufreq_available_frequencies
        }
 }
+static struct cpufreq_affected_cpus *sysfs_get_cpu_list(unsigned int cpu,
+                                                        const char *file)
+{
+        struct cpufreq_affected_cpus *first = NULL;
+        struct cpufreq_affected_cpus *current = NULL;
+        char one_value[SYSFS_PATH_MAX];
+        char linebuf[MAX_LINE_LEN];
+        unsigned int pos, i;
+        unsigned int len;
+        len = sysfs_cpufreq_read_file(cpu, file, linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        pos = 0;
+        for (i = 0; i < len; i++) {
+                if (i == len || linebuf[i] == ' ' || linebuf[i] == '\n') {
+                        if (i - pos  < 1)
+                                continue;
+                        if (i - pos >= SYSFS_PATH_MAX)
+                                goto error_out;
+                        if (current) {
+                                current->next = malloc(sizeof(*current));
+                                if (!current->next)
+                                        goto error_out;
+                                current = current->next;
+                        } else {
+                                first = malloc(sizeof(*first));
+                                if (!first)
+                                        goto error_out;
+                                current = first;
+                        }
+                        current->first = first;
+                        current->next = NULL;
+                        memcpy(one_value, linebuf + pos, i - pos);
+                        one_value[i - pos] = '\0';
+                        if (sscanf(one_value, "%u", &current->cpu) != 1)
+                                goto error_out;
+                        pos = i + 1;
+                }
+        }
+        return first;
+ error_out:
+        while (first) {
+                current = first->next;
+                free(first);
+                first = current;
+        }
+        return NULL;
+}
 struct cpufreq_affected_cpus *cpufreq_get_affected_cpus(unsigned int cpu)
 {
-        return sysfs_get_freq_affected_cpus(cpu);
+        return sysfs_get_cpu_list(cpu, "affected_cpus");
 }
 void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *any)
@@ -138,7 +483,7 @@ void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *any)
 struct cpufreq_affected_cpus *cpufreq_get_related_cpus(unsigned int cpu)
 {
-        return sysfs_get_freq_related_cpus(cpu);
+        return sysfs_get_cpu_list(cpu, "related_cpus");
 }
 void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *any)
@@ -146,45 +491,208 @@ void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *any)
        cpufreq_put_affected_cpus(any);
 }
+static int verify_gov(char *new_gov, char *passed_gov)
+{
+        unsigned int i, j = 0;
+        if (!passed_gov || (strlen(passed_gov) > 19))
+                return -EINVAL;
+        strncpy(new_gov, passed_gov, 20);
+        for (i = 0; i < 20; i++) {
+                if (j) {
+                        new_gov[i] = '\0';
+                        continue;
+                }
+                if ((new_gov[i] >= 'a') && (new_gov[i] <= 'z'))
+                        continue;
+                if ((new_gov[i] >= 'A') && (new_gov[i] <= 'Z'))
+                        continue;
+                if (new_gov[i] == '-')
+                        continue;
+                if (new_gov[i] == '_')
+                        continue;
+                if (new_gov[i] == '\0') {
+                        j = 1;
+                        continue;
+                }
+                return -EINVAL;
+        }
+        new_gov[19] = '\0';
+        return 0;
+}
 int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy)
 {
+        char min[SYSFS_PATH_MAX];
+        char max[SYSFS_PATH_MAX];
+        char gov[SYSFS_PATH_MAX];
+        int ret;
+        unsigned long old_min;
+        int write_max_first;
        if (!policy || !(policy->governor))
                return -EINVAL;
-        return sysfs_set_freq_policy(cpu, policy);
+        if (policy->max < policy->min)
+                return -EINVAL;
+        if (verify_gov(gov, policy->governor))
+                return -EINVAL;
+        snprintf(min, SYSFS_PATH_MAX, "%lu", policy->min);
+        snprintf(max, SYSFS_PATH_MAX, "%lu", policy->max);
+        old_min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
+        write_max_first = (old_min && (policy->max < old_min) ? 0 : 1);
+        if (write_max_first) {
+                ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
+                                                    max, strlen(max));
+                if (ret)
+                        return ret;
+        }
+        ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ, min,
+                                            strlen(min));
+        if (ret)
+                return ret;
+        if (!write_max_first) {
+                ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
+                                                    max, strlen(max));
+                if (ret)
+                        return ret;
+        }
+        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
+                                             gov, strlen(gov));
 }
 int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq)
 {
-        return sysfs_modify_freq_policy_min(cpu, min_freq);
+        char value[SYSFS_PATH_MAX];
+        snprintf(value, SYSFS_PATH_MAX, "%lu", min_freq);
+        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ,
+                                             value, strlen(value));
 }
 int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq)
 {
-        return sysfs_modify_freq_policy_max(cpu, max_freq);
+        char value[SYSFS_PATH_MAX];
-}
+        snprintf(value, SYSFS_PATH_MAX, "%lu", max_freq);
+        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
+                                             value, strlen(value));
+}
 int cpufreq_modify_policy_governor(unsigned int cpu, char *governor)
 {
+        char new_gov[SYSFS_PATH_MAX];
        if ((!governor) || (strlen(governor) > 19))
                return -EINVAL;
-        return sysfs_modify_freq_policy_governor(cpu, governor);
+        if (verify_gov(new_gov, governor))
+                return -EINVAL;
+        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
+                                             new_gov, strlen(new_gov));
 }
 int cpufreq_set_frequency(unsigned int cpu, unsigned long target_frequency)
 {
-        return sysfs_set_frequency(cpu, target_frequency);
+        struct cpufreq_policy *pol = cpufreq_get_policy(cpu);
+        char userspace_gov[] = "userspace";
+        char freq[SYSFS_PATH_MAX];
+        int ret;
+        if (!pol)
+                return -ENODEV;
+        if (strncmp(pol->governor, userspace_gov, 9) != 0) {
+                ret = cpufreq_modify_policy_governor(cpu, userspace_gov);
+                if (ret) {
+                        cpufreq_put_policy(pol);
+                        return ret;
+                }
+        }
+        cpufreq_put_policy(pol);
+        snprintf(freq, SYSFS_PATH_MAX, "%lu", target_frequency);
+        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
+                                             freq, strlen(freq));
 }
 struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
                                        unsigned long long *total_time)
 {
-        return sysfs_get_freq_stats(cpu, total_time);
+        struct cpufreq_stats *first = NULL;
+        struct cpufreq_stats *current = NULL;
+        char one_value[SYSFS_PATH_MAX];
+        char linebuf[MAX_LINE_LEN];
+        unsigned int pos, i;
+        unsigned int len;
+        len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        *total_time = 0;
+        pos = 0;
+        for (i = 0; i < len; i++) {
+                if (i == strlen(linebuf) || linebuf[i] == '\n') {
+                        if (i - pos < 2)
+                                continue;
+                        if ((i - pos) >= SYSFS_PATH_MAX)
+                                goto error_out;
+                        if (current) {
+                                current->next = malloc(sizeof(*current));
+                                if (!current->next)
+                                        goto error_out;
+                                current = current->next;
+                        } else {
+                                first = malloc(sizeof(*first));
+                                if (!first)
+                                        goto error_out;
+                                current = first;
+                        }
+                        current->first = first;
+                        current->next = NULL;
+                        memcpy(one_value, linebuf + pos, i - pos);
+                        one_value[i - pos] = '\0';
+                        if (sscanf(one_value, "%lu %llu",
+                                        &current->frequency,
+                                        &current->time_in_state) != 2)
+                                goto error_out;
+                        *total_time = *total_time + current->time_in_state;
+                        pos = i + 1;
+                }
+        }
+        return first;
+ error_out:
+        while (first) {
+                current = first->next;
+                free(first);
+                first = current;
+        }
+        return NULL;
 }
 void cpufreq_put_stats(struct cpufreq_stats *any)
@@ -204,5 +712,5 @@ void cpufreq_put_stats(struct cpufreq_stats *any)
 unsigned long cpufreq_get_transitions(unsigned int cpu)
 {
-        return sysfs_get_freq_transitions(cpu);
+        return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);
 }
diff --git a/tools/power/cpupower/lib/cpufreq.h b/tools/power/cpupower/lib/cpufreq.h
index 3aae8e7a0839..3b005c39f068 100644
--- a/tools/power/cpupower/lib/cpufreq.h
+++ b/tools/power/cpupower/lib/cpufreq.h
@@ -17,8 +17,8 @@
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
-#ifndef _CPUFREQ_H
+#ifndef __CPUPOWER_CPUFREQ_H__
-#define _CPUFREQ_H 1
+#define __CPUPOWER_CPUFREQ_H__
 struct cpufreq_policy {
        unsigned long min;
@@ -58,13 +58,6 @@ struct cpufreq_stats {
 extern "C" {
 #endif
-/*
- * returns 0 if the specified CPU is present (it doesn't say
- * whether it is online!), and an error value if not.
- */
-extern int cpufreq_cpu_exists(unsigned int cpu);
 /* determine current CPU frequency
 * - _kernel variant means kernel's opinion of CPU frequency
 * - _hardware variant means actual hardware CPU frequency,
@@ -73,9 +66,9 @@ extern int cpufreq_cpu_exists(unsigned int cpu);
 * returns 0 on failure, else frequency in kHz.
 */
-extern unsigned long cpufreq_get_freq_kernel(unsigned int cpu);
+unsigned long cpufreq_get_freq_kernel(unsigned int cpu);
-extern unsigned long cpufreq_get_freq_hardware(unsigned int cpu);
+unsigned long cpufreq_get_freq_hardware(unsigned int cpu);
 #define cpufreq_get(cpu) cpufreq_get_freq_kernel(cpu);
@@ -84,7 +77,7 @@ extern unsigned long cpufreq_get_freq_hardware(unsigned int cpu);
 *
 * returns 0 on failure, else transition latency in 10^(-9) s = nanoseconds
 */
-extern unsigned long cpufreq_get_transition_latency(unsigned int cpu);
+unsigned long cpufreq_get_transition_latency(unsigned int cpu);
 /* determine hardware CPU frequency limits
@@ -93,7 +86,7 @@ extern unsigned long cpufreq_get_transition_latency(unsigned int cpu);
 * considerations by cpufreq policy notifiers in the kernel.
 */
-extern int cpufreq_get_hardware_limits(unsigned int cpu,
+int cpufreq_get_hardware_limits(unsigned int cpu,
                                unsigned long *min,
                                unsigned long *max);
@@ -104,9 +97,9 @@ extern int cpufreq_get_hardware_limits(unsigned int cpu,
 * to avoid memory leakage, please.
 */
-extern char *cpufreq_get_driver(unsigned int cpu);
+char *cpufreq_get_driver(unsigned int cpu);
-extern void cpufreq_put_driver(char *ptr);
+void cpufreq_put_driver(char *ptr);
 /* determine CPUfreq policy currently used
@@ -116,9 +109,9 @@ extern void cpufreq_put_driver(char *ptr);
 */
-extern struct cpufreq_policy *cpufreq_get_policy(unsigned int cpu);
+struct cpufreq_policy *cpufreq_get_policy(unsigned int cpu);
-extern void cpufreq_put_policy(struct cpufreq_policy *policy);
+void cpufreq_put_policy(struct cpufreq_policy *policy);
 /* determine CPUfreq governors currently available
@@ -129,10 +122,10 @@ extern void cpufreq_put_policy(struct cpufreq_policy *policy);
 */
-extern struct cpufreq_available_governors
+struct cpufreq_available_governors
 *cpufreq_get_available_governors(unsigned int cpu);
-extern void cpufreq_put_available_governors(
+void cpufreq_put_available_governors(
        struct cpufreq_available_governors *first);
@@ -143,10 +136,10 @@ extern void cpufreq_put_available_governors(
 * cpufreq_put_available_frequencies after use.
 */
-extern struct cpufreq_available_frequencies
+struct cpufreq_available_frequencies
 *cpufreq_get_available_frequencies(unsigned int cpu);
-extern void cpufreq_put_available_frequencies(
+void cpufreq_put_available_frequencies(
                struct cpufreq_available_frequencies *first);
@@ -156,10 +149,10 @@ extern void cpufreq_put_available_frequencies(
 * to avoid memory leakage, please.
 */
-extern struct cpufreq_affected_cpus *cpufreq_get_affected_cpus(unsigned
+struct cpufreq_affected_cpus *cpufreq_get_affected_cpus(unsigned
                                                        int cpu);
-extern void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *first);
+void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *first);
 /* determine related CPUs
@@ -168,10 +161,10 @@ extern void cpufreq_put_affected_cpus(struct cpufreq_affected_cpus *first);
 * to avoid memory leakage, please.
 */
-extern struct cpufreq_affected_cpus *cpufreq_get_related_cpus(unsigned
+struct cpufreq_affected_cpus *cpufreq_get_related_cpus(unsigned
                                                        int cpu);
-extern void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *first);
+void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *first);
 /* determine stats for cpufreq subsystem
@@ -179,12 +172,12 @@ extern void cpufreq_put_related_cpus(struct cpufreq_affected_cpus *first);
 * This is not available in all kernel versions or configurations.
 */
-extern struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
+struct cpufreq_stats *cpufreq_get_stats(unsigned int cpu,
                                        unsigned long long *total_time);
-extern void cpufreq_put_stats(struct cpufreq_stats *stats);
+void cpufreq_put_stats(struct cpufreq_stats *stats);
-extern unsigned long cpufreq_get_transitions(unsigned int cpu);
+unsigned long cpufreq_get_transitions(unsigned int cpu);
 /* set new cpufreq policy
@@ -193,7 +186,7 @@ extern unsigned long cpufreq_get_transitions(unsigned int cpu);
 * but results may differ depending e.g. on governors being available.
 */
-extern int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy);
+int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy);
 /* modify a policy by only changing min/max freq or governor
@@ -201,9 +194,9 @@ extern int cpufreq_set_policy(unsigned int cpu, struct cpufreq_policy *policy);
 * Does not check whether result is what was intended.
 */
-extern int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq);
+int cpufreq_modify_policy_min(unsigned int cpu, unsigned long min_freq);
-extern int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq);
+int cpufreq_modify_policy_max(unsigned int cpu, unsigned long max_freq);
-extern int cpufreq_modify_policy_governor(unsigned int cpu, char *governor);
+int cpufreq_modify_policy_governor(unsigned int cpu, char *governor);
 /* set a specific frequency
@@ -213,7 +206,7 @@ extern int cpufreq_modify_policy_governor(unsigned int cpu, char *governor);
 * occurs. Also does not work on ->range() cpufreq drivers.
 */
-extern int cpufreq_set_frequency(unsigned int cpu,
+int cpufreq_set_frequency(unsigned int cpu,
                                unsigned long target_frequency);
 #ifdef __cplusplus
diff --git a/tools/power/cpupower/lib/cpuidle.c b/tools/power/cpupower/lib/cpuidle.c
new file mode 100644
index 000000000000..9bd4c7655fdb
--- /dev/null
+++ b/tools/power/cpupower/lib/cpuidle.c
@@ -0,0 +1,380 @@
+/*
+ *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
+ *  (C) 2011       Thomas Renninger <trenn@novell.com> Novell Inc.
+ *
+ *  Licensed under the terms of the GNU GPL License version 2.
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "cpuidle.h"
+#include "cpupower_intern.h"
+/*
+ * helper function to check whether a file under "../cpuX/cpuidle/stateX/" dir
+ * exists.
+ * For example the functionality to disable c-states was introduced in later
+ * kernel versions, this function can be used to explicitly check for this
+ * feature.
+ *
+ * returns 1 if the file exists, 0 otherwise.
+ */
+static
+unsigned int cpuidle_state_file_exists(unsigned int cpu,
+                                       unsigned int idlestate,
+                                       const char *fname)
+{
+        char path[SYSFS_PATH_MAX];
+        struct stat statbuf;
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpuidle/state%u/%s",
+                 cpu, idlestate, fname);
+        if (stat(path, &statbuf) != 0)
+                return 0;
+        return 1;
+}
+/*
+ * helper function to read file from /sys into given buffer
+ * fname is a relative path under "cpuX/cpuidle/stateX/" dir
+ * cstates starting with 0, C0 is not counted as cstate.
+ * This means if you want C1 info, pass 0 as idlestate param
+ */
+static
+unsigned int cpuidle_state_read_file(unsigned int cpu,
+                                            unsigned int idlestate,
+                                            const char *fname, char *buf,
+                                            size_t buflen)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numread;
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpuidle/state%u/%s",
+                 cpu, idlestate, fname);
+        fd = open(path, O_RDONLY);
+        if (fd == -1)
+                return 0;
+        numread = read(fd, buf, buflen - 1);
+        if (numread < 1) {
+                close(fd);
+                return 0;
+        }
+        buf[numread] = '\0';
+        close(fd);
+        return (unsigned int) numread;
+}
+/*
+ * helper function to write a new value to a /sys file
+ * fname is a relative path under "../cpuX/cpuidle/cstateY/" dir
+ *
+ * Returns the number of bytes written or 0 on error
+ */
+static
+unsigned int cpuidle_state_write_file(unsigned int cpu,
+                                      unsigned int idlestate,
+                                      const char *fname,
+                                      const char *value, size_t len)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numwrite;
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpuidle/state%u/%s",
+                 cpu, idlestate, fname);
+        fd = open(path, O_WRONLY);
+        if (fd == -1)
+                return 0;
+        numwrite = write(fd, value, len);
+        if (numwrite < 1) {
+                close(fd);
+                return 0;
+        }
+        close(fd);
+        return (unsigned int) numwrite;
+}
+/* read access to files which contain one numeric value */
+enum idlestate_value {
+        IDLESTATE_USAGE,
+        IDLESTATE_POWER,
+        IDLESTATE_LATENCY,
+        IDLESTATE_TIME,
+        IDLESTATE_DISABLE,
+        MAX_IDLESTATE_VALUE_FILES
+};
+static const char *idlestate_value_files[MAX_IDLESTATE_VALUE_FILES] = {
+        [IDLESTATE_USAGE] = "usage",
+        [IDLESTATE_POWER] = "power",
+        [IDLESTATE_LATENCY] = "latency",
+        [IDLESTATE_TIME]  = "time",
+        [IDLESTATE_DISABLE]  = "disable",
+};
+static
+unsigned long long cpuidle_state_get_one_value(unsigned int cpu,
+                                               unsigned int idlestate,
+                                               enum idlestate_value which)
+{
+        unsigned long long value;
+        unsigned int len;
+        char linebuf[MAX_LINE_LEN];
+        char *endp;
+        if (which >= MAX_IDLESTATE_VALUE_FILES)
+                return 0;
+        len = cpuidle_state_read_file(cpu, idlestate,
+                                      idlestate_value_files[which],
+                                      linebuf, sizeof(linebuf));
+        if (len == 0)
+                return 0;
+        value = strtoull(linebuf, &endp, 0);
+        if (endp == linebuf || errno == ERANGE)
+                return 0;
+        return value;
+}
+/* read access to files which contain one string */
+enum idlestate_string {
+        IDLESTATE_DESC,
+        IDLESTATE_NAME,
+        MAX_IDLESTATE_STRING_FILES
+};
+static const char *idlestate_string_files[MAX_IDLESTATE_STRING_FILES] = {
+        [IDLESTATE_DESC] = "desc",
+        [IDLESTATE_NAME] = "name",
+};
+static char *cpuidle_state_get_one_string(unsigned int cpu,
+                                        unsigned int idlestate,
+                                        enum idlestate_string which)
+{
+        char linebuf[MAX_LINE_LEN];
+        char *result;
+        unsigned int len;
+        if (which >= MAX_IDLESTATE_STRING_FILES)
+                return NULL;
+        len = cpuidle_state_read_file(cpu, idlestate,
+                                      idlestate_string_files[which],
+                                      linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        result = strdup(linebuf);
+        if (result == NULL)
+                return NULL;
+        if (result[strlen(result) - 1] == '\n')
+                result[strlen(result) - 1] = '\0';
+        return result;
+}
+/*
+ * Returns:
+ *    1  if disabled
+ *    0  if enabled
+ *    -1 if idlestate is not available
+ *    -2 if disabling is not supported by the kernel
+ */
+int cpuidle_is_state_disabled(unsigned int cpu,
+                                unsigned int idlestate)
+{
+        if (cpuidle_state_count(cpu) <= idlestate)
+                return -1;
+        if (!cpuidle_state_file_exists(cpu, idlestate,
+                                 idlestate_value_files[IDLESTATE_DISABLE]))
+                return -2;
+        return cpuidle_state_get_one_value(cpu, idlestate, IDLESTATE_DISABLE);
+}
+/*
+ * Pass 1 as last argument to disable or 0 to enable the state
+ * Returns:
+ *    0  on success
+ *    negative values on error, for example:
+ *      -1 if idlestate is not available
+ *      -2 if disabling is not supported by the kernel
+ *      -3 No write access to disable/enable C-states
+ */
+int cpuidle_state_disable(unsigned int cpu,
+                            unsigned int idlestate,
+                            unsigned int disable)
+{
+        char value[SYSFS_PATH_MAX];
+        int bytes_written;
+        if (cpuidle_state_count(cpu) <= idlestate)
+                return -1;
+        if (!cpuidle_state_file_exists(cpu, idlestate,
+                                 idlestate_value_files[IDLESTATE_DISABLE]))
+                return -2;
+        snprintf(value, SYSFS_PATH_MAX, "%u", disable);
+        bytes_written = cpuidle_state_write_file(cpu, idlestate, "disable",
+                                                   value, sizeof(disable));
+        if (bytes_written)
+                return 0;
+        return -3;
+}
+unsigned long cpuidle_state_latency(unsigned int cpu,
+                                          unsigned int idlestate)
+{
+        return cpuidle_state_get_one_value(cpu, idlestate, IDLESTATE_LATENCY);
+}
+unsigned long cpuidle_state_usage(unsigned int cpu,
+                                        unsigned int idlestate)
+{
+        return cpuidle_state_get_one_value(cpu, idlestate, IDLESTATE_USAGE);
+}
+unsigned long long cpuidle_state_time(unsigned int cpu,
+                                        unsigned int idlestate)
+{
+        return cpuidle_state_get_one_value(cpu, idlestate, IDLESTATE_TIME);
+}
+char *cpuidle_state_name(unsigned int cpu, unsigned int idlestate)
+{
+        return cpuidle_state_get_one_string(cpu, idlestate, IDLESTATE_NAME);
+}
+char *cpuidle_state_desc(unsigned int cpu, unsigned int idlestate)
+{
+        return cpuidle_state_get_one_string(cpu, idlestate, IDLESTATE_DESC);
+}
+/*
+ * Returns number of supported C-states of CPU core cpu
+ * Negativ in error case
+ * Zero if cpuidle does not export any C-states
+ */
+unsigned int cpuidle_state_count(unsigned int cpu)
+{
+        char file[SYSFS_PATH_MAX];
+        struct stat statbuf;
+        int idlestates = 1;
+        snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpuidle");
+        if (stat(file, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode))
+                return 0;
+        snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpu%u/cpuidle/state0", cpu);
+        if (stat(file, &statbuf) != 0 || !S_ISDIR(statbuf.st_mode))
+                return 0;
+        while (stat(file, &statbuf) == 0 && S_ISDIR(statbuf.st_mode)) {
+                snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU
+                         "cpu%u/cpuidle/state%d", cpu, idlestates);
+                idlestates++;
+        }
+        idlestates--;
+        return idlestates;
+}
+/* CPUidle general /sys/devices/system/cpu/cpuidle/ sysfs access ********/
+/*
+ * helper function to read file from /sys into given buffer
+ * fname is a relative path under "cpu/cpuidle/" dir
+ */
+static unsigned int sysfs_cpuidle_read_file(const char *fname, char *buf,
+                                            size_t buflen)
+{
+        char path[SYSFS_PATH_MAX];
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpuidle/%s", fname);
+        return sysfs_read_file(path, buf, buflen);
+}
+/* read access to files which contain one string */
+enum cpuidle_string {
+        CPUIDLE_GOVERNOR,
+        CPUIDLE_GOVERNOR_RO,
+        CPUIDLE_DRIVER,
+        MAX_CPUIDLE_STRING_FILES
+};
+static const char *cpuidle_string_files[MAX_CPUIDLE_STRING_FILES] = {
+        [CPUIDLE_GOVERNOR]      = "current_governor",
+        [CPUIDLE_GOVERNOR_RO]   = "current_governor_ro",
+        [CPUIDLE_DRIVER]        = "current_driver",
+};
+static char *sysfs_cpuidle_get_one_string(enum cpuidle_string which)
+{
+        char linebuf[MAX_LINE_LEN];
+        char *result;
+        unsigned int len;
+        if (which >= MAX_CPUIDLE_STRING_FILES)
+                return NULL;
+        len = sysfs_cpuidle_read_file(cpuidle_string_files[which],
+                                linebuf, sizeof(linebuf));
+        if (len == 0)
+                return NULL;
+        result = strdup(linebuf);
+        if (result == NULL)
+                return NULL;
+        if (result[strlen(result) - 1] == '\n')
+                result[strlen(result) - 1] = '\0';
+        return result;
+}
+char *cpuidle_get_governor(void)
+{
+        char *tmp = sysfs_cpuidle_get_one_string(CPUIDLE_GOVERNOR_RO);
+        if (!tmp)
+                return sysfs_cpuidle_get_one_string(CPUIDLE_GOVERNOR);
+        else
+                return tmp;
+}
+char *cpuidle_get_driver(void)
+{
+        return sysfs_cpuidle_get_one_string(CPUIDLE_DRIVER);
+}
+/* CPUidle idlestate specific /sys/devices/system/cpu/cpuX/cpuidle/ access */
diff --git a/tools/power/cpupower/lib/cpuidle.h b/tools/power/cpupower/lib/cpuidle.h
new file mode 100644
index 000000000000..04eb3cfa6e42
--- /dev/null
+++ b/tools/power/cpupower/lib/cpuidle.h
@@ -0,0 +1,23 @@
+#ifndef __CPUPOWER_CPUIDLE_H__
+#define __CPUPOWER_CPUIDLE_H__
+int cpuidle_is_state_disabled(unsigned int cpu,
+                                       unsigned int idlestate);
+int cpuidle_state_disable(unsigned int cpu, unsigned int idlestate,
+                                   unsigned int disable);
+unsigned long cpuidle_state_latency(unsigned int cpu,
+                                                unsigned int idlestate);
+unsigned long cpuidle_state_usage(unsigned int cpu,
+                                        unsigned int idlestate);
+unsigned long long cpuidle_state_time(unsigned int cpu,
+                                                unsigned int idlestate);
+char *cpuidle_state_name(unsigned int cpu,
+                                unsigned int idlestate);
+char *cpuidle_state_desc(unsigned int cpu,
+                                unsigned int idlestate);
+unsigned int cpuidle_state_count(unsigned int cpu);
+char *cpuidle_get_governor(void);
+char *cpuidle_get_driver(void);
+#endif /* __CPUPOWER_HELPERS_SYSFS_H__ */
diff --git a/tools/power/cpupower/lib/cpupower.c b/tools/power/cpupower/lib/cpupower.c
new file mode 100644
index 000000000000..9c395ec924de
--- /dev/null
+++ b/tools/power/cpupower/lib/cpupower.c
@@ -0,0 +1,192 @@
+/*
+ *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
+ *
+ *  Licensed under the terms of the GNU GPL License version 2.
+ */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include "cpupower.h"
+#include "cpupower_intern.h"
+unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen)
+{
+        int fd;
+        ssize_t numread;
+        fd = open(path, O_RDONLY);
+        if (fd == -1)
+                return 0;
+        numread = read(fd, buf, buflen - 1);
+        if (numread < 1) {
+                close(fd);
+                return 0;
+        }
+        buf[numread] = '\0';
+        close(fd);
+        return (unsigned int) numread;
+}
+/*
+ * Detect whether a CPU is online
+ *
+ * Returns:
+ *     1 -> if CPU is online
+ *     0 -> if CPU is offline
+ *     negative errno values in error case
+ */
+int cpupower_is_cpu_online(unsigned int cpu)
+{
+        char path[SYSFS_PATH_MAX];
+        int fd;
+        ssize_t numread;
+        unsigned long long value;
+        char linebuf[MAX_LINE_LEN];
+        char *endp;
+        struct stat statbuf;
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u", cpu);
+        if (stat(path, &statbuf) != 0)
+                return 0;
+        /*
+         * kernel without CONFIG_HOTPLUG_CPU
+         * -> cpuX directory exists, but not cpuX/online file
+         */
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/online", cpu);
+        if (stat(path, &statbuf) != 0)
+                return 1;
+        fd = open(path, O_RDONLY);
+        if (fd == -1)
+                return -errno;
+        numread = read(fd, linebuf, MAX_LINE_LEN - 1);
+        if (numread < 1) {
+                close(fd);
+                return -EIO;
+        }
+        linebuf[numread] = '\0';
+        close(fd);
+        value = strtoull(linebuf, &endp, 0);
+        if (value > 1)
+                return -EINVAL;
+        return value;
+}
+/* returns -1 on failure, 0 on success */
+static int sysfs_topology_read_file(unsigned int cpu, const char *fname, int *result)
+{
+        char linebuf[MAX_LINE_LEN];
+        char *endp;
+        char path[SYSFS_PATH_MAX];
+        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/topology/%s",
+                         cpu, fname);
+        if (sysfs_read_file(path, linebuf, MAX_LINE_LEN) == 0)
+                return -1;
+        *result = strtol(linebuf, &endp, 0);
+        if (endp == linebuf || errno == ERANGE)
+                return -1;
+        return 0;
+}
+static int __compare(const void *t1, const void *t2)
+{
+        struct cpuid_core_info *top1 = (struct cpuid_core_info *)t1;
+        struct cpuid_core_info *top2 = (struct cpuid_core_info *)t2;
+        if (top1->pkg < top2->pkg)
+                return -1;
+        else if (top1->pkg > top2->pkg)
+                return 1;
+        else if (top1->core < top2->core)
+                return -1;
+        else if (top1->core > top2->core)
+                return 1;
+        else if (top1->cpu < top2->cpu)
+                return -1;
+        else if (top1->cpu > top2->cpu)
+                return 1;
+        else
+                return 0;
+}
+/*
+ * Returns amount of cpus, negative on error, cpu_top must be
+ * passed to cpu_topology_release to free resources
+ *
+ * Array is sorted after ->pkg, ->core, then ->cpu
+ */
+int get_cpu_topology(struct cpupower_topology *cpu_top)
+{
+        int cpu, last_pkg, cpus = sysconf(_SC_NPROCESSORS_CONF);
+        cpu_top->core_info = malloc(sizeof(struct cpuid_core_info) * cpus);
+        if (cpu_top->core_info == NULL)
+                return -ENOMEM;
+        cpu_top->pkgs = cpu_top->cores = 0;
+        for (cpu = 0; cpu < cpus; cpu++) {
+                cpu_top->core_info[cpu].cpu = cpu;
+                cpu_top->core_info[cpu].is_online = cpupower_is_cpu_online(cpu);
+                if(sysfs_topology_read_file(
+                        cpu,
+                        "physical_package_id",
+                        &(cpu_top->core_info[cpu].pkg)) < 0) {
+                        cpu_top->core_info[cpu].pkg = -1;
+                        cpu_top->core_info[cpu].core = -1;
+                        continue;
+                }
+                if(sysfs_topology_read_file(
+                        cpu,
+                        "core_id",
+                        &(cpu_top->core_info[cpu].core)) < 0) {
+                        cpu_top->core_info[cpu].pkg = -1;
+                        cpu_top->core_info[cpu].core = -1;
+                        continue;
+                }
+        }
+        qsort(cpu_top->core_info, cpus, sizeof(struct cpuid_core_info),
+              __compare);
+        /* Count the number of distinct pkgs values. This works
+           because the primary sort of the core_info struct was just
+           done by pkg value. */
+        last_pkg = cpu_top->core_info[0].pkg;
+        for(cpu = 1; cpu < cpus; cpu++) {
+                if (cpu_top->core_info[cpu].pkg != last_pkg &&
+                                cpu_top->core_info[cpu].pkg != -1) {
+                        last_pkg = cpu_top->core_info[cpu].pkg;
+                        cpu_top->pkgs++;
+                }
+        }
+        if (!(cpu_top->core_info[0].pkg == -1))
+                cpu_top->pkgs++;
+        /* Intel's cores count is not consecutively numbered, there may
+         * be a core_id of 3, but none of 2. Assume there always is 0
+         * Get amount of cores by counting duplicates in a package
+        for (cpu = 0; cpu_top->core_info[cpu].pkg = 0 && cpu < cpus; cpu++) {
+                if (cpu_top->core_info[cpu].core == 0)
+        cpu_top->cores++;
+        */
+        return cpus;
+}
+void cpu_topology_release(struct cpupower_topology cpu_top)
+{
+        free(cpu_top.core_info);
+}
diff --git a/tools/power/cpupower/lib/cpupower.h b/tools/power/cpupower/lib/cpupower.h
new file mode 100644
index 000000000000..fa031fcc7710
--- /dev/null
+++ b/tools/power/cpupower/lib/cpupower.h
@@ -0,0 +1,35 @@
+#ifndef __CPUPOWER_CPUPOWER_H__
+#define __CPUPOWER_CPUPOWER_H__
+struct cpupower_topology {
+        /* Amount of CPU cores, packages and threads per core in the system */
+        unsigned int cores;
+        unsigned int pkgs;
+        unsigned int threads; /* per core */
+        /* Array gets mallocated with cores entries, holding per core info */
+        struct cpuid_core_info *core_info;
+};
+struct cpuid_core_info {
+        int pkg;
+        int core;
+        int cpu;
+        /* flags */
+        unsigned int is_online:1;
+};
+#ifdef __cplusplus
+extern "C" {
+#endif
+int get_cpu_topology(struct cpupower_topology *cpu_top);
+void cpu_topology_release(struct cpupower_topology cpu_top);
+int cpupower_is_cpu_online(unsigned int cpu);
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/tools/power/cpupower/lib/cpupower_intern.h b/tools/power/cpupower/lib/cpupower_intern.h
new file mode 100644
index 000000000000..f8ec4009621c
--- /dev/null
+++ b/tools/power/cpupower/lib/cpupower_intern.h
@@ -0,0 +1,5 @@
+#define PATH_TO_CPU "/sys/devices/system/cpu/"
+#define MAX_LINE_LEN 4096
+#define SYSFS_PATH_MAX 255
+unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen);
diff --git a/tools/power/cpupower/lib/sysfs.c b/tools/power/cpupower/lib/sysfs.c
deleted file mode 100644
index 870713a75a81..000000000000
--- a/tools/power/cpupower/lib/sysfs.c
+++ /dev/null
@@ -1,672 +0,0 @@
-/*
- *  (C) 2004-2009  Dominik Brodowski <linux@dominikbrodowski.de>
- *
- *  Licensed under the terms of the GNU GPL License version 2.
- */
-#include <stdio.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <limits.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include "cpufreq.h"
-#define PATH_TO_CPU "/sys/devices/system/cpu/"
-#define MAX_LINE_LEN 4096
-#define SYSFS_PATH_MAX 255
-static unsigned int sysfs_read_file(const char *path, char *buf, size_t buflen)
-{
-        int fd;
-        ssize_t numread;
-        fd = open(path, O_RDONLY);
-        if (fd == -1)
-                return 0;
-        numread = read(fd, buf, buflen - 1);
-        if (numread < 1) {
-                close(fd);
-                return 0;
-        }
-        buf[numread] = '\0';
-        close(fd);
-        return (unsigned int) numread;
-}
-/* CPUFREQ sysfs access **************************************************/
-/* helper function to read file from /sys into given buffer */
-/* fname is a relative path under "cpuX/cpufreq" dir */
-static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname,
-                                            char *buf, size_t buflen)
-{
-        char path[SYSFS_PATH_MAX];
-        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
-                         cpu, fname);
-        return sysfs_read_file(path, buf, buflen);
-}
-/* helper function to write a new value to a /sys file */
-/* fname is a relative path under "cpuX/cpufreq" dir */
-static unsigned int sysfs_cpufreq_write_file(unsigned int cpu,
-                                             const char *fname,
-                                             const char *value, size_t len)
-{
-        char path[SYSFS_PATH_MAX];
-        int fd;
-        ssize_t numwrite;
-        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
-                         cpu, fname);
-        fd = open(path, O_WRONLY);
-        if (fd == -1)
-                return 0;
-        numwrite = write(fd, value, len);
-        if (numwrite < 1) {
-                close(fd);
-                return 0;
-        }
-        close(fd);
-        return (unsigned int) numwrite;
-}
-/* read access to files which contain one numeric value */
-enum cpufreq_value {
-        CPUINFO_CUR_FREQ,
-        CPUINFO_MIN_FREQ,
-        CPUINFO_MAX_FREQ,
-        CPUINFO_LATENCY,
-        SCALING_CUR_FREQ,
-        SCALING_MIN_FREQ,
-        SCALING_MAX_FREQ,
-        STATS_NUM_TRANSITIONS,
-        MAX_CPUFREQ_VALUE_READ_FILES
-};
-static const char *cpufreq_value_files[MAX_CPUFREQ_VALUE_READ_FILES] = {
-        [CPUINFO_CUR_FREQ] = "cpuinfo_cur_freq",
-        [CPUINFO_MIN_FREQ] = "cpuinfo_min_freq",
-        [CPUINFO_MAX_FREQ] = "cpuinfo_max_freq",
-        [CPUINFO_LATENCY]  = "cpuinfo_transition_latency",
-        [SCALING_CUR_FREQ] = "scaling_cur_freq",
-        [SCALING_MIN_FREQ] = "scaling_min_freq",
-        [SCALING_MAX_FREQ] = "scaling_max_freq",
-        [STATS_NUM_TRANSITIONS] = "stats/total_trans"
-};
-static unsigned long sysfs_cpufreq_get_one_value(unsigned int cpu,
-                                                 enum cpufreq_value which)
-{
-        unsigned long value;
-        unsigned int len;
-        char linebuf[MAX_LINE_LEN];
-        char *endp;
-        if (which >= MAX_CPUFREQ_VALUE_READ_FILES)
-                return 0;
-        len = sysfs_cpufreq_read_file(cpu, cpufreq_value_files[which],
-                                linebuf, sizeof(linebuf));
-        if (len == 0)
-                return 0;
-        value = strtoul(linebuf, &endp, 0);
-        if (endp == linebuf || errno == ERANGE)
-                return 0;
-        return value;
-}
-/* read access to files which contain one string */
-enum cpufreq_string {
-        SCALING_DRIVER,
-        SCALING_GOVERNOR,
-        MAX_CPUFREQ_STRING_FILES
-};
-static const char *cpufreq_string_files[MAX_CPUFREQ_STRING_FILES] = {
-        [SCALING_DRIVER] = "scaling_driver",
-        [SCALING_GOVERNOR] = "scaling_governor",
-};
-static char *sysfs_cpufreq_get_one_string(unsigned int cpu,
-                                           enum cpufreq_string which)
-{
-        char linebuf[MAX_LINE_LEN];
-        char *result;
-        unsigned int len;
-        if (which >= MAX_CPUFREQ_STRING_FILES)
-                return NULL;
-        len = sysfs_cpufreq_read_file(cpu, cpufreq_string_files[which],
-                                linebuf, sizeof(linebuf));
-        if (len == 0)
-                return NULL;
-        result = strdup(linebuf);
-        if (result == NULL)
-                return NULL;
-        if (result[strlen(result) - 1] == '\n')
-                result[strlen(result) - 1] = '\0';
-        return result;
-}
-/* write access */
-enum cpufreq_write {
-        WRITE_SCALING_MIN_FREQ,
-        WRITE_SCALING_MAX_FREQ,
-        WRITE_SCALING_GOVERNOR,
-        WRITE_SCALING_SET_SPEED,
-        MAX_CPUFREQ_WRITE_FILES
-};
-static const char *cpufreq_write_files[MAX_CPUFREQ_WRITE_FILES] = {
-        [WRITE_SCALING_MIN_FREQ] = "scaling_min_freq",
-        [WRITE_SCALING_MAX_FREQ] = "scaling_max_freq",
-        [WRITE_SCALING_GOVERNOR] = "scaling_governor",
-        [WRITE_SCALING_SET_SPEED] = "scaling_setspeed",
-};
-static int sysfs_cpufreq_write_one_value(unsigned int cpu,
-                                         enum cpufreq_write which,
-                                         const char *new_value, size_t len)
-{
-        if (which >= MAX_CPUFREQ_WRITE_FILES)
-                return 0;
-        if (sysfs_cpufreq_write_file(cpu, cpufreq_write_files[which],
-                                        new_value, len) != len)
-                return -ENODEV;
-        return 0;
-};
-unsigned long sysfs_get_freq_kernel(unsigned int cpu)
-{
-        return sysfs_cpufreq_get_one_value(cpu, SCALING_CUR_FREQ);
-}
-unsigned long sysfs_get_freq_hardware(unsigned int cpu)
-{
-        return sysfs_cpufreq_get_one_value(cpu, CPUINFO_CUR_FREQ);
-}
-unsigned long sysfs_get_freq_transition_latency(unsigned int cpu)
-{
-        return sysfs_cpufreq_get_one_value(cpu, CPUINFO_LATENCY);
-}
-int sysfs_get_freq_hardware_limits(unsigned int cpu,
-                              unsigned long *min,
-                              unsigned long *max)
-{
-        if ((!min) || (!max))
-                return -EINVAL;
-        *min = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MIN_FREQ);
-        if (!*min)
-                return -ENODEV;
-        *max = sysfs_cpufreq_get_one_value(cpu, CPUINFO_MAX_FREQ);
-        if (!*max)
-                return -ENODEV;
-        return 0;
-}
-char *sysfs_get_freq_driver(unsigned int cpu)
-{
-        return sysfs_cpufreq_get_one_string(cpu, SCALING_DRIVER);
-}
-struct cpufreq_policy *sysfs_get_freq_policy(unsigned int cpu)
-{
-        struct cpufreq_policy *policy;
-        policy = malloc(sizeof(struct cpufreq_policy));
-        if (!policy)
-                return NULL;
-        policy->governor = sysfs_cpufreq_get_one_string(cpu, SCALING_GOVERNOR);
-        if (!policy->governor) {
-                free(policy);
-                return NULL;
-        }
-        policy->min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
-        policy->max = sysfs_cpufreq_get_one_value(cpu, SCALING_MAX_FREQ);
-        if ((!policy->min) || (!policy->max)) {
-                free(policy->governor);
-                free(policy);
-                return NULL;
-        }
-        return policy;
-}
-struct cpufreq_available_governors *
-sysfs_get_freq_available_governors(unsigned int cpu) {
-        struct cpufreq_available_governors *first = NULL;
-        struct cpufreq_available_governors *current = NULL;
-        char linebuf[MAX_LINE_LEN];
-        unsigned int pos, i;
-        unsigned int len;
-        len = sysfs_cpufreq_read_file(cpu, "scaling_available_governors",
-                                linebuf, sizeof(linebuf));
-        if (len == 0)
-                return NULL;
-        pos = 0;
-        for (i = 0; i < len; i++) {
-                if (linebuf[i] == ' ' || linebuf[i] == '\n') {
-                        if (i - pos < 2)
-                                continue;
-                        if (current) {
-                                current->next = malloc(sizeof(*current));
-                                if (!current->next)
-                                        goto error_out;
-                                current = current->next;
-                        } else {
-                                first = malloc(sizeof(*first));
-                                if (!first)
-                                        goto error_out;
-                                current = first;
-                        }
-                        current->first = first;
-                        current->next = NULL;
-                        current->governor = malloc(i - pos + 1);
-                        if (!current->governor)
-                                goto error_out;
-                        memcpy(current->governor, linebuf + pos, i - pos);
-                        current->governor[i - pos] = '\0';
-                        pos = i + 1;
-                }
-        }
-        return first;
- error_out:
-        while (first) {
-                current = first->next;
-                if (first->governor)
-                        free(first->governor);
-                free(first);
-                first = current;
-        }
-        return NULL;
-}
-struct cpufreq_available_frequencies *
-sysfs_get_available_frequencies(unsigned int cpu) {
-        struct cpufreq_available_frequencies *first = NULL;
-        struct cpufreq_available_frequencies *current = NULL;
-        char one_value[SYSFS_PATH_MAX];
-        char linebuf[MAX_LINE_LEN];
-        unsigned int pos, i;
-        unsigned int len;
-        len = sysfs_cpufreq_read_file(cpu, "scaling_available_frequencies",
-                                linebuf, sizeof(linebuf));
-        if (len == 0)
-                return NULL;
-        pos = 0;
-        for (i = 0; i < len; i++) {
-                if (linebuf[i] == ' ' || linebuf[i] == '\n') {
-                        if (i - pos < 2)
-                                continue;
-                        if (i - pos >= SYSFS_PATH_MAX)
-                                goto error_out;
-                        if (current) {
-                                current->next = malloc(sizeof(*current));
-                                if (!current->next)
-                                        goto error_out;
-                                current = current->next;
-                        } else {
-                                first = malloc(sizeof(*first));
-                                if (!first)
-                                        goto error_out;
-                                current = first;
-                        }
-                        current->first = first;
-                        current->next = NULL;
-                        memcpy(one_value, linebuf + pos, i - pos);
-                        one_value[i - pos] = '\0';
-                        if (sscanf(one_value, "%lu", &current->frequency) != 1)
-                                goto error_out;
-                        pos = i + 1;
-                }
-        }
-        return first;
- error_out:
-        while (first) {
-                current = first->next;
-                free(first);
-                first = current;
-        }
-        return NULL;
-}
-static struct cpufreq_affected_cpus *sysfs_get_cpu_list(unsigned int cpu,
-                                                        const char *file)
-{
-        struct cpufreq_affected_cpus *first = NULL;
-        struct cpufreq_affected_cpus *current = NULL;
-        char one_value[SYSFS_PATH_MAX];
-        char linebuf[MAX_LINE_LEN];
-        unsigned int pos, i;
-        unsigned int len;
-        len = sysfs_cpufreq_read_file(cpu, file, linebuf, sizeof(linebuf));
-        if (len == 0)
-                return NULL;
-        pos = 0;
-        for (i = 0; i < len; i++) {
-                if (i == len || linebuf[i] == ' ' || linebuf[i] == '\n') {
-                        if (i - pos  < 1)
-                                continue;
-                        if (i - pos >= SYSFS_PATH_MAX)
-                                goto error_out;
-                        if (current) {
-                                current->next = malloc(sizeof(*current));
-                                if (!current->next)
-                                        goto error_out;
-                                current = current->next;
-                        } else {
-                                first = malloc(sizeof(*first));
-                                if (!first)
-                                        goto error_out;
-                                current = first;
-                        }
-                        current->first = first;
-                        current->next = NULL;
-                        memcpy(one_value, linebuf + pos, i - pos);
-                        one_value[i - pos] = '\0';
-                        if (sscanf(one_value, "%u", &current->cpu) != 1)
-                                goto error_out;
-                        pos = i + 1;
-                }
-        }
-        return first;
- error_out:
-        while (first) {
-                current = first->next;
-                free(first);
-                first = current;
-        }
-        return NULL;
-}
-struct cpufreq_affected_cpus *sysfs_get_freq_affected_cpus(unsigned int cpu)
-{
-        return sysfs_get_cpu_list(cpu, "affected_cpus");
-}
-struct cpufreq_affected_cpus *sysfs_get_freq_related_cpus(unsigned int cpu)
-{
-        return sysfs_get_cpu_list(cpu, "related_cpus");
-}
-struct cpufreq_stats *sysfs_get_freq_stats(unsigned int cpu,
-                                        unsigned long long *total_time) {
-        struct cpufreq_stats *first = NULL;
-        struct cpufreq_stats *current = NULL;
-        char one_value[SYSFS_PATH_MAX];
-        char linebuf[MAX_LINE_LEN];
-        unsigned int pos, i;
-        unsigned int len;
-        len = sysfs_cpufreq_read_file(cpu, "stats/time_in_state",
-                                linebuf, sizeof(linebuf));
-        if (len == 0)
-                return NULL;
-        *total_time = 0;
-        pos = 0;
-        for (i = 0; i < len; i++) {
-                if (i == strlen(linebuf) || linebuf[i] == '\n') {
-                        if (i - pos < 2)
-                                continue;
-                        if ((i - pos) >= SYSFS_PATH_MAX)
-                                goto error_out;
-                        if (current) {
-                                current->next = malloc(sizeof(*current));
-                                if (!current->next)
-                                        goto error_out;
-                                current = current->next;
-                        } else {
-                                first = malloc(sizeof(*first));
-                                if (!first)
-                                        goto error_out;
-                                current = first;
-                        }
-                        current->first = first;
-                        current->next = NULL;
-                        memcpy(one_value, linebuf + pos, i - pos);
-                        one_value[i - pos] = '\0';
-                        if (sscanf(one_value, "%lu %llu",
-                                        &current->frequency,
-                                        &current->time_in_state) != 2)
-                                goto error_out;
-                        *total_time = *total_time + current->time_in_state;
-                        pos = i + 1;
-                }
-        }
-        return first;
- error_out:
-        while (first) {
-                current = first->next;
-                free(first);
-                first = current;
-        }
-        return NULL;
-}
-unsigned long sysfs_get_freq_transitions(unsigned int cpu)
-{
-        return sysfs_cpufreq_get_one_value(cpu, STATS_NUM_TRANSITIONS);
-}
-static int verify_gov(char *new_gov, char *passed_gov)
-{
-        unsigned int i, j = 0;
-        if (!passed_gov || (strlen(passed_gov) > 19))
-                return -EINVAL;
-        strncpy(new_gov, passed_gov, 20);
-        for (i = 0; i < 20; i++) {
-                if (j) {
-                        new_gov[i] = '\0';
-                        continue;
-                }
-                if ((new_gov[i] >= 'a') && (new_gov[i] <= 'z'))
-                        continue;
-                if ((new_gov[i] >= 'A') && (new_gov[i] <= 'Z'))
-                        continue;
-                if (new_gov[i] == '-')
-                        continue;
-                if (new_gov[i] == '_')
-                        continue;
-                if (new_gov[i] == '\0') {
-                        j = 1;
-                        continue;
-                }
-                return -EINVAL;
-        }
-        new_gov[19] = '\0';
-        return 0;
-}
-int sysfs_modify_freq_policy_governor(unsigned int cpu, char *governor)
-{
-        char new_gov[SYSFS_PATH_MAX];
-        if (!governor)
-                return -EINVAL;
-        if (verify_gov(new_gov, governor))
-                return -EINVAL;
-        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
-                                             new_gov, strlen(new_gov));
-};
-int sysfs_modify_freq_policy_max(unsigned int cpu, unsigned long max_freq)
-{
-        char value[SYSFS_PATH_MAX];
-        snprintf(value, SYSFS_PATH_MAX, "%lu", max_freq);
-        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
-                                             value, strlen(value));
-};
-int sysfs_modify_freq_policy_min(unsigned int cpu, unsigned long min_freq)
-{
-        char value[SYSFS_PATH_MAX];
-        snprintf(value, SYSFS_PATH_MAX, "%lu", min_freq);
-        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ,
-                                             value, strlen(value));
-};
-int sysfs_set_freq_policy(unsigned int cpu, struct cpufreq_policy *policy)
-{
-        char min[SYSFS_PATH_MAX];
-        char max[SYSFS_PATH_MAX];
-        char gov[SYSFS_PATH_MAX];
-        int ret;
-        unsigned long old_min;
-        int write_max_first;
-        if (!policy || !(policy->governor))
-                return -EINVAL;
-        if (policy->max < policy->min)
-                return -EINVAL;
-        if (verify_gov(gov, policy->governor))
-                return -EINVAL;
-        snprintf(min, SYSFS_PATH_MAX, "%lu", policy->min);
-        snprintf(max, SYSFS_PATH_MAX, "%lu", policy->max);
-        old_min = sysfs_cpufreq_get_one_value(cpu, SCALING_MIN_FREQ);
-        write_max_first = (old_min && (policy->max < old_min) ? 0 : 1);
-        if (write_max_first) {
-                ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
-                                                    max, strlen(max));
-                if (ret)
-                        return ret;
-        }
-        ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MIN_FREQ, min,
-                                            strlen(min));
-        if (ret)
-                return ret;
-        if (!write_max_first) {
-                ret = sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_MAX_FREQ,
-                                                    max, strlen(max));
-                if (ret)
-                        return ret;
-        }
-        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_GOVERNOR,
-                                             gov, strlen(gov));
-}
-int sysfs_set_frequency(unsigned int cpu, unsigned long target_frequency)
-{
-        struct cpufreq_policy *pol = sysfs_get_freq_policy(cpu);
-        char userspace_gov[] = "userspace";
-        char freq[SYSFS_PATH_MAX];
-        int ret;
-        if (!pol)
-                return -ENODEV;
-        if (strncmp(pol->governor, userspace_gov, 9) != 0) {
-                ret = sysfs_modify_freq_policy_governor(cpu, userspace_gov);
-                if (ret) {
-                        cpufreq_put_policy(pol);
-                        return ret;
-                }
-        }
-        cpufreq_put_policy(pol);
-        snprintf(freq, SYSFS_PATH_MAX, "%lu", target_frequency);
-        return sysfs_cpufreq_write_one_value(cpu, WRITE_SCALING_SET_SPEED,
-                                             freq, strlen(freq));
-}
-/* CPUFREQ sysfs access **************************************************/
-/* General sysfs access **************************************************/
-int sysfs_cpu_exists(unsigned int cpu)
-{
-        char file[SYSFS_PATH_MAX];
-        struct stat statbuf;
-        snprintf(file, SYSFS_PATH_MAX, PATH_TO_CPU "cpu%u/", cpu);
-        if (stat(file, &statbuf) != 0)
-                return -ENOSYS;
-        return S_ISDIR(statbuf.st_mode) ? 0 : -ENOSYS;
-}
-/* General sysfs access **************************************************/
diff --git a/tools/power/cpupower/lib/sysfs.h b/tools/power/cpupower/lib/sysfs.h
deleted file mode 100644
index c76a5e0af501..000000000000
--- a/tools/power/cpupower/lib/sysfs.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* General */
-extern unsigned int sysfs_cpu_exists(unsigned int cpu);
-/* CPUfreq */
-extern unsigned long sysfs_get_freq_kernel(unsigned int cpu);
-extern unsigned long sysfs_get_freq_hardware(unsigned int cpu);
-extern unsigned long sysfs_get_freq_transition_latency(unsigned int cpu);
-extern int sysfs_get_freq_hardware_limits(unsigned int cpu,
-                                        unsigned long *min, unsigned long *max);
-extern char *sysfs_get_freq_driver(unsigned int cpu);
-extern struct cpufreq_policy *sysfs_get_freq_policy(unsigned int cpu);
-extern struct cpufreq_available_governors *sysfs_get_freq_available_governors(
-        unsigned int cpu);
-extern struct cpufreq_available_frequencies *sysfs_get_available_frequencies(
-        unsigned int cpu);
-extern struct cpufreq_affected_cpus *sysfs_get_freq_affected_cpus(
-        unsigned int cpu);
-extern struct cpufreq_affected_cpus *sysfs_get_freq_related_cpus(
-        unsigned int cpu);
-extern struct cpufreq_stats *sysfs_get_freq_stats(unsigned int cpu,
-                                                unsigned long long *total_time);
-extern unsigned long sysfs_get_freq_transitions(unsigned int cpu);
-extern int sysfs_set_freq_policy(unsigned int cpu,
-                                struct cpufreq_policy *policy);
-extern int sysfs_modify_freq_policy_min(unsigned int cpu,
-                                        unsigned long min_freq);
-extern int sysfs_modify_freq_policy_max(unsigned int cpu,
-                                        unsigned long max_freq);
-extern int sysfs_modify_freq_policy_governor(unsigned int cpu, char *governor);
-extern int sysfs_set_frequency(unsigned int cpu,
-                        unsigned long target_frequency);
diff --git a/tools/power/cpupower/man/cpupower-frequency-info.1 b/tools/power/cpupower/man/cpupower-frequency-info.1
index 9c85a382e355..6aa8d239dff9 100644
--- a/tools/power/cpupower/man/cpupower-frequency-info.1
+++ b/tools/power/cpupower/man/cpupower-frequency-info.1
@@ -1,7 +1,7 @@
 .TH "CPUPOWER\-FREQUENCY\-INFO" "1" "0.1" "" "cpupower Manual"
 .SH "NAME"
 .LP 
-cpupower frequency\-info \- Utility to retrieve cpufreq kernel information
+cpupower\-frequency\-info \- Utility to retrieve cpufreq kernel information
 .SH "SYNTAX"
 .LP 
 cpupower [ \-c cpulist ] frequency\-info [\fIoptions\fP]
diff --git a/tools/power/cpupower/man/cpupower-frequency-set.1 b/tools/power/cpupower/man/cpupower-frequency-set.1
index 3eacc8d03d1a..b50570221a5b 100644
--- a/tools/power/cpupower/man/cpupower-frequency-set.1
+++ b/tools/power/cpupower/man/cpupower-frequency-set.1
@@ -1,7 +1,7 @@
 .TH "CPUPOWER\-FREQUENCY\-SET" "1" "0.1" "" "cpupower Manual"
 .SH "NAME"
 .LP 
-cpupower frequency\-set \- A small tool which allows to modify cpufreq settings.
+cpupower\-frequency\-set \- A small tool which allows to modify cpufreq settings.
 .SH "SYNTAX"
 .LP 
 cpupower [ \-c cpu ] frequency\-set [\fIoptions\fP]
diff --git a/tools/power/cpupower/man/cpupower-idle-info.1 b/tools/power/cpupower/man/cpupower-idle-info.1
index 7b3646adb92f..80a1311fa747 100644
--- a/tools/power/cpupower/man/cpupower-idle-info.1
+++ b/tools/power/cpupower/man/cpupower-idle-info.1
@@ -1,7 +1,7 @@
 .TH "CPUPOWER-IDLE-INFO" "1" "0.1" "" "cpupower Manual"
 .SH "NAME"
 .LP
-cpupower idle\-info \- Utility to retrieve cpu idle kernel information
+cpupower\-idle\-info \- Utility to retrieve cpu idle kernel information
 .SH "SYNTAX"
 .LP
 cpupower [ \-c cpulist ] idle\-info [\fIoptions\fP]
diff --git a/tools/power/cpupower/man/cpupower-idle-set.1 b/tools/power/cpupower/man/cpupower-idle-set.1
index 580c4e3ea92a..21916cff7516 100644
--- a/tools/power/cpupower/man/cpupower-idle-set.1
+++ b/tools/power/cpupower/man/cpupower-idle-set.1
@@ -1,7 +1,7 @@
 .TH "CPUPOWER-IDLE-SET" "1" "0.1" "" "cpupower Manual"
 .SH "NAME"
 .LP
-cpupower idle\-set \- Utility to set cpu idle state specific kernel options
+cpupower\-idle\-set \- Utility to set cpu idle state specific kernel options
 .SH "SYNTAX"
 .LP
 cpupower [ \-c cpulist ] idle\-info [\fIoptions\fP]
diff --git a/tools/power/cpupower/utils/cpufreq-set.c b/tools/power/cpupower/utils/cpufreq-set.c
index 0fbd1a22c0a9..b4bf76971dc9 100644
--- a/tools/power/cpupower/utils/cpufreq-set.c
+++ b/tools/power/cpupower/utils/cpufreq-set.c
@@ -16,8 +16,8 @@
 #include <getopt.h>
 #include "cpufreq.h"
+#include "cpuidle.h"
 #include "helpers/helpers.h"
-#include "helpers/sysfs.h"
 #define NORM_FREQ_LEN 32
@@ -296,7 +296,7 @@ int cmd_freq_set(int argc, char **argv)
                        struct cpufreq_affected_cpus *cpus;
                        if (!bitmask_isbitset(cpus_chosen, cpu) ||
-                            cpufreq_cpu_exists(cpu))
+                            cpupower_is_cpu_online(cpu))
                                continue;
                        cpus = cpufreq_get_related_cpus(cpu);
@@ -316,10 +316,10 @@ int cmd_freq_set(int argc, char **argv)
             cpu <= bitmask_last(cpus_chosen); cpu++) {
                if (!bitmask_isbitset(cpus_chosen, cpu) ||
-                    cpufreq_cpu_exists(cpu))
+                    cpupower_is_cpu_online(cpu))
                        continue;
-                if (sysfs_is_cpu_online(cpu) != 1)
+                if (cpupower_is_cpu_online(cpu) != 1)
                        continue;
                printf(_("Setting cpu: %d\n"), cpu);
diff --git a/tools/power/cpupower/utils/cpuidle-info.c b/tools/power/cpupower/utils/cpuidle-info.c
index 8bf8ab5ffa25..b59c85defa05 100644
--- a/tools/power/cpupower/utils/cpuidle-info.c
+++ b/tools/power/cpupower/utils/cpuidle-info.c
@@ -13,8 +13,10 @@
 #include <string.h>
 #include <getopt.h>
-#include "helpers/helpers.h"
+#include <cpuidle.h>
 #include "helpers/sysfs.h"
+#include "helpers/helpers.h"
 #include "helpers/bitmask.h"
 #define LINE_LEN 10
@@ -24,7 +26,7 @@ static void cpuidle_cpu_output(unsigned int cpu, int verbose)
        unsigned int idlestates, idlestate;
        char *tmp;
-        idlestates = sysfs_get_idlestate_count(cpu);
+        idlestates = cpuidle_state_count(cpu);
        if (idlestates == 0) {
                printf(_("CPU %u: No idle states\n"), cpu);
                return;
@@ -33,7 +35,7 @@ static void cpuidle_cpu_output(unsigned int cpu, int verbose)
        printf(_("Number of idle states: %d\n"), idlestates);
        printf(_("Available idle states:"));
        for (idlestate = 0; idlestate < idlestates; idlestate++) {
-                tmp = sysfs_get_idlestate_name(cpu, idlestate);
+                tmp = cpuidle_state_name(cpu, idlestate);
                if (!tmp)
                        continue;
                printf(" %s", tmp);
@@ -45,28 +47,28 @@ static void cpuidle_cpu_output(unsigned int cpu, int verbose)
                return;
        for (idlestate = 0; idlestate < idlestates; idlestate++) {
-                int disabled = sysfs_is_idlestate_disabled(cpu, idlestate);
+                int disabled = cpuidle_is_state_disabled(cpu, idlestate);
                /* Disabled interface not supported on older kernels */
                if (disabled < 0)
                        disabled = 0;
-                tmp = sysfs_get_idlestate_name(cpu, idlestate);
+                tmp = cpuidle_state_name(cpu, idlestate);
                if (!tmp)
                        continue;
                printf("%s%s:\n", tmp, (disabled) ? " (DISABLED) " : "");
                free(tmp);
-                tmp = sysfs_get_idlestate_desc(cpu, idlestate);
+                tmp = cpuidle_state_desc(cpu, idlestate);
                if (!tmp)
                        continue;
                printf(_("Flags/Description: %s\n"), tmp);
                free(tmp);
                printf(_("Latency: %lu\n"),
-                       sysfs_get_idlestate_latency(cpu, idlestate));
+                       cpuidle_state_latency(cpu, idlestate));
                printf(_("Usage: %lu\n"),
-                       sysfs_get_idlestate_usage(cpu, idlestate));
+                       cpuidle_state_usage(cpu, idlestate));
                printf(_("Duration: %llu\n"),
-                       sysfs_get_idlestate_time(cpu, idlestate));
+                       cpuidle_state_time(cpu, idlestate));
        }
 }
@@ -74,7 +76,7 @@ static void cpuidle_general_output(void)
 {
        char *tmp;
-        tmp = sysfs_get_cpuidle_driver();
+        tmp = cpuidle_get_driver();
        if (!tmp) {
                printf(_("Could not determine cpuidle driver\n"));
                return;
@@ -83,7 +85,7 @@ static void cpuidle_general_output(void)
        printf(_("CPUidle driver: %s\n"), tmp);
        free(tmp);
-        tmp = sysfs_get_cpuidle_governor();
+        tmp = cpuidle_get_governor();
        if (!tmp) {
                printf(_("Could not determine cpuidle governor\n"));
                return;
@@ -98,7 +100,7 @@ static void proc_cpuidle_cpu_output(unsigned int cpu)
        long max_allowed_cstate = 2000000000;
        unsigned int cstate, cstates;
-        cstates = sysfs_get_idlestate_count(cpu);
+        cstates = cpuidle_state_count(cpu);
        if (cstates == 0) {
                printf(_("CPU %u: No C-states info\n"), cpu);
                return;
@@ -113,11 +115,11 @@ static void proc_cpuidle_cpu_output(unsigned int cpu)
                         "type[C%d] "), cstate, cstate);
                printf(_("promotion[--] demotion[--] "));
                printf(_("latency[%03lu] "),
-                       sysfs_get_idlestate_latency(cpu, cstate));
+                       cpuidle_state_latency(cpu, cstate));
                printf(_("usage[%08lu] "),
-                       sysfs_get_idlestate_usage(cpu, cstate));
+                       cpuidle_state_usage(cpu, cstate));
                printf(_("duration[%020Lu] \n"),
-                       sysfs_get_idlestate_time(cpu, cstate));
+                       cpuidle_state_time(cpu, cstate));
        }
 }
diff --git a/tools/power/cpupower/utils/cpuidle-set.c b/tools/power/cpupower/utils/cpuidle-set.c
index d6b6ae44b8c2..691c24d50ef4 100644
--- a/tools/power/cpupower/utils/cpuidle-set.c
+++ b/tools/power/cpupower/utils/cpuidle-set.c
@@ -5,12 +5,12 @@
 #include <limits.h>
 #include <string.h>
 #include <ctype.h>
 #include <getopt.h>
-#include "cpufreq.h"
+#include <cpufreq.h>
+#include <cpuidle.h>
 #include "helpers/helpers.h"
-#include "helpers/sysfs.h"
 static struct option info_opts[] = {
     {"disable",        required_argument,              NULL, 'd'},
@@ -104,16 +104,16 @@ int cmd_idle_set(int argc, char **argv)
                if (!bitmask_isbitset(cpus_chosen, cpu))
                        continue;
-                if (sysfs_is_cpu_online(cpu) != 1)
+                if (cpupower_is_cpu_online(cpu) != 1)
                        continue;
-                idlestates = sysfs_get_idlestate_count(cpu);
+                idlestates = cpuidle_state_count(cpu);
                if (idlestates <= 0)
                        continue;
                switch (param) {
                case 'd':
-                        ret = sysfs_idlestate_disable(cpu, idlestate, 1);
+                        ret = cpuidle_state_disable(cpu, idlestate, 1);
                        if (ret == 0)
                printf(_("Idlestate %u disabled on CPU %u\n"),  idlestate, cpu);
                        else if (ret == -1)
@@ -126,7 +126,7 @@ int cmd_idle_set(int argc, char **argv)
                       idlestate, cpu);
                        break;
                case 'e':
-                        ret = sysfs_idlestate_disable(cpu, idlestate, 0);
+                        ret = cpuidle_state_disable(cpu, idlestate, 0);
                        if (ret == 0)
                printf(_("Idlestate %u enabled on CPU %u\n"),  idlestate, cpu);
                        else if (ret == -1)
@@ -140,13 +140,13 @@ int cmd_idle_set(int argc, char **argv)
                        break;
                case 'D':
                        for (idlestate = 0; idlestate < idlestates; idlestate++) {
-                                disabled = sysfs_is_idlestate_disabled
+                                disabled = cpuidle_is_state_disabled
                                        (cpu, idlestate);
-                                state_latency = sysfs_get_idlestate_latency
+                                state_latency = cpuidle_state_latency
                                        (cpu, idlestate);
                                if (disabled == 1) {
                                        if (latency > state_latency){
-                                                ret = sysfs_idlestate_disable
+                                                ret = cpuidle_state_disable
                                                        (cpu, idlestate, 0);
                                                if (ret == 0)
                printf(_("Idlestate %u enabled on CPU %u\n"),  idlestate, cpu);
@@ -154,7 +154,7 @@ int cmd_idle_set(int argc, char **argv)
                                        continue;
                                }
                                if (latency <= state_latency){
-                                        ret = sysfs_idlestate_disable
+                                        ret = cpuidle_state_disable
                                                (cpu, idlestate, 1);
                                        if (ret == 0)
                printf(_("Idlestate %u disabled on CPU %u\n"), idlestate, cpu);
@@ -163,10 +163,10 @@ int cmd_idle_set(int argc, char **argv)
                        break;
                case 'E':
                        for (idlestate = 0; idlestate < idlestates; idlestate++) {
-                                disabled = sysfs_is_idlestate_disabled
+                                disabled = cpuidle_is_state_disabled
                                        (cpu, idlestate);
                                if (disabled == 1) {
-                                        ret = sysfs_idlestate_disable
+                                        ret = cpuidle_state_disable
                                                (cpu, idlestate, 0);
                                        if (ret == 0)
                printf(_("Idlestate %u enabled on CPU %u\n"), idlestate, cpu);
diff --git a/tools/power/cpupower/utils/helpers/helpers.h b/tools/power/cpupower/utils/helpers/helpers.h
index aa9e95486a2d..afb66f80554e 100644
--- a/tools/power/cpupower/utils/helpers/helpers.h
+++ b/tools/power/cpupower/utils/helpers/helpers.h
@@ -14,6 +14,7 @@
 #include <locale.h>
 #include "helpers/bitmask.h"
+#include <cpupower.h>
 /* Internationalization ****************************/
 #ifdef NLS
@@ -92,31 +93,6 @@ extern int get_cpu_info(unsigned int cpu, struct cpupower_cpu_info *cpu_info);
 extern struct cpupower_cpu_info cpupower_cpu_info;
 /* cpuid and cpuinfo helpers  **************************/
-struct cpuid_core_info {
-        int pkg;
-        int core;
-        int cpu;
-        /* flags */
-        unsigned int is_online:1;
-};
-/* CPU topology/hierarchy parsing ******************/
-struct cpupower_topology {
-        /* Amount of CPU cores, packages and threads per core in the system */
-        unsigned int cores;
-        unsigned int pkgs;
-        unsigned int threads; /* per core */
-        /* Array gets mallocated with cores entries, holding per core info */
-        struct cpuid_core_info *core_info;
-};
-extern int get_cpu_topology(struct cpupower_topology *cpu_top);
-extern void cpu_topology_release(struct cpupower_topology cpu_top);
-/* CPU topology/hierarchy parsing ******************/
 /* X86 ONLY ****************************************/
 #if defined(__i386__) || defined(__x86_64__)
diff --git a/tools/power/cpupower/utils/helpers/topology.c b/tools/power/cpupower/utils/helpers/topology.c
index 5f9c908f4557..a1a6c6041a1e 100644
--- a/tools/power/cpupower/utils/helpers/topology.c
+++ b/tools/power/cpupower/utils/helpers/topology.c
@@ -16,110 +16,7 @@
 #include <errno.h>
 #include <fcntl.h>
-#include <helpers/helpers.h>
+#include <cpuidle.h>
-#include <helpers/sysfs.h>
-/* returns -1 on failure, 0 on success */
+/* CPU topology/hierarchy parsing ******************/
-static int sysfs_topology_read_file(unsigned int cpu, const char *fname, int *result)
-{
-        char linebuf[MAX_LINE_LEN];
-        char *endp;
-        char path[SYSFS_PATH_MAX];
-        snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/topology/%s",
-                         cpu, fname);
-        if (sysfs_read_file(path, linebuf, MAX_LINE_LEN) == 0)
-                return -1;
-        *result = strtol(linebuf, &endp, 0);
-        if (endp == linebuf || errno == ERANGE)
-                return -1;
-        return 0;
-}
-static int __compare(const void *t1, const void *t2)
-{
-        struct cpuid_core_info *top1 = (struct cpuid_core_info *)t1;
-        struct cpuid_core_info *top2 = (struct cpuid_core_info *)t2;
-        if (top1->pkg < top2->pkg)
-                return -1;
-        else if (top1->pkg > top2->pkg)
-                return 1;
-        else if (top1->core < top2->core)
-                return -1;
-        else if (top1->core > top2->core)
-                return 1;
-        else if (top1->cpu < top2->cpu)
-                return -1;
-        else if (top1->cpu > top2->cpu)
-                return 1;
-        else
-                return 0;
-}
-/*
- * Returns amount of cpus, negative on error, cpu_top must be
- * passed to cpu_topology_release to free resources
- *
- * Array is sorted after ->pkg, ->core, then ->cpu
- */
-int get_cpu_topology(struct cpupower_topology *cpu_top)
-{
-        int cpu, last_pkg, cpus = sysconf(_SC_NPROCESSORS_CONF);
-        cpu_top->core_info = malloc(sizeof(struct cpuid_core_info) * cpus);
-        if (cpu_top->core_info == NULL)
-                return -ENOMEM;
-        cpu_top->pkgs = cpu_top->cores = 0;
-        for (cpu = 0; cpu < cpus; cpu++) {
-                cpu_top->core_info[cpu].cpu = cpu;
-                cpu_top->core_info[cpu].is_online = sysfs_is_cpu_online(cpu);
-                if(sysfs_topology_read_file(
-                        cpu,
-                        "physical_package_id",
-                        &(cpu_top->core_info[cpu].pkg)) < 0) {
-                        cpu_top->core_info[cpu].pkg = -1;
-                        cpu_top->core_info[cpu].core = -1;
-                        continue;
-                }
-                if(sysfs_topology_read_file(
-                        cpu,
-                        "core_id",
-                        &(cpu_top->core_info[cpu].core)) < 0) {
-                        cpu_top->core_info[cpu].pkg = -1;
-                        cpu_top->core_info[cpu].core = -1;
-                        continue;
-                }
-        }
-        qsort(cpu_top->core_info, cpus, sizeof(struct cpuid_core_info),
-              __compare);
-        /* Count the number of distinct pkgs values. This works
-           because the primary sort of the core_info struct was just
-           done by pkg value. */
-        last_pkg = cpu_top->core_info[0].pkg;
-        for(cpu = 1; cpu < cpus; cpu++) {
-                if (cpu_top->core_info[cpu].pkg != last_pkg &&
-                                cpu_top->core_info[cpu].pkg != -1) {
-                        last_pkg = cpu_top->core_info[cpu].pkg;
-                        cpu_top->pkgs++;
-                }
-        }
-        if (!(cpu_top->core_info[0].pkg == -1))
-                cpu_top->pkgs++;
-        /* Intel's cores count is not consecutively numbered, there may
-         * be a core_id of 3, but none of 2. Assume there always is 0
-         * Get amount of cores by counting duplicates in a package
-        for (cpu = 0; cpu_top->core_info[cpu].pkg = 0 && cpu < cpus; cpu++) {
-                if (cpu_top->core_info[cpu].core == 0)
-        cpu_top->cores++;
-        */
-        return cpus;
-}
-void cpu_topology_release(struct cpupower_topology cpu_top)
-{
-        free(cpu_top.core_info);
-}
diff --git a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
index bcd22a1a3970..1b5da0066ebf 100644
--- a/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
+++ b/tools/power/cpupower/utils/idle_monitor/cpuidle_sysfs.c
@@ -10,8 +10,8 @@
 #include <stdint.h>
 #include <string.h>
 #include <limits.h>
+#include <cpuidle.h>
-#include "helpers/sysfs.h"
 #include "helpers/helpers.h"
 #include "idle_monitor/cpupower-monitor.h"
@@ -51,7 +51,7 @@ static int cpuidle_start(void)
                for (state = 0; state < cpuidle_sysfs_monitor.hw_states_num;
                     state++) {
                        previous_count[cpu][state] =
-                                sysfs_get_idlestate_time(cpu, state);
+                                cpuidle_state_time(cpu, state);
                        dprint("CPU %d - State: %d - Val: %llu\n",
                               cpu, state, previous_count[cpu][state]);
                }
@@ -70,7 +70,7 @@ static int cpuidle_stop(void)
                for (state = 0; state < cpuidle_sysfs_monitor.hw_states_num;
                     state++) {
                        current_count[cpu][state] =
-                                sysfs_get_idlestate_time(cpu, state);
+                                cpuidle_state_time(cpu, state);
                        dprint("CPU %d - State: %d - Val: %llu\n",
                               cpu, state, previous_count[cpu][state]);
                }
@@ -132,13 +132,13 @@ static struct cpuidle_monitor *cpuidle_register(void)
        char *tmp;
        /* Assume idle state count is the same for all CPUs */
-        cpuidle_sysfs_monitor.hw_states_num = sysfs_get_idlestate_count(0);
+        cpuidle_sysfs_monitor.hw_states_num = cpuidle_state_count(0);
        if (cpuidle_sysfs_monitor.hw_states_num <= 0)
                return NULL;
        for (num = 0; num < cpuidle_sysfs_monitor.hw_states_num; num++) {
-                tmp = sysfs_get_idlestate_name(0, num);
+                tmp = cpuidle_state_name(0, num);
                if (tmp == NULL)
                        continue;
@@ -146,7 +146,7 @@ static struct cpuidle_monitor *cpuidle_register(void)
                strncpy(cpuidle_cstates[num].name, tmp, CSTATE_NAME_LEN - 1);
                free(tmp);
-                tmp = sysfs_get_idlestate_desc(0, num);
+                tmp = cpuidle_state_desc(0, num);
                if (tmp == NULL)
                        continue;
                strncpy(cpuidle_cstates[num].desc, tmp, CSTATE_DESC_LEN - 1);
diff --git a/tools/testing/nvdimm/Kbuild b/tools/testing/nvdimm/Kbuild
index a34bfd0c8928..785985677159 100644
--- a/tools/testing/nvdimm/Kbuild
+++ b/tools/testing/nvdimm/Kbuild
@@ -7,6 +7,7 @@ ldflags-y += --wrap=ioremap_nocache
 ldflags-y += --wrap=iounmap
 ldflags-y += --wrap=memunmap
 ldflags-y += --wrap=__devm_request_region
+ldflags-y += --wrap=__devm_release_region
 ldflags-y += --wrap=__request_region
 ldflags-y += --wrap=__release_region
 ldflags-y += --wrap=devm_memremap_pages
@@ -15,6 +16,7 @@ ldflags-y += --wrap=phys_to_pfn_t
 DRIVERS := ../../../drivers
 NVDIMM_SRC := $(DRIVERS)/nvdimm
 ACPI_SRC := $(DRIVERS)/acpi
+DAX_SRC := $(DRIVERS)/dax
 obj-$(CONFIG_LIBNVDIMM) += libnvdimm.o
 obj-$(CONFIG_BLK_DEV_PMEM) += nd_pmem.o
@@ -22,6 +24,8 @@ obj-$(CONFIG_ND_BTT) += nd_btt.o
 obj-$(CONFIG_ND_BLK) += nd_blk.o
 obj-$(CONFIG_X86_PMEM_LEGACY) += nd_e820.o
 obj-$(CONFIG_ACPI_NFIT) += nfit.o
+obj-$(CONFIG_DEV_DAX) += dax.o
+obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o
 nfit-y := $(ACPI_SRC)/nfit.o
 nfit-y += config_check.o
@@ -38,6 +42,12 @@ nd_blk-y += config_check.o
 nd_e820-y := $(NVDIMM_SRC)/e820.o
 nd_e820-y += config_check.o
+dax-y := $(DAX_SRC)/dax.o
+dax-y += config_check.o
+dax_pmem-y := $(DAX_SRC)/pmem.o
+dax_pmem-y += config_check.o
 libnvdimm-y := $(NVDIMM_SRC)/core.o
 libnvdimm-y += $(NVDIMM_SRC)/bus.o
 libnvdimm-y += $(NVDIMM_SRC)/dimm_devs.o
@@ -49,6 +59,7 @@ libnvdimm-y += $(NVDIMM_SRC)/label.o
 libnvdimm-$(CONFIG_ND_CLAIM) += $(NVDIMM_SRC)/claim.o
 libnvdimm-$(CONFIG_BTT) += $(NVDIMM_SRC)/btt_devs.o
 libnvdimm-$(CONFIG_NVDIMM_PFN) += $(NVDIMM_SRC)/pfn_devs.o
+libnvdimm-$(CONFIG_NVDIMM_DAX) += $(NVDIMM_SRC)/dax_devs.o
 libnvdimm-y += config_check.o
 obj-m += test/
diff --git a/tools/testing/nvdimm/config_check.c b/tools/testing/nvdimm/config_check.c
index f2c7615554eb..adf18bfeca00 100644
--- a/tools/testing/nvdimm/config_check.c
+++ b/tools/testing/nvdimm/config_check.c
@@ -12,4 +12,6 @@ void check(void)
        BUILD_BUG_ON(!IS_MODULE(CONFIG_ND_BTT));
        BUILD_BUG_ON(!IS_MODULE(CONFIG_ND_BLK));
        BUILD_BUG_ON(!IS_MODULE(CONFIG_ACPI_NFIT));
+        BUILD_BUG_ON(!IS_MODULE(CONFIG_DEV_DAX));
+        BUILD_BUG_ON(!IS_MODULE(CONFIG_DEV_DAX_PMEM));
 }
diff --git a/tools/testing/nvdimm/test/iomap.c b/tools/testing/nvdimm/test/iomap.c
index 0c1a7e65bb81..c842095f2801 100644
--- a/tools/testing/nvdimm/test/iomap.c
+++ b/tools/testing/nvdimm/test/iomap.c
@@ -239,13 +239,11 @@ struct resource *__wrap___devm_request_region(struct device *dev,
 }
 EXPORT_SYMBOL(__wrap___devm_request_region);
-void __wrap___release_region(struct resource *parent, resource_size_t start,
+static bool nfit_test_release_region(struct resource *parent,
-                                resource_size_t n)
+                resource_size_t start, resource_size_t n)
 {
-        struct nfit_test_resource *nfit_res;
        if (parent == &iomem_resource) {
-                nfit_res = get_nfit_res(start);
+                struct nfit_test_resource *nfit_res = get_nfit_res(start);
                if (nfit_res) {
                        struct resource *res = nfit_res->res + 1;
@@ -254,11 +252,26 @@ void __wrap___release_region(struct resource *parent, resource_size_t start,
                                                __func__, start, n, res);
                        else
                                memset(res, 0, sizeof(*res));
-                        return;
+                        return true;
                }
        }
-        __release_region(parent, start, n);
+        return false;
+}
+void __wrap___release_region(struct resource *parent, resource_size_t start,
+                resource_size_t n)
+{
+        if (!nfit_test_release_region(parent, start, n))
+                __release_region(parent, start, n);
 }
 EXPORT_SYMBOL(__wrap___release_region);
+void __wrap___devm_release_region(struct device *dev, struct resource *parent,
+                resource_size_t start, resource_size_t n)
+{
+        if (!nfit_test_release_region(parent, start, n))
+                __devm_release_region(dev, parent, start, n);
+}
+EXPORT_SYMBOL(__wrap___devm_release_region);
 MODULE_LICENSE("GPL v2");
diff --git a/tools/testing/nvdimm/test/nfit.c b/tools/testing/nvdimm/test/nfit.c
index 3187322eeed7..c919866853a0 100644
--- a/tools/testing/nvdimm/test/nfit.c
+++ b/tools/testing/nvdimm/test/nfit.c
@@ -330,12 +330,49 @@ static int nfit_test_cmd_clear_error(struct nd_cmd_clear_error *clear_err,
        return 0;
 }
+static int nfit_test_cmd_smart(struct nd_cmd_smart *smart, unsigned int buf_len)
+{
+        static const struct nd_smart_payload smart_data = {
+                .flags = ND_SMART_HEALTH_VALID | ND_SMART_TEMP_VALID
+                        | ND_SMART_SPARES_VALID | ND_SMART_ALARM_VALID
+                        | ND_SMART_USED_VALID | ND_SMART_SHUTDOWN_VALID,
+                .health = ND_SMART_NON_CRITICAL_HEALTH,
+                .temperature = 23 * 16,
+                .spares = 75,
+                .alarm_flags = ND_SMART_SPARE_TRIP | ND_SMART_TEMP_TRIP,
+                .life_used = 5,
+                .shutdown_state = 0,
+                .vendor_size = 0,
+        };
+        if (buf_len < sizeof(*smart))
+                return -EINVAL;
+        memcpy(smart->data, &smart_data, sizeof(smart_data));
+        return 0;
+}
+static int nfit_test_cmd_smart_threshold(struct nd_cmd_smart_threshold *smart_t,
+                unsigned int buf_len)
+{
+        static const struct nd_smart_threshold_payload smart_t_data = {
+                .alarm_control = ND_SMART_SPARE_TRIP | ND_SMART_TEMP_TRIP,
+                .temperature = 40 * 16,
+                .spares = 5,
+        };
+        if (buf_len < sizeof(*smart_t))
+                return -EINVAL;
+        memcpy(smart_t->data, &smart_t_data, sizeof(smart_t_data));
+        return 0;
+}
 static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                struct nvdimm *nvdimm, unsigned int cmd, void *buf,
                unsigned int buf_len, int *cmd_rc)
 {
        struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
        struct nfit_test *t = container_of(acpi_desc, typeof(*t), acpi_desc);
+        unsigned int func = cmd;
        int i, rc = 0, __cmd_rc;
        if (!cmd_rc)
@@ -344,8 +381,23 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
        if (nvdimm) {
                struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
+                unsigned long cmd_mask = nvdimm_cmd_mask(nvdimm);
-                if (!nfit_mem || !test_bit(cmd, &nfit_mem->dsm_mask))
+                if (!nfit_mem)
+                        return -ENOTTY;
+                if (cmd == ND_CMD_CALL) {
+                        struct nd_cmd_pkg *call_pkg = buf;
+                        buf_len = call_pkg->nd_size_in + call_pkg->nd_size_out;
+                        buf = (void *) call_pkg->nd_payload;
+                        func = call_pkg->nd_command;
+                        if (call_pkg->nd_family != nfit_mem->family)
+                                return -ENOTTY;
+                }
+                if (!test_bit(cmd, &cmd_mask)
+                                || !test_bit(func, &nfit_mem->dsm_mask))
                        return -ENOTTY;
                /* lookup label space for the given dimm */
@@ -356,7 +408,7 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                if (i >= ARRAY_SIZE(handle))
                        return -ENXIO;
-                switch (cmd) {
+                switch (func) {
                case ND_CMD_GET_CONFIG_SIZE:
                        rc = nfit_test_cmd_get_config_size(buf, buf_len);
                        break;
@@ -368,16 +420,22 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
                        rc = nfit_test_cmd_set_config_data(buf, buf_len,
                                t->label[i]);
                        break;
+                case ND_CMD_SMART:
+                        rc = nfit_test_cmd_smart(buf, buf_len);
+                        break;
+                case ND_CMD_SMART_THRESHOLD:
+                        rc = nfit_test_cmd_smart_threshold(buf, buf_len);
+                        break;
                default:
                        return -ENOTTY;
                }
        } else {
                struct ars_state *ars_state = &t->ars_state;
-                if (!nd_desc || !test_bit(cmd, &nd_desc->dsm_mask))
+                if (!nd_desc || !test_bit(cmd, &nd_desc->cmd_mask))
                        return -ENOTTY;
-                switch (cmd) {
+                switch (func) {
                case ND_CMD_ARS_CAP:
                        rc = nfit_test_cmd_ars_cap(buf, buf_len);
                        break;
@@ -1251,13 +1309,15 @@ static void nfit_test0_setup(struct nfit_test *t)
        post_ars_status(&t->ars_state, t->spa_set_dma[0], SPA0_SIZE);
        acpi_desc = &t->acpi_desc;
-        set_bit(ND_CMD_GET_CONFIG_SIZE, &acpi_desc->dimm_dsm_force_en);
+        set_bit(ND_CMD_GET_CONFIG_SIZE, &acpi_desc->dimm_cmd_force_en);
-        set_bit(ND_CMD_GET_CONFIG_DATA, &acpi_desc->dimm_dsm_force_en);
+        set_bit(ND_CMD_GET_CONFIG_DATA, &acpi_desc->dimm_cmd_force_en);
-        set_bit(ND_CMD_SET_CONFIG_DATA, &acpi_desc->dimm_dsm_force_en);
+        set_bit(ND_CMD_SET_CONFIG_DATA, &acpi_desc->dimm_cmd_force_en);
-        set_bit(ND_CMD_ARS_CAP, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_SMART, &acpi_desc->dimm_cmd_force_en);
-        set_bit(ND_CMD_ARS_START, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_CAP, &acpi_desc->bus_cmd_force_en);
-        set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_START, &acpi_desc->bus_cmd_force_en);
-        set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_cmd_force_en);
+        set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_cmd_force_en);
+        set_bit(ND_CMD_SMART_THRESHOLD, &acpi_desc->dimm_cmd_force_en);
 }
 static void nfit_test1_setup(struct nfit_test *t)
@@ -1315,10 +1375,10 @@ static void nfit_test1_setup(struct nfit_test *t)
        post_ars_status(&t->ars_state, t->spa_set_dma[0], SPA2_SIZE);
        acpi_desc = &t->acpi_desc;
-        set_bit(ND_CMD_ARS_CAP, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_CAP, &acpi_desc->bus_cmd_force_en);
-        set_bit(ND_CMD_ARS_START, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_START, &acpi_desc->bus_cmd_force_en);
-        set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_cmd_force_en);
-        set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_dsm_force_en);
+        set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_cmd_force_en);
 }
 static int nfit_test_blk_do_io(struct nd_blk_region *ndbr, resource_size_t dpa,
diff --git a/tools/testing/radix-tree/Makefile b/tools/testing/radix-tree/Makefile
index 604212db9d4b..3b530467148e 100644
--- a/tools/testing/radix-tree/Makefile
+++ b/tools/testing/radix-tree/Makefile
@@ -3,7 +3,7 @@ CFLAGS += -I. -g -Wall -D_LGPL_SOURCE
 LDFLAGS += -lpthread -lurcu
 TARGETS = main
 OFILES = main.o radix-tree.o linux.o test.o tag_check.o find_next_bit.o \
-         regression1.o regression2.o regression3.o
+         regression1.o regression2.o regression3.o multiorder.o
 targets: $(TARGETS)
@@ -13,7 +13,7 @@ main:	$(OFILES)
 clean:
        $(RM) -f $(TARGETS) *.o radix-tree.c
-$(OFILES): *.h */*.h
+$(OFILES): *.h */*.h ../../../include/linux/radix-tree.h ../../include/linux/*.h
 radix-tree.c: ../../../lib/radix-tree.c
        sed -e 's/^static //' -e 's/__always_inline //' -e 's/inline //' < $< > $@
diff --git a/tools/testing/radix-tree/generated/autoconf.h b/tools/testing/radix-tree/generated/autoconf.h
new file mode 100644
index 000000000000..ad18cf5a2a3a
--- /dev/null
+++ b/tools/testing/radix-tree/generated/autoconf.h
@@ -0,0 +1,3 @@
+#define CONFIG_RADIX_TREE_MULTIORDER 1
+#define CONFIG_SHMEM 1
+#define CONFIG_SWAP 1
diff --git a/tools/testing/radix-tree/linux/init.h b/tools/testing/radix-tree/linux/init.h
new file mode 100644
index 000000000000..360cabb3c4e7
--- /dev/null
+++ b/tools/testing/radix-tree/linux/init.h
@@ -0,0 +1 @@
+/* An empty file stub that allows radix-tree.c to compile. */
diff --git a/tools/testing/radix-tree/linux/kernel.h b/tools/testing/radix-tree/linux/kernel.h
index ae013b0160ac..be98a47b4e1b 100644
--- a/tools/testing/radix-tree/linux/kernel.h
+++ b/tools/testing/radix-tree/linux/kernel.h
@@ -7,19 +7,28 @@
 #include <stddef.h>
 #include <limits.h>
+#include "../../include/linux/compiler.h"
+#include "../../../include/linux/kconfig.h"
+#define RADIX_TREE_MAP_SHIFT    3
 #ifndef NULL
 #define NULL    0
 #endif
 #define BUG_ON(expr)    assert(!(expr))
+#define WARN_ON(expr)   assert(!(expr))
 #define __init
 #define __must_check
 #define panic(expr)
 #define printk printf
 #define __force
-#define likely(c) (c)
-#define unlikely(c) (c)
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
+#define pr_debug printk
+#define smp_rmb()       barrier()
+#define smp_wmb()       barrier()
+#define cpu_relax()     barrier()
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
@@ -28,6 +37,8 @@
        (type *)( (char *)__mptr - offsetof(type, member) );})
 #define min(a, b) ((a) < (b) ? (a) : (b))
+#define cond_resched()  sched_yield()
 static inline int in_interrupt(void)
 {
        return 0;
diff --git a/tools/testing/radix-tree/linux/slab.h b/tools/testing/radix-tree/linux/slab.h
index 57282506c21d..6d5a34770fd4 100644
--- a/tools/testing/radix-tree/linux/slab.h
+++ b/tools/testing/radix-tree/linux/slab.h
@@ -3,7 +3,6 @@
 #include <linux/types.h>
-#define GFP_KERNEL 1
 #define SLAB_HWCACHE_ALIGN 1
 #define SLAB_PANIC 2
 #define SLAB_RECLAIM_ACCOUNT    0x00020000UL            /* Objects are reclaimable */
diff --git a/tools/testing/radix-tree/linux/types.h b/tools/testing/radix-tree/linux/types.h
index 72a9d85f6c76..faa0b6ff9ca8 100644
--- a/tools/testing/radix-tree/linux/types.h
+++ b/tools/testing/radix-tree/linux/types.h
@@ -1,15 +1,13 @@
 #ifndef _TYPES_H
 #define _TYPES_H
+#include "../../include/linux/types.h"
 #define __rcu
 #define __read_mostly
 #define BITS_PER_LONG (sizeof(long) * 8)
-struct list_head {
-        struct list_head *next, *prev;
-};
 static inline void INIT_LIST_HEAD(struct list_head *list)
 {
        list->next = list;
@@ -22,7 +20,6 @@ typedef struct {
 #define uninitialized_var(x) x = x
-typedef unsigned gfp_t;
 #include <linux/gfp.h>
 #endif
diff --git a/tools/testing/radix-tree/main.c b/tools/testing/radix-tree/main.c
index 0e83cad27a9f..b7619ff3b552 100644
--- a/tools/testing/radix-tree/main.c
+++ b/tools/testing/radix-tree/main.c
@@ -61,11 +61,11 @@ void __big_gang_check(void)
        } while (!wrapped);
 }
-void big_gang_check(void)
+void big_gang_check(bool long_run)
 {
        int i;
-        for (i = 0; i < 1000; i++) {
+        for (i = 0; i < (long_run ? 1000 : 3); i++) {
                __big_gang_check();
                srand(time(0));
                printf("%d ", i);
@@ -232,10 +232,72 @@ void copy_tag_check(void)
        item_kill_tree(&tree);
 }
-static void single_thread_tests(void)
+static void __locate_check(struct radix_tree_root *tree, unsigned long index,
+                        unsigned order)
+{
+        struct item *item;
+        unsigned long index2;
+        item_insert_order(tree, index, order);
+        item = item_lookup(tree, index);
+        index2 = radix_tree_locate_item(tree, item);
+        if (index != index2) {
+                printf("index %ld order %d inserted; found %ld\n",
+                        index, order, index2);
+                abort();
+        }
+}
+static void __order_0_locate_check(void)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        int i;
+        for (i = 0; i < 50; i++)
+                __locate_check(&tree, rand() % INT_MAX, 0);
+        item_kill_tree(&tree);
+}
+static void locate_check(void)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        unsigned order;
+        unsigned long offset, index;
+        __order_0_locate_check();
+        for (order = 0; order < 20; order++) {
+                for (offset = 0; offset < (1 << (order + 3));
+                     offset += (1UL << order)) {
+                        for (index = 0; index < (1UL << (order + 5));
+                             index += (1UL << order)) {
+                                __locate_check(&tree, index + offset, order);
+                        }
+                        if (radix_tree_locate_item(&tree, &tree) != -1)
+                                abort();
+                        item_kill_tree(&tree);
+                }
+        }
+        if (radix_tree_locate_item(&tree, &tree) != -1)
+                abort();
+        __locate_check(&tree, -1, 0);
+        if (radix_tree_locate_item(&tree, &tree) != -1)
+                abort();
+        item_kill_tree(&tree);
+}
+static void single_thread_tests(bool long_run)
 {
        int i;
+        printf("starting single_thread_tests: %d allocated\n", nr_allocated);
+        multiorder_checks();
+        printf("after multiorder_check: %d allocated\n", nr_allocated);
+        locate_check();
+        printf("after locate_check: %d allocated\n", nr_allocated);
        tag_check();
        printf("after tag_check: %d allocated\n", nr_allocated);
        gang_check();
@@ -244,9 +306,9 @@ static void single_thread_tests(void)
        printf("after add_and_check: %d allocated\n", nr_allocated);
        dynamic_height_check();
        printf("after dynamic_height_check: %d allocated\n", nr_allocated);
-        big_gang_check();
+        big_gang_check(long_run);
        printf("after big_gang_check: %d allocated\n", nr_allocated);
-        for (i = 0; i < 2000; i++) {
+        for (i = 0; i < (long_run ? 2000 : 3); i++) {
                copy_tag_check();
                printf("%d ", i);
                fflush(stdout);
@@ -254,15 +316,23 @@ static void single_thread_tests(void)
        printf("after copy_tag_check: %d allocated\n", nr_allocated);
 }
-int main(void)
+int main(int argc, char **argv)
 {
+        bool long_run = false;
+        int opt;
+        while ((opt = getopt(argc, argv, "l")) != -1) {
+                if (opt == 'l')
+                        long_run = true;
+        }
        rcu_register_thread();
        radix_tree_init();
        regression1_test();
        regression2_test();
        regression3_test();
-        single_thread_tests();
+        single_thread_tests(long_run);
        sleep(1);
        printf("after sleep(1): %d allocated\n", nr_allocated);
diff --git a/tools/testing/radix-tree/multiorder.c b/tools/testing/radix-tree/multiorder.c
new file mode 100644
index 000000000000..39d9b9568fe2
--- /dev/null
+++ b/tools/testing/radix-tree/multiorder.c
@@ -0,0 +1,337 @@
+/*
+ * multiorder.c: Multi-order radix tree entry testing
+ * Copyright (c) 2016 Intel Corporation
+ * Author: Ross Zwisler <ross.zwisler@linux.intel.com>
+ * Author: Matthew Wilcox <matthew.r.wilcox@intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+#include <linux/radix-tree.h>
+#include <linux/slab.h>
+#include <linux/errno.h>
+#include "test.h"
+#define for_each_index(i, base, order) \
+        for (i = base; i < base + (1 << order); i++)
+static void __multiorder_tag_test(int index, int order)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        int base, err, i;
+        unsigned long first = 0;
+        /* our canonical entry */
+        base = index & ~((1 << order) - 1);
+        printf("Multiorder tag test with index %d, canonical entry %d\n",
+                        index, base);
+        err = item_insert_order(&tree, index, order);
+        assert(!err);
+        /*
+         * Verify we get collisions for covered indices.  We try and fail to
+         * insert an exceptional entry so we don't leak memory via
+         * item_insert_order().
+         */
+        for_each_index(i, base, order) {
+                err = __radix_tree_insert(&tree, i, order,
+                                (void *)(0xA0 | RADIX_TREE_EXCEPTIONAL_ENTRY));
+                assert(err == -EEXIST);
+        }
+        for_each_index(i, base, order) {
+                assert(!radix_tree_tag_get(&tree, i, 0));
+                assert(!radix_tree_tag_get(&tree, i, 1));
+        }
+        assert(radix_tree_tag_set(&tree, index, 0));
+        for_each_index(i, base, order) {
+                assert(radix_tree_tag_get(&tree, i, 0));
+                assert(!radix_tree_tag_get(&tree, i, 1));
+        }
+        assert(radix_tree_range_tag_if_tagged(&tree, &first, ~0UL, 10, 0, 1) == 1);
+        assert(radix_tree_tag_clear(&tree, index, 0));
+        for_each_index(i, base, order) {
+                assert(!radix_tree_tag_get(&tree, i, 0));
+                assert(radix_tree_tag_get(&tree, i, 1));
+        }
+        assert(radix_tree_tag_clear(&tree, index, 1));
+        assert(!radix_tree_tagged(&tree, 0));
+        assert(!radix_tree_tagged(&tree, 1));
+        item_kill_tree(&tree);
+}
+static void multiorder_tag_tests(void)
+{
+        /* test multi-order entry for indices 0-7 with no sibling pointers */
+        __multiorder_tag_test(0, 3);
+        __multiorder_tag_test(5, 3);
+        /* test multi-order entry for indices 8-15 with no sibling pointers */
+        __multiorder_tag_test(8, 3);
+        __multiorder_tag_test(15, 3);
+        /*
+         * Our order 5 entry covers indices 0-31 in a tree with height=2.
+         * This is broken up as follows:
+         * 0-7:         canonical entry
+         * 8-15:        sibling 1
+         * 16-23:       sibling 2
+         * 24-31:       sibling 3
+         */
+        __multiorder_tag_test(0, 5);
+        __multiorder_tag_test(29, 5);
+        /* same test, but with indices 32-63 */
+        __multiorder_tag_test(32, 5);
+        __multiorder_tag_test(44, 5);
+        /*
+         * Our order 8 entry covers indices 0-255 in a tree with height=3.
+         * This is broken up as follows:
+         * 0-63:        canonical entry
+         * 64-127:      sibling 1
+         * 128-191:     sibling 2
+         * 192-255:     sibling 3
+         */
+        __multiorder_tag_test(0, 8);
+        __multiorder_tag_test(190, 8);
+        /* same test, but with indices 256-511 */
+        __multiorder_tag_test(256, 8);
+        __multiorder_tag_test(300, 8);
+        __multiorder_tag_test(0x12345678UL, 8);
+}
+static void multiorder_check(unsigned long index, int order)
+{
+        unsigned long i;
+        unsigned long min = index & ~((1UL << order) - 1);
+        unsigned long max = min + (1UL << order);
+        RADIX_TREE(tree, GFP_KERNEL);
+        printf("Multiorder index %ld, order %d\n", index, order);
+        assert(item_insert_order(&tree, index, order) == 0);
+        for (i = min; i < max; i++) {
+                struct item *item = item_lookup(&tree, i);
+                assert(item != 0);
+                assert(item->index == index);
+        }
+        for (i = 0; i < min; i++)
+                item_check_absent(&tree, i);
+        for (i = max; i < 2*max; i++)
+                item_check_absent(&tree, i);
+        for (i = min; i < max; i++) {
+                static void *entry = (void *)
+                                        (0xA0 | RADIX_TREE_EXCEPTIONAL_ENTRY);
+                assert(radix_tree_insert(&tree, i, entry) == -EEXIST);
+        }
+        assert(item_delete(&tree, index) != 0);
+        for (i = 0; i < 2*max; i++)
+                item_check_absent(&tree, i);
+}
+static void multiorder_shrink(unsigned long index, int order)
+{
+        unsigned long i;
+        unsigned long max = 1 << order;
+        RADIX_TREE(tree, GFP_KERNEL);
+        struct radix_tree_node *node;
+        printf("Multiorder shrink index %ld, order %d\n", index, order);
+        assert(item_insert_order(&tree, 0, order) == 0);
+        node = tree.rnode;
+        assert(item_insert(&tree, index) == 0);
+        assert(node != tree.rnode);
+        assert(item_delete(&tree, index) != 0);
+        assert(node == tree.rnode);
+        for (i = 0; i < max; i++) {
+                struct item *item = item_lookup(&tree, i);
+                assert(item != 0);
+                assert(item->index == 0);
+        }
+        for (i = max; i < 2*max; i++)
+                item_check_absent(&tree, i);
+        if (!item_delete(&tree, 0)) {
+                printf("failed to delete index %ld (order %d)\n", index, order);                abort();
+        }
+        for (i = 0; i < 2*max; i++)
+                item_check_absent(&tree, i);
+}
+static void multiorder_insert_bug(void)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        item_insert(&tree, 0);
+        radix_tree_tag_set(&tree, 0, 0);
+        item_insert_order(&tree, 3 << 6, 6);
+        item_kill_tree(&tree);
+}
+void multiorder_iteration(void)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        struct radix_tree_iter iter;
+        void **slot;
+        int i, j, err;
+        printf("Multiorder iteration test\n");
+#define NUM_ENTRIES 11
+        int index[NUM_ENTRIES] = {0, 2, 4, 8, 16, 32, 34, 36, 64, 72, 128};
+        int order[NUM_ENTRIES] = {1, 1, 2, 3,  4,  1,  0,  1,  3,  0, 7};
+        for (i = 0; i < NUM_ENTRIES; i++) {
+                err = item_insert_order(&tree, index[i], order[i]);
+                assert(!err);
+        }
+        for (j = 0; j < 256; j++) {
+                for (i = 0; i < NUM_ENTRIES; i++)
+                        if (j <= (index[i] | ((1 << order[i]) - 1)))
+                                break;
+                radix_tree_for_each_slot(slot, &tree, &iter, j) {
+                        int height = order[i] / RADIX_TREE_MAP_SHIFT;
+                        int shift = height * RADIX_TREE_MAP_SHIFT;
+                        int mask = (1 << order[i]) - 1;
+                        assert(iter.index >= (index[i] &~ mask));
+                        assert(iter.index <= (index[i] | mask));
+                        assert(iter.shift == shift);
+                        i++;
+                }
+        }
+        item_kill_tree(&tree);
+}
+void multiorder_tagged_iteration(void)
+{
+        RADIX_TREE(tree, GFP_KERNEL);
+        struct radix_tree_iter iter;
+        void **slot;
+        unsigned long first = 0;
+        int i, j;
+        printf("Multiorder tagged iteration test\n");
+#define MT_NUM_ENTRIES 9
+        int index[MT_NUM_ENTRIES] = {0, 2, 4, 16, 32, 40, 64, 72, 128};
+        int order[MT_NUM_ENTRIES] = {1, 0, 2, 4,  3,  1,  3,  0,   7};
+#define TAG_ENTRIES 7
+        int tag_index[TAG_ENTRIES] = {0, 4, 16, 40, 64, 72, 128};
+        for (i = 0; i < MT_NUM_ENTRIES; i++)
+                assert(!item_insert_order(&tree, index[i], order[i]));
+        assert(!radix_tree_tagged(&tree, 1));
+        for (i = 0; i < TAG_ENTRIES; i++)
+                assert(radix_tree_tag_set(&tree, tag_index[i], 1));
+        for (j = 0; j < 256; j++) {
+                int mask, k;
+                for (i = 0; i < TAG_ENTRIES; i++) {
+                        for (k = i; index[k] < tag_index[i]; k++)
+                                ;
+                        if (j <= (index[k] | ((1 << order[k]) - 1)))
+                                break;
+                }
+                radix_tree_for_each_tagged(slot, &tree, &iter, j, 1) {
+                        for (k = i; index[k] < tag_index[i]; k++)
+                                ;
+                        mask = (1 << order[k]) - 1;
+                        assert(iter.index >= (tag_index[i] &~ mask));
+                        assert(iter.index <= (tag_index[i] | mask));
+                        i++;
+                }
+        }
+        radix_tree_range_tag_if_tagged(&tree, &first, ~0UL,
+                                        MT_NUM_ENTRIES, 1, 2);
+        for (j = 0; j < 256; j++) {
+                int mask, k;
+                for (i = 0; i < TAG_ENTRIES; i++) {
+                        for (k = i; index[k] < tag_index[i]; k++)
+                                ;
+                        if (j <= (index[k] | ((1 << order[k]) - 1)))
+                                break;
+                }
+                radix_tree_for_each_tagged(slot, &tree, &iter, j, 2) {
+                        for (k = i; index[k] < tag_index[i]; k++)
+                                ;
+                        mask = (1 << order[k]) - 1;
+                        assert(iter.index >= (tag_index[i] &~ mask));
+                        assert(iter.index <= (tag_index[i] | mask));
+                        i++;
+                }
+        }
+        first = 1;
+        radix_tree_range_tag_if_tagged(&tree, &first, ~0UL,
+                                        MT_NUM_ENTRIES, 1, 0);
+        i = 0;
+        radix_tree_for_each_tagged(slot, &tree, &iter, 0, 0) {
+                assert(iter.index == tag_index[i]);
+                i++;
+        }
+        item_kill_tree(&tree);
+}
+void multiorder_checks(void)
+{
+        int i;
+        for (i = 0; i < 20; i++) {
+                multiorder_check(200, i);
+                multiorder_check(0, i);
+                multiorder_check((1UL << i) + 1, i);
+        }
+        for (i = 0; i < 15; i++)
+                multiorder_shrink((1UL << (i + RADIX_TREE_MAP_SHIFT)), i);
+        multiorder_insert_bug();
+        multiorder_tag_tests();
+        multiorder_iteration();
+        multiorder_tagged_iteration();
+}
diff --git a/tools/testing/radix-tree/regression2.c b/tools/testing/radix-tree/regression2.c
index 5d2fa28cdca3..63bf347aaf33 100644
--- a/tools/testing/radix-tree/regression2.c
+++ b/tools/testing/radix-tree/regression2.c
@@ -51,13 +51,6 @@
 #include "regression.h"
-#ifdef __KERNEL__
-#define RADIX_TREE_MAP_SHIFT    (CONFIG_BASE_SMALL ? 4 : 6)
-#else
-#define RADIX_TREE_MAP_SHIFT    3       /* For more stressful testing */
-#endif
-#define RADIX_TREE_MAP_SIZE     (1UL << RADIX_TREE_MAP_SHIFT)
 #define PAGECACHE_TAG_DIRTY     0
 #define PAGECACHE_TAG_WRITEBACK 1
 #define PAGECACHE_TAG_TOWRITE   2
diff --git a/tools/testing/radix-tree/tag_check.c b/tools/testing/radix-tree/tag_check.c
index 83136be552a0..b7447ceb75e9 100644
--- a/tools/testing/radix-tree/tag_check.c
+++ b/tools/testing/radix-tree/tag_check.c
@@ -12,6 +12,7 @@
 static void
 __simple_checks(struct radix_tree_root *tree, unsigned long index, int tag)
 {
+        unsigned long first = 0;
        int ret;
        item_check_absent(tree, index);
@@ -22,6 +23,10 @@ __simple_checks(struct radix_tree_root *tree, unsigned long index, int tag)
        item_tag_set(tree, index, tag);
        ret = item_tag_get(tree, index, tag);
        assert(ret != 0);
+        ret = radix_tree_range_tag_if_tagged(tree, &first, ~0UL, 10, tag, !tag);
+        assert(ret == 1);
+        ret = item_tag_get(tree, index, !tag);
+        assert(ret != 0);
        ret = item_delete(tree, index);
        assert(ret != 0);
        item_insert(tree, index);
@@ -304,6 +309,7 @@ static void single_check(void)
        struct item *items[BATCH];
        RADIX_TREE(tree, GFP_KERNEL);
        int ret;
+        unsigned long first = 0;
        item_insert(&tree, 0);
        item_tag_set(&tree, 0, 0);
@@ -313,6 +319,10 @@ static void single_check(void)
        assert(ret == 0);
        verify_tag_consistency(&tree, 0);
        verify_tag_consistency(&tree, 1);
+        ret = radix_tree_range_tag_if_tagged(&tree, &first, 10, 10, 0, 1);
+        assert(ret == 1);
+        ret = radix_tree_gang_lookup_tag(&tree, (void **)items, 0, BATCH, 1);
+        assert(ret == 1);
        item_kill_tree(&tree);
 }
diff --git a/tools/testing/radix-tree/test.c b/tools/testing/radix-tree/test.c
index 2bebf34cdc27..a6e8099eaf4f 100644
--- a/tools/testing/radix-tree/test.c
+++ b/tools/testing/radix-tree/test.c
@@ -24,14 +24,21 @@ int item_tag_get(struct radix_tree_root *root, unsigned long index, int tag)
        return radix_tree_tag_get(root, index, tag);
 }
-int __item_insert(struct radix_tree_root *root, struct item *item)
+int __item_insert(struct radix_tree_root *root, struct item *item,
+                        unsigned order)
 {
-        return radix_tree_insert(root, item->index, item);
+        return __radix_tree_insert(root, item->index, order, item);
 }
 int item_insert(struct radix_tree_root *root, unsigned long index)
 {
-        return __item_insert(root, item_create(index));
+        return __item_insert(root, item_create(index), 0);
+}
+int item_insert_order(struct radix_tree_root *root, unsigned long index,
+                        unsigned order)
+{
+        return __item_insert(root, item_create(index), order);
 }
 int item_delete(struct radix_tree_root *root, unsigned long index)
@@ -136,13 +143,13 @@ void item_full_scan(struct radix_tree_root *root, unsigned long start,
 }
 static int verify_node(struct radix_tree_node *slot, unsigned int tag,
-                        unsigned int height, int tagged)
+                        int tagged)
 {
        int anyset = 0;
        int i;
        int j;
-        slot = indirect_to_ptr(slot);
+        slot = entry_to_node(slot);
        /* Verify consistency at this level */
        for (i = 0; i < RADIX_TREE_TAG_LONGS; i++) {
@@ -152,7 +159,8 @@ static int verify_node(struct radix_tree_node *slot, unsigned int tag,
                }
        }
        if (tagged != anyset) {
-                printf("tag: %u, height %u, tagged: %d, anyset: %d\n", tag, height, tagged, anyset);
+                printf("tag: %u, shift %u, tagged: %d, anyset: %d\n",
+                        tag, slot->shift, tagged, anyset);
                for (j = 0; j < RADIX_TREE_MAX_TAGS; j++) {
                        printf("tag %d: ", j);
                        for (i = 0; i < RADIX_TREE_TAG_LONGS; i++)
@@ -164,10 +172,10 @@ static int verify_node(struct radix_tree_node *slot, unsigned int tag,
        assert(tagged == anyset);
        /* Go for next level */
-        if (height > 1) {
+        if (slot->shift > 0) {
                for (i = 0; i < RADIX_TREE_MAP_SIZE; i++)
                        if (slot->slots[i])
-                                if (verify_node(slot->slots[i], tag, height - 1,
+                                if (verify_node(slot->slots[i], tag,
                                            !!test_bit(i, slot->tags[tag]))) {
                                        printf("Failure at off %d\n", i);
                                        for (j = 0; j < RADIX_TREE_MAX_TAGS; j++) {
@@ -184,9 +192,10 @@ static int verify_node(struct radix_tree_node *slot, unsigned int tag,
 void verify_tag_consistency(struct radix_tree_root *root, unsigned int tag)
 {
-        if (!root->height)
+        struct radix_tree_node *node = root->rnode;
+        if (!radix_tree_is_internal_node(node))
                return;
-        verify_node(root->rnode, tag, root->height, !!root_tag_get(root, tag));
+        verify_node(node, tag, !!root_tag_get(root, tag));
 }
 void item_kill_tree(struct radix_tree_root *root)
@@ -211,9 +220,19 @@ void item_kill_tree(struct radix_tree_root *root)
 void tree_verify_min_height(struct radix_tree_root *root, int maxindex)
 {
-        assert(radix_tree_maxindex(root->height) >= maxindex);
+        unsigned shift;
-        if (root->height > 1)
+        struct radix_tree_node *node = root->rnode;
-                assert(radix_tree_maxindex(root->height-1) < maxindex);
+        if (!radix_tree_is_internal_node(node)) {
-        else if (root->height == 1)
+                assert(maxindex == 0);
-                assert(radix_tree_maxindex(root->height-1) <= maxindex);
+                return;
+        }
+        node = entry_to_node(node);
+        assert(maxindex <= node_maxindex(node));
+        shift = node->shift;
+        if (shift > 0)
+                assert(maxindex > shift_maxindex(shift - RADIX_TREE_MAP_SHIFT));
+        else
+                assert(maxindex > 0);
 }
diff --git a/tools/testing/radix-tree/test.h b/tools/testing/radix-tree/test.h
index 4e1d95faaa94..e85131369723 100644
--- a/tools/testing/radix-tree/test.h
+++ b/tools/testing/radix-tree/test.h
@@ -8,8 +8,11 @@ struct item {
 };
 struct item *item_create(unsigned long index);
-int __item_insert(struct radix_tree_root *root, struct item *item);
+int __item_insert(struct radix_tree_root *root, struct item *item,
+                        unsigned order);
 int item_insert(struct radix_tree_root *root, unsigned long index);
+int item_insert_order(struct radix_tree_root *root, unsigned long index,
+                        unsigned order);
 int item_delete(struct radix_tree_root *root, unsigned long index);
 struct item *item_lookup(struct radix_tree_root *root, unsigned long index);
@@ -23,6 +26,7 @@ void item_full_scan(struct radix_tree_root *root, unsigned long start,
 void item_kill_tree(struct radix_tree_root *root);
 void tag_check(void);
+void multiorder_checks(void);
 struct item *
 item_tag_set(struct radix_tree_root *root, unsigned long index, int tag);
@@ -35,6 +39,7 @@ void verify_tag_consistency(struct radix_tree_root *root, unsigned int tag);
 extern int nr_allocated;
 /* Normally private parts of lib/radix-tree.c */
-void *indirect_to_ptr(void *ptr);
+void radix_tree_dump(struct radix_tree_root *root);
 int root_tag_get(struct radix_tree_root *root, unsigned int tag);
-unsigned long radix_tree_maxindex(unsigned int height);
+unsigned long node_maxindex(struct radix_tree_node *);
+unsigned long shift_maxindex(unsigned int shift);
diff --git a/tools/testing/selftests/ftrace/ftracetest b/tools/testing/selftests/ftrace/ftracetest
index da48812ab95e..4c6a0bf8ba79 100755
--- a/tools/testing/selftests/ftrace/ftracetest
+++ b/tools/testing/selftests/ftrace/ftracetest
@@ -88,7 +88,12 @@ parse_opts() { # opts
 # Parameters
 DEBUGFS_DIR=`grep debugfs /proc/mounts | cut -f2 -d' ' | head -1`
-TRACING_DIR=$DEBUGFS_DIR/tracing
+if [ -z "$DEBUGFS_DIR" ]; then
+    TRACING_DIR=`grep tracefs /proc/mounts | cut -f2 -d' ' | head -1`
+else
+    TRACING_DIR=$DEBUGFS_DIR/tracing
+fi
 TOP_DIR=`absdir $0`
 TEST_DIR=$TOP_DIR/test.d
 TEST_CASES=`find_testcases $TEST_DIR`
@@ -102,7 +107,7 @@ parse_opts $*
 [ $DEBUG -ne 0 ] && set -x
 # Verify parameters
-if [ -z "$DEBUGFS_DIR" -o ! -d "$TRACING_DIR" ]; then
+if [ -z "$TRACING_DIR" -o ! -d "$TRACING_DIR" ]; then
  errexit "No ftrace directory found"
 fi
diff --git a/tools/testing/selftests/ftrace/test.d/event/event-pid.tc b/tools/testing/selftests/ftrace/test.d/event/event-pid.tc
new file mode 100644
index 000000000000..d4ab27b522f8
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/event/event-pid.tc
@@ -0,0 +1,72 @@
+#!/bin/sh
+# description: event tracing - restricts events based on pid
+do_reset() {
+    echo > set_event
+    echo > set_event_pid
+    echo 0 > options/event-fork
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+yield() {
+    ping localhost -c 1 || sleep .001 || usleep 1 || sleep 1
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f set_event_pid ]; then
+    echo "event pid filtering is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+echo 1 > events/sched/sched_switch/enable
+yield
+count=`cat trace | grep sched_switch | wc -l`
+if [ $count -eq 0 ]; then
+    fail "sched_switch events are not recorded"
+fi
+do_reset
+read mypid rest < /proc/self/stat
+echo $mypid > set_event_pid
+echo 'sched:sched_switch' > set_event
+yield
+count=`cat trace | grep sched_switch | grep -v "pid=$mypid" | wc -l`
+if [ $count -ne 0 ]; then
+    fail "sched_switch events from other task are recorded"
+fi
+do_reset
+echo $mypid > set_event_pid
+echo 1 > options/event-fork
+echo 1 > events/sched/sched_switch/enable
+yield
+count=`cat trace | grep sched_switch | grep -v "pid=$mypid" | wc -l`
+if [ $count -eq 0 ]; then
+    fail "sched_switch events from other task are not recorded"
+fi
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/functions b/tools/testing/selftests/ftrace/test.d/functions
index 5d8cd06d920f..c37262f6c269 100644
--- a/tools/testing/selftests/ftrace/test.d/functions
+++ b/tools/testing/selftests/ftrace/test.d/functions
@@ -14,3 +14,12 @@ enable_tracing() { # start trace recording
 reset_tracer() { # reset the current tracer
    echo nop > current_tracer
 }
+reset_trigger() { # reset all current setting triggers
+    grep -v ^# events/*/*/trigger |
+    while read line; do
+        cmd=`echo $line | cut -f2- -d: | cut -f1 -d" "`
+        echo "!$cmd" > `echo $line | cut -f1 -d:`
+    done
+}
diff --git a/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc b/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc
new file mode 100644
index 000000000000..4c5a061a5b4e
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/instances/instance-event.tc
@@ -0,0 +1,138 @@
+#!/bin/sh
+# description: Test creation and deletion of trace instances while setting an event
+if [ ! -d instances ] ; then
+    echo "no instance directory with this kernel"
+    exit_unsupported;
+fi
+fail() { # mesg
+    rmdir foo 2>/dev/null
+    echo $1
+    set -e
+    exit $FAIL
+}
+cd instances
+# we don't want to fail on error
+set +e
+mkdir x
+rmdir x
+result=$?
+if [ $result -ne 0 ]; then
+    echo "instance rmdir not supported"
+    exit_unsupported
+fi
+instance_slam() {
+        while :; do
+                mkdir foo 2> /dev/null
+                rmdir foo 2> /dev/null
+        done
+}
+instance_read() {
+        while :; do
+                cat foo/trace 1> /dev/null 2>&1
+        done
+}
+instance_set() {
+        while :; do
+                echo 1 > foo/events/sched/sched_switch
+        done 2> /dev/null
+}
+instance_slam &
+p1=$!
+echo $p1
+instance_set &
+p2=$!
+echo $p2
+instance_read &
+p3=$!
+echo $p3
+sleep 1
+kill -1 $p3
+kill -1 $p2
+kill -1 $p1
+echo "Wait for processes to finish"
+wait $p1 $p2 $p3
+echo "all processes finished, wait for cleanup"
+sleep 1
+mkdir foo
+ls foo > /dev/null
+rmdir foo
+if [ -d foo ]; then
+        fail "foo still exists"
+fi
+exit 0
+instance_slam() {
+    while :; do
+        mkdir x
+        mkdir y
+        mkdir z
+        rmdir x
+        rmdir y
+        rmdir z
+    done 2>/dev/null
+}
+instance_slam &
+p1=$!
+echo $p1
+instance_slam &
+p2=$!
+echo $p2
+instance_slam &
+p3=$!
+echo $p3
+instance_slam &
+p4=$!
+echo $p4
+instance_slam &
+p5=$!
+echo $p5
+ls -lR >/dev/null
+sleep 1
+kill -1 $p1
+kill -1 $p2
+kill -1 $p3
+kill -1 $p4
+kill -1 $p5
+echo "Wait for processes to finish"
+wait $p1 $p2 $p3 $p4 $p5
+echo "all processes finished, wait for cleanup"
+mkdir x y z
+ls x y z
+rmdir x y z
+for d in x y z; do
+        if [ -d $d ]; then
+                fail "instance $d still exists"
+        fi
+done
+set -e
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc
new file mode 100644
index 000000000000..1a9445021bf1
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-eventonoff.tc
@@ -0,0 +1,64 @@
+#!/bin/sh
+# description: event trigger - test event enable/disable trigger
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep enable_event events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "event enable/disable trigger is not supported"
+    exit_unsupported
+fi
+echo "Test enable_event trigger"
+echo 0 > events/sched/sched_switch/enable
+echo 'enable_event:sched:sched_switch' > events/sched/sched_process_fork/trigger
+( echo "forked")
+if [ `cat events/sched/sched_switch/enable` != '1*' ]; then
+    fail "enable_event trigger on sched_process_fork did not work"
+fi
+reset_trigger
+echo "Test disable_event trigger"
+echo 1 > events/sched/sched_switch/enable
+echo 'disable_event:sched:sched_switch' > events/sched/sched_process_fork/trigger
+( echo "forked")
+if [ `cat events/sched/sched_switch/enable` != '0*' ]; then
+    fail "disable_event trigger on sched_process_fork did not work"
+fi
+reset_trigger
+echo "Test semantic error for event enable/disable trigger"
+! echo 'enable_event:nogroup:noevent' > events/sched/sched_process_fork/trigger
+! echo 'disable_event+1' > events/sched/sched_process_fork/trigger
+echo 'enable_event:sched:sched_switch' > events/sched/sched_process_fork/trigger
+! echo 'enable_event:sched:sched_switch' > events/sched/sched_process_fork/trigger
+! echo 'disable_event:sched:sched_switch' > events/sched/sched_process_fork/trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc
new file mode 100644
index 000000000000..514e466e198b
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-filter.tc
@@ -0,0 +1,59 @@
+#!/bin/sh
+# description: event trigger - test trigger filter
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+echo "Test trigger filter"
+echo 1 > tracing_on
+echo 'traceoff if child_pid == 0' > events/sched/sched_process_fork/trigger
+( echo "forked")
+if [ `cat tracing_on` -ne 1 ]; then
+    fail "traceoff trigger on sched_process_fork did not work"
+fi
+reset_trigger
+echo "Test semantic error for trigger filter"
+! echo 'traceoff if a' > events/sched/sched_process_fork/trigger
+! echo 'traceoff if common_pid=0' > events/sched/sched_process_fork/trigger
+! echo 'traceoff if common_pid==b' > events/sched/sched_process_fork/trigger
+echo 'traceoff if common_pid == 0' > events/sched/sched_process_fork/trigger
+echo '!traceoff' > events/sched/sched_process_fork/trigger
+! echo 'traceoff if common_pid == child_pid' > events/sched/sched_process_fork/trigger
+echo 'traceoff if common_pid <= 0' > events/sched/sched_process_fork/trigger
+echo '!traceoff' > events/sched/sched_process_fork/trigger
+echo 'traceoff if common_pid >= 0' > events/sched/sched_process_fork/trigger
+echo '!traceoff' > events/sched/sched_process_fork/trigger
+echo 'traceoff if parent_pid >= 0 && child_pid >= 0' > events/sched/sched_process_fork/trigger
+echo '!traceoff' > events/sched/sched_process_fork/trigger
+echo 'traceoff if parent_pid >= 0 || child_pid >= 0' > events/sched/sched_process_fork/trigger
+echo '!traceoff' > events/sched/sched_process_fork/trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
new file mode 100644
index 000000000000..c2b61c4fda11
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist-mod.tc
@@ -0,0 +1,75 @@
+#!/bin/sh
+# description: event trigger - test histogram modifiers
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep hist events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "hist trigger is not supported"
+    exit_unsupported
+fi
+echo "Test histogram with execname modifier"
+echo 'hist:keys=common_pid.execname' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+COMM=`cat /proc/$$/comm`
+grep "common_pid: $COMM" events/sched/sched_process_fork/hist > /dev/null || \
+    fail "execname modifier on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with hex modifier"
+echo 'hist:keys=parent_pid.hex' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+# Note that $$ is the parent pid. $PID is current PID.
+HEX=`printf %x $PID`
+grep "parent_pid: $HEX" events/sched/sched_process_fork/hist > /dev/null || \
+    fail "hex modifier on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with syscall modifier"
+echo 'hist:keys=id.syscall' > events/raw_syscalls/sys_exit/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep "id: sys_" events/raw_syscalls/sys_exit/hist > /dev/null || \
+    fail "syscall modifier on raw_syscalls/sys_exit did not work"
+reset_trigger
+echo "Test histgram with log2 modifier"
+echo 'hist:keys=bytes_req.log2' > events/kmem/kmalloc/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep 'bytes_req: ~ 2^[0-9]*' events/kmem/kmalloc/hist > /dev/null || \
+    fail "log2 modifier on kmem/kmalloc did not work"
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
new file mode 100644
index 000000000000..b2902d42a537
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-hist.tc
@@ -0,0 +1,83 @@
+#!/bin/sh
+# description: event trigger - test histogram trigger
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep hist events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "hist trigger is not supported"
+    exit_unsupported
+fi
+echo "Test histogram basic tigger"
+echo 'hist:keys=parent_pid:vals=child_pid' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep parent_pid events/sched/sched_process_fork/hist > /dev/null || \
+    fail "hist trigger on sched_process_fork did not work"
+grep child events/sched/sched_process_fork/hist > /dev/null || \
+    fail "hist trigger on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with compound keys"
+echo 'hist:keys=parent_pid,child_pid' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep '^{ parent_pid:.*, child_pid:.*}' events/sched/sched_process_fork/hist > /dev/null || \
+    fail "compound keys on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with string key"
+echo 'hist:keys=parent_comm' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+COMM=`cat /proc/$$/comm`
+grep "parent_comm: $COMM" events/sched/sched_process_fork/hist > /dev/null || \
+    fail "string key on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with sort key"
+echo 'hist:keys=parent_pid,child_pid:sort=child_pid.ascending' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+check_inc() {
+    while [ $# -gt 1 ]; do
+        [ $1 -gt $2 ] && return 1
+        shift 1
+    done
+    return 0
+}
+check_inc `grep -o "child_pid:[[:space:]]*[[:digit:]]*" \
+    events/sched/sched_process_fork/hist | cut -d: -f2 ` ||
+    fail "sort param on sched_process_fork did not work"
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
new file mode 100644
index 000000000000..03c4a46561fc
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-multihist.tc
@@ -0,0 +1,73 @@
+#!/bin/sh
+# description: event trigger - test multiple histogram triggers
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep hist events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "hist trigger is not supported"
+    exit_unsupported
+fi
+reset_trigger
+echo "Test histogram multiple tiggers"
+echo 'hist:keys=parent_pid:vals=child_pid' > events/sched/sched_process_fork/trigger
+echo 'hist:keys=parent_comm:vals=child_pid' >> events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep parent_pid events/sched/sched_process_fork/hist > /dev/null || \
+    fail "hist trigger on sched_process_fork did not work"
+grep child events/sched/sched_process_fork/hist > /dev/null || \
+    fail "hist trigger on sched_process_fork did not work"
+COMM=`cat /proc/$$/comm`
+grep "parent_comm: $COMM" events/sched/sched_process_fork/hist > /dev/null || \
+    fail "string key on sched_process_fork did not work"
+reset_trigger
+echo "Test histogram with its name"
+echo 'hist:name=test_hist:keys=common_pid' > events/sched/sched_process_fork/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep test_hist events/sched/sched_process_fork/hist > /dev/null || \
+    fail "named event on sched_process_fork did not work"
+echo "Test same named histogram on different events"
+echo 'hist:name=test_hist:keys=common_pid' > events/sched/sched_process_exit/trigger
+for i in `seq 1 10` ; do ( echo "forked" > /dev/null); done
+grep test_hist events/sched/sched_process_exit/hist > /dev/null || \
+    fail "named event on sched_process_fork did not work"
+diffs=`diff events/sched/sched_process_exit/hist events/sched/sched_process_fork/hist | wc -l`
+test $diffs -eq 0 || fail "Same name histograms are not same"
+reset_trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-snapshot.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-snapshot.tc
new file mode 100644
index 000000000000..f84b80d551a2
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-snapshot.tc
@@ -0,0 +1,56 @@
+#!/bin/sh
+# description: event trigger - test snapshot-trigger
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep snapshot events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "snapshot trigger is not supported"
+    exit_unsupported
+fi
+echo "Test snapshot tigger"
+echo 0 > snapshot
+echo 1 > events/sched/sched_process_fork/enable
+( echo "forked")
+echo 'snapshot:1' > events/sched/sched_process_fork/trigger
+( echo "forked")
+grep sched_process_fork snapshot > /dev/null || \
+    fail "snapshot trigger on sched_process_fork did not work"
+reset_trigger
+echo 0 > snapshot
+echo 0 > events/sched/sched_process_fork/enable
+echo "Test snapshot semantic errors"
+! echo "snapshot+1" > events/sched/sched_process_fork/trigger
+echo "snapshot" > events/sched/sched_process_fork/trigger
+! echo "snapshot" > events/sched/sched_process_fork/trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-stacktrace.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-stacktrace.tc
new file mode 100644
index 000000000000..9fa23b085def
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-stacktrace.tc
@@ -0,0 +1,53 @@
+#!/bin/sh
+# description: event trigger - test stacktrace-trigger
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+FEATURE=`grep stacktrace events/sched/sched_process_fork/trigger`
+if [ -z "$FEATURE" ]; then
+    echo "stacktrace trigger is not supported"
+    exit_unsupported
+fi
+echo "Test stacktrace tigger"
+echo 0 > trace
+echo 0 > options/stacktrace
+echo 'stacktrace' > events/sched/sched_process_fork/trigger
+( echo "forked")
+grep "<stack trace>" trace > /dev/null || \
+    fail "stacktrace trigger on sched_process_fork did not work"
+reset_trigger
+echo "Test stacktrace semantic errors"
+! echo "stacktrace:foo" > events/sched/sched_process_fork/trigger
+echo "stacktrace" > events/sched/sched_process_fork/trigger
+! echo "stacktrace" > events/sched/sched_process_fork/trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-traceonoff.tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-traceonoff.tc
new file mode 100644
index 000000000000..87648e5f987c
--- /dev/null
+++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-traceonoff.tc
@@ -0,0 +1,58 @@
+#!/bin/sh
+# description: event trigger - test traceon/off trigger
+do_reset() {
+    reset_trigger
+    echo > set_event
+    clear_trace
+}
+fail() { #msg
+    do_reset
+    echo $1
+    exit $FAIL
+}
+if [ ! -f set_event -o ! -d events/sched ]; then
+    echo "event tracing is not supported"
+    exit_unsupported
+fi
+if [ ! -f events/sched/sched_process_fork/trigger ]; then
+    echo "event trigger is not supported"
+    exit_unsupported
+fi
+reset_tracer
+do_reset
+echo "Test traceoff trigger"
+echo 1 > tracing_on
+echo 'traceoff' > events/sched/sched_process_fork/trigger
+( echo "forked")
+if [ `cat tracing_on` -ne 0 ]; then
+    fail "traceoff trigger on sched_process_fork did not work"
+fi
+reset_trigger
+echo "Test traceon trigger"
+echo 0 > tracing_on
+echo 'traceon' > events/sched/sched_process_fork/trigger
+( echo "forked")
+if [ `cat tracing_on` -ne 1 ]; then
+    fail "traceoff trigger on sched_process_fork did not work"
+fi
+reset_trigger
+echo "Test semantic error for traceoff/on trigger"
+! echo 'traceoff:badparam' > events/sched/sched_process_fork/trigger
+! echo 'traceoff+0' > events/sched/sched_process_fork/trigger
+echo 'traceon' > events/sched/sched_process_fork/trigger
+! echo 'traceon' > events/sched/sched_process_fork/trigger
+! echo 'traceoff' > events/sched/sched_process_fork/trigger
+do_reset
+exit 0
diff --git a/tools/testing/selftests/intel_pstate/run.sh b/tools/testing/selftests/intel_pstate/run.sh
index bdaf37e92684..7868c106b8b1 100755
--- a/tools/testing/selftests/intel_pstate/run.sh
+++ b/tools/testing/selftests/intel_pstate/run.sh
@@ -32,7 +32,7 @@ EVALUATE_ONLY=0
 max_cpus=$(($(nproc)-1))
 # compile programs
-gcc -o aperf aperf.c -lm
+gcc aperf.c -Wall -D_GNU_SOURCE -o aperf  -lm
 [ $? -ne 0 ] && echo "Problem compiling aperf.c." && exit 1
 gcc -o msr msr.c -lm
 [ $? -ne 0 ] && echo "Problem compiling msr.c." && exit 1
diff --git a/tools/testing/selftests/net/reuseport_bpf.c b/tools/testing/selftests/net/reuseport_bpf.c
index 96ba386b1b7b..4a8217448f20 100644
--- a/tools/testing/selftests/net/reuseport_bpf.c
+++ b/tools/testing/selftests/net/reuseport_bpf.c
@@ -111,9 +111,9 @@ static void attach_ebpf(int fd, uint16_t mod)
        memset(&attr, 0, sizeof(attr));
        attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
        attr.insn_cnt = ARRAY_SIZE(prog);
-        attr.insns = (uint64_t)prog;
+        attr.insns = (unsigned long) &prog;
-        attr.license = (uint64_t)bpf_license;
+        attr.license = (unsigned long) &bpf_license;
-        attr.log_buf = (uint64_t)bpf_log_buf;
+        attr.log_buf = (unsigned long) &bpf_log_buf;
        attr.log_size = sizeof(bpf_log_buf);
        attr.log_level = 1;
        attr.kern_version = 0;
@@ -351,8 +351,8 @@ static void test_filter_no_reuseport(const struct test_params p)
        memset(&eprog, 0, sizeof(eprog));
        eprog.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
        eprog.insn_cnt = ARRAY_SIZE(ecode);
-        eprog.insns = (uint64_t)ecode;
+        eprog.insns = (unsigned long) &ecode;
-        eprog.license = (uint64_t)bpf_license;
+        eprog.license = (unsigned long) &bpf_license;
        eprog.kern_version = 0;
        memset(&cprog, 0, sizeof(cprog));
diff --git a/tools/testing/selftests/powerpc/Makefile b/tools/testing/selftests/powerpc/Makefile
index b08f77cbe31b..4ca83fe80654 100644
--- a/tools/testing/selftests/powerpc/Makefile
+++ b/tools/testing/selftests/powerpc/Makefile
@@ -14,6 +14,7 @@ export CFLAGS
 SUB_DIRS = benchmarks           \
           copyloops            \
+           context_switch       \
           dscr                 \
           mm                   \
           pmu                  \
diff --git a/tools/testing/selftests/powerpc/context_switch/.gitignore b/tools/testing/selftests/powerpc/context_switch/.gitignore
new file mode 100644
index 000000000000..c1431af7b51c
--- /dev/null
+++ b/tools/testing/selftests/powerpc/context_switch/.gitignore
@@ -0,0 +1 @@
+cp_abort
diff --git a/tools/testing/selftests/powerpc/context_switch/Makefile b/tools/testing/selftests/powerpc/context_switch/Makefile
new file mode 100644
index 000000000000..e164d1466466
--- /dev/null
+++ b/tools/testing/selftests/powerpc/context_switch/Makefile
@@ -0,0 +1,10 @@
+TEST_PROGS := cp_abort
+all: $(TEST_PROGS)
+$(TEST_PROGS): ../harness.c ../utils.c
+include ../../lib.mk
+clean:
+        rm -f $(TEST_PROGS)
diff --git a/tools/testing/selftests/powerpc/context_switch/cp_abort.c b/tools/testing/selftests/powerpc/context_switch/cp_abort.c
new file mode 100644
index 000000000000..5a5b55afda0e
--- /dev/null
+++ b/tools/testing/selftests/powerpc/context_switch/cp_abort.c
@@ -0,0 +1,110 @@
+/*
+ * Adapted from Anton Blanchard's context switch microbenchmark.
+ *
+ * Copyright 2009, Anton Blanchard, IBM Corporation.
+ * Copyright 2016, Mikey Neuling, Chris Smart, IBM Corporation.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * This program tests the copy paste abort functionality of a P9
+ * (or later) by setting up two processes on the same CPU, one
+ * which executes the copy instruction and the other which
+ * executes paste.
+ *
+ * The paste instruction should never succeed, as the cp_abort
+ * instruction is called by the kernel during a context switch.
+ *
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include "utils.h"
+#include <sched.h>
+#define READ_FD 0
+#define WRITE_FD 1
+#define NUM_LOOPS 1000
+/* This defines the "paste" instruction from Power ISA 3.0 Book II, section 4.4. */
+#define PASTE(RA, RB, L, RC) \
+        .long (0x7c00070c | (RA) << (31-15) | (RB) << (31-20) | (L) << (31-10) | (RC) << (31-31))
+int paste(void *i)
+{
+        int cr;
+        asm volatile(str(PASTE(0, %1, 1, 1))";"
+                        "mfcr %0;"
+                        : "=r" (cr)
+                        : "b" (i)
+                        : "memory"
+                    );
+        return cr;
+}
+/* This defines the "copy" instruction from Power ISA 3.0 Book II, section 4.4. */
+#define COPY(RA, RB, L) \
+        .long (0x7c00060c | (RA) << (31-15) | (RB) << (31-20) | (L) << (31-10))
+void copy(void *i)
+{
+        asm volatile(str(COPY(0, %0, 1))";"
+                        :
+                        : "b" (i)
+                        : "memory"
+                    );
+}
+int test_cp_abort(void)
+{
+        /* 128 bytes for a full cache line */
+        char buf[128] __cacheline_aligned;
+        cpu_set_t cpuset;
+        int fd1[2], fd2[2], pid;
+        char c;
+        /* only run this test on a P9 or later */
+        SKIP_IF(!have_hwcap2(PPC_FEATURE2_ARCH_3_00));
+        /*
+         * Run both processes on the same CPU, so that copy is more likely
+         * to leak into a paste.
+         */
+        CPU_ZERO(&cpuset);
+        CPU_SET(pick_online_cpu(), &cpuset);
+        FAIL_IF(sched_setaffinity(0, sizeof(cpuset), &cpuset));
+        FAIL_IF(pipe(fd1) || pipe(fd2));
+        pid = fork();
+        FAIL_IF(pid < 0);
+        if (!pid) {
+                for (int i = 0; i < NUM_LOOPS; i++) {
+                        FAIL_IF((write(fd1[WRITE_FD], &c, 1)) != 1);
+                        FAIL_IF((read(fd2[READ_FD], &c, 1)) != 1);
+                        /* A paste succeeds if CR0 EQ bit is set */
+                        FAIL_IF(paste(buf) & 0x20000000);
+                }
+        } else {
+                for (int i = 0; i < NUM_LOOPS; i++) {
+                        FAIL_IF((read(fd1[READ_FD], &c, 1)) != 1);
+                        copy(buf);
+                        FAIL_IF((write(fd2[WRITE_FD], &c, 1) != 1));
+                }
+        }
+        return 0;
+}
+int main(int argc, char *argv[])
+{
+        return test_harness(test_cp_abort, "cp_abort");
+}
diff --git a/tools/testing/selftests/powerpc/mm/subpage_prot.c b/tools/testing/selftests/powerpc/mm/subpage_prot.c
index 440180ff8089..35ade7406dcd 100644
--- a/tools/testing/selftests/powerpc/mm/subpage_prot.c
+++ b/tools/testing/selftests/powerpc/mm/subpage_prot.c
@@ -73,7 +73,7 @@ static inline void check_faulted(void *addr, long page, long subpage, int write)
                want_fault |= (subpage == ((page + 1) % 16));
        if (faulted != want_fault) {
-                printf("Failed at 0x%p (p=%ld,sp=%ld,w=%d), want=%s, got=%s !\n",
+                printf("Failed at %p (p=%ld,sp=%ld,w=%d), want=%s, got=%s !\n",
                       addr, page, subpage, write,
                       want_fault ? "fault" : "pass",
                       faulted ? "fault" : "pass");
@@ -82,7 +82,7 @@ static inline void check_faulted(void *addr, long page, long subpage, int write)
        if (faulted) {
                if (dar != addr) {
-                        printf("Fault expected at 0x%p and happened at 0x%p !\n",
+                        printf("Fault expected at %p and happened at %p !\n",
                               addr, dar);
                }
                faulted = 0;
@@ -162,7 +162,7 @@ int test_anon(void)
        mallocblock = (void *)align;
-        printf("allocated malloc block of 0x%lx bytes at 0x%p\n",
+        printf("allocated malloc block of 0x%lx bytes at %p\n",
               mallocsize, mallocblock);
        printf("testing malloc block...\n");
@@ -197,7 +197,7 @@ int test_file(void)
                perror("failed to map file");
                return 1;
        }
-        printf("allocated %s for 0x%lx bytes at 0x%p\n",
+        printf("allocated %s for 0x%lx bytes at %p\n",
               file_name, filesize, fileblock);
        printf("testing file map...\n");
@@ -207,14 +207,16 @@ int test_file(void)
 int main(int argc, char *argv[])
 {
-        test_harness(test_anon, "subpage_prot_anon");
+        int rc;
+        rc = test_harness(test_anon, "subpage_prot_anon");
+        if (rc)
+                return rc;
        if (argc > 1)
                file_name = argv[1];
        else
                file_name = "tempfile";
-        test_harness(test_file, "subpage_prot_file");
+        return test_harness(test_file, "subpage_prot_file");
-        return 0;
 }
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/ebb.c b/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
index e67452f1bcff..46681fec549b 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
+++ b/tools/testing/selftests/powerpc/pmu/ebb/ebb.c
@@ -15,7 +15,6 @@
 #include <sys/ioctl.h>
 #include "trace.h"
-#include "reg.h"
 #include "ebb.h"
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/reg_access_test.c b/tools/testing/selftests/powerpc/pmu/ebb/reg_access_test.c
index 5b1188f10c15..f923228bca22 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/reg_access_test.c
+++ b/tools/testing/selftests/powerpc/pmu/ebb/reg_access_test.c
@@ -7,7 +7,6 @@
 #include <stdlib.h>
 #include "ebb.h"
-#include "reg.h"
 /*
diff --git a/tools/testing/selftests/powerpc/pmu/ebb/reg.h b/tools/testing/selftests/powerpc/reg.h
index 5921b0dfe2e9..65bfdeeebdee 100644
--- a/tools/testing/selftests/powerpc/pmu/ebb/reg.h
+++ b/tools/testing/selftests/powerpc/reg.h
@@ -9,12 +9,12 @@
 #define __stringify_1(x)        #x
 #define __stringify(x)          __stringify_1(x)
-#define mfspr(rn)       ({unsigned long rval; \
+#define mfspr(rn)       ({unsigned long rval; \
-                         asm volatile("mfspr %0," __stringify(rn) \
+                         asm volatile("mfspr %0," _str(rn) \
-                                 : "=r" (rval)); rval; })
+                                    : "=r" (rval)); rval; })
-#define mtspr(rn, v)    asm volatile("mtspr " __stringify(rn) ",%0" : \
+#define mtspr(rn, v)    asm volatile("mtspr " _str(rn) ",%0" : \
-                                    : "r" ((unsigned long)(v)) \
+                                    : "r" ((unsigned long)(v)) \
-                                    : "memory")
+                                    : "memory")
 #define mb()            asm volatile("sync" : : : "memory");
@@ -46,4 +46,10 @@
 #define SPRN_SDAR      781
 #define SPRN_SIER      768
+#define SPRN_TEXASR     0x82
+#define SPRN_TFIAR      0x81    /* Transaction Failure Inst Addr    */
+#define SPRN_TFHAR      0x80    /* Transaction Failure Handler Addr */
+#define TEXASR_FS       0x08000000
+#define SPRN_TAR        0x32f
 #endif /* _SELFTESTS_POWERPC_REG_H */
diff --git a/tools/testing/selftests/powerpc/tm/.gitignore b/tools/testing/selftests/powerpc/tm/.gitignore
index 7d0f14b8cb2e..bb942db845bf 100644
--- a/tools/testing/selftests/powerpc/tm/.gitignore
+++ b/tools/testing/selftests/powerpc/tm/.gitignore
@@ -3,3 +3,6 @@ tm-syscall
 tm-signal-msr-resv
 tm-signal-stack
 tm-vmxcopy
+tm-fork
+tm-tar
+tm-tmspr
diff --git a/tools/testing/selftests/powerpc/tm/Makefile b/tools/testing/selftests/powerpc/tm/Makefile
index 737f72c964e6..d0505dbd22d5 100644
--- a/tools/testing/selftests/powerpc/tm/Makefile
+++ b/tools/testing/selftests/powerpc/tm/Makefile
@@ -1,4 +1,4 @@
-TEST_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack tm-vmxcopy
+TEST_PROGS := tm-resched-dscr tm-syscall tm-signal-msr-resv tm-signal-stack tm-vmxcopy tm-fork tm-tar tm-tmspr
 all: $(TEST_PROGS)
@@ -6,6 +6,7 @@ $(TEST_PROGS): ../harness.c ../utils.c
 tm-syscall: tm-syscall-asm.S
 tm-syscall: CFLAGS += -mhtm -I../../../../../usr/include
+tm-tmspr: CFLAGS += -pthread
 include ../../lib.mk
diff --git a/tools/testing/selftests/powerpc/tm/tm-fork.c b/tools/testing/selftests/powerpc/tm/tm-fork.c
new file mode 100644
index 000000000000..8d48579b7778
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-fork.c
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2015, Michael Neuling, IBM Corp.
+ * Licensed under GPLv2.
+ *
+ * Edited: Rashmica Gupta, Nov 2015
+ *
+ * This test does a fork syscall inside a transaction. Basic sniff test
+ * to see if we can enter the kernel during a transaction.
+ */
+#include <errno.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "utils.h"
+#include "tm.h"
+int test_fork(void)
+{
+        SKIP_IF(!have_htm());
+        asm __volatile__(
+                "tbegin.;"
+                "blt    1f; "
+                "li     0, 2;"  /* fork syscall */
+                "sc  ;"
+                "tend.;"
+                "1: ;"
+                : : : "memory", "r0");
+        /* If we reach here, we've passed.  Otherwise we've probably crashed
+         * the kernel */
+        return 0;
+}
+int main(int argc, char *argv[])
+{
+        return test_harness(test_fork, "tm_fork");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-resched-dscr.c b/tools/testing/selftests/powerpc/tm/tm-resched-dscr.c
index 8fde93d6021f..d9c49f41515e 100644
--- a/tools/testing/selftests/powerpc/tm/tm-resched-dscr.c
+++ b/tools/testing/selftests/powerpc/tm/tm-resched-dscr.c
@@ -31,12 +31,6 @@
 #include "utils.h"
 #include "tm.h"
-#define TBEGIN          ".long 0x7C00051D ;"
-#define TEND            ".long 0x7C00055D ;"
-#define TCHECK          ".long 0x7C00059C ;"
-#define TSUSPEND        ".long 0x7C0005DD ;"
-#define TRESUME         ".long 0x7C2005DD ;"
-#define SPRN_TEXASR     0x82
 #define SPRN_DSCR       0x03
 int test_body(void)
@@ -55,13 +49,13 @@ int test_body(void)
                        "mtspr   %[sprn_dscr], 3;"
                        /* start and suspend a transaction */
-                        TBEGIN
+                        "tbegin.;"
                        "beq     1f;"
-                        TSUSPEND
+                        "tsuspend.;"
                        /* hard loop until the transaction becomes doomed */
                        "2: ;"
-                        TCHECK
+                        "tcheck 0;"
                        "bc      4, 0, 2b;"
                        /* record DSCR and TEXASR */
@@ -70,8 +64,8 @@ int test_body(void)
                        "mfspr   3, %[sprn_texasr];"
                        "std     3, %[texasr];"
-                        TRESUME
+                        "tresume.;"
-                        TEND
+                        "tend.;"
                        "li      %[rv], 0;"
                        "1: ;"
                        : [rv]"=r"(rv), [dscr2]"=m"(dscr2), [texasr]"=m"(texasr)
diff --git a/tools/testing/selftests/powerpc/tm/tm-signal-stack.c b/tools/testing/selftests/powerpc/tm/tm-signal-stack.c
index e44a238c1d77..1f0eb567438d 100644
--- a/tools/testing/selftests/powerpc/tm/tm-signal-stack.c
+++ b/tools/testing/selftests/powerpc/tm/tm-signal-stack.c
@@ -60,9 +60,9 @@ int tm_signal_stack()
                exit(1);
        asm volatile("li 1, 0 ;"                /* stack ptr == NULL */
                     "1:"
-                     ".long 0x7C00051D ;"       /* tbegin */
+                     "tbegin.;"
                     "beq 1b ;"                 /* retry forever */
-                     ".long 0x7C0005DD ; ;"     /* tsuspend */
+                     "tsuspend.;"
                     "ld 2, 0(1) ;"             /* trigger segv" */
                     : : : "memory");
diff --git a/tools/testing/selftests/powerpc/tm/tm-tar.c b/tools/testing/selftests/powerpc/tm/tm-tar.c
new file mode 100644
index 000000000000..2d2fcc2b7a60
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-tar.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2015, Michael Neuling, IBM Corp.
+ * Licensed under GPLv2.
+ * Original: Michael Neuling 19/7/2013
+ * Edited: Rashmica Gupta 01/12/2015
+ *
+ * Do some transactions, see if the tar is corrupted.
+ * If the transaction is aborted, the TAR should be rolled back to the
+ * checkpointed value before the transaction began. The value written to
+ * TAR in suspended mode should only remain in TAR if the transaction
+ * completes.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include "tm.h"
+#include "utils.h"
+int     num_loops       = 10000;
+int test_tar(void)
+{
+        int i;
+        SKIP_IF(!have_htm());
+        for (i = 0; i < num_loops; i++)
+        {
+                uint64_t result = 0;
+                asm __volatile__(
+                        "li     7, 1;"
+                        "mtspr  %[tar], 7;"     /* tar = 1 */
+                        "tbegin.;"
+                        "beq    3f;"
+                        "li     4, 0x7000;"     /* Loop lots, to use time */
+                        "2:;"                   /* Start loop */
+                        "li     7, 2;"
+                        "mtspr  %[tar], 7;"     /* tar = 2 */
+                        "tsuspend.;"
+                        "li     7, 3;"
+                        "mtspr  %[tar], 7;"     /* tar = 3 */
+                        "tresume.;"
+                        "subi   4, 4, 1;"
+                        "cmpdi  4, 0;"
+                        "bne    2b;"
+                        "tend.;"
+                        /* Transaction sucess! TAR should be 3 */
+                        "mfspr  7, %[tar];"
+                        "ori    %[res], 7, 4;"  // res = 3|4 = 7
+                        "b      4f;"
+                        /* Abort handler. TAR should be rolled back to 1 */
+                        "3:;"
+                        "mfspr  7, %[tar];"
+                        "ori    %[res], 7, 8;"  // res = 1|8 = 9
+                        "4:;"
+                        : [res]"=r"(result)
+                        : [tar]"i"(SPRN_TAR)
+                           : "memory", "r0", "r4", "r7");
+                /* If result is anything else other than 7 or 9, the tar
+                 * value must have been corrupted. */
+                if ((result != 7) && (result != 9))
+                        return 1;
+        }
+        return 0;
+}
+int main(int argc, char *argv[])
+{
+        /* A low number of iterations (eg 100) can cause a false pass */
+        if (argc > 1) {
+                if (strcmp(argv[1], "-h") == 0) {
+                        printf("Syntax:\n\t%s [<num loops>]\n",
+                               argv[0]);
+                        return 1;
+                } else {
+                        num_loops = atoi(argv[1]);
+                }
+        }
+        printf("Starting, %d loops\n", num_loops);
+        return test_harness(test_tar, "tm_tar");
+}
diff --git a/tools/testing/selftests/powerpc/tm/tm-tmspr.c b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
new file mode 100644
index 000000000000..2bda81c7bf23
--- /dev/null
+++ b/tools/testing/selftests/powerpc/tm/tm-tmspr.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright 2015, Michael Neuling, IBM Corp.
+ * Licensed under GPLv2.
+ *
+ * Original: Michael Neuling 3/4/2014
+ * Modified: Rashmica Gupta 8/12/2015
+ *
+ * Check if any of the Transaction Memory SPRs get corrupted.
+ * - TFIAR  - stores address of location of transaction failure
+ * - TFHAR  - stores address of software failure handler (if transaction
+ *   fails)
+ * - TEXASR - lots of info about the transacion(s)
+ *
+ * (1) create more threads than cpus
+ * (2) in each thread:
+ *      (a) set TFIAR and TFHAR a unique value
+ *      (b) loop for awhile, continually checking to see if
+ *      either register has been corrupted.
+ *
+ * (3) Loop:
+ *      (a) begin transaction
+ *      (b) abort transaction
+ *      (c) check TEXASR to see if FS has been corrupted
+ *
+ */
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <string.h>
+#include "utils.h"
+#include "tm.h"
+int     num_loops       = 10000;
+int     passed = 1;
+void tfiar_tfhar(void *in)
+{
+        int i, cpu;
+        unsigned long tfhar, tfhar_rd, tfiar, tfiar_rd;
+        cpu_set_t cpuset;
+        CPU_ZERO(&cpuset);
+        cpu = (unsigned long)in >> 1;
+        CPU_SET(cpu, &cpuset);
+        sched_setaffinity(0, sizeof(cpuset), &cpuset);
+        /* TFIAR: Last bit has to be high so userspace can read register */
+        tfiar = ((unsigned long)in) + 1;
+        tfiar += 2;
+        mtspr(SPRN_TFIAR, tfiar);
+        /* TFHAR: Last two bits are reserved */
+        tfhar = ((unsigned long)in);
+        tfhar &= ~0x3UL;
+        tfhar += 4;
+        mtspr(SPRN_TFHAR, tfhar);
+        for (i = 0; i < num_loops; i++) {
+                tfhar_rd = mfspr(SPRN_TFHAR);
+                tfiar_rd = mfspr(SPRN_TFIAR);
+                if ( (tfhar != tfhar_rd) || (tfiar != tfiar_rd) ) {
+                        passed = 0;
+                        return;
+                }
+        }
+        return;
+}
+void texasr(void *in)
+{
+        unsigned long i;
+        uint64_t result = 0;
+        for (i = 0; i < num_loops; i++) {
+                asm __volatile__(
+                        "tbegin.;"
+                        "beq    3f ;"
+                        "tabort. 0 ;"
+                        "tend.;"
+                        /* Abort handler */
+                        "3: ;"
+                        ::: "memory");
+                /* Check the TEXASR */
+                result = mfspr(SPRN_TEXASR);
+                if ((result & TEXASR_FS) == 0) {
+                        passed = 0;
+                        return;
+                }
+        }
+        return;
+}
+int test_tmspr()
+{
+        pthread_t       thread;
+        int             thread_num;
+        unsigned long   i;
+        SKIP_IF(!have_htm());
+        /* To cause some context switching */
+        thread_num = 10 * sysconf(_SC_NPROCESSORS_ONLN);
+        /* Test TFIAR and TFHAR */
+        for (i = 0 ; i < thread_num ; i += 2){
+                if (pthread_create(&thread, NULL, (void*)tfiar_tfhar, (void *)i))
+                        return EXIT_FAILURE;
+        }
+        if (pthread_join(thread, NULL) != 0)
+                return EXIT_FAILURE;
+        /* Test TEXASR */
+        for (i = 0 ; i < thread_num ; i++){
+                if (pthread_create(&thread, NULL, (void*)texasr, (void *)i))
+                        return EXIT_FAILURE;
+        }
+        if (pthread_join(thread, NULL) != 0)
+                return EXIT_FAILURE;
+        if (passed)
+                return 0;
+        else
+                return 1;
+}
+int main(int argc, char *argv[])
+{
+        if (argc > 1) {
+                if (strcmp(argv[1], "-h") == 0) {
+                        printf("Syntax:\t [<num loops>]\n");
+                        return 0;
+                } else {
+                        num_loops = atoi(argv[1]);
+                }
+        }
+        return test_harness(test_tmspr, "tm_tmspr");
+}
diff --git a/tools/testing/selftests/powerpc/utils.h b/tools/testing/selftests/powerpc/utils.h
index 175ac6ad10dd..a985cfaa535e 100644
--- a/tools/testing/selftests/powerpc/utils.h
+++ b/tools/testing/selftests/powerpc/utils.h
@@ -6,9 +6,12 @@
 #ifndef _SELFTESTS_POWERPC_UTILS_H
 #define _SELFTESTS_POWERPC_UTILS_H
+#define __cacheline_aligned __attribute__((aligned(128)))
 #include <stdint.h>
 #include <stdbool.h>
 #include <linux/auxvec.h>
+#include "reg.h"
 /* Avoid headaches with PRI?64 - just use %ll? always */
 typedef unsigned long long u64;
@@ -54,4 +57,9 @@ do {								\
 #define _str(s) #s
 #define str(s) _str(s)
+/* POWER9 feature */
+#ifndef PPC_FEATURE2_ARCH_3_00
+#define PPC_FEATURE2_ARCH_3_00 0x00800000
+#endif
 #endif /* _SELFTESTS_POWERPC_UTILS_H */
diff --git a/tools/testing/selftests/seccomp/seccomp_bpf.c b/tools/testing/selftests/seccomp/seccomp_bpf.c
index 150829dd7998..2e58549b2f02 100644
--- a/tools/testing/selftests/seccomp/seccomp_bpf.c
+++ b/tools/testing/selftests/seccomp/seccomp_bpf.c
@@ -5,6 +5,7 @@
 * Test code for seccomp bpf.
 */
+#include <sys/types.h>
 #include <asm/siginfo.h>
 #define __have_siginfo_t 1
 #define __have_sigval_t 1
@@ -14,7 +15,6 @@
 #include <linux/filter.h>
 #include <sys/prctl.h>
 #include <sys/ptrace.h>
-#include <sys/types.h>
 #include <sys/user.h>
 #include <linux/prctl.h>
 #include <linux/ptrace.h>
@@ -1234,6 +1234,10 @@ TEST_F(TRACE_poke, getpid_runs_normally)
 # define ARCH_REGS      struct user_pt_regs
 # define SYSCALL_NUM    regs[8]
 # define SYSCALL_RET    regs[0]
+#elif defined(__hppa__)
+# define ARCH_REGS      struct user_regs_struct
+# define SYSCALL_NUM    gr[20]
+# define SYSCALL_RET    gr[28]
 #elif defined(__powerpc__)
 # define ARCH_REGS      struct pt_regs
 # define SYSCALL_NUM    gpr[0]
@@ -1242,6 +1246,12 @@ TEST_F(TRACE_poke, getpid_runs_normally)
 # define ARCH_REGS     s390_regs
 # define SYSCALL_NUM   gprs[2]
 # define SYSCALL_RET   gprs[2]
+#elif defined(__mips__)
+# define ARCH_REGS      struct pt_regs
+# define SYSCALL_NUM    regs[2]
+# define SYSCALL_SYSCALL_NUM regs[4]
+# define SYSCALL_RET    regs[2]
+# define SYSCALL_NUM_RET_SHARE_REG
 #else
 # error "Do not know how to find your architecture's registers and syscalls"
 #endif
@@ -1249,7 +1259,7 @@ TEST_F(TRACE_poke, getpid_runs_normally)
 /* Use PTRACE_GETREGS and PTRACE_SETREGS when available. This is useful for
 * architectures without HAVE_ARCH_TRACEHOOK (e.g. User-mode Linux).
 */
-#if defined(__x86_64__) || defined(__i386__)
+#if defined(__x86_64__) || defined(__i386__) || defined(__mips__)
 #define HAVE_GETREGS
 #endif
@@ -1273,6 +1283,10 @@ int get_syscall(struct __test_metadata *_metadata, pid_t tracee)
        }
 #endif
+#if defined(__mips__)
+        if (regs.SYSCALL_NUM == __NR_O32_Linux)
+                return regs.SYSCALL_SYSCALL_NUM;
+#endif
        return regs.SYSCALL_NUM;
 }
@@ -1293,10 +1307,17 @@ void change_syscall(struct __test_metadata *_metadata,
        EXPECT_EQ(0, ret);
 #if defined(__x86_64__) || defined(__i386__) || defined(__powerpc__) || \
-    defined(__s390__)
+    defined(__s390__) || defined(__hppa__)
        {
                regs.SYSCALL_NUM = syscall;
        }
+#elif defined(__mips__)
+        {
+                if (regs.SYSCALL_NUM == __NR_O32_Linux)
+                        regs.SYSCALL_SYSCALL_NUM = syscall;
+                else
+                        regs.SYSCALL_NUM = syscall;
+        }
 #elif defined(__arm__)
 # ifndef PTRACE_SET_SYSCALL
@@ -1327,7 +1348,11 @@ void change_syscall(struct __test_metadata *_metadata,
        /* If syscall is skipped, change return value. */
        if (syscall == -1)
+#ifdef SYSCALL_NUM_RET_SHARE_REG
+                TH_LOG("Can't modify syscall return on this architecture");
+#else
                regs.SYSCALL_RET = 1;
+#endif
 #ifdef HAVE_GETREGS
        ret = ptrace(PTRACE_SETREGS, tracee, 0, &regs);
@@ -1465,8 +1490,13 @@ TEST_F(TRACE_syscall, syscall_dropped)
        ret = prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &self->prog, 0, 0);
        ASSERT_EQ(0, ret);
+#ifdef SYSCALL_NUM_RET_SHARE_REG
+        /* gettid has been skipped */
+        EXPECT_EQ(-1, syscall(__NR_gettid));
+#else
        /* gettid has been skipped and an altered return value stored. */
        EXPECT_EQ(1, syscall(__NR_gettid));
+#endif
        EXPECT_NE(self->mytid, syscall(__NR_gettid));
 }
@@ -1479,6 +1509,8 @@ TEST_F(TRACE_syscall, syscall_dropped)
 #  define __NR_seccomp 383
 # elif defined(__aarch64__)
 #  define __NR_seccomp 277
+# elif defined(__hppa__)
+#  define __NR_seccomp 338
 # elif defined(__powerpc__)
 #  define __NR_seccomp 358
 # elif defined(__s390__)
diff --git a/tools/testing/selftests/vm/thuge-gen.c b/tools/testing/selftests/vm/thuge-gen.c
index c87957295f74..0bc737a75150 100644
--- a/tools/testing/selftests/vm/thuge-gen.c
+++ b/tools/testing/selftests/vm/thuge-gen.c
@@ -30,7 +30,9 @@
 #define MAP_HUGE_1GB    (30 << MAP_HUGE_SHIFT)
 #define MAP_HUGE_SHIFT  26
 #define MAP_HUGE_MASK   0x3f
+#if !defined(MAP_HUGETLB)
 #define MAP_HUGETLB     0x40000
+#endif
 #define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
 #define SHM_HUGE_SHIFT  26
diff --git a/tools/usb/usbip/libsrc/Makefile.am b/tools/usb/usbip/libsrc/Makefile.am
index 7c8f8a4d54e4..90daf95c0804 100644
--- a/tools/usb/usbip/libsrc/Makefile.am
+++ b/tools/usb/usbip/libsrc/Makefile.am
@@ -4,5 +4,7 @@ libusbip_la_LDFLAGS  = -version-info @LIBUSBIP_VERSION@
 lib_LTLIBRARIES := libusbip.la
 libusbip_la_SOURCES := names.c names.h usbip_host_driver.c usbip_host_driver.h \
-                       usbip_common.c usbip_common.h vhci_driver.c vhci_driver.h \
+                       usbip_device_driver.c usbip_device_driver.h \
+                       usbip_common.c usbip_common.h usbip_host_common.h \
+                       usbip_host_common.c vhci_driver.c vhci_driver.h \
                       sysfs_utils.c sysfs_utils.h
diff --git a/tools/usb/usbip/libsrc/usbip_common.h b/tools/usb/usbip/libsrc/usbip_common.h
index 15fe792e1e96..51ef5fe485dd 100644
--- a/tools/usb/usbip/libsrc/usbip_common.h
+++ b/tools/usb/usbip/libsrc/usbip_common.h
@@ -25,9 +25,12 @@
 #define VHCI_STATE_PATH "/var/run/vhci_hcd"
 #endif
+#define VUDC_DEVICE_DESCR_FILE "dev_desc"
 /* kernel module names */
 #define USBIP_CORE_MOD_NAME     "usbip-core"
 #define USBIP_HOST_DRV_NAME     "usbip-host"
+#define USBIP_DEVICE_DRV_NAME   "usbip-vudc"
 #define USBIP_VHCI_DRV_NAME     "vhci_hcd"
 /* sysfs constants */
diff --git a/tools/usb/usbip/libsrc/usbip_device_driver.c b/tools/usb/usbip/libsrc/usbip_device_driver.c
new file mode 100644
index 000000000000..e059b7d1ec5b
--- /dev/null
+++ b/tools/usb/usbip/libsrc/usbip_device_driver.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
+ *               2015 Samsung Electronics
+ * Author:       Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *
+ * Based on tools/usb/usbip/libsrc/usbip_host_driver.c, which is:
+ * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
+ *               2005-2007 Takahiro Hirofuchi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <fcntl.h>
+#include <string.h>
+#include <linux/usb/ch9.h>
+#include <unistd.h>
+#include "usbip_host_common.h"
+#include "usbip_device_driver.h"
+#undef  PROGNAME
+#define PROGNAME "libusbip"
+#define copy_descr_attr16(dev, descr, attr)                     \
+                ((dev)->attr = le16toh((descr)->attr))          \
+#define copy_descr_attr(dev, descr, attr)                       \
+                ((dev)->attr = (descr)->attr)                   \
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+static struct {
+        enum usb_device_speed speed;
+        const char *name;
+} speed_names[] = {
+        {
+                .speed = USB_SPEED_UNKNOWN,
+                .name = "UNKNOWN",
+        },
+        {
+                .speed = USB_SPEED_LOW,
+                .name = "low-speed",
+        },
+        {
+                .speed = USB_SPEED_FULL,
+                .name = "full-speed",
+        },
+        {
+                .speed = USB_SPEED_HIGH,
+                .name = "high-speed",
+        },
+        {
+                .speed = USB_SPEED_WIRELESS,
+                .name = "wireless",
+        },
+        {
+                .speed = USB_SPEED_SUPER,
+                .name = "super-speed",
+        },
+};
+static
+int read_usb_vudc_device(struct udev_device *sdev, struct usbip_usb_device *dev)
+{
+        const char *path, *name;
+        char filepath[SYSFS_PATH_MAX];
+        struct usb_device_descriptor descr;
+        unsigned i;
+        FILE *fd = NULL;
+        struct udev_device *plat;
+        const char *speed;
+        int ret = 0;
+        plat = udev_device_get_parent(sdev);
+        path = udev_device_get_syspath(plat);
+        snprintf(filepath, SYSFS_PATH_MAX, "%s/%s",
+                 path, VUDC_DEVICE_DESCR_FILE);
+        fd = fopen(filepath, "r");
+        if (!fd)
+                return -1;
+        ret = fread((char *) &descr, sizeof(descr), 1, fd);
+        if (ret < 0)
+                return -1;
+        fclose(fd);
+        copy_descr_attr(dev, &descr, bDeviceClass);
+        copy_descr_attr(dev, &descr, bDeviceSubClass);
+        copy_descr_attr(dev, &descr, bDeviceProtocol);
+        copy_descr_attr(dev, &descr, bNumConfigurations);
+        copy_descr_attr16(dev, &descr, idVendor);
+        copy_descr_attr16(dev, &descr, idProduct);
+        copy_descr_attr16(dev, &descr, bcdDevice);
+        strncpy(dev->path, path, SYSFS_PATH_MAX);
+        dev->speed = USB_SPEED_UNKNOWN;
+        speed = udev_device_get_sysattr_value(sdev, "current_speed");
+        if (speed) {
+                for (i = 0; i < ARRAY_SIZE(speed_names); i++) {
+                        if (!strcmp(speed_names[i].name, speed)) {
+                                dev->speed = speed_names[i].speed;
+                                break;
+                        }
+                }
+        }
+        /* Only used for user output, little sense to output them in general */
+        dev->bNumInterfaces = 0;
+        dev->bConfigurationValue = 0;
+        dev->busnum = 0;
+        name = udev_device_get_sysname(plat);
+        strncpy(dev->busid, name, SYSFS_BUS_ID_SIZE);
+        return 0;
+}
+static int is_my_device(struct udev_device *dev)
+{
+        const char *driver;
+        driver = udev_device_get_property_value(dev, "USB_UDC_NAME");
+        return driver != NULL && !strcmp(driver, USBIP_DEVICE_DRV_NAME);
+}
+static int usbip_device_driver_open(struct usbip_host_driver *hdriver)
+{
+        int ret;
+        hdriver->ndevs = 0;
+        INIT_LIST_HEAD(&hdriver->edev_list);
+        ret = usbip_generic_driver_open(hdriver);
+        if (ret)
+                err("please load " USBIP_CORE_MOD_NAME ".ko and "
+                    USBIP_DEVICE_DRV_NAME ".ko!");
+        return ret;
+}
+struct usbip_host_driver device_driver = {
+        .edev_list = LIST_HEAD_INIT(device_driver.edev_list),
+        .udev_subsystem = "udc",
+        .ops = {
+                .open = usbip_device_driver_open,
+                .close = usbip_generic_driver_close,
+                .refresh_device_list = usbip_generic_refresh_device_list,
+                .get_device = usbip_generic_get_device,
+                .read_device = read_usb_vudc_device,
+                .is_my_device = is_my_device,
+        },
+};
diff --git a/tools/usb/usbip/libsrc/usbip_device_driver.h b/tools/usb/usbip/libsrc/usbip_device_driver.h
new file mode 100644
index 000000000000..54cb658b37a3
--- /dev/null
+++ b/tools/usb/usbip/libsrc/usbip_device_driver.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2015 Karol Kosik <karo9@interia.eu>
+ *               2015 Samsung Electronics
+ * Author:       Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *
+ * Based on tools/usb/usbip/libsrc/usbip_host_driver.c, which is:
+ * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
+ *               2005-2007 Takahiro Hirofuchi
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __USBIP_DEVICE_DRIVER_H
+#define __USBIP_DEVICE_DRIVER_H
+#include <stdint.h>
+#include "usbip_common.h"
+#include "usbip_host_common.h"
+#include "list.h"
+extern struct usbip_host_driver device_driver;
+#endif /* __USBIP_DEVICE_DRIVER_H */
diff --git a/tools/usb/usbip/libsrc/usbip_host_common.c b/tools/usb/usbip/libsrc/usbip_host_common.c
new file mode 100644
index 000000000000..9d415228883d
--- /dev/null
+++ b/tools/usb/usbip/libsrc/usbip_host_common.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
+ *
+ * Refactored from usbip_host_driver.c, which is:
+ * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
+ *               2005-2007 Takahiro Hirofuchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <libudev.h>
+#include "usbip_common.h"
+#include "usbip_host_common.h"
+#include "list.h"
+#include "sysfs_utils.h"
+struct udev *udev_context;
+static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
+{
+        char status_attr_path[SYSFS_PATH_MAX];
+        int fd;
+        int length;
+        char status;
+        int value = 0;
+        snprintf(status_attr_path, SYSFS_PATH_MAX, "%s/usbip_status",
+                 udev->path);
+        fd = open(status_attr_path, O_RDONLY);
+        if (fd < 0) {
+                err("error opening attribute %s", status_attr_path);
+                return -1;
+        }
+        length = read(fd, &status, 1);
+        if (length < 0) {
+                err("error reading attribute %s", status_attr_path);
+                close(fd);
+                return -1;
+        }
+        value = atoi(&status);
+        return value;
+}
+static
+struct usbip_exported_device *usbip_exported_device_new(
+                struct usbip_host_driver *hdriver, const char *sdevpath)
+{
+        struct usbip_exported_device *edev = NULL;
+        struct usbip_exported_device *edev_old;
+        size_t size;
+        int i;
+        edev = calloc(1, sizeof(struct usbip_exported_device));
+        edev->sudev =
+                udev_device_new_from_syspath(udev_context, sdevpath);
+        if (!edev->sudev) {
+                err("udev_device_new_from_syspath: %s", sdevpath);
+                goto err;
+        }
+        if (hdriver->ops.read_device(edev->sudev, &edev->udev) < 0)
+                goto err;
+        edev->status = read_attr_usbip_status(&edev->udev);
+        if (edev->status < 0)
+                goto err;
+        /* reallocate buffer to include usb interface data */
+        size = sizeof(struct usbip_exported_device) +
+                edev->udev.bNumInterfaces * sizeof(struct usbip_usb_interface);
+        edev_old = edev;
+        edev = realloc(edev, size);
+        if (!edev) {
+                edev = edev_old;
+                dbg("realloc failed");
+                goto err;
+        }
+        for (i = 0; i < edev->udev.bNumInterfaces; i++) {
+                /* vudc does not support reading interfaces */
+                if (!hdriver->ops.read_interface)
+                        break;
+                hdriver->ops.read_interface(&edev->udev, i, &edev->uinf[i]);
+        }
+        return edev;
+err:
+        if (edev->sudev)
+                udev_device_unref(edev->sudev);
+        if (edev)
+                free(edev);
+        return NULL;
+}
+static int refresh_exported_devices(struct usbip_host_driver *hdriver)
+{
+        struct usbip_exported_device *edev;
+        struct udev_enumerate *enumerate;
+        struct udev_list_entry *devices, *dev_list_entry;
+        struct udev_device *dev;
+        const char *path;
+        enumerate = udev_enumerate_new(udev_context);
+        udev_enumerate_add_match_subsystem(enumerate, hdriver->udev_subsystem);
+        udev_enumerate_scan_devices(enumerate);
+        devices = udev_enumerate_get_list_entry(enumerate);
+        udev_list_entry_foreach(dev_list_entry, devices) {
+                path = udev_list_entry_get_name(dev_list_entry);
+                dev = udev_device_new_from_syspath(udev_context,
+                                                   path);
+                if (dev == NULL)
+                        continue;
+                /* Check whether device uses usbip driver. */
+                if (hdriver->ops.is_my_device(dev)) {
+                        edev = usbip_exported_device_new(hdriver, path);
+                        if (!edev) {
+                                dbg("usbip_exported_device_new failed");
+                                continue;
+                        }
+                        list_add(&edev->node, &hdriver->edev_list);
+                        hdriver->ndevs++;
+                }
+        }
+        return 0;
+}
+static void usbip_exported_device_destroy(struct list_head *devs)
+{
+        struct list_head *i, *tmp;
+        struct usbip_exported_device *edev;
+        list_for_each_safe(i, tmp, devs) {
+                edev = list_entry(i, struct usbip_exported_device, node);
+                list_del(i);
+                free(edev);
+        }
+}
+int usbip_generic_driver_open(struct usbip_host_driver *hdriver)
+{
+        int rc;
+        udev_context = udev_new();
+        if (!udev_context) {
+                err("udev_new failed");
+                return -1;
+        }
+        rc = refresh_exported_devices(hdriver);
+        if (rc < 0)
+                goto err;
+        return 0;
+err:
+        udev_unref(udev_context);
+        return -1;
+}
+void usbip_generic_driver_close(struct usbip_host_driver *hdriver)
+{
+        if (!hdriver)
+                return;
+        usbip_exported_device_destroy(&hdriver->edev_list);
+        udev_unref(udev_context);
+}
+int usbip_generic_refresh_device_list(struct usbip_host_driver *hdriver)
+{
+        int rc;
+        usbip_exported_device_destroy(&hdriver->edev_list);
+        hdriver->ndevs = 0;
+        INIT_LIST_HEAD(&hdriver->edev_list);
+        rc = refresh_exported_devices(hdriver);
+        if (rc < 0)
+                return -1;
+        return 0;
+}
+int usbip_export_device(struct usbip_exported_device *edev, int sockfd)
+{
+        char attr_name[] = "usbip_sockfd";
+        char sockfd_attr_path[SYSFS_PATH_MAX];
+        char sockfd_buff[30];
+        int ret;
+        if (edev->status != SDEV_ST_AVAILABLE) {
+                dbg("device not available: %s", edev->udev.busid);
+                switch (edev->status) {
+                case SDEV_ST_ERROR:
+                        dbg("status SDEV_ST_ERROR");
+                        break;
+                case SDEV_ST_USED:
+                        dbg("status SDEV_ST_USED");
+                        break;
+                default:
+                        dbg("status unknown: 0x%x", edev->status);
+                }
+                return -1;
+        }
+        /* only the first interface is true */
+        snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
+                 edev->udev.path, attr_name);
+        snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
+        ret = write_sysfs_attribute(sockfd_attr_path, sockfd_buff,
+                                    strlen(sockfd_buff));
+        if (ret < 0) {
+                err("write_sysfs_attribute failed: sockfd %s to %s",
+                    sockfd_buff, sockfd_attr_path);
+                return ret;
+        }
+        info("connect: %s", edev->udev.busid);
+        return ret;
+}
+struct usbip_exported_device *usbip_generic_get_device(
+                struct usbip_host_driver *hdriver, int num)
+{
+        struct list_head *i;
+        struct usbip_exported_device *edev;
+        int cnt = 0;
+        list_for_each(i, &hdriver->edev_list) {
+                edev = list_entry(i, struct usbip_exported_device, node);
+                if (num == cnt)
+                        return edev;
+                cnt++;
+        }
+        return NULL;
+}
diff --git a/tools/usb/usbip/libsrc/usbip_host_common.h b/tools/usb/usbip/libsrc/usbip_host_common.h
new file mode 100644
index 000000000000..a64b8033fe64
--- /dev/null
+++ b/tools/usb/usbip/libsrc/usbip_host_common.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
+ *
+ * Refactored from usbip_host_driver.c, which is:
+ * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
+ *               2005-2007 Takahiro Hirofuchi
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+#ifndef __USBIP_HOST_COMMON_H
+#define __USBIP_HOST_COMMON_H
+#include <stdint.h>
+#include <libudev.h>
+#include <errno.h>
+#include "list.h"
+#include "usbip_common.h"
+#include "sysfs_utils.h"
+struct usbip_host_driver;
+struct usbip_host_driver_ops {
+        int (*open)(struct usbip_host_driver *hdriver);
+        void (*close)(struct usbip_host_driver *hdriver);
+        int (*refresh_device_list)(struct usbip_host_driver *hdriver);
+        struct usbip_exported_device * (*get_device)(
+                struct usbip_host_driver *hdriver, int num);
+        int (*read_device)(struct udev_device *sdev,
+                           struct usbip_usb_device *dev);
+        int (*read_interface)(struct usbip_usb_device *udev, int i,
+                              struct usbip_usb_interface *uinf);
+        int (*is_my_device)(struct udev_device *udev);
+};
+struct usbip_host_driver {
+        int ndevs;
+        /* list of exported device */
+        struct list_head edev_list;
+        const char *udev_subsystem;
+        struct usbip_host_driver_ops ops;
+};
+struct usbip_exported_device {
+        struct udev_device *sudev;
+        int32_t status;
+        struct usbip_usb_device udev;
+        struct list_head node;
+        struct usbip_usb_interface uinf[];
+};
+/* External API to access the driver */
+static inline int usbip_driver_open(struct usbip_host_driver *hdriver)
+{
+        if (!hdriver->ops.open)
+                return -EOPNOTSUPP;
+        return hdriver->ops.open(hdriver);
+}
+static inline void usbip_driver_close(struct usbip_host_driver *hdriver)
+{
+        if (!hdriver->ops.close)
+                return;
+        hdriver->ops.close(hdriver);
+}
+static inline int usbip_refresh_device_list(struct usbip_host_driver *hdriver)
+{
+        if (!hdriver->ops.refresh_device_list)
+                return -EOPNOTSUPP;
+        return hdriver->ops.refresh_device_list(hdriver);
+}
+static inline struct usbip_exported_device *
+usbip_get_device(struct usbip_host_driver *hdriver, int num)
+{
+        if (!hdriver->ops.get_device)
+                return NULL;
+        return hdriver->ops.get_device(hdriver, num);
+}
+/* Helper functions for implementing driver backend */
+int usbip_generic_driver_open(struct usbip_host_driver *hdriver);
+void usbip_generic_driver_close(struct usbip_host_driver *hdriver);
+int usbip_generic_refresh_device_list(struct usbip_host_driver *hdriver);
+int usbip_export_device(struct usbip_exported_device *edev, int sockfd);
+struct usbip_exported_device *usbip_generic_get_device(
+                struct usbip_host_driver *hdriver, int num);
+#endif /* __USBIP_HOST_COMMON_H */
diff --git a/tools/usb/usbip/libsrc/usbip_host_driver.c b/tools/usb/usbip/libsrc/usbip_host_driver.c
index bef08d5c44e8..4de6edc54d35 100644
--- a/tools/usb/usbip/libsrc/usbip_host_driver.c
+++ b/tools/usb/usbip/libsrc/usbip_host_driver.c
@@ -1,6 +1,9 @@
 /*
 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
 *               2005-2007 Takahiro Hirofuchi
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -16,265 +19,47 @@
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <errno.h>
 #include <unistd.h>
 #include <libudev.h>
-#include "usbip_common.h"
+#include "usbip_host_common.h"
 #include "usbip_host_driver.h"
-#include "list.h"
-#include "sysfs_utils.h"
 #undef  PROGNAME
 #define PROGNAME "libusbip"
-struct usbip_host_driver *host_driver;
+static int is_my_device(struct udev_device *dev)
-struct udev *udev_context;
-static int32_t read_attr_usbip_status(struct usbip_usb_device *udev)
-{
-        char status_attr_path[SYSFS_PATH_MAX];
-        int fd;
-        int length;
-        char status;
-        int value = 0;
-        snprintf(status_attr_path, SYSFS_PATH_MAX, "%s/usbip_status",
-                 udev->path);
-        fd = open(status_attr_path, O_RDONLY);
-        if (fd < 0) {
-                err("error opening attribute %s", status_attr_path);
-                return -1;
-        }
-        length = read(fd, &status, 1);
-        if (length < 0) {
-                err("error reading attribute %s", status_attr_path);
-                close(fd);
-                return -1;
-        }
-        value = atoi(&status);
-        return value;
-}
-static
-struct usbip_exported_device *usbip_exported_device_new(const char *sdevpath)
-{
-        struct usbip_exported_device *edev = NULL;
-        struct usbip_exported_device *edev_old;
-        size_t size;
-        int i;
-        edev = calloc(1, sizeof(struct usbip_exported_device));
-        edev->sudev = udev_device_new_from_syspath(udev_context, sdevpath);
-        if (!edev->sudev) {
-                err("udev_device_new_from_syspath: %s", sdevpath);
-                goto err;
-        }
-        read_usb_device(edev->sudev, &edev->udev);
-        edev->status = read_attr_usbip_status(&edev->udev);
-        if (edev->status < 0)
-                goto err;
-        /* reallocate buffer to include usb interface data */
-        size = sizeof(struct usbip_exported_device) +
-                edev->udev.bNumInterfaces * sizeof(struct usbip_usb_interface);
-        edev_old = edev;
-        edev = realloc(edev, size);
-        if (!edev) {
-                edev = edev_old;
-                dbg("realloc failed");
-                goto err;
-        }
-        for (i = 0; i < edev->udev.bNumInterfaces; i++)
-                read_usb_interface(&edev->udev, i, &edev->uinf[i]);
-        return edev;
-err:
-        if (edev->sudev)
-                udev_device_unref(edev->sudev);
-        if (edev)
-                free(edev);
-        return NULL;
-}
-static int refresh_exported_devices(void)
 {
-        struct usbip_exported_device *edev;
-        struct udev_enumerate *enumerate;
-        struct udev_list_entry *devices, *dev_list_entry;
-        struct udev_device *dev;
-        const char *path;
        const char *driver;
-        enumerate = udev_enumerate_new(udev_context);
+        driver = udev_device_get_driver(dev);
-        udev_enumerate_add_match_subsystem(enumerate, "usb");
+        return driver != NULL && !strcmp(driver, USBIP_HOST_DRV_NAME);
-        udev_enumerate_scan_devices(enumerate);
-        devices = udev_enumerate_get_list_entry(enumerate);
-        udev_list_entry_foreach(dev_list_entry, devices) {
-                path = udev_list_entry_get_name(dev_list_entry);
-                dev = udev_device_new_from_syspath(udev_context, path);
-                if (dev == NULL)
-                        continue;
-                /* Check whether device uses usbip-host driver. */
-                driver = udev_device_get_driver(dev);
-                if (driver != NULL && !strcmp(driver, USBIP_HOST_DRV_NAME)) {
-                        edev = usbip_exported_device_new(path);
-                        if (!edev) {
-                                dbg("usbip_exported_device_new failed");
-                                continue;
-                        }
-                        list_add(&edev->node, &host_driver->edev_list);
-                        host_driver->ndevs++;
-                }
-        }
-        return 0;
-}
-static void usbip_exported_device_destroy(void)
-{
-        struct list_head *i, *tmp;
-        struct usbip_exported_device *edev;
-        list_for_each_safe(i, tmp, &host_driver->edev_list) {
-                edev = list_entry(i, struct usbip_exported_device, node);
-                list_del(i);
-                free(edev);
-        }
 }
-int usbip_host_driver_open(void)
+static int usbip_host_driver_open(struct usbip_host_driver *hdriver)
 {
-        int rc;
-        udev_context = udev_new();
-        if (!udev_context) {
-                err("udev_new failed");
-                return -1;
-        }
-        host_driver = calloc(1, sizeof(*host_driver));
-        host_driver->ndevs = 0;
-        INIT_LIST_HEAD(&host_driver->edev_list);
-        rc = refresh_exported_devices();
-        if (rc < 0)
-                goto err_free_host_driver;
-        return 0;
-err_free_host_driver:
-        free(host_driver);
-        host_driver = NULL;
-        udev_unref(udev_context);
-        return -1;
-}
-void usbip_host_driver_close(void)
-{
-        if (!host_driver)
-                return;
-        usbip_exported_device_destroy();
-        free(host_driver);
-        host_driver = NULL;
-        udev_unref(udev_context);
-}
-int usbip_host_refresh_device_list(void)
-{
-        int rc;
-        usbip_exported_device_destroy();
-        host_driver->ndevs = 0;
-        INIT_LIST_HEAD(&host_driver->edev_list);
-        rc = refresh_exported_devices();
-        if (rc < 0)
-                return -1;
-        return 0;
-}
-int usbip_host_export_device(struct usbip_exported_device *edev, int sockfd)
-{
-        char attr_name[] = "usbip_sockfd";
-        char sockfd_attr_path[SYSFS_PATH_MAX];
-        char sockfd_buff[30];
        int ret;
-        if (edev->status != SDEV_ST_AVAILABLE) {
+        hdriver->ndevs = 0;
-                dbg("device not available: %s", edev->udev.busid);
+        INIT_LIST_HEAD(&hdriver->edev_list);
-                switch (edev->status) {
-                case SDEV_ST_ERROR:
-                        dbg("status SDEV_ST_ERROR");
-                        break;
-                case SDEV_ST_USED:
-                        dbg("status SDEV_ST_USED");
-                        break;
-                default:
-                        dbg("status unknown: 0x%x", edev->status);
-                }
-                return -1;
-        }
-        /* only the first interface is true */
-        snprintf(sockfd_attr_path, sizeof(sockfd_attr_path), "%s/%s",
-                 edev->udev.path, attr_name);
-        snprintf(sockfd_buff, sizeof(sockfd_buff), "%d\n", sockfd);
-        ret = write_sysfs_attribute(sockfd_attr_path, sockfd_buff,
-                                    strlen(sockfd_buff));
-        if (ret < 0) {
-                err("write_sysfs_attribute failed: sockfd %s to %s",
-                    sockfd_buff, sockfd_attr_path);
-                return ret;
-        }
-        info("connect: %s", edev->udev.busid);
+        ret = usbip_generic_driver_open(hdriver);
+        if (ret)
+                err("please load " USBIP_CORE_MOD_NAME ".ko and "
+                    USBIP_HOST_DRV_NAME ".ko!");
        return ret;
 }
-struct usbip_exported_device *usbip_host_get_device(int num)
+struct usbip_host_driver host_driver = {
-{
+        .edev_list = LIST_HEAD_INIT(host_driver.edev_list),
-        struct list_head *i;
+        .udev_subsystem = "usb",
-        struct usbip_exported_device *edev;
+        .ops = {
-        int cnt = 0;
+                .open = usbip_host_driver_open,
+                .close = usbip_generic_driver_close,
-        list_for_each(i, &host_driver->edev_list) {
+                .refresh_device_list = usbip_generic_refresh_device_list,
-                edev = list_entry(i, struct usbip_exported_device, node);
+                .get_device = usbip_generic_get_device,
-                if (num == cnt)
+                .read_device = read_usb_device,
-                        return edev;
+                .read_interface = read_usb_interface,
-                else
+                .is_my_device = is_my_device,
-                        cnt++;
+        },
-        }
+};
-        return NULL;
-}
diff --git a/tools/usb/usbip/libsrc/usbip_host_driver.h b/tools/usb/usbip/libsrc/usbip_host_driver.h
index 2a31f855c616..77f07e72a7fe 100644
--- a/tools/usb/usbip/libsrc/usbip_host_driver.h
+++ b/tools/usb/usbip/libsrc/usbip_host_driver.h
@@ -1,6 +1,9 @@
 /*
 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
 *               2005-2007 Takahiro Hirofuchi
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -22,28 +25,8 @@
 #include <stdint.h>
 #include "usbip_common.h"
 #include "list.h"
+#include "usbip_host_common.h"
-struct usbip_host_driver {
+extern struct usbip_host_driver host_driver;
-        int ndevs;
-        /* list of exported device */
-        struct list_head edev_list;
-};
-struct usbip_exported_device {
-        struct udev_device *sudev;
-        int32_t status;
-        struct usbip_usb_device udev;
-        struct list_head node;
-        struct usbip_usb_interface uinf[];
-};
-extern struct usbip_host_driver *host_driver;
-int usbip_host_driver_open(void);
-void usbip_host_driver_close(void);
-int usbip_host_refresh_device_list(void);
-int usbip_host_export_device(struct usbip_exported_device *edev, int sockfd);
-struct usbip_exported_device *usbip_host_get_device(int num);
 #endif /* __USBIP_HOST_DRIVER_H */
diff --git a/tools/usb/usbip/src/usbip_attach.c b/tools/usb/usbip/src/usbip_attach.c
index d58a14dfc094..70a6b507fb62 100644
--- a/tools/usb/usbip/src/usbip_attach.c
+++ b/tools/usb/usbip/src/usbip_attach.c
@@ -1,6 +1,9 @@
 /*
 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
 *               2005-2007 Takahiro Hirofuchi
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -36,7 +39,8 @@
 static const char usbip_attach_usage_string[] =
        "usbip attach <args>\n"
        "    -r, --remote=<host>      The machine with exported USB devices\n"
-        "    -b, --busid=<busid>    Busid of the device on <host>\n";
+        "    -b, --busid=<busid>    Busid of the device on <host>\n"
+        "    -d, --device=<devid>    Id of the virtual UDC on <host>\n";
 void usbip_attach_usage(void)
 {
@@ -203,6 +207,7 @@ int usbip_attach(int argc, char *argv[])
        static const struct option opts[] = {
                { "remote", required_argument, NULL, 'r' },
                { "busid",  required_argument, NULL, 'b' },
+                { "device",  required_argument, NULL, 'd' },
                { NULL, 0,  NULL, 0 }
        };
        char *host = NULL;
@@ -211,7 +216,7 @@ int usbip_attach(int argc, char *argv[])
        int ret = -1;
        for (;;) {
-                opt = getopt_long(argc, argv, "r:b:", opts, NULL);
+                opt = getopt_long(argc, argv, "d:r:b:", opts, NULL);
                if (opt == -1)
                        break;
@@ -220,6 +225,7 @@ int usbip_attach(int argc, char *argv[])
                case 'r':
                        host = optarg;
                        break;
+                case 'd':
                case 'b':
                        busid = optarg;
                        break;
diff --git a/tools/usb/usbip/src/usbip_list.c b/tools/usb/usbip/src/usbip_list.c
index d5ce34a410e7..f1b38e866dd7 100644
--- a/tools/usb/usbip/src/usbip_list.c
+++ b/tools/usb/usbip/src/usbip_list.c
@@ -1,6 +1,9 @@
 /*
 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
 *               2005-2007 Takahiro Hirofuchi
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -30,6 +33,10 @@
 #include <netdb.h>
 #include <unistd.h>
+#include <dirent.h>
+#include <linux/usb/ch9.h>
 #include "usbip_common.h"
 #include "usbip_network.h"
 #include "usbip.h"
@@ -205,8 +212,10 @@ static int list_devices(bool parsable)
                /* Get device information. */
                idVendor = udev_device_get_sysattr_value(dev, "idVendor");
                idProduct = udev_device_get_sysattr_value(dev, "idProduct");
-                bConfValue = udev_device_get_sysattr_value(dev, "bConfigurationValue");
+                bConfValue = udev_device_get_sysattr_value(dev,
-                bNumIntfs = udev_device_get_sysattr_value(dev, "bNumInterfaces");
+                                "bConfigurationValue");
+                bNumIntfs = udev_device_get_sysattr_value(dev,
+                                "bNumInterfaces");
                busid = udev_device_get_sysname(dev);
                if (!idVendor || !idProduct || !bConfValue || !bNumIntfs) {
                        err("problem getting device attributes: %s",
@@ -237,12 +246,90 @@ err_out:
        return ret;
 }
+static int list_gadget_devices(bool parsable)
+{
+        int ret = -1;
+        struct udev *udev;
+        struct udev_enumerate *enumerate;
+        struct udev_list_entry *devices, *dev_list_entry;
+        struct udev_device *dev;
+        const char *path;
+        const char *driver;
+        const struct usb_device_descriptor *d_desc;
+        const char *descriptors;
+        char product_name[128];
+        uint16_t idVendor;
+        char idVendor_buf[8];
+        uint16_t idProduct;
+        char idProduct_buf[8];
+        const char *busid;
+        udev = udev_new();
+        enumerate = udev_enumerate_new(udev);
+        udev_enumerate_add_match_subsystem(enumerate, "platform");
+        udev_enumerate_scan_devices(enumerate);
+        devices = udev_enumerate_get_list_entry(enumerate);
+        udev_list_entry_foreach(dev_list_entry, devices) {
+                path = udev_list_entry_get_name(dev_list_entry);
+                dev = udev_device_new_from_syspath(udev, path);
+                driver = udev_device_get_driver(dev);
+                /* We only have mechanism to enumerate gadgets bound to vudc */
+                if (driver == NULL || strcmp(driver, USBIP_DEVICE_DRV_NAME))
+                        continue;
+                /* Get device information. */
+                descriptors = udev_device_get_sysattr_value(dev,
+                                VUDC_DEVICE_DESCR_FILE);
+                if (!descriptors) {
+                        err("problem getting device attributes: %s",
+                            strerror(errno));
+                        goto err_out;
+                }
+                d_desc = (const struct usb_device_descriptor *) descriptors;
+                idVendor = le16toh(d_desc->idVendor);
+                sprintf(idVendor_buf, "0x%4x", idVendor);
+                idProduct = le16toh(d_desc->idProduct);
+                sprintf(idProduct_buf, "0x%4x", idVendor);
+                busid = udev_device_get_sysname(dev);
+                /* Get product name. */
+                usbip_names_get_product(product_name, sizeof(product_name),
+                                        le16toh(idVendor),
+                                        le16toh(idProduct));
+                /* Print information. */
+                print_device(busid, idVendor_buf, idProduct_buf, parsable);
+                print_product_name(product_name, parsable);
+                printf("\n");
+                udev_device_unref(dev);
+        }
+        ret = 0;
+err_out:
+        udev_enumerate_unref(enumerate);
+        udev_unref(udev);
+        return ret;
+}
 int usbip_list(int argc, char *argv[])
 {
        static const struct option opts[] = {
                { "parsable", no_argument,       NULL, 'p' },
                { "remote",   required_argument, NULL, 'r' },
                { "local",    no_argument,       NULL, 'l' },
+                { "device",    no_argument,       NULL, 'd' },
                { NULL,       0,                 NULL,  0  }
        };
@@ -254,7 +341,7 @@ int usbip_list(int argc, char *argv[])
                err("failed to open %s", USBIDS_FILE);
        for (;;) {
-                opt = getopt_long(argc, argv, "pr:l", opts, NULL);
+                opt = getopt_long(argc, argv, "pr:ld", opts, NULL);
                if (opt == -1)
                        break;
@@ -269,6 +356,9 @@ int usbip_list(int argc, char *argv[])
                case 'l':
                        ret = list_devices(parsable);
                        goto out;
+                case 'd':
+                        ret = list_gadget_devices(parsable);
+                        goto out;
                default:
                        goto err_out;
                }
diff --git a/tools/usb/usbip/src/usbip_port.c b/tools/usb/usbip/src/usbip_port.c
index a2e884fd9226..7bd74fb3a9cd 100644
--- a/tools/usb/usbip/src/usbip_port.c
+++ b/tools/usb/usbip/src/usbip_port.c
@@ -22,10 +22,13 @@ static int list_imported_devices(void)
        struct usbip_imported_device *idev;
        int ret;
+        if (usbip_names_init(USBIDS_FILE))
+                err("failed to open %s", USBIDS_FILE);
        ret = usbip_vhci_driver_open();
        if (ret < 0) {
                err("open vhci_driver");
-                return -1;
+                goto err_names_free;
        }
        printf("Imported USB devices\n");
@@ -35,13 +38,19 @@ static int list_imported_devices(void)
                idev = &vhci_driver->idev[i];
                if (usbip_vhci_imported_device_dump(idev) < 0)
-                        ret = -1;
+                        goto err_driver_close;
        }
        usbip_vhci_driver_close();
+        usbip_names_free();
        return ret;
+err_driver_close:
+        usbip_vhci_driver_close();
+err_names_free:
+        usbip_names_free();
+        return -1;
 }
 int usbip_port_show(__attribute__((unused)) int argc,
diff --git a/tools/usb/usbip/src/usbipd.c b/tools/usb/usbip/src/usbipd.c
index 2a7cd2b8d966..a0972dea9e6c 100644
--- a/tools/usb/usbip/src/usbipd.c
+++ b/tools/usb/usbip/src/usbipd.c
@@ -1,6 +1,9 @@
 /*
 * Copyright (C) 2011 matt mooney <mfm@muteddisk.com>
 *               2005-2007 Takahiro Hirofuchi
+ * Copyright (C) 2015-2016 Samsung Electronics
+ *               Igor Kotrasinski <i.kotrasinsk@samsung.com>
+ *               Krzysztof Opasiak <k.opasiak@samsung.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
@@ -41,6 +44,8 @@
 #include <poll.h>
 #include "usbip_host_driver.h"
+#include "usbip_host_common.h"
+#include "usbip_device_driver.h"
 #include "usbip_common.h"
 #include "usbip_network.h"
 #include "list.h"
@@ -64,6 +69,11 @@ static const char usbipd_help_string[] =
        "       -6, --ipv6\n"
        "               Bind to IPv6. Default is both.\n"
        "\n"
+        "       -e, --device\n"
+        "               Run in device mode.\n"
+        "               Rather than drive an attached device, create\n"
+        "               a virtual UDC to bind gadgets to.\n"
+        "\n"
        "       -D, --daemon\n"
        "               Run as a daemon process.\n"
        "\n"
@@ -83,6 +93,8 @@ static const char usbipd_help_string[] =
        "       -v, --version\n"
        "               Show version.\n";
+static struct usbip_host_driver *driver;
 static void usbipd_help(void)
 {
        printf("%s\n", usbipd_help_string);
@@ -107,7 +119,7 @@ static int recv_request_import(int sockfd)
        }
        PACK_OP_IMPORT_REQUEST(0, &req);
-        list_for_each(i, &host_driver->edev_list) {
+        list_for_each(i, &driver->edev_list) {
                edev = list_entry(i, struct usbip_exported_device, node);
                if (!strncmp(req.busid, edev->udev.busid, SYSFS_BUS_ID_SIZE)) {
                        info("found requested device: %s", req.busid);
@@ -121,7 +133,7 @@ static int recv_request_import(int sockfd)
                usbip_net_set_nodelay(sockfd);
                /* export device needs a TCP/IP socket descriptor */
-                rc = usbip_host_export_device(edev, sockfd);
+                rc = usbip_export_device(edev, sockfd);
                if (rc < 0)
                        error = 1;
        } else {
@@ -166,7 +178,7 @@ static int send_reply_devlist(int connfd)
        reply.ndev = 0;
        /* number of exported devices */
-        list_for_each(j, &host_driver->edev_list) {
+        list_for_each(j, &driver->edev_list) {
                reply.ndev += 1;
        }
        info("exportable devices: %d", reply.ndev);
@@ -184,7 +196,7 @@ static int send_reply_devlist(int connfd)
                return -1;
        }
-        list_for_each(j, &host_driver->edev_list) {
+        list_for_each(j, &driver->edev_list) {
                edev = list_entry(j, struct usbip_exported_device, node);
                dump_usb_device(&edev->udev);
                memcpy(&pdu_udev, &edev->udev, sizeof(pdu_udev));
@@ -246,7 +258,7 @@ static int recv_pdu(int connfd)
                return -1;
        }
-        ret = usbip_host_refresh_device_list();
+        ret = usbip_refresh_device_list(driver);
        if (ret < 0) {
                dbg("could not refresh device list: %d", ret);
                return -1;
@@ -491,16 +503,13 @@ static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
        struct timespec timeout;
        sigset_t sigmask;
-        if (usbip_host_driver_open()) {
+        if (usbip_driver_open(driver))
-                err("please load " USBIP_CORE_MOD_NAME ".ko and "
-                    USBIP_HOST_DRV_NAME ".ko!");
                return -1;
-        }
        if (daemonize) {
                if (daemon(0, 0) < 0) {
                        err("daemonizing failed: %s", strerror(errno));
-                        usbip_host_driver_close();
+                        usbip_driver_close(driver);
                        return -1;
                }
                umask(0);
@@ -525,7 +534,7 @@ static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
        ai_head = do_getaddrinfo(NULL, family);
        if (!ai_head) {
-                usbip_host_driver_close();
+                usbip_driver_close(driver);
                return -1;
        }
        nsockfd = listen_all_addrinfo(ai_head, sockfdlist,
@@ -533,7 +542,7 @@ static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
        freeaddrinfo(ai_head);
        if (nsockfd <= 0) {
                err("failed to open a listening socket");
-                usbip_host_driver_close();
+                usbip_driver_close(driver);
                return -1;
        }
@@ -574,7 +583,7 @@ static int do_standalone_mode(int daemonize, int ipv4, int ipv6)
        info("shutting down " PROGNAME);
        free(fds);
-        usbip_host_driver_close();
+        usbip_driver_close(driver);
        return 0;
 }
@@ -587,6 +596,7 @@ int main(int argc, char *argv[])
                { "daemon",   no_argument,       NULL, 'D' },
                { "daemon",   no_argument,       NULL, 'D' },
                { "debug",    no_argument,       NULL, 'd' },
+                { "device",   no_argument,       NULL, 'e' },
                { "pid",      optional_argument, NULL, 'P' },
                { "tcp-port", required_argument, NULL, 't' },
                { "help",     no_argument,       NULL, 'h' },
@@ -613,8 +623,9 @@ int main(int argc, char *argv[])
                err("not running as root?");
        cmd = cmd_standalone_mode;
+        driver = &host_driver;
        for (;;) {
-                opt = getopt_long(argc, argv, "46DdP::t:hv", longopts, NULL);
+                opt = getopt_long(argc, argv, "46DdeP::t:hv", longopts, NULL);
                if (opt == -1)
                        break;
@@ -644,6 +655,9 @@ int main(int argc, char *argv[])
                case 'v':
                        cmd = cmd_version;
                        break;
+                case 'e':
+                        driver = &device_driver;
+                        break;
                case '?':
                        usbipd_help();
                default:
diff --git a/tools/virtio/ringtest/Makefile b/tools/virtio/ringtest/Makefile
index feaa64ac4630..6ba745529833 100644
--- a/tools/virtio/ringtest/Makefile
+++ b/tools/virtio/ringtest/Makefile
@@ -1,6 +1,6 @@
 all:
-all: ring virtio_ring_0_9 virtio_ring_poll
+all: ring virtio_ring_0_9 virtio_ring_poll virtio_ring_inorder
 CFLAGS += -Wall
 CFLAGS += -pthread -O2 -ggdb
@@ -10,13 +10,16 @@ main.o: main.c main.h
 ring.o: ring.c main.h
 virtio_ring_0_9.o: virtio_ring_0_9.c main.h
 virtio_ring_poll.o: virtio_ring_poll.c virtio_ring_0_9.c main.h
+virtio_ring_inorder.o: virtio_ring_inorder.c virtio_ring_0_9.c main.h
 ring: ring.o main.o
 virtio_ring_0_9: virtio_ring_0_9.o main.o
 virtio_ring_poll: virtio_ring_poll.o main.o
+virtio_ring_inorder: virtio_ring_inorder.o main.o
 clean:
        -rm main.o
        -rm ring.o ring
        -rm virtio_ring_0_9.o virtio_ring_0_9
        -rm virtio_ring_poll.o virtio_ring_poll
+        -rm virtio_ring_inorder.o virtio_ring_inorder
 .PHONY: all clean
diff --git a/tools/virtio/ringtest/main.c b/tools/virtio/ringtest/main.c
index 3a5ff438bd62..147abb452a6c 100644
--- a/tools/virtio/ringtest/main.c
+++ b/tools/virtio/ringtest/main.c
@@ -115,7 +115,7 @@ static void run_guest(void)
                do {
                        if (started < bufs &&
                            started - completed < max_outstanding) {
-                                r = add_inbuf(0, NULL, "Hello, world!");
+                                r = add_inbuf(0, "Buffer\n", "Hello, world!");
                                if (__builtin_expect(r == 0, true)) {
                                        ++started;
                                        if (!--tokick) {
diff --git a/tools/virtio/ringtest/virtio_ring_0_9.c b/tools/virtio/ringtest/virtio_ring_0_9.c
index 47c9a1a18d36..761866212aac 100644
--- a/tools/virtio/ringtest/virtio_ring_0_9.c
+++ b/tools/virtio/ringtest/virtio_ring_0_9.c
@@ -26,6 +26,14 @@ struct vring ring;
 * high bits of ring id ^ 0x8000).
 */
 /* #ifdef RING_POLL */
+/* enabling the below activates experimental in-order code
+ * (which skips ring updates and reads and writes len in descriptor).
+ */
+/* #ifdef INORDER */
+#if defined(RING_POLL) && defined(INORDER)
+#error "RING_POLL and INORDER are mutually exclusive"
+#endif
 /* how much padding is needed to avoid false cache sharing */
 #define HOST_GUEST_PADDING 0x80
@@ -35,7 +43,11 @@ struct guest {
        unsigned short last_used_idx;
        unsigned short num_free;
        unsigned short kicked_avail_idx;
+#ifndef INORDER
        unsigned short free_head;
+#else
+        unsigned short reserved_free_head;
+#endif
        unsigned char reserved[HOST_GUEST_PADDING - 10];
 } guest;
@@ -66,8 +78,10 @@ void alloc_ring(void)
        guest.avail_idx = 0;
        guest.kicked_avail_idx = -1;
        guest.last_used_idx = 0;
+#ifndef INORDER
        /* Put everything in free lists. */
        guest.free_head = 0;
+#endif
        for (i = 0; i < ring_size - 1; i++)
                ring.desc[i].next = i + 1;
        host.used_idx = 0;
@@ -84,13 +98,20 @@ void alloc_ring(void)
 /* guest side */
 int add_inbuf(unsigned len, void *buf, void *datap)
 {
-        unsigned head, avail;
+        unsigned head;
+#ifndef INORDER
+        unsigned avail;
+#endif
        struct vring_desc *desc;
        if (!guest.num_free)
                return -1;
+#ifdef INORDER
+        head = (ring_size - 1) & (guest.avail_idx++);
+#else
        head = guest.free_head;
+#endif
        guest.num_free--;
        desc = ring.desc;
@@ -102,7 +123,9 @@ int add_inbuf(unsigned len, void *buf, void *datap)
         * descriptors.
         */
        desc[head].flags &= ~VRING_DESC_F_NEXT;
+#ifndef INORDER
        guest.free_head = desc[head].next;
+#endif
        data[head].data = datap;
@@ -113,8 +136,12 @@ int add_inbuf(unsigned len, void *buf, void *datap)
        ring.avail->ring[avail & (ring_size - 1)] =
                (head | (avail & ~(ring_size - 1))) ^ 0x8000;
 #else
+#ifndef INORDER
+        /* Barrier A (for pairing) */
+        smp_release();
        avail = (ring_size - 1) & (guest.avail_idx++);
        ring.avail->ring[avail] = head;
+#endif
        /* Barrier A (for pairing) */
        smp_release();
 #endif
@@ -141,15 +168,27 @@ void *get_buf(unsigned *lenp, void **bufp)
                return NULL;
        /* Barrier B (for pairing) */
        smp_acquire();
+#ifdef INORDER
+        head = (ring_size - 1) & guest.last_used_idx;
+        index = head;
+#else
        head = (ring_size - 1) & guest.last_used_idx;
        index = ring.used->ring[head].id;
 #endif
+#endif
+#ifdef INORDER
+        *lenp = ring.desc[index].len;
+#else
        *lenp = ring.used->ring[head].len;
+#endif
        datap = data[index].data;
        *bufp = (void*)(unsigned long)ring.desc[index].addr;
        data[index].data = NULL;
+#ifndef INORDER
        ring.desc[index].next = guest.free_head;
        guest.free_head = index;
+#endif
        guest.num_free++;
        guest.last_used_idx++;
        return datap;
@@ -283,16 +322,24 @@ bool use_buf(unsigned *lenp, void **bufp)
        smp_acquire();
        used_idx &= ring_size - 1;
+#ifdef INORDER
+        head = used_idx;
+#else
        head = ring.avail->ring[used_idx];
+#endif
        desc = &ring.desc[head];
 #endif
        *lenp = desc->len;
        *bufp = (void *)(unsigned long)desc->addr;
+#ifdef INORDER
+        desc->len = desc->len - 1;
+#else
        /* now update used ring */
        ring.used->ring[used_idx].id = head;
        ring.used->ring[used_idx].len = desc->len - 1;
+#endif
        /* Barrier B (for pairing) */
        smp_release();
        host.used_idx++;
diff --git a/tools/virtio/ringtest/virtio_ring_inorder.c b/tools/virtio/ringtest/virtio_ring_inorder.c
new file mode 100644
index 000000000000..2438ca58a2ad
--- /dev/null
+++ b/tools/virtio/ringtest/virtio_ring_inorder.c
@@ -0,0 +1,2 @@
+#define INORDER 1
+#include "virtio_ring_0_9.c"