Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

85 files changed, 3095 insertions, 792 deletions

diff --git a/tools/hv/hv_kvp_daemon.c b/tools/hv/hv_kvp_daemon.c
index 11224eddcdc2..146fd6147e84 100644
--- a/tools/hv/hv_kvp_daemon.c
+++ b/tools/hv/hv_kvp_daemon.c
@@ -34,21 +34,13 @@
 #include <errno.h>
 #include <arpa/inet.h>
 #include <linux/connector.h>
+#include <linux/hyperv.h>
 #include <linux/netlink.h>
 #include <ifaddrs.h>
 #include <netdb.h>
 #include <syslog.h>
-
-/*
- * KYS: TODO. Need to register these in the kernel.
- *
- * The following definitions are shared with the in-kernel component; do not
- * change any of this without making the corresponding changes in
- * the KVP kernel component.
- */
-#define CN_KVP_IDX              0x9     /* MSFT KVP functionality */
-#define CN_KVP_VAL              0x1 /* This supports queries from the kernel */
-#define CN_KVP_USER_VAL         0x2 /* This supports queries from the user  */
+#include <sys/stat.h>
+#include <fcntl.h>
 
 /*
  * KVP protocol: The user mode component first registers with the
@@ -60,25 +52,8 @@
  * We use this infrastructure for also supporting queries from user mode
  * application for state that may be maintained in the KVP kernel component.
  *
- * XXXKYS: Have a shared header file between the user and kernel (TODO)
  */
 
-enum kvp_op {
-        KVP_REGISTER = 0, /* Register the user mode component*/
-        KVP_KERNEL_GET, /*Kernel is requesting the value for the specified key*/
-        KVP_KERNEL_SET, /*Kernel is providing the value for the specified key*/
-        KVP_USER_GET, /*User is requesting the value for the specified key*/
-        KVP_USER_SET /*User is providing the value for the specified key*/
-};
-
-#define HV_KVP_EXCHANGE_MAX_KEY_SIZE    512
-#define HV_KVP_EXCHANGE_MAX_VALUE_SIZE  2048
-
-struct hv_ku_msg {
-        __u32   kvp_index;
-        __u8  kvp_key[HV_KVP_EXCHANGE_MAX_KEY_SIZE]; /* Key name */
-        __u8  kvp_value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE]; /* Key  value */
-};
 
 enum key_index {
         FullyQualifiedDomainName = 0,
@@ -93,10 +68,6 @@ enum key_index {
         ProcessorArchitecture
 };
 
-/*
- * End of shared definitions.
- */
-
 static char kvp_send_buffer[4096];
 static char kvp_recv_buffer[4096];
 static struct sockaddr_nl addr;
@@ -109,6 +80,345 @@ static char *os_build;
 static char *lic_version;
 static struct utsname uts_buf;
 
+
+#define MAX_FILE_NAME 100
+#define ENTRIES_PER_BLOCK 50
+
+struct kvp_record {
+        __u8 key[HV_KVP_EXCHANGE_MAX_KEY_SIZE];
+        __u8 value[HV_KVP_EXCHANGE_MAX_VALUE_SIZE];
+};
+
+struct kvp_file_state {
+        int fd;
+        int num_blocks;
+        struct kvp_record *records;
+        int num_records;
+        __u8 fname[MAX_FILE_NAME];
+};
+
+static struct kvp_file_state kvp_file_info[KVP_POOL_COUNT];
+
+static void kvp_acquire_lock(int pool)
+{
+        struct flock fl = {F_WRLCK, SEEK_SET, 0, 0, 0};
+        fl.l_pid = getpid();
+
+        if (fcntl(kvp_file_info[pool].fd, F_SETLKW, &fl) == -1) {
+                syslog(LOG_ERR, "Failed to acquire the lock pool: %d", pool);
+                exit(-1);
+        }
+}
+
+static void kvp_release_lock(int pool)
+{
+        struct flock fl = {F_UNLCK, SEEK_SET, 0, 0, 0};
+        fl.l_pid = getpid();
+
+        if (fcntl(kvp_file_info[pool].fd, F_SETLK, &fl) == -1) {
+                perror("fcntl");
+                syslog(LOG_ERR, "Failed to release the lock pool: %d", pool);
+                exit(-1);
+        }
+}
+
+static void kvp_update_file(int pool)
+{
+        FILE *filep;
+        size_t bytes_written;
+
+        /*
+         * We are going to write our in-memory registry out to
+         * disk; acquire the lock first.
+         */
+        kvp_acquire_lock(pool);
+
+        filep = fopen(kvp_file_info[pool].fname, "w");
+        if (!filep) {
+                kvp_release_lock(pool);
+                syslog(LOG_ERR, "Failed to open file, pool: %d", pool);
+                exit(-1);
+        }
+
+        bytes_written = fwrite(kvp_file_info[pool].records,
+                                sizeof(struct kvp_record),
+                                kvp_file_info[pool].num_records, filep);
+
+        fflush(filep);
+        kvp_release_lock(pool);
+}
+
+static void kvp_update_mem_state(int pool)
+{
+        FILE *filep;
+        size_t records_read = 0;
+        struct kvp_record *record = kvp_file_info[pool].records;
+        struct kvp_record *readp;
+        int num_blocks = kvp_file_info[pool].num_blocks;
+        int alloc_unit = sizeof(struct kvp_record) * ENTRIES_PER_BLOCK;
+
+        kvp_acquire_lock(pool);
+
+        filep = fopen(kvp_file_info[pool].fname, "r");
+        if (!filep) {
+                kvp_release_lock(pool);
+                syslog(LOG_ERR, "Failed to open file, pool: %d", pool);
+                exit(-1);
+        }
+        while (!feof(filep)) {
+                readp = &record[records_read];
+                records_read += fread(readp, sizeof(struct kvp_record),
+                                        ENTRIES_PER_BLOCK * num_blocks,
+                                        filep);
+
+                if (!feof(filep)) {
+                        /*
+                         * We have more data to read.
+                         */
+                        num_blocks++;
+                        record = realloc(record, alloc_unit * num_blocks);
+
+                        if (record == NULL) {
+                                syslog(LOG_ERR, "malloc failed");
+                                exit(-1);
+                        }
+                        continue;
+                }
+                break;
+        }
+
+        kvp_file_info[pool].num_blocks = num_blocks;
+        kvp_file_info[pool].records = record;
+        kvp_file_info[pool].num_records = records_read;
+
+        kvp_release_lock(pool);
+}
+static int kvp_file_init(void)
+{
+        int ret, fd;
+        FILE *filep;
+        size_t records_read;
+        __u8 *fname;
+        struct kvp_record *record;
+        struct kvp_record *readp;
+        int num_blocks;
+        int i;
+        int alloc_unit = sizeof(struct kvp_record) * ENTRIES_PER_BLOCK;
+
+        if (access("/var/opt/hyperv", F_OK)) {
+                if (mkdir("/var/opt/hyperv", S_IRUSR | S_IWUSR | S_IROTH)) {
+                        syslog(LOG_ERR, " Failed to create /var/opt/hyperv");
+                        exit(-1);
+                }
+        }
+
+        for (i = 0; i < KVP_POOL_COUNT; i++) {
+                fname = kvp_file_info[i].fname;
+                records_read = 0;
+                num_blocks = 1;
+                sprintf(fname, "/var/opt/hyperv/.kvp_pool_%d", i);
+                fd = open(fname, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IROTH);
+
+                if (fd == -1)
+                        return 1;
+
+
+                filep = fopen(fname, "r");
+                if (!filep)
+                        return 1;
+
+                record = malloc(alloc_unit * num_blocks);
+                if (record == NULL) {
+                        fclose(filep);
+                        return 1;
+                }
+                while (!feof(filep)) {
+                        readp = &record[records_read];
+                        records_read += fread(readp, sizeof(struct kvp_record),
+                                        ENTRIES_PER_BLOCK,
+                                        filep);
+
+                        if (!feof(filep)) {
+                                /*
+                                 * We have more data to read.
+                                 */
+                                num_blocks++;
+                                record = realloc(record, alloc_unit *
+                                                num_blocks);
+                                if (record == NULL) {
+                                        fclose(filep);
+                                        return 1;
+                                }
+                                continue;
+                        }
+                        break;
+                }
+                kvp_file_info[i].fd = fd;
+                kvp_file_info[i].num_blocks = num_blocks;
+                kvp_file_info[i].records = record;
+                kvp_file_info[i].num_records = records_read;
+                fclose(filep);
+
+        }
+
+        return 0;
+}
+
+static int kvp_key_delete(int pool, __u8 *key, int key_size)
+{
+        int i;
+        int j, k;
+        int num_records;
+        struct kvp_record *record;
+
+        /*
+         * First update the in-memory state.
+         */
+        kvp_update_mem_state(pool);
+
+        num_records = kvp_file_info[pool].num_records;
+        record = kvp_file_info[pool].records;
+
+        for (i = 0; i < num_records; i++) {
+                if (memcmp(key, record[i].key, key_size))
+                        continue;
+                /*
+                 * Found a match; just move the remaining
+                 * entries up.
+                 */
+                if (i == num_records) {
+                        kvp_file_info[pool].num_records--;
+                        kvp_update_file(pool);
+                        return 0;
+                }
+
+                j = i;
+                k = j + 1;
+                for (; k < num_records; k++) {
+                        strcpy(record[j].key, record[k].key);
+                        strcpy(record[j].value, record[k].value);
+                        j++;
+                }
+
+                kvp_file_info[pool].num_records--;
+                kvp_update_file(pool);
+                return 0;
+        }
+        return 1;
+}
+
+static int kvp_key_add_or_modify(int pool, __u8 *key, int key_size, __u8 *value,
+                        int value_size)
+{
+        int i;
+        int j, k;
+        int num_records;
+        struct kvp_record *record;
+        int num_blocks;
+
+        if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) ||
+                (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE))
+                return 1;
+
+        /*
+         * First update the in-memory state.
+         */
+        kvp_update_mem_state(pool);
+
+        num_records = kvp_file_info[pool].num_records;
+        record = kvp_file_info[pool].records;
+        num_blocks = kvp_file_info[pool].num_blocks;
+
+        for (i = 0; i < num_records; i++) {
+                if (memcmp(key, record[i].key, key_size))
+                        continue;
+                /*
+                 * Found a match; just update the value -
+                 * this is the modify case.
+                 */
+                memcpy(record[i].value, value, value_size);
+                kvp_update_file(pool);
+                return 0;
+        }
+
+        /*
+         * Need to add a new entry;
+         */
+        if (num_records == (ENTRIES_PER_BLOCK * num_blocks)) {
+                /* Need to allocate a larger array for reg entries. */
+                record = realloc(record, sizeof(struct kvp_record) *
+                         ENTRIES_PER_BLOCK * (num_blocks + 1));
+
+                if (record == NULL)
+                        return 1;
+                kvp_file_info[pool].num_blocks++;
+
+        }
+        memcpy(record[i].value, value, value_size);
+        memcpy(record[i].key, key, key_size);
+        kvp_file_info[pool].records = record;
+        kvp_file_info[pool].num_records++;
+        kvp_update_file(pool);
+        return 0;
+}
+
+static int kvp_get_value(int pool, __u8 *key, int key_size, __u8 *value,
+                        int value_size)
+{
+        int i;
+        int num_records;
+        struct kvp_record *record;
+
+        if ((key_size > HV_KVP_EXCHANGE_MAX_KEY_SIZE) ||
+                (value_size > HV_KVP_EXCHANGE_MAX_VALUE_SIZE))
+                return 1;
+
+        /*
+         * First update the in-memory state.
+         */
+        kvp_update_mem_state(pool);
+
+        num_records = kvp_file_info[pool].num_records;
+        record = kvp_file_info[pool].records;
+
+        for (i = 0; i < num_records; i++) {
+                if (memcmp(key, record[i].key, key_size))
+                        continue;
+                /*
+                 * Found a match; just copy the value out.
+                 */
+                memcpy(value, record[i].value, value_size);
+                return 0;
+        }
+
+        return 1;
+}
+
+static void kvp_pool_enumerate(int pool, int index, __u8 *key, int key_size,
+                                __u8 *value, int value_size)
+{
+        struct kvp_record *record;
+
+        /*
+         * First update our in-memory database.
+         */
+        kvp_update_mem_state(pool);
+        record = kvp_file_info[pool].records;
+
+        if (index >= kvp_file_info[pool].num_records) {
+                /*
+                 * This is an invalid index; terminate enumeration;
+                 * - a NULL value will do the trick.
+                 */
+                strcpy(value, "");
+                return;
+        }
+
+        memcpy(key, record[index].key, key_size);
+        memcpy(value, record[index].value, value_size);
+}
+
+
 void kvp_get_os_info(void)
 {
         FILE    *file;
@@ -332,7 +642,7 @@ int main(void)
         struct pollfd pfd;
         struct nlmsghdr *incoming_msg;
         struct cn_msg   *incoming_cn_msg;
-        struct hv_ku_msg *hv_msg;
+        struct hv_kvp_msg *hv_msg;
         char    *p;
         char    *key_value;
         char    *key_name;
@@ -345,6 +655,11 @@ int main(void)
          */
         kvp_get_os_info();
 
+        if (kvp_file_init()) {
+                syslog(LOG_ERR, "Failed to initialize the pools");
+                exit(-1);
+        }
+
         fd = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_CONNECTOR);
         if (fd < 0) {
                 syslog(LOG_ERR, "netlink socket creation failed; error:%d", fd);
@@ -370,9 +685,11 @@ int main(void)
         message = (struct cn_msg *)kvp_send_buffer;
         message->id.idx = CN_KVP_IDX;
         message->id.val = CN_KVP_VAL;
-        message->seq = KVP_REGISTER;
+
+        hv_msg = (struct hv_kvp_msg *)message->data;
+        hv_msg->kvp_hdr.operation = KVP_OP_REGISTER;
         message->ack = 0;
-        message->len = 0;
+        message->len = sizeof(struct hv_kvp_msg);
 
         len = netlink_send(fd, message);
         if (len < 0) {
@@ -398,14 +715,15 @@ int main(void)
 
                 incoming_msg = (struct nlmsghdr *)kvp_recv_buffer;
                 incoming_cn_msg = (struct cn_msg *)NLMSG_DATA(incoming_msg);
+                hv_msg = (struct hv_kvp_msg *)incoming_cn_msg->data;
 
-                switch (incoming_cn_msg->seq) {
-                case KVP_REGISTER:
+                switch (hv_msg->kvp_hdr.operation) {
+                case KVP_OP_REGISTER:
                         /*
                          * Driver is registering with us; stash away the version
                          * information.
                          */
-                        p = (char *)incoming_cn_msg->data;
+                        p = (char *)hv_msg->body.kvp_register.version;
                         lic_version = malloc(strlen(p) + 1);
                         if (lic_version) {
                                 strcpy(lic_version, p);
@@ -416,17 +734,65 @@ int main(void)
                         }
                         continue;
 
-                case KVP_KERNEL_GET:
+                /*
+                 * The current protocol with the kernel component uses a
+                 * NULL key name to pass an error condition.
+                 * For the SET, GET and DELETE operations,
+                 * use the existing protocol to pass back error.
+                 */
+
+                case KVP_OP_SET:
+                        if (kvp_key_add_or_modify(hv_msg->kvp_hdr.pool,
+                                        hv_msg->body.kvp_set.data.key,
+                                        hv_msg->body.kvp_set.data.key_size,
+                                        hv_msg->body.kvp_set.data.value,
+                                        hv_msg->body.kvp_set.data.value_size))
+                                strcpy(hv_msg->body.kvp_set.data.key, "");
+                        break;
+
+                case KVP_OP_GET:
+                        if (kvp_get_value(hv_msg->kvp_hdr.pool,
+                                        hv_msg->body.kvp_set.data.key,
+                                        hv_msg->body.kvp_set.data.key_size,
+                                        hv_msg->body.kvp_set.data.value,
+                                        hv_msg->body.kvp_set.data.value_size))
+                                strcpy(hv_msg->body.kvp_set.data.key, "");
+                        break;
+
+                case KVP_OP_DELETE:
+                        if (kvp_key_delete(hv_msg->kvp_hdr.pool,
+                                        hv_msg->body.kvp_delete.key,
+                                        hv_msg->body.kvp_delete.key_size))
+                                strcpy(hv_msg->body.kvp_delete.key, "");
                         break;
+
                 default:
-                        continue;
+                        break;
+                }
+
+                if (hv_msg->kvp_hdr.operation != KVP_OP_ENUMERATE)
+                        goto kvp_done;
+
+                /*
+                 * If the pool is KVP_POOL_AUTO, dynamically generate
+                 * both the key and the value; if not read from the
+                 * appropriate pool.
+                 */
+                if (hv_msg->kvp_hdr.pool != KVP_POOL_AUTO) {
+                        kvp_pool_enumerate(hv_msg->kvp_hdr.pool,
+                                        hv_msg->body.kvp_enum_data.index,
+                                        hv_msg->body.kvp_enum_data.data.key,
+                                        HV_KVP_EXCHANGE_MAX_KEY_SIZE,
+                                        hv_msg->body.kvp_enum_data.data.value,
+                                        HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
+                        goto kvp_done;
                 }
 
-                hv_msg = (struct hv_ku_msg *)incoming_cn_msg->data;
-                key_name = (char *)hv_msg->kvp_key;
-                key_value = (char *)hv_msg->kvp_value;
+                hv_msg = (struct hv_kvp_msg *)incoming_cn_msg->data;
+                key_name = (char *)hv_msg->body.kvp_enum_data.data.key;
+                key_value = (char *)hv_msg->body.kvp_enum_data.data.value;
 
-                switch (hv_msg->kvp_index) {
+                switch (hv_msg->body.kvp_enum_data.index) {
                 case FullyQualifiedDomainName:
                         kvp_get_domain_name(key_value,
                                         HV_KVP_EXCHANGE_MAX_VALUE_SIZE);
@@ -483,12 +849,12 @@ int main(void)
                  * already in the receive buffer. Update the cn_msg header to
                  * reflect the key value that has been added to the message
                  */
+kvp_done:
 
                 incoming_cn_msg->id.idx = CN_KVP_IDX;
                 incoming_cn_msg->id.val = CN_KVP_VAL;
-                incoming_cn_msg->seq = KVP_USER_SET;
                 incoming_cn_msg->ack = 0;
-                incoming_cn_msg->len = sizeof(struct hv_ku_msg);
+                incoming_cn_msg->len = sizeof(struct hv_kvp_msg);
 
                 len = netlink_send(fd, incoming_cn_msg);
                 if (len < 0) {
diff --git a/tools/perf/Documentation/Makefile b/tools/perf/Documentation/Makefile
index 4626a398836a..ca600e09c8d4 100644
--- a/tools/perf/Documentation/Makefile
+++ b/tools/perf/Documentation/Makefile
@@ -1,3 +1,10 @@
+OUTPUT := ./
+ifeq ("$(origin O)", "command line")
+  ifneq ($(O),)
+        OUTPUT := $(O)/
+  endif
+endif
+
 MAN1_TXT= \
         $(filter-out $(addsuffix .txt, $(ARTICLES) $(SP_ARTICLES)), \
                 $(wildcard perf-*.txt)) \
@@ -6,10 +13,11 @@ MAN5_TXT=
 MAN7_TXT=
 
 MAN_TXT = $(MAN1_TXT) $(MAN5_TXT) $(MAN7_TXT)
-MAN_XML=$(patsubst %.txt,%.xml,$(MAN_TXT))
-MAN_HTML=$(patsubst %.txt,%.html,$(MAN_TXT))
+_MAN_XML=$(patsubst %.txt,%.xml,$(MAN_TXT))
+_MAN_HTML=$(patsubst %.txt,%.html,$(MAN_TXT))
 
-DOC_HTML=$(MAN_HTML)
+MAN_XML=$(addprefix $(OUTPUT),$(_MAN_XML))
+MAN_HTML=$(addprefix $(OUTPUT),$(_MAN_HTML))
 
 ARTICLES =
 # with their own formatting rules.
@@ -18,11 +26,17 @@ API_DOCS = $(patsubst %.txt,%,$(filter-out technical/api-index-skel.txt technica
 SP_ARTICLES += $(API_DOCS)
 SP_ARTICLES += technical/api-index
 
-DOC_HTML += $(patsubst %,%.html,$(ARTICLES) $(SP_ARTICLES))
+_DOC_HTML = $(_MAN_HTML)
+_DOC_HTML+=$(patsubst %,%.html,$(ARTICLES) $(SP_ARTICLES))
+DOC_HTML=$(addprefix $(OUTPUT),$(_DOC_HTML))
 
-DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
-DOC_MAN5=$(patsubst %.txt,%.5,$(MAN5_TXT))
-DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
+_DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
+_DOC_MAN5=$(patsubst %.txt,%.5,$(MAN5_TXT))
+_DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
+
+DOC_MAN1=$(addprefix $(OUTPUT),$(_DOC_MAN1))
+DOC_MAN5=$(addprefix $(OUTPUT),$(_DOC_MAN5))
+DOC_MAN7=$(addprefix $(OUTPUT),$(_DOC_MAN7))
 
 # Make the path relative to DESTDIR, not prefix
 ifndef DESTDIR
@@ -150,9 +164,9 @@ man1: $(DOC_MAN1)
 man5: $(DOC_MAN5)
 man7: $(DOC_MAN7)
 
-info: perf.info perfman.info
+info: $(OUTPUT)perf.info $(OUTPUT)perfman.info
 
-pdf: user-manual.pdf
+pdf: $(OUTPUT)user-manual.pdf
 
 install: install-man
 
@@ -166,7 +180,7 @@ install-man: man
 
 install-info: info
         $(INSTALL) -d -m 755 $(DESTDIR)$(infodir)
-        $(INSTALL) -m 644 perf.info perfman.info $(DESTDIR)$(infodir)
+        $(INSTALL) -m 644 $(OUTPUT)perf.info $(OUTPUT)perfman.info $(DESTDIR)$(infodir)
         if test -r $(DESTDIR)$(infodir)/dir; then \
           $(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) perf.info ;\
           $(INSTALL_INFO) --info-dir=$(DESTDIR)$(infodir) perfman.info ;\
@@ -176,7 +190,7 @@ install-info: info
 
 install-pdf: pdf
         $(INSTALL) -d -m 755 $(DESTDIR)$(pdfdir)
-        $(INSTALL) -m 644 user-manual.pdf $(DESTDIR)$(pdfdir)
+        $(INSTALL) -m 644 $(OUTPUT)user-manual.pdf $(DESTDIR)$(pdfdir)
 
 #install-html: html
 #       '$(SHELL_PATH_SQ)' ./install-webdoc.sh $(DESTDIR)$(htmldir)
@@ -189,14 +203,14 @@ install-pdf: pdf
 #
 # Determine "include::" file references in asciidoc files.
 #
-doc.dep : $(wildcard *.txt) build-docdep.perl
+$(OUTPUT)doc.dep : $(wildcard *.txt) build-docdep.perl
         $(QUIET_GEN)$(RM) $@+ $@ && \
         $(PERL_PATH) ./build-docdep.perl >$@+ $(QUIET_STDERR) && \
         mv $@+ $@
 
--include doc.dep
+-include $(OUPTUT)doc.dep
 
-cmds_txt = cmds-ancillaryinterrogators.txt \
+_cmds_txt = cmds-ancillaryinterrogators.txt \
         cmds-ancillarymanipulators.txt \
         cmds-mainporcelain.txt \
         cmds-plumbinginterrogators.txt \
@@ -205,32 +219,36 @@ cmds_txt = cmds-ancillaryinterrogators.txt \
         cmds-synchelpers.txt \
         cmds-purehelpers.txt \
         cmds-foreignscminterface.txt
+cmds_txt=$(addprefix $(OUTPUT),$(_cmds_txt))
 
-$(cmds_txt): cmd-list.made
+$(cmds_txt): $(OUTPUT)cmd-list.made
 
-cmd-list.made: cmd-list.perl ../command-list.txt $(MAN1_TXT)
+$(OUTPUT)cmd-list.made: cmd-list.perl ../command-list.txt $(MAN1_TXT)
         $(QUIET_GEN)$(RM) $@ && \
         $(PERL_PATH) ./cmd-list.perl ../command-list.txt $(QUIET_STDERR) && \
         date >$@
 
 clean:
-        $(RM) *.xml *.xml+ *.html *.html+ *.1 *.5 *.7
-        $(RM) *.texi *.texi+ *.texi++ perf.info perfman.info
-        $(RM) howto-index.txt howto/*.html doc.dep
-        $(RM) technical/api-*.html technical/api-index.txt
-        $(RM) $(cmds_txt) *.made
-
-$(MAN_HTML): %.html : %.txt
+        $(RM) $(MAN_XML) $(addsuffix +,$(MAN_XML))
+        $(RM) $(MAN_HTML) $(addsuffix +,$(MAN_HTML))
+        $(RM) $(DOC_HTML) $(DOC_MAN1) $(DOC_MAN5) $(DOC_MAN7)
+        $(RM) $(OUTPUT)*.texi $(OUTPUT)*.texi+ $(OUTPUT)*.texi++
+        $(RM) $(OUTPUT)perf.info $(OUTPUT)perfman.info
+        $(RM) $(OUTPUT)howto-index.txt $(OUTPUT)howto/*.html $(OUTPUT)doc.dep
+        $(RM) $(OUTPUT)technical/api-*.html $(OUTPUT)technical/api-index.txt
+        $(RM) $(cmds_txt) $(OUTPUT)*.made
+
+$(MAN_HTML): $(OUTPUT)%.html : %.txt
         $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
         $(ASCIIDOC) -b xhtml11 -d manpage -f asciidoc.conf \
                 $(ASCIIDOC_EXTRA) -aperf_version=$(PERF_VERSION) -o $@+ $< && \
         mv $@+ $@
 
-%.1 %.5 %.7 : %.xml
+$(OUTPUT)%.1 $(OUTPUT)%.5 $(OUTPUT)%.7 : $(OUTPUT)%.xml
         $(QUIET_XMLTO)$(RM) $@ && \
-        xmlto -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
+        xmlto -o $(OUTPUT) -m $(MANPAGE_XSL) $(XMLTO_EXTRA) man $<
 
-%.xml : %.txt
+$(OUTPUT)%.xml : %.txt
         $(QUIET_ASCIIDOC)$(RM) $@+ $@ && \
         $(ASCIIDOC) -b docbook -d manpage -f asciidoc.conf \
                 $(ASCIIDOC_EXTRA) -aperf_version=$(PERF_VERSION) -o $@+ $< && \
@@ -239,25 +257,25 @@ $(MAN_HTML): %.html : %.txt
 XSLT = docbook.xsl
 XSLTOPTS = --xinclude --stringparam html.stylesheet docbook-xsl.css
 
-user-manual.html: user-manual.xml
+$(OUTPUT)user-manual.html: $(OUTPUT)user-manual.xml
         $(QUIET_XSLTPROC)xsltproc $(XSLTOPTS) -o $@ $(XSLT) $<
 
-perf.info: user-manual.texi
-        $(QUIET_MAKEINFO)$(MAKEINFO) --no-split -o $@ user-manual.texi
+$(OUTPUT)perf.info: $(OUTPUT)user-manual.texi
+        $(QUIET_MAKEINFO)$(MAKEINFO) --no-split -o $@ $(OUTPUT)user-manual.texi
 
-user-manual.texi: user-manual.xml
+$(OUTPUT)user-manual.texi: $(OUTPUT)user-manual.xml
         $(QUIET_DB2TEXI)$(RM) $@+ $@ && \
-        $(DOCBOOK2X_TEXI) user-manual.xml --encoding=UTF-8 --to-stdout >$@++ && \
+        $(DOCBOOK2X_TEXI) $(OUTPUT)user-manual.xml --encoding=UTF-8 --to-stdout >$@++ && \
         $(PERL_PATH) fix-texi.perl <$@++ >$@+ && \
         rm $@++ && \
         mv $@+ $@
 
-user-manual.pdf: user-manual.xml
+$(OUTPUT)user-manual.pdf: $(OUTPUT)user-manual.xml
         $(QUIET_DBLATEX)$(RM) $@+ $@ && \
         $(DBLATEX) -o $@+ -p /etc/asciidoc/dblatex/asciidoc-dblatex.xsl -s /etc/asciidoc/dblatex/asciidoc-dblatex.sty $< && \
         mv $@+ $@
 
-perfman.texi: $(MAN_XML) cat-texi.perl
+$(OUTPUT)perfman.texi: $(MAN_XML) cat-texi.perl
         $(QUIET_DB2TEXI)$(RM) $@+ $@ && \
         ($(foreach xml,$(MAN_XML),$(DOCBOOK2X_TEXI) --encoding=UTF-8 \
                 --to-stdout $(xml) &&) true) > $@++ && \
@@ -265,7 +283,7 @@ perfman.texi: $(MAN_XML) cat-texi.perl
         rm $@++ && \
         mv $@+ $@
 
-perfman.info: perfman.texi
+$(OUTPUT)perfman.info: $(OUTPUT)perfman.texi
         $(QUIET_MAKEINFO)$(MAKEINFO) --no-split --no-validate $*.texi
 
 $(patsubst %.txt,%.texi,$(MAN_TXT)): %.texi : %.xml
diff --git a/tools/perf/Documentation/perf-lock.txt b/tools/perf/Documentation/perf-lock.txt
index d6b2a4f2108b..c7f5f55634ac 100644
--- a/tools/perf/Documentation/perf-lock.txt
+++ b/tools/perf/Documentation/perf-lock.txt
@@ -8,7 +8,7 @@ perf-lock - Analyze lock events
 SYNOPSIS
 --------
 [verse]
-'perf lock' {record|report|trace}
+'perf lock' {record|report|script|info}
 
 DESCRIPTION
 -----------
@@ -20,10 +20,13 @@ and statistics with this 'perf lock' command.
   produces the file "perf.data" which contains tracing
   results of lock events.
 
-  'perf lock trace' shows raw lock events.
-
   'perf lock report' reports statistical data.
 
+  'perf lock script' shows raw lock events.
+
+  'perf lock info' shows metadata like threads or addresses
+  of lock instances.
+
 COMMON OPTIONS
 --------------
 
@@ -47,6 +50,17 @@ REPORT OPTIONS
         Sorting key. Possible values: acquired (default), contended,
         wait_total, wait_max, wait_min.
 
+INFO OPTIONS
+------------
+
+-t::
+--threads::
+        dump thread list in perf.data
+
+-m::
+--map::
+        dump map of lock instances (address:name table)
+
 SEE ALSO
 --------
 linkperf:perf[1]
diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Documentation/perf-record.txt
index 2937f7e14bb7..a1386b2fff00 100644
--- a/tools/perf/Documentation/perf-record.txt
+++ b/tools/perf/Documentation/perf-record.txt
@@ -52,11 +52,15 @@ OPTIONS
 
 -p::
 --pid=::
-        Record events on existing process ID.
+        Record events on existing process ID (comma separated list).
 
 -t::
 --tid=::
-        Record events on existing thread ID.
+        Record events on existing thread ID (comma separated list).
+
+-u::
+--uid=::
+        Record events in threads owned by uid. Name or number.
 
 -r::
 --realtime=::
@@ -148,6 +152,36 @@ an empty cgroup (monitor all the time) using, e.g., -G foo,,bar. Cgroups must ha
 corresponding events, i.e., they always refer to events defined earlier on the command
 line.
 
+-b::
+--branch-any::
+Enable taken branch stack sampling. Any type of taken branch may be sampled.
+This is a shortcut for --branch-filter any. See --branch-filter for more infos.
+
+-j::
+--branch-filter::
+Enable taken branch stack sampling. Each sample captures a series of consecutive
+taken branches. The number of branches captured with each sample depends on the
+underlying hardware, the type of branches of interest, and the executed code.
+It is possible to select the types of branches captured by enabling filters. The
+following filters are defined:
+
+        - any:  any type of branches
+        - any_call: any function call or system call
+        - any_ret: any function return or system call return
+        - any_ind: any indirect branch
+        - u:  only when the branch target is at the user level
+        - k: only when the branch target is in the kernel
+        - hv: only when the target is at the hypervisor level
+
++
+The option requires at least one branch type among any, any_call, any_ret, ind_call.
+The privilege levels may be ommitted, in which case, the privilege levels of the associated
+event are applied to the branch filter. Both kernel (k) and hypervisor (hv) privilege
+levels are subject to permissions.  When sampling on multiple events, branch stack sampling
+is enabled for all the sampling events. The sampled branch type is the same for all events.
+The various filters must be specified as a comma separated list: --branch-filter any_ret,u,k
+Note that this feature may not be available on all processors.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-list[1]
diff --git a/tools/perf/Documentation/perf-report.txt b/tools/perf/Documentation/perf-report.txt
index 9b430e98712e..87feeee8b90c 100644
--- a/tools/perf/Documentation/perf-report.txt
+++ b/tools/perf/Documentation/perf-report.txt
@@ -153,6 +153,16 @@ OPTIONS
         information which may be very large and thus may clutter the display.
         It currently includes: cpu and numa topology of the host system.
 
+-b::
+--branch-stack::
+        Use the addresses of sampled taken branches instead of the instruction
+        address to build the histograms. To generate meaningful output, the
+        perf.data file must have been obtained using perf record -b or
+        perf record --branch-filter xxx where xxx is a branch filter option.
+        perf report is able to auto-detect whether a perf.data file contains
+        branch stacks and it will automatically switch to the branch view mode,
+        unless --no-branch-stack is used.
+
 SEE ALSO
 --------
 linkperf:perf-stat[1], linkperf:perf-annotate[1]
diff --git a/tools/perf/Documentation/perf-script.txt b/tools/perf/Documentation/perf-script.txt
index 2f6cef43da25..e9cbfcddfa3f 100644
--- a/tools/perf/Documentation/perf-script.txt
+++ b/tools/perf/Documentation/perf-script.txt
@@ -115,7 +115,7 @@ OPTIONS
 -f::
 --fields::
         Comma separated list of fields to print. Options are:
-        comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr.
+        comm, tid, pid, time, cpu, event, trace, ip, sym, dso, addr, symoff.
         Field list can be prepended with the type, trace, sw or hw,
         to indicate to which event type the field list applies.
         e.g., -f sw:comm,tid,time,ip,sym  and -f trace:time,cpu,trace
@@ -200,6 +200,9 @@ OPTIONS
         It currently includes: cpu and numa topology of the host system.
         It can only be used with the perf script report mode.
 
+--show-kernel-path::
+        Try to resolve the path of [kernel.kallsyms]
+
 SEE ALSO
 --------
 linkperf:perf-record[1], linkperf:perf-script-perl[1],
diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 8966b9ab2014..2fa173b51970 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -35,11 +35,11 @@ OPTIONS
         child tasks do not inherit counters
 -p::
 --pid=<pid>::
-        stat events on existing process id
+        stat events on existing process id (comma separated list)
 
 -t::
 --tid=<tid>::
-        stat events on existing thread id
+        stat events on existing thread id (comma separated list)
 
 
 -a::
diff --git a/tools/perf/Documentation/perf-top.txt b/tools/perf/Documentation/perf-top.txt
index b1a5bbbfebef..4a5680cb242e 100644
--- a/tools/perf/Documentation/perf-top.txt
+++ b/tools/perf/Documentation/perf-top.txt
@@ -72,11 +72,15 @@ Default is to monitor all CPUS.
 
 -p <pid>::
 --pid=<pid>::
-        Profile events on existing Process ID.
+        Profile events on existing Process ID (comma separated list).
 
 -t <tid>::
 --tid=<tid>::
-        Profile events on existing thread ID.
+        Profile events on existing thread ID (comma separated list).
+
+-u::
+--uid=::
+        Record events in threads owned by uid. Name or number.
 
 -r <priority>::
 --realtime=<priority>::
diff --git a/tools/perf/MANIFEST b/tools/perf/MANIFEST
index 1078c5fadd5b..5476bc0a1eac 100644
--- a/tools/perf/MANIFEST
+++ b/tools/perf/MANIFEST
@@ -9,6 +9,7 @@ lib/rbtree.c
 include/linux/swab.h
 arch/*/include/asm/unistd*.h
 arch/*/lib/memcpy*.S
+arch/*/lib/memset*.S
 include/linux/poison.h
 include/linux/magic.h
 include/linux/hw_breakpoint.h
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 7c12650165ae..74fd7f89208a 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -15,6 +15,16 @@ endif
 
 # Define V to have a more verbose compile.
 #
+# Define O to save output files in a separate directory.
+#
+# Define ARCH as name of target architecture if you want cross-builds.
+#
+# Define CROSS_COMPILE as prefix name of compiler if you want cross-builds.
+#
+# Define NO_LIBPERL to disable perl script extension.
+#
+# Define NO_LIBPYTHON to disable python script extension.
+#
 # Define PYTHON to point to the python binary if the default
 # `python' is not correct; for example: PYTHON=python2
 #
@@ -32,6 +42,10 @@ endif
 # Define NO_DWARF if you do not want debug-info analysis feature at all.
 #
 # Define WERROR=0 to disable treating any warnings as errors.
+#
+# Define NO_NEWT if you do not want TUI support.
+#
+# Define NO_DEMANGLE if you do not want C++ symbol demangling.
 
 $(OUTPUT)PERF-VERSION-FILE: .FORCE-PERF-VERSION-FILE
         @$(SHELL_PATH) util/PERF-VERSION-GEN $(OUTPUT)
@@ -61,7 +75,7 @@ ifeq ($(ARCH),x86_64)
         ifeq (${IS_X86_64}, 1)
                 RAW_ARCH := x86_64
                 ARCH_CFLAGS := -DARCH_X86_64
-                ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S
+                ARCH_INCLUDE = ../../arch/x86/lib/memcpy_64.S ../../arch/x86/lib/memset_64.S
         endif
 endif
 
@@ -183,7 +197,10 @@ SCRIPT_SH += perf-archive.sh
 grep-libs = $(filter -l%,$(1))
 strip-libs = $(filter-out -l%,$(1))
 
-$(OUTPUT)python/perf.so: $(PYRF_OBJS)
+PYTHON_EXT_SRCS := $(shell grep -v ^\# util/python-ext-sources)
+PYTHON_EXT_DEPS := util/python-ext-sources util/setup.py
+
+$(OUTPUT)python/perf.so: $(PYRF_OBJS) $(PYTHON_EXT_SRCS) $(PYTHON_EXT_DEPS)
         $(QUIET_GEN)CFLAGS='$(BASIC_CFLAGS)' $(PYTHON_WORD) util/setup.py \
           --quiet build_ext; \
         mkdir -p $(OUTPUT)python && \
@@ -249,6 +266,8 @@ LIB_H += util/include/asm/uaccess.h
 LIB_H += util/include/dwarf-regs.h
 LIB_H += util/include/asm/dwarf2.h
 LIB_H += util/include/asm/cpufeature.h
+LIB_H += util/include/asm/unistd_32.h
+LIB_H += util/include/asm/unistd_64.h
 LIB_H += perf.h
 LIB_H += util/annotate.h
 LIB_H += util/cache.h
@@ -256,6 +275,7 @@ LIB_H += util/callchain.h
 LIB_H += util/build-id.h
 LIB_H += util/debug.h
 LIB_H += util/debugfs.h
+LIB_H += util/sysfs.h
 LIB_H += util/event.h
 LIB_H += util/evsel.h
 LIB_H += util/evlist.h
@@ -302,6 +322,7 @@ LIB_OBJS += $(OUTPUT)util/build-id.o
 LIB_OBJS += $(OUTPUT)util/config.o
 LIB_OBJS += $(OUTPUT)util/ctype.o
 LIB_OBJS += $(OUTPUT)util/debugfs.o
+LIB_OBJS += $(OUTPUT)util/sysfs.o
 LIB_OBJS += $(OUTPUT)util/environment.o
 LIB_OBJS += $(OUTPUT)util/event.o
 LIB_OBJS += $(OUTPUT)util/evlist.o
@@ -359,8 +380,10 @@ BUILTIN_OBJS += $(OUTPUT)bench/sched-messaging.o
 BUILTIN_OBJS += $(OUTPUT)bench/sched-pipe.o
 ifeq ($(RAW_ARCH),x86_64)
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy-x86-64-asm.o
+BUILTIN_OBJS += $(OUTPUT)bench/mem-memset-x86-64-asm.o
 endif
 BUILTIN_OBJS += $(OUTPUT)bench/mem-memcpy.o
+BUILTIN_OBJS += $(OUTPUT)bench/mem-memset.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-diff.o
 BUILTIN_OBJS += $(OUTPUT)builtin-evlist.o
@@ -792,7 +815,6 @@ help:
         @echo '  quick-install-html     - install the html documentation quickly'
         @echo ''
         @echo 'Perf maintainer targets:'
-        @echo '  distclean              - alias to clean'
         @echo '  clean                  - clean all binary objects and build output'
 
 doc:
diff --git a/tools/perf/arch/powerpc/util/header.c b/tools/perf/arch/powerpc/util/header.c
index eba80c292945..2f7073d107fd 100644
--- a/tools/perf/arch/powerpc/util/header.c
+++ b/tools/perf/arch/powerpc/util/header.c
@@ -25,7 +25,7 @@ get_cpuid(char *buffer, size_t sz)
 
         pvr = mfspr(SPRN_PVR);
 
-        nb = snprintf(buffer, sz, "%lu,%lu$", PVR_VER(pvr), PVR_REV(pvr));
+        nb = scnprintf(buffer, sz, "%lu,%lu$", PVR_VER(pvr), PVR_REV(pvr));
 
         /* look for end marker to ensure the entire data fit */
         if (strchr(buffer, '$')) {
diff --git a/tools/perf/arch/x86/util/header.c b/tools/perf/arch/x86/util/header.c
index f94006068d2b..146d12a1cec0 100644
--- a/tools/perf/arch/x86/util/header.c
+++ b/tools/perf/arch/x86/util/header.c
@@ -48,7 +48,7 @@ get_cpuid(char *buffer, size_t sz)
                 if (family >= 0x6)
                         model += ((a >> 16) & 0xf) << 4;
         }
-        nb = snprintf(buffer, sz, "%s,%u,%u,%u$", vendor, family, model, step);
+        nb = scnprintf(buffer, sz, "%s,%u,%u,%u$", vendor, family, model, step);
 
         /* look for end marker to ensure the entire data fit */
         if (strchr(buffer, '$')) {
diff --git a/tools/perf/bench/bench.h b/tools/perf/bench/bench.h
index f7781c6267c0..a09bece6dad2 100644
--- a/tools/perf/bench/bench.h
+++ b/tools/perf/bench/bench.h
@@ -4,6 +4,7 @@
 extern int bench_sched_messaging(int argc, const char **argv, const char *prefix);
 extern int bench_sched_pipe(int argc, const char **argv, const char *prefix);
 extern int bench_mem_memcpy(int argc, const char **argv, const char *prefix __used);
+extern int bench_mem_memset(int argc, const char **argv, const char *prefix);
 
 #define BENCH_FORMAT_DEFAULT_STR        "default"
 #define BENCH_FORMAT_DEFAULT            0
diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm-def.h b/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
index d588b87696fc..d66ab799b35f 100644
--- a/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
+++ b/tools/perf/bench/mem-memcpy-x86-64-asm-def.h
@@ -2,3 +2,11 @@
 MEMCPY_FN(__memcpy,
         "x86-64-unrolled",
         "unrolled memcpy() in arch/x86/lib/memcpy_64.S")
+
+MEMCPY_FN(memcpy_c,
+        "x86-64-movsq",
+        "movsq-based memcpy() in arch/x86/lib/memcpy_64.S")
+
+MEMCPY_FN(memcpy_c_e,
+        "x86-64-movsb",
+        "movsb-based memcpy() in arch/x86/lib/memcpy_64.S")
diff --git a/tools/perf/bench/mem-memcpy-x86-64-asm.S b/tools/perf/bench/mem-memcpy-x86-64-asm.S
index 185a96d66dd1..fcd9cf00600a 100644
--- a/tools/perf/bench/mem-memcpy-x86-64-asm.S
+++ b/tools/perf/bench/mem-memcpy-x86-64-asm.S
@@ -1,4 +1,8 @@
-
+#define memcpy MEMCPY /* don't hide glibc's memcpy() */
+#define altinstr_replacement text
+#define globl p2align 4; .globl
+#define Lmemcpy_c globl memcpy_c; memcpy_c
+#define Lmemcpy_c_e globl memcpy_c_e; memcpy_c_e
 #include "../../../arch/x86/lib/memcpy_64.S"
 /*
  * We need to provide note.GNU-stack section, saying that we want
diff --git a/tools/perf/bench/mem-memcpy.c b/tools/perf/bench/mem-memcpy.c
index db82021f4b91..71557225bf92 100644
--- a/tools/perf/bench/mem-memcpy.c
+++ b/tools/perf/bench/mem-memcpy.c
@@ -5,7 +5,6 @@
  *
  * Written by Hitoshi Mitake <mitake@dcl.info.waseda.ac.jp>
  */
-#include <ctype.h>
 
 #include "../perf.h"
 #include "../util/util.h"
@@ -24,6 +23,7 @@
 
 static const char       *length_str     = "1MB";
 static const char       *routine        = "default";
+static int              iterations      = 1;
 static bool             use_clock;
 static int              clock_fd;
 static bool             only_prefault;
@@ -35,6 +35,8 @@ static const struct option options[] = {
                     "available unit: B, MB, GB (upper and lower)"),
         OPT_STRING('r', "routine", &routine, "default",
                     "Specify routine to copy"),
+        OPT_INTEGER('i', "iterations", &iterations,
+                    "repeat memcpy() invocation this number of times"),
         OPT_BOOLEAN('c', "clock", &use_clock,
                     "Use CPU clock for measuring"),
         OPT_BOOLEAN('o', "only-prefault", &only_prefault,
@@ -121,6 +123,7 @@ static u64 do_memcpy_clock(memcpy_t fn, size_t len, bool prefault)
 {
         u64 clock_start = 0ULL, clock_end = 0ULL;
         void *src = NULL, *dst = NULL;
+        int i;
 
         alloc_mem(&src, &dst, len);
 
@@ -128,7 +131,8 @@ static u64 do_memcpy_clock(memcpy_t fn, size_t len, bool prefault)
                 fn(dst, src, len);
 
         clock_start = get_clock();
-        fn(dst, src, len);
+        for (i = 0; i < iterations; ++i)
+                fn(dst, src, len);
         clock_end = get_clock();
 
         free(src);
@@ -140,6 +144,7 @@ static double do_memcpy_gettimeofday(memcpy_t fn, size_t len, bool prefault)
 {
         struct timeval tv_start, tv_end, tv_diff;
         void *src = NULL, *dst = NULL;
+        int i;
 
         alloc_mem(&src, &dst, len);
 
@@ -147,7 +152,8 @@ static double do_memcpy_gettimeofday(memcpy_t fn, size_t len, bool prefault)
                 fn(dst, src, len);
 
         BUG_ON(gettimeofday(&tv_start, NULL));
-        fn(dst, src, len);
+        for (i = 0; i < iterations; ++i)
+                fn(dst, src, len);
         BUG_ON(gettimeofday(&tv_end, NULL));
 
         timersub(&tv_end, &tv_start, &tv_diff);
diff --git a/tools/perf/bench/mem-memset-arch.h b/tools/perf/bench/mem-memset-arch.h
new file mode 100644
index 000000000000..a040fa77665b
--- /dev/null
+++ b/tools/perf/bench/mem-memset-arch.h
@@ -0,0 +1,12 @@
+
+#ifdef ARCH_X86_64
+
+#define MEMSET_FN(fn, name, desc)               \
+        extern void *fn(void *, int, size_t);
+
+#include "mem-memset-x86-64-asm-def.h"
+
+#undef MEMSET_FN
+
+#endif
+
diff --git a/tools/perf/bench/mem-memset-x86-64-asm-def.h b/tools/perf/bench/mem-memset-x86-64-asm-def.h
new file mode 100644
index 000000000000..a71dff97c1f5
--- /dev/null
+++ b/tools/perf/bench/mem-memset-x86-64-asm-def.h
@@ -0,0 +1,12 @@
+
+MEMSET_FN(__memset,
+        "x86-64-unrolled",
+        "unrolled memset() in arch/x86/lib/memset_64.S")
+
+MEMSET_FN(memset_c,
+        "x86-64-stosq",
+        "movsq-based memset() in arch/x86/lib/memset_64.S")
+
+MEMSET_FN(memset_c_e,
+        "x86-64-stosb",
+        "movsb-based memset() in arch/x86/lib/memset_64.S")
diff --git a/tools/perf/bench/mem-memset-x86-64-asm.S b/tools/perf/bench/mem-memset-x86-64-asm.S
new file mode 100644
index 000000000000..9e5af89ed13a
--- /dev/null
+++ b/tools/perf/bench/mem-memset-x86-64-asm.S
@@ -0,0 +1,13 @@
+#define memset MEMSET /* don't hide glibc's memset() */
+#define altinstr_replacement text
+#define globl p2align 4; .globl
+#define Lmemset_c globl memset_c; memset_c
+#define Lmemset_c_e globl memset_c_e; memset_c_e
+#include "../../../arch/x86/lib/memset_64.S"
+
+/*
+ * We need to provide note.GNU-stack section, saying that we want
+ * NOT executable stack. Otherwise the final linking will assume that
+ * the ELF stack should not be restricted at all and set it RWX.
+ */
+.section .note.GNU-stack,"",@progbits
diff --git a/tools/perf/bench/mem-memset.c b/tools/perf/bench/mem-memset.c
new file mode 100644
index 000000000000..e9079185bd72
--- /dev/null
+++ b/tools/perf/bench/mem-memset.c
@@ -0,0 +1,297 @@
+/*
+ * mem-memset.c
+ *
+ * memset: Simple memory set in various ways
+ *
+ * Trivial clone of mem-memcpy.c.
+ */
+
+#include "../perf.h"
+#include "../util/util.h"
+#include "../util/parse-options.h"
+#include "../util/header.h"
+#include "bench.h"
+#include "mem-memset-arch.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <errno.h>
+
+#define K 1024
+
+static const char       *length_str     = "1MB";
+static const char       *routine        = "default";
+static int              iterations      = 1;
+static bool             use_clock;
+static int              clock_fd;
+static bool             only_prefault;
+static bool             no_prefault;
+
+static const struct option options[] = {
+        OPT_STRING('l', "length", &length_str, "1MB",
+                    "Specify length of memory to copy. "
+                    "available unit: B, MB, GB (upper and lower)"),
+        OPT_STRING('r', "routine", &routine, "default",
+                    "Specify routine to copy"),
+        OPT_INTEGER('i', "iterations", &iterations,
+                    "repeat memset() invocation this number of times"),
+        OPT_BOOLEAN('c', "clock", &use_clock,
+                    "Use CPU clock for measuring"),
+        OPT_BOOLEAN('o', "only-prefault", &only_prefault,
+                    "Show only the result with page faults before memset()"),
+        OPT_BOOLEAN('n', "no-prefault", &no_prefault,
+                    "Show only the result without page faults before memset()"),
+        OPT_END()
+};
+
+typedef void *(*memset_t)(void *, int, size_t);
+
+struct routine {
+        const char *name;
+        const char *desc;
+        memset_t fn;
+};
+
+static const struct routine routines[] = {
+        { "default",
+          "Default memset() provided by glibc",
+          memset },
+#ifdef ARCH_X86_64
+
+#define MEMSET_FN(fn, name, desc) { name, desc, fn },
+#include "mem-memset-x86-64-asm-def.h"
+#undef MEMSET_FN
+
+#endif
+
+        { NULL,
+          NULL,
+          NULL   }
+};
+
+static const char * const bench_mem_memset_usage[] = {
+        "perf bench mem memset <options>",
+        NULL
+};
+
+static struct perf_event_attr clock_attr = {
+        .type           = PERF_TYPE_HARDWARE,
+        .config         = PERF_COUNT_HW_CPU_CYCLES
+};
+
+static void init_clock(void)
+{
+        clock_fd = sys_perf_event_open(&clock_attr, getpid(), -1, -1, 0);
+
+        if (clock_fd < 0 && errno == ENOSYS)
+                die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
+        else
+                BUG_ON(clock_fd < 0);
+}
+
+static u64 get_clock(void)
+{
+        int ret;
+        u64 clk;
+
+        ret = read(clock_fd, &clk, sizeof(u64));
+        BUG_ON(ret != sizeof(u64));
+
+        return clk;
+}
+
+static double timeval2double(struct timeval *ts)
+{
+        return (double)ts->tv_sec +
+                (double)ts->tv_usec / (double)1000000;
+}
+
+static void alloc_mem(void **dst, size_t length)
+{
+        *dst = zalloc(length);
+        if (!dst)
+                die("memory allocation failed - maybe length is too large?\n");
+}
+
+static u64 do_memset_clock(memset_t fn, size_t len, bool prefault)
+{
+        u64 clock_start = 0ULL, clock_end = 0ULL;
+        void *dst = NULL;
+        int i;
+
+        alloc_mem(&dst, len);
+
+        if (prefault)
+                fn(dst, -1, len);
+
+        clock_start = get_clock();
+        for (i = 0; i < iterations; ++i)
+                fn(dst, i, len);
+        clock_end = get_clock();
+
+        free(dst);
+        return clock_end - clock_start;
+}
+
+static double do_memset_gettimeofday(memset_t fn, size_t len, bool prefault)
+{
+        struct timeval tv_start, tv_end, tv_diff;
+        void *dst = NULL;
+        int i;
+
+        alloc_mem(&dst, len);
+
+        if (prefault)
+                fn(dst, -1, len);
+
+        BUG_ON(gettimeofday(&tv_start, NULL));
+        for (i = 0; i < iterations; ++i)
+                fn(dst, i, len);
+        BUG_ON(gettimeofday(&tv_end, NULL));
+
+        timersub(&tv_end, &tv_start, &tv_diff);
+
+        free(dst);
+        return (double)((double)len / timeval2double(&tv_diff));
+}
+
+#define pf (no_prefault ? 0 : 1)
+
+#define print_bps(x) do {                                       \
+                if (x < K)                                      \
+                        printf(" %14lf B/Sec", x);              \
+                else if (x < K * K)                             \
+                        printf(" %14lfd KB/Sec", x / K);        \
+                else if (x < K * K * K)                         \
+                        printf(" %14lf MB/Sec", x / K / K);     \
+                else                                            \
+                        printf(" %14lf GB/Sec", x / K / K / K); \
+        } while (0)
+
+int bench_mem_memset(int argc, const char **argv,
+                     const char *prefix __used)
+{
+        int i;
+        size_t len;
+        double result_bps[2];
+        u64 result_clock[2];
+
+        argc = parse_options(argc, argv, options,
+                             bench_mem_memset_usage, 0);
+
+        if (use_clock)
+                init_clock();
+
+        len = (size_t)perf_atoll((char *)length_str);
+
+        result_clock[0] = result_clock[1] = 0ULL;
+        result_bps[0] = result_bps[1] = 0.0;
+
+        if ((s64)len <= 0) {
+                fprintf(stderr, "Invalid length:%s\n", length_str);
+                return 1;
+        }
+
+        /* same to without specifying either of prefault and no-prefault */
+        if (only_prefault && no_prefault)
+                only_prefault = no_prefault = false;
+
+        for (i = 0; routines[i].name; i++) {
+                if (!strcmp(routines[i].name, routine))
+                        break;
+        }
+        if (!routines[i].name) {
+                printf("Unknown routine:%s\n", routine);
+                printf("Available routines...\n");
+                for (i = 0; routines[i].name; i++) {
+                        printf("\t%s ... %s\n",
+                               routines[i].name, routines[i].desc);
+                }
+                return 1;
+        }
+
+        if (bench_format == BENCH_FORMAT_DEFAULT)
+                printf("# Copying %s Bytes ...\n\n", length_str);
+
+        if (!only_prefault && !no_prefault) {
+                /* show both of results */
+                if (use_clock) {
+                        result_clock[0] =
+                                do_memset_clock(routines[i].fn, len, false);
+                        result_clock[1] =
+                                do_memset_clock(routines[i].fn, len, true);
+                } else {
+                        result_bps[0] =
+                                do_memset_gettimeofday(routines[i].fn,
+                                                len, false);
+                        result_bps[1] =
+                                do_memset_gettimeofday(routines[i].fn,
+                                                len, true);
+                }
+        } else {
+                if (use_clock) {
+                        result_clock[pf] =
+                                do_memset_clock(routines[i].fn,
+                                                len, only_prefault);
+                } else {
+                        result_bps[pf] =
+                                do_memset_gettimeofday(routines[i].fn,
+                                                len, only_prefault);
+                }
+        }
+
+        switch (bench_format) {
+        case BENCH_FORMAT_DEFAULT:
+                if (!only_prefault && !no_prefault) {
+                        if (use_clock) {
+                                printf(" %14lf Clock/Byte\n",
+                                        (double)result_clock[0]
+                                        / (double)len);
+                                printf(" %14lf Clock/Byte (with prefault)\n ",
+                                        (double)result_clock[1]
+                                        / (double)len);
+                        } else {
+                                print_bps(result_bps[0]);
+                                printf("\n");
+                                print_bps(result_bps[1]);
+                                printf(" (with prefault)\n");
+                        }
+                } else {
+                        if (use_clock) {
+                                printf(" %14lf Clock/Byte",
+                                        (double)result_clock[pf]
+                                        / (double)len);
+                        } else
+                                print_bps(result_bps[pf]);
+
+                        printf("%s\n", only_prefault ? " (with prefault)" : "");
+                }
+                break;
+        case BENCH_FORMAT_SIMPLE:
+                if (!only_prefault && !no_prefault) {
+                        if (use_clock) {
+                                printf("%lf %lf\n",
+                                        (double)result_clock[0] / (double)len,
+                                        (double)result_clock[1] / (double)len);
+                        } else {
+                                printf("%lf %lf\n",
+                                        result_bps[0], result_bps[1]);
+                        }
+                } else {
+                        if (use_clock) {
+                                printf("%lf\n", (double)result_clock[pf]
+                                        / (double)len);
+                        } else
+                                printf("%lf\n", result_bps[pf]);
+                }
+                break;
+        default:
+                /* reaching this means there's some disaster: */
+                die("unknown format: %d\n", bench_format);
+                break;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/builtin-bench.c b/tools/perf/builtin-bench.c
index fcb96269852a..b0e74ab2d7a2 100644
--- a/tools/perf/builtin-bench.c
+++ b/tools/perf/builtin-bench.c
@@ -52,6 +52,9 @@ static struct bench_suite mem_suites[] = {
         { "memcpy",
           "Simple memory copy in various ways",
           bench_mem_memcpy },
+        { "memset",
+          "Simple memory set in various ways",
+          bench_mem_memset },
         suite_all,
         { NULL,
           NULL,
diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 2296c391d0f5..12c814838993 100644
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -922,12 +922,12 @@ static const struct option info_options[] = {
         OPT_BOOLEAN('t', "threads", &info_threads,
                     "dump thread list in perf.data"),
         OPT_BOOLEAN('m', "map", &info_map,
-                    "map of lock instances (name:address table)"),
+                    "map of lock instances (address:name table)"),
         OPT_END()
 };
 
 static const char * const lock_usage[] = {
-        "perf lock [<options>] {record|trace|report}",
+        "perf lock [<options>] {record|report|script|info}",
         NULL
 };
 
diff --git a/tools/perf/builtin-probe.c b/tools/perf/builtin-probe.c
index fb8566181f27..4935c09dd5b5 100644
--- a/tools/perf/builtin-probe.c
+++ b/tools/perf/builtin-probe.c
@@ -58,7 +58,7 @@ static struct {
         struct perf_probe_event events[MAX_PROBES];
         struct strlist *dellist;
         struct line_range line_range;
-        const char *target_module;
+        const char *target;
         int max_probe_points;
         struct strfilter *filter;
 } params;
@@ -246,7 +246,7 @@ static const struct option options[] = {
                    "file", "vmlinux pathname"),
         OPT_STRING('s', "source", &symbol_conf.source_prefix,
                    "directory", "path to kernel source"),
-        OPT_STRING('m', "module", &params.target_module,
+        OPT_STRING('m', "module", &params.target,
                    "modname|path",
                    "target module name (for online) or path (for offline)"),
 #endif
@@ -333,7 +333,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
                 if (!params.filter)
                         params.filter = strfilter__new(DEFAULT_FUNC_FILTER,
                                                        NULL);
-                ret = show_available_funcs(params.target_module,
+                ret = show_available_funcs(params.target,
                                            params.filter);
                 strfilter__delete(params.filter);
                 if (ret < 0)
@@ -354,7 +354,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
                         usage_with_options(probe_usage, options);
                 }
 
-                ret = show_line_range(&params.line_range, params.target_module);
+                ret = show_line_range(&params.line_range, params.target);
                 if (ret < 0)
                         pr_err("  Error: Failed to show lines. (%d)\n", ret);
                 return ret;
@@ -371,7 +371,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
 
                 ret = show_available_vars(params.events, params.nevents,
                                           params.max_probe_points,
-                                          params.target_module,
+                                          params.target,
                                           params.filter,
                                           params.show_ext_vars);
                 strfilter__delete(params.filter);
@@ -393,7 +393,7 @@ int cmd_probe(int argc, const char **argv, const char *prefix __used)
         if (params.nevents) {
                 ret = add_perf_probe_events(params.events, params.nevents,
                                             params.max_probe_points,
-                                            params.target_module,
+                                            params.target,
                                             params.force_add);
                 if (ret < 0) {
                         pr_err("  Error: Failed to add events. (%d)\n", ret);
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 227b6ae99785..be4e1eee782e 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -44,6 +44,7 @@ struct perf_record {
         struct perf_evlist      *evlist;
         struct perf_session     *session;
         const char              *progname;
+        const char              *uid_str;
         int                     output;
         unsigned int            page_size;
         int                     realtime_prio;
@@ -208,7 +209,7 @@ fallback_missing_features:
                 if (opts->exclude_guest_missing)
                         attr->exclude_guest = attr->exclude_host = 0;
 retry_sample_id:
-                attr->sample_id_all = opts->sample_id_all_avail ? 1 : 0;
+                attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
 try_again:
                 if (perf_evsel__open(pos, evlist->cpus, evlist->threads,
                                      opts->group, group_fd) < 0) {
@@ -227,11 +228,11 @@ try_again:
                                                  "guest or host samples.\n");
                                         opts->exclude_guest_missing = true;
                                         goto fallback_missing_features;
-                                } else if (opts->sample_id_all_avail) {
+                                } else if (!opts->sample_id_all_missing) {
                                         /*
                                          * Old kernel, no attr->sample_id_type_all field
                                          */
-                                        opts->sample_id_all_avail = false;
+                                        opts->sample_id_all_missing = true;
                                         if (!opts->sample_time && !opts->raw_samples && !time_needed)
                                                 attr->sample_type &= ~PERF_SAMPLE_TIME;
 
@@ -396,7 +397,7 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 {
         struct stat st;
         int flags;
-        int err, output;
+        int err, output, feat;
         unsigned long waking = 0;
         const bool forks = argc > 0;
         struct machine *machine;
@@ -463,8 +464,17 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
 
         rec->session = session;
 
-        if (!rec->no_buildid)
-                perf_header__set_feat(&session->header, HEADER_BUILD_ID);
+        for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
+                perf_header__set_feat(&session->header, feat);
+
+        if (rec->no_buildid)
+                perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
+
+        if (!have_tracepoints(&evsel_list->entries))
+                perf_header__clear_feat(&session->header, HEADER_TRACE_INFO);
+
+        if (!rec->opts.branch_stack)
+                perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
 
         if (!rec->file_new) {
                 err = perf_session__read_header(session, output);
@@ -472,22 +482,6 @@ static int __cmd_record(struct perf_record *rec, int argc, const char **argv)
                         goto out_delete_session;
         }
 
-        if (have_tracepoints(&evsel_list->entries))
-                perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
-
-        perf_header__set_feat(&session->header, HEADER_HOSTNAME);
-        perf_header__set_feat(&session->header, HEADER_OSRELEASE);
-        perf_header__set_feat(&session->header, HEADER_ARCH);
-        perf_header__set_feat(&session->header, HEADER_CPUDESC);
-        perf_header__set_feat(&session->header, HEADER_NRCPUS);
-        perf_header__set_feat(&session->header, HEADER_EVENT_DESC);
-        perf_header__set_feat(&session->header, HEADER_CMDLINE);
-        perf_header__set_feat(&session->header, HEADER_VERSION);
-        perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
-        perf_header__set_feat(&session->header, HEADER_TOTAL_MEM);
-        perf_header__set_feat(&session->header, HEADER_NUMA_TOPOLOGY);
-        perf_header__set_feat(&session->header, HEADER_CPUID);
-
         if (forks) {
                 err = perf_evlist__prepare_workload(evsel_list, opts, argv);
                 if (err < 0) {
@@ -647,6 +641,90 @@ out_delete_session:
         return err;
 }
 
+#define BRANCH_OPT(n, m) \
+        { .name = n, .mode = (m) }
+
+#define BRANCH_END { .name = NULL }
+
+struct branch_mode {
+        const char *name;
+        int mode;
+};
+
+static const struct branch_mode branch_modes[] = {
+        BRANCH_OPT("u", PERF_SAMPLE_BRANCH_USER),
+        BRANCH_OPT("k", PERF_SAMPLE_BRANCH_KERNEL),
+        BRANCH_OPT("hv", PERF_SAMPLE_BRANCH_HV),
+        BRANCH_OPT("any", PERF_SAMPLE_BRANCH_ANY),
+        BRANCH_OPT("any_call", PERF_SAMPLE_BRANCH_ANY_CALL),
+        BRANCH_OPT("any_ret", PERF_SAMPLE_BRANCH_ANY_RETURN),
+        BRANCH_OPT("ind_call", PERF_SAMPLE_BRANCH_IND_CALL),
+        BRANCH_END
+};
+
+static int
+parse_branch_stack(const struct option *opt, const char *str, int unset)
+{
+#define ONLY_PLM \
+        (PERF_SAMPLE_BRANCH_USER        |\
+         PERF_SAMPLE_BRANCH_KERNEL      |\
+         PERF_SAMPLE_BRANCH_HV)
+
+        uint64_t *mode = (uint64_t *)opt->value;
+        const struct branch_mode *br;
+        char *s, *os = NULL, *p;
+        int ret = -1;
+
+        if (unset)
+                return 0;
+
+        /*
+         * cannot set it twice, -b + --branch-filter for instance
+         */
+        if (*mode)
+                return -1;
+
+        /* str may be NULL in case no arg is passed to -b */
+        if (str) {
+                /* because str is read-only */
+                s = os = strdup(str);
+                if (!s)
+                        return -1;
+
+                for (;;) {
+                        p = strchr(s, ',');
+                        if (p)
+                                *p = '\0';
+
+                        for (br = branch_modes; br->name; br++) {
+                                if (!strcasecmp(s, br->name))
+                                        break;
+                        }
+                        if (!br->name) {
+                                ui__warning("unknown branch filter %s,"
+                                            " check man page\n", s);
+                                goto error;
+                        }
+
+                        *mode |= br->mode;
+
+                        if (!p)
+                                break;
+
+                        s = p + 1;
+                }
+        }
+        ret = 0;
+
+        /* default to any branch */
+        if ((*mode & ~ONLY_PLM) == 0) {
+                *mode = PERF_SAMPLE_BRANCH_ANY;
+        }
+error:
+        free(os);
+        return ret;
+}
+
 static const char * const record_usage[] = {
         "perf record [<options>] [<command>]",
         "perf record [<options>] -- <command> [<options>]",
@@ -665,13 +743,10 @@ static const char * const record_usage[] = {
  */
 static struct perf_record record = {
         .opts = {
-                .target_pid          = -1,
-                .target_tid          = -1,
                 .mmap_pages          = UINT_MAX,
                 .user_freq           = UINT_MAX,
                 .user_interval       = ULLONG_MAX,
                 .freq                = 1000,
-                .sample_id_all_avail = true,
         },
         .write_mode = WRITE_FORCE,
         .file_new   = true,
@@ -690,9 +765,9 @@ const struct option record_options[] = {
                      parse_events_option),
         OPT_CALLBACK(0, "filter", &record.evlist, "filter",
                      "event filter", parse_filter),
-        OPT_INTEGER('p', "pid", &record.opts.target_pid,
+        OPT_STRING('p', "pid", &record.opts.target_pid, "pid",
                     "record events on existing process id"),
-        OPT_INTEGER('t', "tid", &record.opts.target_tid,
+        OPT_STRING('t', "tid", &record.opts.target_tid, "tid",
                     "record events on existing thread id"),
         OPT_INTEGER('r', "realtime", &record.realtime_prio,
                     "collect data with this RT SCHED_FIFO priority"),
@@ -738,6 +813,15 @@ const struct option record_options[] = {
         OPT_CALLBACK('G', "cgroup", &record.evlist, "name",
                      "monitor event in cgroup name only",
                      parse_cgroups),
+        OPT_STRING('u', "uid", &record.uid_str, "user", "user to profile"),
+
+        OPT_CALLBACK_NOOPT('b', "branch-any", &record.opts.branch_stack,
+                     "branch any", "sample any taken branches",
+                     parse_branch_stack),
+
+        OPT_CALLBACK('j', "branch-filter", &record.opts.branch_stack,
+                     "branch filter mask", "branch stack filter modes",
+                     parse_branch_stack),
         OPT_END()
 };
 
@@ -758,8 +842,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 
         argc = parse_options(argc, argv, record_options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
-        if (!argc && rec->opts.target_pid == -1 && rec->opts.target_tid == -1 &&
-                !rec->opts.system_wide && !rec->opts.cpu_list)
+        if (!argc && !rec->opts.target_pid && !rec->opts.target_tid &&
+                !rec->opts.system_wide && !rec->opts.cpu_list && !rec->uid_str)
                 usage_with_options(record_usage, record_options);
 
         if (rec->force && rec->append_file) {
@@ -799,11 +883,17 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
                 goto out_symbol_exit;
         }
 
-        if (rec->opts.target_pid != -1)
+        rec->opts.uid = parse_target_uid(rec->uid_str, rec->opts.target_tid,
+                                         rec->opts.target_pid);
+        if (rec->uid_str != NULL && rec->opts.uid == UINT_MAX - 1)
+                goto out_free_fd;
+
+        if (rec->opts.target_pid)
                 rec->opts.target_tid = rec->opts.target_pid;
 
         if (perf_evlist__create_maps(evsel_list, rec->opts.target_pid,
-                                     rec->opts.target_tid, rec->opts.cpu_list) < 0)
+                                     rec->opts.target_tid, rec->opts.uid,
+                                     rec->opts.cpu_list) < 0)
                 usage_with_options(record_usage, record_options);
 
         list_for_each_entry(pos, &evsel_list->entries, node) {
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 25d34d483e49..8e91c6eba18a 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -53,6 +53,82 @@ struct perf_report {
         DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 };
 
+static int perf_report__add_branch_hist_entry(struct perf_tool *tool,
+                                        struct addr_location *al,
+                                        struct perf_sample *sample,
+                                        struct perf_evsel *evsel,
+                                      struct machine *machine)
+{
+        struct perf_report *rep = container_of(tool, struct perf_report, tool);
+        struct symbol *parent = NULL;
+        int err = 0;
+        unsigned i;
+        struct hist_entry *he;
+        struct branch_info *bi, *bx;
+
+        if ((sort__has_parent || symbol_conf.use_callchain)
+            && sample->callchain) {
+                err = machine__resolve_callchain(machine, evsel, al->thread,
+                                                 sample->callchain, &parent);
+                if (err)
+                        return err;
+        }
+
+        bi = machine__resolve_bstack(machine, al->thread,
+                                     sample->branch_stack);
+        if (!bi)
+                return -ENOMEM;
+
+        for (i = 0; i < sample->branch_stack->nr; i++) {
+                if (rep->hide_unresolved && !(bi[i].from.sym && bi[i].to.sym))
+                        continue;
+                /*
+                 * The report shows the percentage of total branches captured
+                 * and not events sampled. Thus we use a pseudo period of 1.
+                 */
+                he = __hists__add_branch_entry(&evsel->hists, al, parent,
+                                &bi[i], 1);
+                if (he) {
+                        struct annotation *notes;
+                        err = -ENOMEM;
+                        bx = he->branch_info;
+                        if (bx->from.sym && use_browser > 0) {
+                                notes = symbol__annotation(bx->from.sym);
+                                if (!notes->src
+                                    && symbol__alloc_hist(bx->from.sym) < 0)
+                                        goto out;
+
+                                err = symbol__inc_addr_samples(bx->from.sym,
+                                                               bx->from.map,
+                                                               evsel->idx,
+                                                               bx->from.al_addr);
+                                if (err)
+                                        goto out;
+                        }
+
+                        if (bx->to.sym && use_browser > 0) {
+                                notes = symbol__annotation(bx->to.sym);
+                                if (!notes->src
+                                    && symbol__alloc_hist(bx->to.sym) < 0)
+                                        goto out;
+
+                                err = symbol__inc_addr_samples(bx->to.sym,
+                                                               bx->to.map,
+                                                               evsel->idx,
+                                                               bx->to.al_addr);
+                                if (err)
+                                        goto out;
+                        }
+                        evsel->hists.stats.total_period += 1;
+                        hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
+                        err = 0;
+                } else
+                        return -ENOMEM;
+        }
+out:
+        return err;
+}
+
 static int perf_evsel__add_hist_entry(struct perf_evsel *evsel,
                                       struct addr_location *al,
                                       struct perf_sample *sample,
@@ -126,14 +202,21 @@ static int process_sample_event(struct perf_tool *tool,
         if (rep->cpu_list && !test_bit(sample->cpu, rep->cpu_bitmap))
                 return 0;
 
-        if (al.map != NULL)
-                al.map->dso->hit = 1;
+        if (sort__branch_mode == 1) {
+                if (perf_report__add_branch_hist_entry(tool, &al, sample,
+                                                       evsel, machine)) {
+                        pr_debug("problem adding lbr entry, skipping event\n");
+                        return -1;
+                }
+        } else {
+                if (al.map != NULL)
+                        al.map->dso->hit = 1;
 
-        if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
-                pr_debug("problem incrementing symbol period, skipping event\n");
-                return -1;
+                if (perf_evsel__add_hist_entry(evsel, &al, sample, machine)) {
+                        pr_debug("problem incrementing symbol period, skipping event\n");
+                        return -1;
+                }
         }
-
         return 0;
 }
 
@@ -188,6 +271,15 @@ static int perf_report__setup_sample_type(struct perf_report *rep)
                         }
         }
 
+        if (sort__branch_mode == 1) {
+                if (!(self->sample_type & PERF_SAMPLE_BRANCH_STACK)) {
+                        fprintf(stderr, "selected -b but no branch data."
+                                        " Did you call perf record without"
+                                        " -b?\n");
+                        return -1;
+                }
+        }
+
         return 0;
 }
 
@@ -246,7 +338,7 @@ static int __cmd_report(struct perf_report *rep)
 {
         int ret = -EINVAL;
         u64 nr_samples;
-        struct perf_session *session;
+        struct perf_session *session = rep->session;
         struct perf_evsel *pos;
         struct map *kernel_map;
         struct kmap *kernel_kmap;
@@ -254,13 +346,6 @@ static int __cmd_report(struct perf_report *rep)
 
         signal(SIGINT, sig_handler);
 
-        session = perf_session__new(rep->input_name, O_RDONLY,
-                                    rep->force, false, &rep->tool);
-        if (session == NULL)
-                return -ENOMEM;
-
-        rep->session = session;
-
         if (rep->cpu_list) {
                 ret = perf_session__cpu_bitmap(session, rep->cpu_list,
                                                rep->cpu_bitmap);
@@ -427,9 +512,19 @@ setup:
         return 0;
 }
 
+static int
+parse_branch_mode(const struct option *opt __used, const char *str __used, int unset)
+{
+        sort__branch_mode = !unset;
+        return 0;
+}
+
 int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
+        struct perf_session *session;
         struct stat st;
+        bool has_br_stack = false;
+        int ret = -1;
         char callchain_default_opt[] = "fractal,0.5,callee";
         const char * const report_usage[] = {
                 "perf report [<options>]",
@@ -477,7 +572,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         OPT_BOOLEAN(0, "stdio", &report.use_stdio,
                     "Use the stdio interface"),
         OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
-                   "sort by key(s): pid, comm, dso, symbol, parent"),
+                   "sort by key(s): pid, comm, dso, symbol, parent, dso_to,"
+                   " dso_from, symbol_to, symbol_from, mispredict"),
         OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
                     "Show sample percentage for different cpu modes"),
         OPT_STRING('p', "parent", &parent_pattern, "regex",
@@ -517,6 +613,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
         OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
                     "Show a column with the sum of periods"),
+        OPT_CALLBACK_NOOPT('b', "branch-stack", &sort__branch_mode, "",
+                    "use branch records for histogram filling", parse_branch_mode),
         OPT_END()
         };
 
@@ -536,11 +634,36 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
                 else
                         report.input_name = "perf.data";
         }
+        session = perf_session__new(report.input_name, O_RDONLY,
+                                    report.force, false, &report.tool);
+        if (session == NULL)
+                return -ENOMEM;
 
-        if (strcmp(report.input_name, "-") != 0)
+        report.session = session;
+
+        has_br_stack = perf_header__has_feat(&session->header,
+                                             HEADER_BRANCH_STACK);
+
+        if (sort__branch_mode == -1 && has_br_stack)
+                sort__branch_mode = 1;
+
+        /* sort__branch_mode could be 0 if --no-branch-stack */
+        if (sort__branch_mode == 1) {
+                /*
+                 * if no sort_order is provided, then specify
+                 * branch-mode specific order
+                 */
+                if (sort_order == default_sort_order)
+                        sort_order = "comm,dso_from,symbol_from,"
+                                     "dso_to,symbol_to";
+
+        }
+
+        if (strcmp(report.input_name, "-") != 0) {
                 setup_browser(true);
-        else
+        } else {
                 use_browser = 0;
+        }
 
         /*
          * Only in the newt browser we are doing integrated annotation,
@@ -568,13 +691,13 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         }
 
         if (symbol__init() < 0)
-                return -1;
+                goto error;
 
         setup_sorting(report_usage, options);
 
         if (parent_pattern != default_parent_pattern) {
                 if (sort_dimension__add("parent") < 0)
-                        return -1;
+                        goto error;
 
                 /*
                  * Only show the parent fields if we explicitly
@@ -592,9 +715,20 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         if (argc)
                 usage_with_options(report_usage, options);
 
-        sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
         sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
-        sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
 
-        return __cmd_report(&report);
+        if (sort__branch_mode == 1) {
+                sort_entry__setup_elide(&sort_dso_from, symbol_conf.dso_from_list, "dso_from", stdout);
+                sort_entry__setup_elide(&sort_dso_to, symbol_conf.dso_to_list, "dso_to", stdout);
+                sort_entry__setup_elide(&sort_sym_from, symbol_conf.sym_from_list, "sym_from", stdout);
+                sort_entry__setup_elide(&sort_sym_to, symbol_conf.sym_to_list, "sym_to", stdout);
+        } else {
+                sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
+                sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
+        }
+
+        ret = __cmd_report(&report);
+error:
+        perf_session__delete(session);
+        return ret;
 }
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index bb68ddf257b7..d4ce733b9eba 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -40,6 +40,7 @@ enum perf_output_field {
         PERF_OUTPUT_SYM             = 1U << 8,
         PERF_OUTPUT_DSO             = 1U << 9,
         PERF_OUTPUT_ADDR            = 1U << 10,
+        PERF_OUTPUT_SYMOFFSET       = 1U << 11,
 };
 
 struct output_option {
@@ -57,6 +58,7 @@ struct output_option {
         {.str = "sym",   .field = PERF_OUTPUT_SYM},
         {.str = "dso",   .field = PERF_OUTPUT_DSO},
         {.str = "addr",  .field = PERF_OUTPUT_ADDR},
+        {.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
 };
 
 /* default set to maintain compatibility with current format */
@@ -193,6 +195,11 @@ static int perf_evsel__check_attr(struct perf_evsel *evsel,
                        "to symbols.\n");
                 return -EINVAL;
         }
+        if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
+                pr_err("Display of offsets requested but symbol is not"
+                       "selected.\n");
+                return -EINVAL;
+        }
         if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
                 pr_err("Display of DSO requested but neither sample IP nor "
                            "sample address\nis selected. Hence, no addresses to convert "
@@ -300,10 +307,17 @@ static void print_sample_start(struct perf_sample *sample,
                 } else
                         evname = __event_name(attr->type, attr->config);
 
-                printf("%s: ", evname ? evname : "(unknown)");
+                printf("%s: ", evname ? evname : "[unknown]");
         }
 }
 
+static bool is_bts_event(struct perf_event_attr *attr)
+{
+        return ((attr->type == PERF_TYPE_HARDWARE) &&
+                (attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
+                (attr->sample_period == 1));
+}
+
 static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
 {
         if ((attr->type == PERF_TYPE_SOFTWARE) &&
@@ -312,6 +326,9 @@ static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
              (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
                 return true;
 
+        if (is_bts_event(attr))
+                return true;
+
         return false;
 }
 
@@ -323,7 +340,6 @@ static void print_sample_addr(union perf_event *event,
 {
         struct addr_location al;
         u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        const char *symname, *dsoname;
 
         printf("%16" PRIx64, sample->addr);
 
@@ -343,22 +359,46 @@ static void print_sample_addr(union perf_event *event,
                 al.sym = map__find_symbol(al.map, al.addr, NULL);
 
         if (PRINT_FIELD(SYM)) {
-                if (al.sym && al.sym->name)
-                        symname = al.sym->name;
+                printf(" ");
+                if (PRINT_FIELD(SYMOFFSET))
+                        symbol__fprintf_symname_offs(al.sym, &al, stdout);
                 else
-                        symname = "";
-
-                printf(" %16s", symname);
+                        symbol__fprintf_symname(al.sym, stdout);
         }
 
         if (PRINT_FIELD(DSO)) {
-                if (al.map && al.map->dso && al.map->dso->name)
-                        dsoname = al.map->dso->name;
-                else
-                        dsoname = "";
+                printf(" (");
+                map__fprintf_dsoname(al.map, stdout);
+                printf(")");
+        }
+}
 
-                printf(" (%s)", dsoname);
+static void print_sample_bts(union perf_event *event,
+                             struct perf_sample *sample,
+                             struct perf_evsel *evsel,
+                             struct machine *machine,
+                             struct thread *thread)
+{
+        struct perf_event_attr *attr = &evsel->attr;
+
+        /* print branch_from information */
+        if (PRINT_FIELD(IP)) {
+                if (!symbol_conf.use_callchain)
+                        printf(" ");
+                else
+                        printf("\n");
+                perf_event__print_ip(event, sample, machine, evsel,
+                                     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
+                                     PRINT_FIELD(SYMOFFSET));
         }
+
+        printf(" => ");
+
+        /* print branch_to information */
+        if (PRINT_FIELD(ADDR))
+                print_sample_addr(event, sample, machine, thread, attr);
+
+        printf("\n");
 }
 
 static void process_event(union perf_event *event __unused,
@@ -374,6 +414,11 @@ static void process_event(union perf_event *event __unused,
 
         print_sample_start(sample, thread, attr);
 
+        if (is_bts_event(attr)) {
+                print_sample_bts(event, sample, evsel, machine, thread);
+                return;
+        }
+
         if (PRINT_FIELD(TRACE))
                 print_trace_event(sample->cpu, sample->raw_data,
                                   sample->raw_size);
@@ -387,7 +432,8 @@ static void process_event(union perf_event *event __unused,
                 else
                         printf("\n");
                 perf_event__print_ip(event, sample, machine, evsel,
-                                     PRINT_FIELD(SYM), PRINT_FIELD(DSO));
+                                     PRINT_FIELD(SYM), PRINT_FIELD(DSO),
+                                     PRINT_FIELD(SYMOFFSET));
         }
 
         printf("\n");
@@ -1097,7 +1143,10 @@ static const struct option options[] = {
         OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
                     "Look for files with symbols relative to this directory"),
         OPT_CALLBACK('f', "fields", NULL, "str",
-                     "comma separated output fields prepend with 'type:'. Valid types: hw,sw,trace,raw. Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,addr",
+                     "comma separated output fields prepend with 'type:'. "
+                     "Valid types: hw,sw,trace,raw. "
+                     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
+                     "addr,symoff",
                      parse_output_fields),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                      "system-wide collection from all CPUs"),
@@ -1106,6 +1155,9 @@ static const struct option options[] = {
                    "only display events for these comms"),
         OPT_BOOLEAN('I', "show-info", &show_full_info,
                     "display extended information from perf.data file"),
+        OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
+                    "Show the path of [kernel.kallsyms]"),
+
         OPT_END()
 };
 
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index f5d2a63eba66..ea40e4e8b227 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -182,8 +182,8 @@ static int			run_count			=  1;
 static bool                     no_inherit                      = false;
 static bool                     scale                           =  true;
 static bool                     no_aggr                         = false;
-static pid_t                    target_pid                      = -1;
-static pid_t                    target_tid                      = -1;
+static const char               *target_pid;
+static const char               *target_tid;
 static pid_t                    child_pid                       = -1;
 static bool                     null_run                        =  false;
 static int                      detailed_run                    =  0;
@@ -296,7 +296,7 @@ static int create_perf_stat_counter(struct perf_evsel *evsel,
         if (system_wide)
                 return perf_evsel__open_per_cpu(evsel, evsel_list->cpus,
                                                 group, group_fd);
-        if (target_pid == -1 && target_tid == -1) {
+        if (!target_pid && !target_tid) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
@@ -446,7 +446,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                         exit(-1);
                 }
 
-                if (target_tid == -1 && target_pid == -1 && !system_wide)
+                if (!target_tid && !target_pid && !system_wide)
                         evsel_list->threads->map[0] = child_pid;
 
                 /*
@@ -576,6 +576,8 @@ static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
         if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
                 fprintf(output, " # %8.3f CPUs utilized          ",
                         avg / avg_stats(&walltime_nsecs_stats));
+        else
+                fprintf(output, "                                   ");
 }
 
 /* used for get_ratio_color() */
@@ -844,12 +846,18 @@ static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
 
                 fprintf(output, " # %8.3f GHz                    ", ratio);
         } else if (runtime_nsecs_stats[cpu].n != 0) {
+                char unit = 'M';
+
                 total = avg_stats(&runtime_nsecs_stats[cpu]);
 
                 if (total)
                         ratio = 1000.0 * avg / total;
+                if (ratio < 0.001) {
+                        ratio *= 1000;
+                        unit = 'K';
+                }
 
-                fprintf(output, " # %8.3f M/sec                  ", ratio);
+                fprintf(output, " # %8.3f %c/sec                  ", ratio, unit);
         } else {
                 fprintf(output, "                                   ");
         }
@@ -960,14 +968,14 @@ static void print_stat(int argc, const char **argv)
         if (!csv_output) {
                 fprintf(output, "\n");
                 fprintf(output, " Performance counter stats for ");
-                if(target_pid == -1 && target_tid == -1) {
+                if (!target_pid && !target_tid) {
                         fprintf(output, "\'%s", argv[0]);
                         for (i = 1; i < argc; i++)
                                 fprintf(output, " %s", argv[i]);
-                } else if (target_pid != -1)
-                        fprintf(output, "process id \'%d", target_pid);
+                } else if (target_pid)
+                        fprintf(output, "process id \'%s", target_pid);
                 else
-                        fprintf(output, "thread id \'%d", target_tid);
+                        fprintf(output, "thread id \'%s", target_tid);
 
                 fprintf(output, "\'");
                 if (run_count > 1)
@@ -1041,10 +1049,10 @@ static const struct option options[] = {
                      "event filter", parse_filter),
         OPT_BOOLEAN('i', "no-inherit", &no_inherit,
                     "child tasks do not inherit counters"),
-        OPT_INTEGER('p', "pid", &target_pid,
-                    "stat events on existing process id"),
-        OPT_INTEGER('t', "tid", &target_tid,
-                    "stat events on existing thread id"),
+        OPT_STRING('p', "pid", &target_pid, "pid",
+                   "stat events on existing process id"),
+        OPT_STRING('t', "tid", &target_tid, "tid",
+                   "stat events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
         OPT_BOOLEAN('g', "group", &group,
@@ -1182,7 +1190,7 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         } else if (big_num_opt == 0) /* User passed --no-big-num */
                 big_num = false;
 
-        if (!argc && target_pid == -1 && target_tid == -1)
+        if (!argc && !target_pid && !target_tid)
                 usage_with_options(stat_usage, options);
         if (run_count <= 0)
                 usage_with_options(stat_usage, options);
@@ -1198,10 +1206,11 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
         if (add_default_attributes())
                 goto out;
 
-        if (target_pid != -1)
+        if (target_pid)
                 target_tid = target_pid;
 
-        evsel_list->threads = thread_map__new(target_pid, target_tid);
+        evsel_list->threads = thread_map__new_str(target_pid,
+                                                  target_tid, UINT_MAX);
         if (evsel_list->threads == NULL) {
                 pr_err("Problems finding threads of monitor\n");
                 usage_with_options(stat_usage, options);
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index 3854e869dce1..3e087ce8daa6 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -15,6 +15,8 @@
 #include "util/thread_map.h"
 #include "../../include/linux/hw_breakpoint.h"
 
+#include <sys/mman.h>
+
 static int vmlinux_matches_kallsyms_filter(struct map *map __used, struct symbol *sym)
 {
         bool *visited = symbol__priv(sym);
@@ -276,7 +278,7 @@ static int test__open_syscall_event(void)
                 return -1;
         }
 
-        threads = thread_map__new(-1, getpid());
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
                 return -1;
@@ -342,7 +344,7 @@ static int test__open_syscall_event_on_all_cpus(void)
                 return -1;
         }
 
-        threads = thread_map__new(-1, getpid());
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
                 return -1;
@@ -490,7 +492,7 @@ static int test__basic_mmap(void)
                 expected_nr_events[i] = random() % 257;
         }
 
-        threads = thread_map__new(-1, getpid());
+        threads = thread_map__new(-1, getpid(), UINT_MAX);
         if (threads == NULL) {
                 pr_debug("thread_map__new\n");
                 return -1;
@@ -1008,12 +1010,9 @@ realloc:
 static int test__PERF_RECORD(void)
 {
         struct perf_record_opts opts = {
-                .target_pid = -1,
-                .target_tid = -1,
                 .no_delay   = true,
                 .freq       = 10,
                 .mmap_pages = 256,
-                .sample_id_all_avail = true,
         };
         cpu_set_t *cpu_mask = NULL;
         size_t cpu_mask_size = 0;
@@ -1054,7 +1053,7 @@ static int test__PERF_RECORD(void)
          * we're monitoring, the one forked there.
          */
         err = perf_evlist__create_maps(evlist, opts.target_pid,
-                                       opts.target_tid, opts.cpu_list);
+                                       opts.target_tid, UINT_MAX, opts.cpu_list);
         if (err < 0) {
                 pr_debug("Not enough memory to create thread/cpu maps\n");
                 goto out_delete_evlist;
@@ -1296,6 +1295,173 @@ out:
         return (err < 0 || errs > 0) ? -1 : 0;
 }
 
+
+#if defined(__x86_64__) || defined(__i386__)
+
+#define barrier() asm volatile("" ::: "memory")
+
+static u64 rdpmc(unsigned int counter)
+{
+        unsigned int low, high;
+
+        asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
+
+        return low | ((u64)high) << 32;
+}
+
+static u64 rdtsc(void)
+{
+        unsigned int low, high;
+
+        asm volatile("rdtsc" : "=a" (low), "=d" (high));
+
+        return low | ((u64)high) << 32;
+}
+
+static u64 mmap_read_self(void *addr)
+{
+        struct perf_event_mmap_page *pc = addr;
+        u32 seq, idx, time_mult = 0, time_shift = 0;
+        u64 count, cyc = 0, time_offset = 0, enabled, running, delta;
+
+        do {
+                seq = pc->lock;
+                barrier();
+
+                enabled = pc->time_enabled;
+                running = pc->time_running;
+
+                if (enabled != running) {
+                        cyc = rdtsc();
+                        time_mult = pc->time_mult;
+                        time_shift = pc->time_shift;
+                        time_offset = pc->time_offset;
+                }
+
+                idx = pc->index;
+                count = pc->offset;
+                if (idx)
+                        count += rdpmc(idx - 1);
+
+                barrier();
+        } while (pc->lock != seq);
+
+        if (enabled != running) {
+                u64 quot, rem;
+
+                quot = (cyc >> time_shift);
+                rem = cyc & ((1 << time_shift) - 1);
+                delta = time_offset + quot * time_mult +
+                        ((rem * time_mult) >> time_shift);
+
+                enabled += delta;
+                if (idx)
+                        running += delta;
+
+                quot = count / running;
+                rem = count % running;
+                count = quot * enabled + (rem * enabled) / running;
+        }
+
+        return count;
+}
+
+/*
+ * If the RDPMC instruction faults then signal this back to the test parent task:
+ */
+static void segfault_handler(int sig __used, siginfo_t *info __used, void *uc __used)
+{
+        exit(-1);
+}
+
+static int __test__rdpmc(void)
+{
+        long page_size = sysconf(_SC_PAGE_SIZE);
+        volatile int tmp = 0;
+        u64 i, loops = 1000;
+        int n;
+        int fd;
+        void *addr;
+        struct perf_event_attr attr = {
+                .type = PERF_TYPE_HARDWARE,
+                .config = PERF_COUNT_HW_INSTRUCTIONS,
+                .exclude_kernel = 1,
+        };
+        u64 delta_sum = 0;
+        struct sigaction sa;
+
+        sigfillset(&sa.sa_mask);
+        sa.sa_sigaction = segfault_handler;
+        sigaction(SIGSEGV, &sa, NULL);
+
+        fprintf(stderr, "\n\n");
+
+        fd = sys_perf_event_open(&attr, 0, -1, -1, 0);
+        if (fd < 0) {
+                die("Error: sys_perf_event_open() syscall returned "
+                    "with %d (%s)\n", fd, strerror(errno));
+        }
+
+        addr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, fd, 0);
+        if (addr == (void *)(-1)) {
+                die("Error: mmap() syscall returned "
+                    "with (%s)\n", strerror(errno));
+        }
+
+        for (n = 0; n < 6; n++) {
+                u64 stamp, now, delta;
+
+                stamp = mmap_read_self(addr);
+
+                for (i = 0; i < loops; i++)
+                        tmp++;
+
+                now = mmap_read_self(addr);
+                loops *= 10;
+
+                delta = now - stamp;
+                fprintf(stderr, "%14d: %14Lu\n", n, (long long)delta);
+
+                delta_sum += delta;
+        }
+
+        munmap(addr, page_size);
+        close(fd);
+
+        fprintf(stderr, "   ");
+
+        if (!delta_sum)
+                return -1;
+
+        return 0;
+}
+
+static int test__rdpmc(void)
+{
+        int status = 0;
+        int wret = 0;
+        int ret;
+        int pid;
+
+        pid = fork();
+        if (pid < 0)
+                return -1;
+
+        if (!pid) {
+                ret = __test__rdpmc();
+
+                exit(ret);
+        }
+
+        wret = waitpid(pid, &status, 0);
+        if (wret < 0 || status)
+                return -1;
+
+        return 0;
+}
+
+#endif
+
 static struct test {
         const char *desc;
         int (*func)(void);
@@ -1320,6 +1486,12 @@ static struct test {
                 .desc = "parse events tests",
                 .func = test__parse_events,
         },
+#if defined(__x86_64__) || defined(__i386__)
+        {
+                .desc = "x86 rdpmc test",
+                .func = test__rdpmc,
+        },
+#endif
         {
                 .desc = "Validate PERF_RECORD_* events & perf_sample fields",
                 .func = test__PERF_RECORD,
@@ -1412,7 +1584,5 @@ int cmd_test(int argc, const char **argv, const char *prefix __used)
         if (symbol__init() < 0)
                 return -1;
 
-        setup_pager();
-
         return __cmd_test(argc, argv);
 }
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index ecff31257eb3..e3c63aef8efc 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -64,7 +64,6 @@
 #include <linux/unistd.h>
 #include <linux/types.h>
 
-
 void get_term_dimensions(struct winsize *ws)
 {
         char *s = getenv("LINES");
@@ -544,10 +543,20 @@ static void perf_top__sort_new_samples(void *arg)
 
 static void *display_thread_tui(void *arg)
 {
+        struct perf_evsel *pos;
         struct perf_top *top = arg;
         const char *help = "For a higher level overview, try: perf top --sort comm,dso";
 
         perf_top__sort_new_samples(top);
+
+        /*
+         * Initialize the uid_filter_str, in the future the TUI will allow
+         * Zooming in/out UIDs. For now juse use whatever the user passed
+         * via --uid.
+         */
+        list_for_each_entry(pos, &top->evlist->entries, node)
+                pos->hists.uid_filter_str = top->uid_str;
+
         perf_evlist__tui_browse_hists(top->evlist, help,
                                       perf_top__sort_new_samples,
                                       top, top->delay_secs);
@@ -668,6 +677,12 @@ static void perf_event__process_sample(struct perf_tool *tool,
                 return;
         }
 
+        if (!machine) {
+                pr_err("%u unprocessable samples recorded.",
+                       top->session->hists.stats.nr_unprocessable_samples++);
+                return;
+        }
+
         if (event->header.misc & PERF_RECORD_MISC_EXACT_IP)
                 top->exact_samples++;
 
@@ -861,7 +876,7 @@ fallback_missing_features:
                 if (top->exclude_guest_missing)
                         attr->exclude_guest = attr->exclude_host = 0;
 retry_sample_id:
-                attr->sample_id_all = top->sample_id_all_avail ? 1 : 0;
+                attr->sample_id_all = top->sample_id_all_missing ? 0 : 1;
 try_again:
                 if (perf_evsel__open(counter, top->evlist->cpus,
                                      top->evlist->threads, top->group,
@@ -878,11 +893,11 @@ try_again:
                                                  "guest or host samples.\n");
                                         top->exclude_guest_missing = true;
                                         goto fallback_missing_features;
-                                } else if (top->sample_id_all_avail) {
+                                } else if (!top->sample_id_all_missing) {
                                         /*
                                          * Old kernel, no attr->sample_id_type_all field
                                          */
-                                        top->sample_id_all_avail = false;
+                                        top->sample_id_all_missing = true;
                                         goto retry_sample_id;
                                 }
                         }
@@ -967,7 +982,7 @@ static int __cmd_top(struct perf_top *top)
         if (ret)
                 goto out_delete;
 
-        if (top->target_tid != -1)
+        if (top->target_tid || top->uid != UINT_MAX)
                 perf_event__synthesize_thread_map(&top->tool, top->evlist->threads,
                                                   perf_event__process,
                                                   &top->session->host_machine);
@@ -1105,10 +1120,8 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         struct perf_top top = {
                 .count_filter        = 5,
                 .delay_secs          = 2,
-                .target_pid          = -1,
-                .target_tid          = -1,
+                .uid                 = UINT_MAX,
                 .freq                = 1000, /* 1 KHz */
-                .sample_id_all_avail = true,
                 .mmap_pages          = 128,
                 .sym_pcnt_filter     = 5,
         };
@@ -1119,9 +1132,9 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                      parse_events_option),
         OPT_INTEGER('c', "count", &top.default_interval,
                     "event period to sample"),
-        OPT_INTEGER('p', "pid", &top.target_pid,
+        OPT_STRING('p', "pid", &top.target_pid, "pid",
                     "profile events on existing process id"),
-        OPT_INTEGER('t', "tid", &top.target_tid,
+        OPT_STRING('t', "tid", &top.target_tid, "tid",
                     "profile events on existing thread id"),
         OPT_BOOLEAN('a', "all-cpus", &top.system_wide,
                             "system-wide collection from all CPUs"),
@@ -1180,6 +1193,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                     "Display raw encoding of assembly instructions (default)"),
         OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
                    "Specify disassembler style (e.g. -M intel for intel syntax)"),
+        OPT_STRING('u', "uid", &top.uid_str, "user", "user to profile"),
         OPT_END()
         };
 
@@ -1205,18 +1219,22 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 
         setup_browser(false);
 
+        top.uid = parse_target_uid(top.uid_str, top.target_tid, top.target_pid);
+        if (top.uid_str != NULL && top.uid == UINT_MAX - 1)
+                goto out_delete_evlist;
+
         /* CPU and PID are mutually exclusive */
-        if (top.target_tid > 0 && top.cpu_list) {
+        if (top.target_tid && top.cpu_list) {
                 printf("WARNING: PID switch overriding CPU\n");
                 sleep(1);
                 top.cpu_list = NULL;
         }
 
-        if (top.target_pid != -1)
+        if (top.target_pid)
                 top.target_tid = top.target_pid;
 
         if (perf_evlist__create_maps(top.evlist, top.target_pid,
-                                     top.target_tid, top.cpu_list) < 0)
+                                     top.target_tid, top.uid, top.cpu_list) < 0)
                 usage_with_options(top_usage, options);
 
         if (!top.evlist->nr_entries &&
@@ -1280,6 +1298,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
 
         status = __cmd_top(&top);
 
+out_delete_evlist:
         perf_evlist__delete(top.evlist);
 
         return status;
diff --git a/tools/perf/perf.h b/tools/perf/perf.h
index 16e7d20eee83..89e3355ab173 100644
--- a/tools/perf/perf.h
+++ b/tools/perf/perf.h
@@ -10,6 +10,9 @@ void get_term_dimensions(struct winsize *ws);
 #define rmb()           asm volatile("lock; addl $0,0(%%esp)" ::: "memory")
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC    "model name"
+#ifndef __NR_perf_event_open
+# define __NR_perf_event_open 336
+#endif
 #endif
 
 #if defined(__x86_64__)
@@ -17,6 +20,9 @@ void get_term_dimensions(struct winsize *ws);
 #define rmb()           asm volatile("lfence" ::: "memory")
 #define cpu_relax()     asm volatile("rep; nop" ::: "memory");
 #define CPUINFO_PROC    "model name"
+#ifndef __NR_perf_event_open
+# define __NR_perf_event_open 298
+#endif
 #endif
 
 #ifdef __powerpc__
@@ -167,7 +173,6 @@ sys_perf_event_open(struct perf_event_attr *attr,
                       pid_t pid, int cpu, int group_fd,
                       unsigned long flags)
 {
-        attr->size = sizeof(*attr);
         return syscall(__NR_perf_event_open, attr, pid, cpu,
                        group_fd, flags);
 }
@@ -180,14 +185,32 @@ struct ip_callchain {
         u64 ips[0];
 };
 
+struct branch_flags {
+        u64 mispred:1;
+        u64 predicted:1;
+        u64 reserved:62;
+};
+
+struct branch_entry {
+        u64                             from;
+        u64                             to;
+        struct branch_flags flags;
+};
+
+struct branch_stack {
+        u64                             nr;
+        struct branch_entry     entries[0];
+};
+
 extern bool perf_host, perf_guest;
 extern const char perf_version_string[];
 
 void pthread__unblock_sigwinch(void);
 
 struct perf_record_opts {
-        pid_t        target_pid;
-        pid_t        target_tid;
+        const char   *target_pid;
+        const char   *target_tid;
+        uid_t        uid;
         bool         call_graph;
         bool         group;
         bool         inherit_stat;
@@ -198,13 +221,14 @@ struct perf_record_opts {
         bool         raw_samples;
         bool         sample_address;
         bool         sample_time;
-        bool         sample_id_all_avail;
+        bool         sample_id_all_missing;
         bool         exclude_guest_missing;
         bool         system_wide;
         bool         period;
         unsigned int freq;
         unsigned int mmap_pages;
         unsigned int user_freq;
+        int          branch_stack;
         u64          default_interval;
         u64          user_interval;
         const char   *cpu_list;
diff --git a/tools/perf/python/twatch.py b/tools/perf/python/twatch.py
index df638c438a9f..b11cca584238 100755
--- a/tools/perf/python/twatch.py
+++ b/tools/perf/python/twatch.py
@@ -19,7 +19,7 @@ def main():
         cpus = perf.cpu_map()
         threads = perf.thread_map()
         evsel = perf.evsel(task = 1, comm = 1, mmap = 0,
-                           wakeup_events = 1, sample_period = 1,
+                           wakeup_events = 1, watermark = 1,
                            sample_id_all = 1,
                            sample_type = perf.SAMPLE_PERIOD | perf.SAMPLE_TID | perf.SAMPLE_CPU | perf.SAMPLE_TID)
         evsel.open(cpus = cpus, threads = threads);
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 011ed2676604..e5a462f1d07c 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -315,7 +315,7 @@ fallback:
                        "Please use:\n\n"
                        "  perf buildid-cache -av vmlinux\n\n"
                        "or:\n\n"
-                       "  --vmlinux vmlinux",
+                       "  --vmlinux vmlinux\n",
                        sym->name, build_id_msg ?: "");
                 goto out_free_filename;
         }
diff --git a/tools/perf/util/bitmap.c b/tools/perf/util/bitmap.c
index 5e230acae1e9..0a1adc1111fd 100644
--- a/tools/perf/util/bitmap.c
+++ b/tools/perf/util/bitmap.c
@@ -19,3 +19,13 @@ int __bitmap_weight(const unsigned long *bitmap, int bits)
 
         return w;
 }
+
+void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
+                 const unsigned long *bitmap2, int bits)
+{
+        int k;
+        int nr = BITS_TO_LONGS(bits);
+
+        for (k = 0; k < nr; k++)
+                dst[k] = bitmap1[k] | bitmap2[k];
+}
diff --git a/tools/perf/util/color.c b/tools/perf/util/color.c
index 521c38a79190..11e46da17bbb 100644
--- a/tools/perf/util/color.c
+++ b/tools/perf/util/color.c
@@ -1,3 +1,4 @@
+#include <linux/kernel.h>
 #include "cache.h"
 #include "color.h"
 
@@ -182,12 +183,12 @@ static int __color_vsnprintf(char *bf, size_t size, const char *color,
         }
 
         if (perf_use_color_default && *color)
-                r += snprintf(bf, size, "%s", color);
-        r += vsnprintf(bf + r, size - r, fmt, args);
+                r += scnprintf(bf, size, "%s", color);
+        r += vscnprintf(bf + r, size - r, fmt, args);
         if (perf_use_color_default && *color)
-                r += snprintf(bf + r, size - r, "%s", PERF_COLOR_RESET);
+                r += scnprintf(bf + r, size - r, "%s", PERF_COLOR_RESET);
         if (trail)
-                r += snprintf(bf + r, size - r, "%s", trail);
+                r += scnprintf(bf + r, size - r, "%s", trail);
         return r;
 }
 
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 6893eec693ab..adc72f09914d 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -166,6 +166,17 @@ out:
         return cpus;
 }
 
+size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp)
+{
+        int i;
+        size_t printed = fprintf(fp, "%d cpu%s: ",
+                                 map->nr, map->nr > 1 ? "s" : "");
+        for (i = 0; i < map->nr; ++i)
+                printed += fprintf(fp, "%s%d", i ? ", " : "", map->map[i]);
+
+        return printed + fprintf(fp, "\n");
+}
+
 struct cpu_map *cpu_map__dummy_new(void)
 {
         struct cpu_map *cpus = malloc(sizeof(*cpus) + sizeof(int));
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 072c0a374794..c41518573c6a 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -1,6 +1,8 @@
 #ifndef __PERF_CPUMAP_H
 #define __PERF_CPUMAP_H
 
+#include <stdio.h>
+
 struct cpu_map {
         int nr;
         int map[];
@@ -10,4 +12,6 @@ struct cpu_map *cpu_map__new(const char *cpu_list);
 struct cpu_map *cpu_map__dummy_new(void);
 void cpu_map__delete(struct cpu_map *map);
 
+size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
+
 #endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/ctype.c b/tools/perf/util/ctype.c
index 35073621e5de..aada3ac5e891 100644
--- a/tools/perf/util/ctype.c
+++ b/tools/perf/util/ctype.c
@@ -3,7 +3,7 @@
  *
  * No surprises, and works with signed and unsigned chars.
  */
-#include "cache.h"
+#include "util.h"
 
 enum {
         S = GIT_SPACE,
diff --git a/tools/perf/util/debugfs.c b/tools/perf/util/debugfs.c
index ffc35e748e89..dd8b19319c03 100644
--- a/tools/perf/util/debugfs.c
+++ b/tools/perf/util/debugfs.c
@@ -15,32 +15,6 @@ static const char *debugfs_known_mountpoints[] = {
         0,
 };
 
-/* use this to force a umount */
-void debugfs_force_cleanup(void)
-{
-        debugfs_find_mountpoint();
-        debugfs_premounted = 0;
-        debugfs_umount();
-}
-
-/* construct a full path to a debugfs element */
-int debugfs_make_path(const char *element, char *buffer, int size)
-{
-        int len;
-
-        if (strlen(debugfs_mountpoint) == 0) {
-                buffer[0] = '\0';
-                return -1;
-        }
-
-        len = strlen(debugfs_mountpoint) + strlen(element) + 1;
-        if (len >= size)
-                return len+1;
-
-        snprintf(buffer, size-1, "%s/%s", debugfs_mountpoint, element);
-        return 0;
-}
-
 static int debugfs_found;
 
 /* find the path to the mounted debugfs */
@@ -97,17 +71,6 @@ int debugfs_valid_mountpoint(const char *debugfs)
         return 0;
 }
 
-
-int debugfs_valid_entry(const char *path)
-{
-        struct stat st;
-
-        if (stat(path, &st))
-                return -errno;
-
-        return 0;
-}
-
 static void debugfs_set_tracing_events_path(const char *mountpoint)
 {
         snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
@@ -149,107 +112,3 @@ void debugfs_set_path(const char *mountpoint)
         snprintf(debugfs_mountpoint, sizeof(debugfs_mountpoint), "%s", mountpoint);
         debugfs_set_tracing_events_path(mountpoint);
 }
-
-/* umount the debugfs */
-
-int debugfs_umount(void)
-{
-        char umountcmd[128];
-        int ret;
-
-        /* if it was already mounted, leave it */
-        if (debugfs_premounted)
-                return 0;
-
-        /* make sure it's a valid mount point */
-        ret = debugfs_valid_mountpoint(debugfs_mountpoint);
-        if (ret)
-                return ret;
-
-        snprintf(umountcmd, sizeof(umountcmd),
-                 "/bin/umount %s", debugfs_mountpoint);
-        return system(umountcmd);
-}
-
-int debugfs_write(const char *entry, const char *value)
-{
-        char path[PATH_MAX + 1];
-        int ret, count;
-        int fd;
-
-        /* construct the path */
-        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
-
-        /* verify that it exists */
-        ret = debugfs_valid_entry(path);
-        if (ret)
-                return ret;
-
-        /* get how many chars we're going to write */
-        count = strlen(value);
-
-        /* open the debugfs entry */
-        fd = open(path, O_RDWR);
-        if (fd < 0)
-                return -errno;
-
-        while (count > 0) {
-                /* write it */
-                ret = write(fd, value, count);
-                if (ret <= 0) {
-                        if (ret == EAGAIN)
-                                continue;
-                        close(fd);
-                        return -errno;
-                }
-                count -= ret;
-        }
-
-        /* close it */
-        close(fd);
-
-        /* return success */
-        return 0;
-}
-
-/*
- * read a debugfs entry
- * returns the number of chars read or a negative errno
- */
-int debugfs_read(const char *entry, char *buffer, size_t size)
-{
-        char path[PATH_MAX + 1];
-        int ret;
-        int fd;
-
-        /* construct the path */
-        snprintf(path, sizeof(path), "%s/%s", debugfs_mountpoint, entry);
-
-        /* verify that it exists */
-        ret = debugfs_valid_entry(path);
-        if (ret)
-                return ret;
-
-        /* open the debugfs entry */
-        fd = open(path, O_RDONLY);
-        if (fd < 0)
-                return -errno;
-
-        do {
-                /* read it */
-                ret = read(fd, buffer, size);
-                if (ret == 0) {
-                        close(fd);
-                        return EOF;
-                }
-        } while (ret < 0 && errno == EAGAIN);
-
-        /* close it */
-        close(fd);
-
-        /* make *sure* there's a null character at the end */
-        buffer[ret] = '\0';
-
-        /* return the number of chars read */
-        return ret;
-}
diff --git a/tools/perf/util/debugfs.h b/tools/perf/util/debugfs.h
index 4a878f735eb0..68f3e87ec57f 100644
--- a/tools/perf/util/debugfs.h
+++ b/tools/perf/util/debugfs.h
@@ -3,14 +3,8 @@
 
 const char *debugfs_find_mountpoint(void);
 int debugfs_valid_mountpoint(const char *debugfs);
-int debugfs_valid_entry(const char *path);
 char *debugfs_mount(const char *mountpoint);
-int debugfs_umount(void);
 void debugfs_set_path(const char *mountpoint);
-int debugfs_write(const char *entry, const char *value);
-int debugfs_read(const char *entry, char *buffer, size_t size);
-void debugfs_force_cleanup(void);
-int debugfs_make_path(const char *element, char *buffer, int size);
 
 extern char debugfs_mountpoint[];
 extern char tracing_events_path[];
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index cbdeaad9c5e5..1b197280c621 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -81,6 +81,7 @@ struct perf_sample {
         u32 raw_size;
         void *raw_data;
         struct ip_callchain *callchain;
+        struct branch_stack *branch_stack;
 };
 
 #define BUILD_ID_SIZE 20
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index ea32a061f1c8..159263d17c2d 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -97,9 +97,9 @@ void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry)
         ++evlist->nr_entries;
 }
 
-static void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
-                                          struct list_head *list,
-                                          int nr_entries)
+void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
+                                   struct list_head *list,
+                                   int nr_entries)
 {
         list_splice_tail(list, &evlist->entries);
         evlist->nr_entries += nr_entries;
@@ -597,15 +597,15 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         return perf_evlist__mmap_per_cpu(evlist, prot, mask);
 }
 
-int perf_evlist__create_maps(struct perf_evlist *evlist, pid_t target_pid,
-                             pid_t target_tid, const char *cpu_list)
+int perf_evlist__create_maps(struct perf_evlist *evlist, const char *target_pid,
+                             const char *target_tid, uid_t uid, const char *cpu_list)
 {
-        evlist->threads = thread_map__new(target_pid, target_tid);
+        evlist->threads = thread_map__new_str(target_pid, target_tid, uid);
 
         if (evlist->threads == NULL)
                 return -1;
 
-        if (cpu_list == NULL && target_tid != -1)
+        if (uid != UINT_MAX || (cpu_list == NULL && target_tid))
                 evlist->cpus = cpu_map__dummy_new();
         else
                 evlist->cpus = cpu_map__new(cpu_list);
@@ -765,6 +765,7 @@ out_err:
         list_for_each_entry_reverse(evsel, &evlist->entries, node)
                 perf_evsel__close(evsel, ncpus, nthreads);
 
+        errno = -err;
         return err;
 }
 
@@ -824,7 +825,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
                 exit(-1);
         }
 
-        if (!opts->system_wide && opts->target_tid == -1 && opts->target_pid == -1)
+        if (!opts->system_wide && !opts->target_tid && !opts->target_pid)
                 evlist->threads->map[0] = evlist->workload.pid;
 
         close(child_ready_pipe[1]);
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 8922aeed0467..21f1c9e57f13 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -106,8 +106,8 @@ static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
         evlist->threads = threads;
 }
 
-int perf_evlist__create_maps(struct perf_evlist *evlist, pid_t target_pid,
-                             pid_t target_tid, const char *cpu_list);
+int perf_evlist__create_maps(struct perf_evlist *evlist, const char *target_pid,
+                             const char *tid, uid_t uid, const char *cpu_list);
 void perf_evlist__delete_maps(struct perf_evlist *evlist);
 int perf_evlist__set_filters(struct perf_evlist *evlist);
 
@@ -117,4 +117,9 @@ u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist);
 
 bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist);
 bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist);
+
+void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
+                                   struct list_head *list,
+                                   int nr_entries);
+
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 7132ee834e0e..f421f7cbc0d3 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -68,7 +68,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
         struct perf_event_attr *attr = &evsel->attr;
         int track = !evsel->idx; /* only the first counter needs these */
 
-        attr->sample_id_all = opts->sample_id_all_avail ? 1 : 0;
+        attr->sample_id_all = opts->sample_id_all_missing ? 0 : 1;
         attr->inherit       = !opts->no_inherit;
         attr->read_format   = PERF_FORMAT_TOTAL_TIME_ENABLED |
                               PERF_FORMAT_TOTAL_TIME_RUNNING |
@@ -111,7 +111,7 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
         if (opts->period)
                 attr->sample_type       |= PERF_SAMPLE_PERIOD;
 
-        if (opts->sample_id_all_avail &&
+        if (!opts->sample_id_all_missing &&
             (opts->sample_time || opts->system_wide ||
              !opts->no_inherit || opts->cpu_list))
                 attr->sample_type       |= PERF_SAMPLE_TIME;
@@ -126,11 +126,15 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts)
                 attr->watermark = 0;
                 attr->wakeup_events = 1;
         }
+        if (opts->branch_stack) {
+                attr->sample_type       |= PERF_SAMPLE_BRANCH_STACK;
+                attr->branch_sample_type = opts->branch_stack;
+        }
 
         attr->mmap = track;
         attr->comm = track;
 
-        if (opts->target_pid == -1 && opts->target_tid == -1 && !opts->system_wide) {
+        if (!opts->target_pid && !opts->target_tid && !opts->system_wide) {
                 attr->disabled = 1;
                 attr->enable_on_exec = 1;
         }
@@ -536,7 +540,7 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
         }
 
         if (type & PERF_SAMPLE_READ) {
-                fprintf(stderr, "PERF_SAMPLE_READ is unsuported for now\n");
+                fprintf(stderr, "PERF_SAMPLE_READ is unsupported for now\n");
                 return -1;
         }
 
@@ -576,6 +580,16 @@ int perf_event__parse_sample(const union perf_event *event, u64 type,
                 data->raw_data = (void *) pdata;
         }
 
+        if (type & PERF_SAMPLE_BRANCH_STACK) {
+                u64 sz;
+
+                data->branch_stack = (struct branch_stack *)array;
+                array++; /* nr */
+
+                sz = data->branch_stack->nr * sizeof(struct branch_entry);
+                sz /= sizeof(u64);
+                array += sz;
+        }
         return 0;
 }
 
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index ecd7f4dd7eea..fcd9cf3ea63e 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -63,9 +63,20 @@ char *perf_header__find_event(u64 id)
         return NULL;
 }
 
-static const char *__perf_magic = "PERFFILE";
+/*
+ * magic2 = "PERFILE2"
+ * must be a numerical value to let the endianness
+ * determine the memory layout. That way we are able
+ * to detect endianness when reading the perf.data file
+ * back.
+ *
+ * we check for legacy (PERFFILE) format.
+ */
+static const char *__perf_magic1 = "PERFFILE";
+static const u64 __perf_magic2    = 0x32454c4946524550ULL;
+static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
 
-#define PERF_MAGIC      (*(u64 *)__perf_magic)
+#define PERF_MAGIC      __perf_magic2
 
 struct perf_file_attr {
         struct perf_event_attr  attr;
@@ -280,7 +291,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
         if (realname == NULL || filename == NULL || linkname == NULL)
                 goto out_free;
 
-        len = snprintf(filename, size, "%s%s%s",
+        len = scnprintf(filename, size, "%s%s%s",
                        debugdir, is_kallsyms ? "/" : "", realname);
         if (mkdir_p(filename, 0755))
                 goto out_free;
@@ -295,7 +306,7 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                         goto out_free;
         }
 
-        len = snprintf(linkname, size, "%s/.build-id/%.2s",
+        len = scnprintf(linkname, size, "%s/.build-id/%.2s",
                        debugdir, sbuild_id);
 
         if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
@@ -1012,6 +1023,12 @@ write_it:
         return do_write_string(fd, buffer);
 }
 
+static int write_branch_stack(int fd __used, struct perf_header *h __used,
+                       struct perf_evlist *evlist __used)
+{
+        return 0;
+}
+
 static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
 {
         char *str = do_read_string(fd, ph);
@@ -1133,8 +1150,9 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
         uint64_t id;
         void *buf = NULL;
         char *str;
-        u32 nre, sz, nr, i, j, msz;
-        int ret;
+        u32 nre, sz, nr, i, j;
+        ssize_t ret;
+        size_t msz;
 
         /* number of events */
         ret = read(fd, &nre, sizeof(nre));
@@ -1151,25 +1169,23 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
         if (ph->needs_swap)
                 sz = bswap_32(sz);
 
-        /*
-         * ensure it is at least to our ABI rev
-         */
-        if (sz < (u32)sizeof(attr))
-                goto error;
-
         memset(&attr, 0, sizeof(attr));
 
-        /* read entire region to sync up to next field */
+        /* buffer to hold on file attr struct */
         buf = malloc(sz);
         if (!buf)
                 goto error;
 
         msz = sizeof(attr);
-        if (sz < msz)
+        if (sz < (ssize_t)msz)
                 msz = sz;
 
         for (i = 0 ; i < nre; i++) {
 
+                /*
+                 * must read entire on-file attr struct to
+                 * sync up with layout.
+                 */
                 ret = read(fd, buf, sz);
                 if (ret != (ssize_t)sz)
                         goto error;
@@ -1305,25 +1321,204 @@ static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
         free(str);
 }
 
+static void print_branch_stack(struct perf_header *ph __used, int fd __used,
+                               FILE *fp)
+{
+        fprintf(fp, "# contains samples with branch stack\n");
+}
+
+static int __event_process_build_id(struct build_id_event *bev,
+                                    char *filename,
+                                    struct perf_session *session)
+{
+        int err = -1;
+        struct list_head *head;
+        struct machine *machine;
+        u16 misc;
+        struct dso *dso;
+        enum dso_kernel_type dso_type;
+
+        machine = perf_session__findnew_machine(session, bev->pid);
+        if (!machine)
+                goto out;
+
+        misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+
+        switch (misc) {
+        case PERF_RECORD_MISC_KERNEL:
+                dso_type = DSO_TYPE_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_GUEST_KERNEL:
+                dso_type = DSO_TYPE_GUEST_KERNEL;
+                head = &machine->kernel_dsos;
+                break;
+        case PERF_RECORD_MISC_USER:
+        case PERF_RECORD_MISC_GUEST_USER:
+                dso_type = DSO_TYPE_USER;
+                head = &machine->user_dsos;
+                break;
+        default:
+                goto out;
+        }
+
+        dso = __dsos__findnew(head, filename);
+        if (dso != NULL) {
+                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+
+                dso__set_build_id(dso, &bev->build_id);
+
+                if (filename[0] == '[')
+                        dso->kernel = dso_type;
+
+                build_id__sprintf(dso->build_id, sizeof(dso->build_id),
+                                  sbuild_id);
+                pr_debug("build id event received for %s: %s\n",
+                         dso->long_name, sbuild_id);
+        }
+
+        err = 0;
+out:
+        return err;
+}
+
+static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
+                                                 int input, u64 offset, u64 size)
+{
+        struct perf_session *session = container_of(header, struct perf_session, header);
+        struct {
+                struct perf_event_header   header;
+                u8                         build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
+                char                       filename[0];
+        } old_bev;
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        u64 limit = offset + size;
+
+        while (offset < limit) {
+                ssize_t len;
+
+                if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
+                        return -1;
+
+                if (header->needs_swap)
+                        perf_event_header__bswap(&old_bev.header);
+
+                len = old_bev.header.size - sizeof(old_bev);
+                if (read(input, filename, len) != len)
+                        return -1;
+
+                bev.header = old_bev.header;
+
+                /*
+                 * As the pid is the missing value, we need to fill
+                 * it properly. The header.misc value give us nice hint.
+                 */
+                bev.pid = HOST_KERNEL_ID;
+                if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
+                    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
+                        bev.pid = DEFAULT_GUEST_KERNEL_ID;
+
+                memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
+                __event_process_build_id(&bev, filename, session);
+
+                offset += bev.header.size;
+        }
+
+        return 0;
+}
+
+static int perf_header__read_build_ids(struct perf_header *header,
+                                       int input, u64 offset, u64 size)
+{
+        struct perf_session *session = container_of(header, struct perf_session, header);
+        struct build_id_event bev;
+        char filename[PATH_MAX];
+        u64 limit = offset + size, orig_offset = offset;
+        int err = -1;
+
+        while (offset < limit) {
+                ssize_t len;
+
+                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
+                        goto out;
+
+                if (header->needs_swap)
+                        perf_event_header__bswap(&bev.header);
+
+                len = bev.header.size - sizeof(bev);
+                if (read(input, filename, len) != len)
+                        goto out;
+                /*
+                 * The a1645ce1 changeset:
+                 *
+                 * "perf: 'perf kvm' tool for monitoring guest performance from host"
+                 *
+                 * Added a field to struct build_id_event that broke the file
+                 * format.
+                 *
+                 * Since the kernel build-id is the first entry, process the
+                 * table using the old format if the well known
+                 * '[kernel.kallsyms]' string for the kernel build-id has the
+                 * first 4 characters chopped off (where the pid_t sits).
+                 */
+                if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
+                        if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
+                                return -1;
+                        return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
+                }
+
+                __event_process_build_id(&bev, filename, session);
+
+                offset += bev.header.size;
+        }
+        err = 0;
+out:
+        return err;
+}
+
+static int process_trace_info(struct perf_file_section *section __unused,
+                              struct perf_header *ph __unused,
+                              int feat __unused, int fd)
+{
+        trace_report(fd, false);
+        return 0;
+}
+
+static int process_build_id(struct perf_file_section *section,
+                            struct perf_header *ph,
+                            int feat __unused, int fd)
+{
+        if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
+                pr_debug("Failed to read buildids, continuing...\n");
+        return 0;
+}
+
 struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
+        int (*process)(struct perf_file_section *section,
+                       struct perf_header *h, int feat, int fd);
         const char *name;
         bool full_only;
 };
 
 #define FEAT_OPA(n, func) \
         [n] = { .name = #n, .write = write_##func, .print = print_##func }
+#define FEAT_OPP(n, func) \
+        [n] = { .name = #n, .write = write_##func, .print = print_##func, \
+                .process = process_##func }
 #define FEAT_OPF(n, func) \
-        [n] = { .name = #n, .write = write_##func, .print = print_##func, .full_only = true }
+        [n] = { .name = #n, .write = write_##func, .print = print_##func, \
+                .full_only = true }
 
 /* feature_ops not implemented: */
 #define print_trace_info                NULL
 #define print_build_id                  NULL
 
 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
-        FEAT_OPA(HEADER_TRACE_INFO,     trace_info),
-        FEAT_OPA(HEADER_BUILD_ID,       build_id),
+        FEAT_OPP(HEADER_TRACE_INFO,     trace_info),
+        FEAT_OPP(HEADER_BUILD_ID,       build_id),
         FEAT_OPA(HEADER_HOSTNAME,       hostname),
         FEAT_OPA(HEADER_OSRELEASE,      osrelease),
         FEAT_OPA(HEADER_VERSION,        version),
@@ -1336,6 +1531,7 @@ static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPA(HEADER_CMDLINE,        cmdline),
         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
+        FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
 };
 
 struct header_print_data {
@@ -1620,24 +1816,128 @@ out_free:
         return err;
 }
 
+static const int attr_file_abi_sizes[] = {
+        [0] = PERF_ATTR_SIZE_VER0,
+        [1] = PERF_ATTR_SIZE_VER1,
+        0,
+};
+
+/*
+ * In the legacy file format, the magic number is not used to encode endianness.
+ * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
+ * on ABI revisions, we need to try all combinations for all endianness to
+ * detect the endianness.
+ */
+static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
+{
+        uint64_t ref_size, attr_size;
+        int i;
+
+        for (i = 0 ; attr_file_abi_sizes[i]; i++) {
+                ref_size = attr_file_abi_sizes[i]
+                         + sizeof(struct perf_file_section);
+                if (hdr_sz != ref_size) {
+                        attr_size = bswap_64(hdr_sz);
+                        if (attr_size != ref_size)
+                                continue;
+
+                        ph->needs_swap = true;
+                }
+                pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
+                         i,
+                         ph->needs_swap);
+                return 0;
+        }
+        /* could not determine endianness */
+        return -1;
+}
+
+#define PERF_PIPE_HDR_VER0      16
+
+static const size_t attr_pipe_abi_sizes[] = {
+        [0] = PERF_PIPE_HDR_VER0,
+        0,
+};
+
+/*
+ * In the legacy pipe format, there is an implicit assumption that endiannesss
+ * between host recording the samples, and host parsing the samples is the
+ * same. This is not always the case given that the pipe output may always be
+ * redirected into a file and analyzed on a different machine with possibly a
+ * different endianness and perf_event ABI revsions in the perf tool itself.
+ */
+static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
+{
+        u64 attr_size;
+        int i;
+
+        for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
+                if (hdr_sz != attr_pipe_abi_sizes[i]) {
+                        attr_size = bswap_64(hdr_sz);
+                        if (attr_size != hdr_sz)
+                                continue;
+
+                        ph->needs_swap = true;
+                }
+                pr_debug("Pipe ABI%d perf.data file detected\n", i);
+                return 0;
+        }
+        return -1;
+}
+
+static int check_magic_endian(u64 magic, uint64_t hdr_sz,
+                              bool is_pipe, struct perf_header *ph)
+{
+        int ret;
+
+        /* check for legacy format */
+        ret = memcmp(&magic, __perf_magic1, sizeof(magic));
+        if (ret == 0) {
+                pr_debug("legacy perf.data format\n");
+                if (is_pipe)
+                        return try_all_pipe_abis(hdr_sz, ph);
+
+                return try_all_file_abis(hdr_sz, ph);
+        }
+        /*
+         * the new magic number serves two purposes:
+         * - unique number to identify actual perf.data files
+         * - encode endianness of file
+         */
+
+        /* check magic number with one endianness */
+        if (magic == __perf_magic2)
+                return 0;
+
+        /* check magic number with opposite endianness */
+        if (magic != __perf_magic2_sw)
+                return -1;
+
+        ph->needs_swap = true;
+
+        return 0;
+}
+
 int perf_file_header__read(struct perf_file_header *header,
                            struct perf_header *ph, int fd)
 {
+        int ret;
+
         lseek(fd, 0, SEEK_SET);
 
-        if (readn(fd, header, sizeof(*header)) <= 0 ||
-            memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
+        ret = readn(fd, header, sizeof(*header));
+        if (ret <= 0)
                 return -1;
 
-        if (header->attr_size != sizeof(struct perf_file_attr)) {
-                u64 attr_size = bswap_64(header->attr_size);
-
-                if (attr_size != sizeof(struct perf_file_attr))
-                        return -1;
+        if (check_magic_endian(header->magic,
+                               header->attr_size, false, ph) < 0) {
+                pr_debug("magic/endian check failed\n");
+                return -1;
+        }
 
+        if (ph->needs_swap) {
                 mem_bswap_64(header, offsetof(struct perf_file_header,
-                                            adds_features));
-                ph->needs_swap = true;
+                             adds_features));
         }
 
         if (header->size != sizeof(*header)) {
@@ -1689,156 +1989,6 @@ int perf_file_header__read(struct perf_file_header *header,
         return 0;
 }
 
-static int __event_process_build_id(struct build_id_event *bev,
-                                    char *filename,
-                                    struct perf_session *session)
-{
-        int err = -1;
-        struct list_head *head;
-        struct machine *machine;
-        u16 misc;
-        struct dso *dso;
-        enum dso_kernel_type dso_type;
-
-        machine = perf_session__findnew_machine(session, bev->pid);
-        if (!machine)
-                goto out;
-
-        misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-
-        switch (misc) {
-        case PERF_RECORD_MISC_KERNEL:
-                dso_type = DSO_TYPE_KERNEL;
-                head = &machine->kernel_dsos;
-                break;
-        case PERF_RECORD_MISC_GUEST_KERNEL:
-                dso_type = DSO_TYPE_GUEST_KERNEL;
-                head = &machine->kernel_dsos;
-                break;
-        case PERF_RECORD_MISC_USER:
-        case PERF_RECORD_MISC_GUEST_USER:
-                dso_type = DSO_TYPE_USER;
-                head = &machine->user_dsos;
-                break;
-        default:
-                goto out;
-        }
-
-        dso = __dsos__findnew(head, filename);
-        if (dso != NULL) {
-                char sbuild_id[BUILD_ID_SIZE * 2 + 1];
-
-                dso__set_build_id(dso, &bev->build_id);
-
-                if (filename[0] == '[')
-                        dso->kernel = dso_type;
-
-                build_id__sprintf(dso->build_id, sizeof(dso->build_id),
-                                  sbuild_id);
-                pr_debug("build id event received for %s: %s\n",
-                         dso->long_name, sbuild_id);
-        }
-
-        err = 0;
-out:
-        return err;
-}
-
-static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
-                                                 int input, u64 offset, u64 size)
-{
-        struct perf_session *session = container_of(header, struct perf_session, header);
-        struct {
-                struct perf_event_header   header;
-                u8                         build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
-                char                       filename[0];
-        } old_bev;
-        struct build_id_event bev;
-        char filename[PATH_MAX];
-        u64 limit = offset + size;
-
-        while (offset < limit) {
-                ssize_t len;
-
-                if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
-                        return -1;
-
-                if (header->needs_swap)
-                        perf_event_header__bswap(&old_bev.header);
-
-                len = old_bev.header.size - sizeof(old_bev);
-                if (read(input, filename, len) != len)
-                        return -1;
-
-                bev.header = old_bev.header;
-
-                /*
-                 * As the pid is the missing value, we need to fill
-                 * it properly. The header.misc value give us nice hint.
-                 */
-                bev.pid = HOST_KERNEL_ID;
-                if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
-                    bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
-                        bev.pid = DEFAULT_GUEST_KERNEL_ID;
-
-                memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
-                __event_process_build_id(&bev, filename, session);
-
-                offset += bev.header.size;
-        }
-
-        return 0;
-}
-
-static int perf_header__read_build_ids(struct perf_header *header,
-                                       int input, u64 offset, u64 size)
-{
-        struct perf_session *session = container_of(header, struct perf_session, header);
-        struct build_id_event bev;
-        char filename[PATH_MAX];
-        u64 limit = offset + size, orig_offset = offset;
-        int err = -1;
-
-        while (offset < limit) {
-                ssize_t len;
-
-                if (read(input, &bev, sizeof(bev)) != sizeof(bev))
-                        goto out;
-
-                if (header->needs_swap)
-                        perf_event_header__bswap(&bev.header);
-
-                len = bev.header.size - sizeof(bev);
-                if (read(input, filename, len) != len)
-                        goto out;
-                /*
-                 * The a1645ce1 changeset:
-                 *
-                 * "perf: 'perf kvm' tool for monitoring guest performance from host"
-                 *
-                 * Added a field to struct build_id_event that broke the file
-                 * format.
-                 *
-                 * Since the kernel build-id is the first entry, process the
-                 * table using the old format if the well known
-                 * '[kernel.kallsyms]' string for the kernel build-id has the
-                 * first 4 characters chopped off (where the pid_t sits).
-                 */
-                if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
-                        if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
-                                return -1;
-                        return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
-                }
-
-                __event_process_build_id(&bev, filename, session);
-
-                offset += bev.header.size;
-        }
-        err = 0;
-out:
-        return err;
-}
-
 static int perf_file_section__process(struct perf_file_section *section,
                                       struct perf_header *ph,
                                       int feat, int fd, void *data __used)
@@ -1854,40 +2004,32 @@ static int perf_file_section__process(struct perf_file_section *section,
                 return 0;
         }
 
-        switch (feat) {
-        case HEADER_TRACE_INFO:
-                trace_report(fd, false);
-                break;
-        case HEADER_BUILD_ID:
-                if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
-                        pr_debug("Failed to read buildids, continuing...\n");
-                break;
-        default:
-                break;
-        }
+        if (!feat_ops[feat].process)
+                return 0;
 
-        return 0;
+        return feat_ops[feat].process(section, ph, feat, fd);
 }
 
 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
                                        struct perf_header *ph, int fd,
                                        bool repipe)
 {
-        if (readn(fd, header, sizeof(*header)) <= 0 ||
-            memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
-                return -1;
+        int ret;
 
-        if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
+        ret = readn(fd, header, sizeof(*header));
+        if (ret <= 0)
                 return -1;
 
-        if (header->size != sizeof(*header)) {
-                u64 size = bswap_64(header->size);
+        if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
+                pr_debug("endian/magic failed\n");
+                return -1;
+        }
 
-                if (size != sizeof(*header))
-                        return -1;
+        if (ph->needs_swap)
+                header->size = bswap_64(header->size);
 
-                ph->needs_swap = true;
-        }
+        if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
+                return -1;
 
         return 0;
 }
@@ -1908,6 +2050,52 @@ static int perf_header__read_pipe(struct perf_session *session, int fd)
         return 0;
 }
 
+static int read_attr(int fd, struct perf_header *ph,
+                     struct perf_file_attr *f_attr)
+{
+        struct perf_event_attr *attr = &f_attr->attr;
+        size_t sz, left;
+        size_t our_sz = sizeof(f_attr->attr);
+        int ret;
+
+        memset(f_attr, 0, sizeof(*f_attr));
+
+        /* read minimal guaranteed structure */
+        ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
+        if (ret <= 0) {
+                pr_debug("cannot read %d bytes of header attr\n",
+                         PERF_ATTR_SIZE_VER0);
+                return -1;
+        }
+
+        /* on file perf_event_attr size */
+        sz = attr->size;
+
+        if (ph->needs_swap)
+                sz = bswap_32(sz);
+
+        if (sz == 0) {
+                /* assume ABI0 */
+                sz =  PERF_ATTR_SIZE_VER0;
+        } else if (sz > our_sz) {
+                pr_debug("file uses a more recent and unsupported ABI"
+                         " (%zu bytes extra)\n", sz - our_sz);
+                return -1;
+        }
+        /* what we have not yet read and that we know about */
+        left = sz - PERF_ATTR_SIZE_VER0;
+        if (left) {
+                void *ptr = attr;
+                ptr += PERF_ATTR_SIZE_VER0;
+
+                ret = readn(fd, ptr, left);
+        }
+        /* read perf_file_section, ids are read in caller */
+        ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
+
+        return ret <= 0 ? -1 : 0;
+}
+
 int perf_session__read_header(struct perf_session *session, int fd)
 {
         struct perf_header *header = &session->header;
@@ -1923,19 +2111,17 @@ int perf_session__read_header(struct perf_session *session, int fd)
         if (session->fd_pipe)
                 return perf_header__read_pipe(session, fd);
 
-        if (perf_file_header__read(&f_header, header, fd) < 0) {
-                pr_debug("incompatible file format\n");
+        if (perf_file_header__read(&f_header, header, fd) < 0)
                 return -EINVAL;
-        }
 
-        nr_attrs = f_header.attrs.size / sizeof(f_attr);
+        nr_attrs = f_header.attrs.size / f_header.attr_size;
         lseek(fd, f_header.attrs.offset, SEEK_SET);
 
         for (i = 0; i < nr_attrs; i++) {
                 struct perf_evsel *evsel;
                 off_t tmp;
 
-                if (readn(fd, &f_attr, sizeof(f_attr)) <= 0)
+                if (read_attr(fd, header, &f_attr) < 0)
                         goto out_errno;
 
                 if (header->needs_swap)
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index ac4ec956024e..21a6be09c129 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -11,6 +11,7 @@
 
 enum {
         HEADER_RESERVED         = 0,    /* always cleared */
+        HEADER_FIRST_FEATURE    = 1,
         HEADER_TRACE_INFO       = 1,
         HEADER_BUILD_ID,
 
@@ -26,7 +27,7 @@ enum {
         HEADER_EVENT_DESC,
         HEADER_CPU_TOPOLOGY,
         HEADER_NUMA_TOPOLOGY,
-
+        HEADER_BRANCH_STACK,
         HEADER_LAST_FEATURE,
         HEADER_FEAT_BITS        = 256,
 };
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 6f505d1abac7..3dc99a9b71f5 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -50,21 +50,25 @@ static void hists__reset_col_len(struct hists *hists)
                 hists__set_col_len(hists, col, 0);
 }
 
+static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
+{
+        const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
+
+        if (hists__col_len(hists, dso) < unresolved_col_width &&
+            !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
+            !symbol_conf.dso_list)
+                hists__set_col_len(hists, dso, unresolved_col_width);
+}
+
 static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 {
+        const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
         u16 len;
 
         if (h->ms.sym)
-                hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen);
-        else {
-                const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
-
-                if (hists__col_len(hists, HISTC_DSO) < unresolved_col_width &&
-                    !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
-                    !symbol_conf.dso_list)
-                        hists__set_col_len(hists, HISTC_DSO,
-                                           unresolved_col_width);
-        }
+                hists__new_col_len(hists, HISTC_SYMBOL, h->ms.sym->namelen + 4);
+        else
+                hists__set_unres_dso_col_len(hists, HISTC_DSO);
 
         len = thread__comm_len(h->thread);
         if (hists__new_col_len(hists, HISTC_COMM, len))
@@ -74,6 +78,37 @@ static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
                 len = dso__name_len(h->ms.map->dso);
                 hists__new_col_len(hists, HISTC_DSO, len);
         }
+
+        if (h->branch_info) {
+                int symlen;
+                /*
+                 * +4 accounts for '[x] ' priv level info
+                 * +2 account of 0x prefix on raw addresses
+                 */
+                if (h->branch_info->from.sym) {
+                        symlen = (int)h->branch_info->from.sym->namelen + 4;
+                        hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
+
+                        symlen = dso__name_len(h->branch_info->from.map->dso);
+                        hists__new_col_len(hists, HISTC_DSO_FROM, symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__new_col_len(hists, HISTC_SYMBOL_FROM, symlen);
+                        hists__set_unres_dso_col_len(hists, HISTC_DSO_FROM);
+                }
+
+                if (h->branch_info->to.sym) {
+                        symlen = (int)h->branch_info->to.sym->namelen + 4;
+                        hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
+
+                        symlen = dso__name_len(h->branch_info->to.map->dso);
+                        hists__new_col_len(hists, HISTC_DSO_TO, symlen);
+                } else {
+                        symlen = unresolved_col_width + 4 + 2;
+                        hists__new_col_len(hists, HISTC_SYMBOL_TO, symlen);
+                        hists__set_unres_dso_col_len(hists, HISTC_DSO_TO);
+                }
+        }
 }
 
 static void hist_entry__add_cpumode_period(struct hist_entry *he,
@@ -195,26 +230,14 @@ static u8 symbol__parent_filter(const struct symbol *parent)
         return 0;
 }
 
-struct hist_entry *__hists__add_entry(struct hists *hists,
+static struct hist_entry *add_hist_entry(struct hists *hists,
+                                      struct hist_entry *entry,
                                       struct addr_location *al,
-                                      struct symbol *sym_parent, u64 period)
+                                      u64 period)
 {
         struct rb_node **p;
         struct rb_node *parent = NULL;
         struct hist_entry *he;
-        struct hist_entry entry = {
-                .thread = al->thread,
-                .ms = {
-                        .map    = al->map,
-                        .sym    = al->sym,
-                },
-                .cpu    = al->cpu,
-                .ip     = al->addr,
-                .level  = al->level,
-                .period = period,
-                .parent = sym_parent,
-                .filtered = symbol__parent_filter(sym_parent),
-        };
         int cmp;
 
         pthread_mutex_lock(&hists->lock);
@@ -225,7 +248,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
                 parent = *p;
                 he = rb_entry(parent, struct hist_entry, rb_node_in);
 
-                cmp = hist_entry__cmp(&entry, he);
+                cmp = hist_entry__cmp(entry, he);
 
                 if (!cmp) {
                         he->period += period;
@@ -239,7 +262,7 @@ struct hist_entry *__hists__add_entry(struct hists *hists,
                         p = &(*p)->rb_right;
         }
 
-        he = hist_entry__new(&entry);
+        he = hist_entry__new(entry);
         if (!he)
                 goto out_unlock;
 
@@ -252,6 +275,51 @@ out_unlock:
         return he;
 }
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+                                             struct addr_location *al,
+                                             struct symbol *sym_parent,
+                                             struct branch_info *bi,
+                                             u64 period)
+{
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .ms = {
+                        .map    = bi->to.map,
+                        .sym    = bi->to.sym,
+                },
+                .cpu    = al->cpu,
+                .ip     = bi->to.addr,
+                .level  = al->level,
+                .period = period,
+                .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
+                .branch_info = bi,
+        };
+
+        return add_hist_entry(self, &entry, al, period);
+}
+
+struct hist_entry *__hists__add_entry(struct hists *self,
+                                      struct addr_location *al,
+                                      struct symbol *sym_parent, u64 period)
+{
+        struct hist_entry entry = {
+                .thread = al->thread,
+                .ms = {
+                        .map    = al->map,
+                        .sym    = al->sym,
+                },
+                .cpu    = al->cpu,
+                .ip     = al->addr,
+                .level  = al->level,
+                .period = period,
+                .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
+        };
+
+        return add_hist_entry(self, &entry, al, period);
+}
+
 int64_t
 hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
 {
@@ -768,7 +836,7 @@ static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
                                                      sep ? "%.2f" : "   %6.2f%%",
                                                      (period * 100.0) / total);
                 else
-                        ret = snprintf(s, size, sep ? "%.2f" : "   %6.2f%%",
+                        ret = scnprintf(s, size, sep ? "%.2f" : "   %6.2f%%",
                                        (period * 100.0) / total);
                 if (symbol_conf.show_cpu_utilization) {
                         ret += percent_color_snprintf(s + ret, size - ret,
@@ -791,20 +859,20 @@ static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
                         }
                 }
         } else
-                ret = snprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period);
+                ret = scnprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period);
 
         if (symbol_conf.show_nr_samples) {
                 if (sep)
-                        ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
+                        ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
                 else
-                        ret += snprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
+                        ret += scnprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
         }
 
         if (symbol_conf.show_total_period) {
                 if (sep)
-                        ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
+                        ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
                 else
-                        ret += snprintf(s + ret, size - ret, " %12" PRIu64, period);
+                        ret += scnprintf(s + ret, size - ret, " %12" PRIu64, period);
         }
 
         if (pair_hists) {
@@ -819,25 +887,25 @@ static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
                 diff = new_percent - old_percent;
 
                 if (fabs(diff) >= 0.01)
-                        snprintf(bf, sizeof(bf), "%+4.2F%%", diff);
+                        ret += scnprintf(bf, sizeof(bf), "%+4.2F%%", diff);
                 else
-                        snprintf(bf, sizeof(bf), " ");
+                        ret += scnprintf(bf, sizeof(bf), " ");
 
                 if (sep)
-                        ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
+                        ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
                 else
-                        ret += snprintf(s + ret, size - ret, "%11.11s", bf);
+                        ret += scnprintf(s + ret, size - ret, "%11.11s", bf);
 
                 if (show_displacement) {
                         if (displacement)
-                                snprintf(bf, sizeof(bf), "%+4ld", displacement);
+                                ret += scnprintf(bf, sizeof(bf), "%+4ld", displacement);
                         else
-                                snprintf(bf, sizeof(bf), " ");
+                                ret += scnprintf(bf, sizeof(bf), " ");
 
                         if (sep)
-                                ret += snprintf(s + ret, size - ret, "%c%s", *sep, bf);
+                                ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
                         else
-                                ret += snprintf(s + ret, size - ret, "%6.6s", bf);
+                                ret += scnprintf(s + ret, size - ret, "%6.6s", bf);
                 }
         }
 
@@ -855,7 +923,7 @@ int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
                 if (se->elide)
                         continue;
 
-                ret += snprintf(s + ret, size - ret, "%s", sep ?: "  ");
+                ret += scnprintf(s + ret, size - ret, "%s", sep ?: "  ");
                 ret += se->se_snprintf(he, s + ret, size - ret,
                                        hists__col_len(hists, se->se_width_idx));
         }
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index f55f0a8d1f81..9413f3e31fea 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -32,6 +32,7 @@ struct events_stats {
         u32 nr_unknown_events;
         u32 nr_invalid_chains;
         u32 nr_unknown_id;
+        u32 nr_unprocessable_samples;
 };
 
 enum hist_column {
@@ -41,6 +42,11 @@ enum hist_column {
         HISTC_COMM,
         HISTC_PARENT,
         HISTC_CPU,
+        HISTC_MISPREDICT,
+        HISTC_SYMBOL_FROM,
+        HISTC_SYMBOL_TO,
+        HISTC_DSO_FROM,
+        HISTC_DSO_TO,
         HISTC_NR_COLS, /* Last entry */
 };
 
@@ -55,6 +61,7 @@ struct hists {
         u64                     nr_entries;
         const struct thread     *thread_filter;
         const struct dso        *dso_filter;
+        const char              *uid_filter_str;
         pthread_mutex_t         lock;
         struct events_stats     stats;
         u64                     event_stream;
@@ -72,6 +79,12 @@ int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
                          struct hists *hists);
 void hist_entry__free(struct hist_entry *);
 
+struct hist_entry *__hists__add_branch_entry(struct hists *self,
+                                             struct addr_location *al,
+                                             struct symbol *sym_parent,
+                                             struct branch_info *bi,
+                                             u64 period);
+
 void hists__output_resort(struct hists *self);
 void hists__output_resort_threaded(struct hists *hists);
 void hists__collapse_resort(struct hists *self);
diff --git a/tools/perf/util/include/asm/dwarf2.h b/tools/perf/util/include/asm/dwarf2.h
index bb4198e7837a..afe38199e922 100644
--- a/tools/perf/util/include/asm/dwarf2.h
+++ b/tools/perf/util/include/asm/dwarf2.h
@@ -2,10 +2,12 @@
 #ifndef PERF_DWARF2_H
 #define PERF_DWARF2_H
 
-/* dwarf2.h ... dummy header file for including arch/x86/lib/memcpy_64.S */
+/* dwarf2.h ... dummy header file for including arch/x86/lib/mem{cpy,set}_64.S */
 
 #define CFI_STARTPROC
 #define CFI_ENDPROC
+#define CFI_REMEMBER_STATE
+#define CFI_RESTORE_STATE
 
 #endif  /* PERF_DWARF2_H */
 
diff --git a/tools/perf/util/include/asm/unistd_32.h b/tools/perf/util/include/asm/unistd_32.h
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/tools/perf/util/include/asm/unistd_32.h
@@ -0,0 +1 @@
+
diff --git a/tools/perf/util/include/asm/unistd_64.h b/tools/perf/util/include/asm/unistd_64.h
new file mode 100644
index 000000000000..8b137891791f
--- /dev/null
+++ b/tools/perf/util/include/asm/unistd_64.h
@@ -0,0 +1 @@
+
diff --git a/tools/perf/util/include/linux/bitmap.h b/tools/perf/util/include/linux/bitmap.h
index eda4416efa0a..bb162e40c76c 100644
--- a/tools/perf/util/include/linux/bitmap.h
+++ b/tools/perf/util/include/linux/bitmap.h
@@ -5,6 +5,8 @@
 #include <linux/bitops.h>
 
 int __bitmap_weight(const unsigned long *bitmap, int bits);
+void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
+                 const unsigned long *bitmap2, int bits);
 
 #define BITMAP_LAST_WORD_MASK(nbits)                                    \
 (                                                                       \
@@ -32,4 +34,13 @@ static inline int bitmap_weight(const unsigned long *src, int nbits)
         return __bitmap_weight(src, nbits);
 }
 
+static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
+                             const unsigned long *src2, int nbits)
+{
+        if (small_const_nbits(nbits))
+                *dst = *src1 | *src2;
+        else
+                __bitmap_or(dst, src1, src2, nbits);
+}
+
 #endif /* _PERF_BITOPS_H */
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index 316aa0ab7122..dea6d1c1a954 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -212,6 +212,21 @@ size_t map__fprintf(struct map *self, FILE *fp)
                        self->start, self->end, self->pgoff, self->dso->name);
 }
 
+size_t map__fprintf_dsoname(struct map *map, FILE *fp)
+{
+        const char *dsoname;
+
+        if (map && map->dso && (map->dso->name || map->dso->long_name)) {
+                if (symbol_conf.show_kernel_path && map->dso->long_name)
+                        dsoname = map->dso->long_name;
+                else if (map->dso->name)
+                        dsoname = map->dso->name;
+        } else
+                dsoname = "[unknown]";
+
+        return fprintf(fp, "%s", dsoname);
+}
+
 /*
  * objdump wants/reports absolute IPs for ET_EXEC, and RIPs for ET_DYN.
  * map->dso->adjust_symbols==1 for ET_EXEC-like cases.
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 2b8017f8a930..b100c20b7f94 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -118,6 +118,7 @@ void map__delete(struct map *self);
 struct map *map__clone(struct map *self);
 int map__overlap(struct map *l, struct map *r);
 size_t map__fprintf(struct map *self, FILE *fp);
+size_t map__fprintf_dsoname(struct map *map, FILE *fp);
 
 int map__load(struct map *self, symbol_filter_t filter);
 struct symbol *map__find_symbol(struct map *self,
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index e33554a562b3..8a8ee64e72d1 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -34,7 +34,6 @@
 
 #include "util.h"
 #include "event.h"
-#include "string.h"
 #include "strlist.h"
 #include "debug.h"
 #include "cache.h"
@@ -273,10 +272,10 @@ static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
 /* Try to find perf_probe_event with debuginfo */
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
                                           struct probe_trace_event **tevs,
-                                          int max_tevs, const char *module)
+                                          int max_tevs, const char *target)
 {
         bool need_dwarf = perf_probe_event_need_dwarf(pev);
-        struct debuginfo *dinfo = open_debuginfo(module);
+        struct debuginfo *dinfo = open_debuginfo(target);
         int ntevs, ret = 0;
 
         if (!dinfo) {
@@ -295,9 +294,9 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 
         if (ntevs > 0) {        /* Succeeded to find trace events */
                 pr_debug("find %d probe_trace_events.\n", ntevs);
-                if (module)
+                if (target)
                         ret = add_module_to_probe_trace_events(*tevs, ntevs,
-                                                               module);
+                                                               target);
                 return ret < 0 ? ret : ntevs;
         }
 
@@ -1729,7 +1728,7 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
         }
 
         ret = 0;
-        printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
+        printf("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
         for (i = 0; i < ntevs; i++) {
                 tev = &tevs[i];
                 if (pev->event)
@@ -1784,7 +1783,7 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 
         if (ret >= 0) {
                 /* Show how to use the event. */
-                printf("\nYou can now use it on all perf tools, such as:\n\n");
+                printf("\nYou can now use it in all perf tools, such as:\n\n");
                 printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
                          tev->event);
         }
@@ -1796,14 +1795,14 @@ static int __add_probe_trace_events(struct perf_probe_event *pev,
 
 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                                           struct probe_trace_event **tevs,
-                                          int max_tevs, const char *module)
+                                          int max_tevs, const char *target)
 {
         struct symbol *sym;
         int ret = 0, i;
         struct probe_trace_event *tev;
 
         /* Convert perf_probe_event with debuginfo */
-        ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, module);
+        ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
         if (ret != 0)
                 return ret;     /* Found in debuginfo or got an error */
 
@@ -1819,8 +1818,8 @@ static int convert_to_probe_trace_events(struct perf_probe_event *pev,
                 goto error;
         }
 
-        if (module) {
-                tev->point.module = strdup(module);
+        if (target) {
+                tev->point.module = strdup(target);
                 if (tev->point.module == NULL) {
                         ret = -ENOMEM;
                         goto error;
@@ -1890,7 +1889,7 @@ struct __event_package {
 };
 
 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
-                          int max_tevs, const char *module, bool force_add)
+                          int max_tevs, const char *target, bool force_add)
 {
         int i, j, ret;
         struct __event_package *pkgs;
@@ -1913,7 +1912,7 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
                 ret  = convert_to_probe_trace_events(pkgs[i].pev,
                                                      &pkgs[i].tevs,
                                                      max_tevs,
-                                                     module);
+                                                     target);
                 if (ret < 0)
                         goto end;
                 pkgs[i].ntevs = ret;
@@ -1965,7 +1964,7 @@ static int __del_trace_probe_event(int fd, struct str_node *ent)
                 goto error;
         }
 
-        printf("Remove event: %s\n", ent->s);
+        printf("Removed event: %s\n", ent->s);
         return 0;
 error:
         pr_warning("Failed to delete event: %s\n", strerror(-ret));
@@ -2069,7 +2068,7 @@ static int filter_available_functions(struct map *map __unused,
         return 1;
 }
 
-int show_available_funcs(const char *module, struct strfilter *_filter)
+int show_available_funcs(const char *target, struct strfilter *_filter)
 {
         struct map *map;
         int ret;
@@ -2080,9 +2079,9 @@ int show_available_funcs(const char *module, struct strfilter *_filter)
         if (ret < 0)
                 return ret;
 
-        map = kernel_get_module_map(module);
+        map = kernel_get_module_map(target);
         if (!map) {
-                pr_err("Failed to find %s map.\n", (module) ? : "kernel");
+                pr_err("Failed to find %s map.\n", (target) ? : "kernel");
                 return -EINVAL;
         }
         available_func_filter = _filter;
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index 74bd2e63c4b4..2cc162d3b78c 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -30,7 +30,6 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
-#include <ctype.h>
 #include <dwarf-regs.h>
 
 #include <linux/bitops.h>
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
new file mode 100644
index 000000000000..2884e67ee625
--- /dev/null
+++ b/tools/perf/util/python-ext-sources
@@ -0,0 +1,19 @@
+#
+# List of files needed by perf python extention
+#
+# Each source file must be placed on its own line so that it can be
+# processed by Makefile and util/setup.py accordingly.
+#
+
+util/python.c
+util/ctype.c
+util/evlist.c
+util/evsel.c
+util/cpumap.c
+util/thread_map.c
+util/util.c
+util/xyarray.c
+util/cgroup.c
+util/debugfs.c
+util/strlist.c
+../../lib/rbtree.c
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 9dd47a4f2596..e03b58a48424 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -425,14 +425,14 @@ struct pyrf_thread_map {
 static int pyrf_thread_map__init(struct pyrf_thread_map *pthreads,
                                  PyObject *args, PyObject *kwargs)
 {
-        static char *kwlist[] = { "pid", "tid", NULL };
-        int pid = -1, tid = -1;
+        static char *kwlist[] = { "pid", "tid", "uid", NULL };
+        int pid = -1, tid = -1, uid = UINT_MAX;
 
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii",
-                                         kwlist, &pid, &tid))
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iii",
+                                         kwlist, &pid, &tid, &uid))
                 return -1;
 
-        pthreads->threads = thread_map__new(pid, tid);
+        pthreads->threads = thread_map__new(pid, tid, uid);
         if (pthreads->threads == NULL)
                 return -1;
         return 0;
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 0b2a48783172..c2623c6f9b51 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -24,7 +24,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <errno.h>
 
 #include "../../perf.h"
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index b5ca2558c7bb..002ebbf59f48 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -24,7 +24,7 @@ static int perf_session__open(struct perf_session *self, bool force)
                 self->fd = STDIN_FILENO;
 
                 if (perf_session__read_header(self, self->fd) < 0)
-                        pr_err("incompatible file format");
+                        pr_err("incompatible file format (rerun with -v to learn more)");
 
                 return 0;
         }
@@ -56,7 +56,7 @@ static int perf_session__open(struct perf_session *self, bool force)
         }
 
         if (perf_session__read_header(self, self->fd) < 0) {
-                pr_err("incompatible file format");
+                pr_err("incompatible file format (rerun with -v to learn more)");
                 goto out_close;
         }
 
@@ -229,6 +229,64 @@ static bool symbol__match_parent_regex(struct symbol *sym)
         return 0;
 }
 
+static const u8 cpumodes[] = {
+        PERF_RECORD_MISC_USER,
+        PERF_RECORD_MISC_KERNEL,
+        PERF_RECORD_MISC_GUEST_USER,
+        PERF_RECORD_MISC_GUEST_KERNEL
+};
+#define NCPUMODES (sizeof(cpumodes)/sizeof(u8))
+
+static void ip__resolve_ams(struct machine *self, struct thread *thread,
+                            struct addr_map_symbol *ams,
+                            u64 ip)
+{
+        struct addr_location al;
+        size_t i;
+        u8 m;
+
+        memset(&al, 0, sizeof(al));
+
+        for (i = 0; i < NCPUMODES; i++) {
+                m = cpumodes[i];
+                /*
+                 * We cannot use the header.misc hint to determine whether a
+                 * branch stack address is user, kernel, guest, hypervisor.
+                 * Branches may straddle the kernel/user/hypervisor boundaries.
+                 * Thus, we have to try consecutively until we find a match
+                 * or else, the symbol is unknown
+                 */
+                thread__find_addr_location(thread, self, m, MAP__FUNCTION,
+                                ip, &al, NULL);
+                if (al.sym)
+                        goto found;
+        }
+found:
+        ams->addr = ip;
+        ams->al_addr = al.addr;
+        ams->sym = al.sym;
+        ams->map = al.map;
+}
+
+struct branch_info *machine__resolve_bstack(struct machine *self,
+                                            struct thread *thr,
+                                            struct branch_stack *bs)
+{
+        struct branch_info *bi;
+        unsigned int i;
+
+        bi = calloc(bs->nr, sizeof(struct branch_info));
+        if (!bi)
+                return NULL;
+
+        for (i = 0; i < bs->nr; i++) {
+                ip__resolve_ams(self, thr, &bi[i].to, bs->entries[i].to);
+                ip__resolve_ams(self, thr, &bi[i].from, bs->entries[i].from);
+                bi[i].flags = bs->entries[i].flags;
+        }
+        return bi;
+}
+
 int machine__resolve_callchain(struct machine *self, struct perf_evsel *evsel,
                                struct thread *thread,
                                struct ip_callchain *chain,
@@ -697,6 +755,18 @@ static void callchain__printf(struct perf_sample *sample)
                        i, sample->callchain->ips[i]);
 }
 
+static void branch_stack__printf(struct perf_sample *sample)
+{
+        uint64_t i;
+
+        printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
+
+        for (i = 0; i < sample->branch_stack->nr; i++)
+                printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
+                        i, sample->branch_stack->entries[i].from,
+                        sample->branch_stack->entries[i].to);
+}
+
 static void perf_session__print_tstamp(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_sample *sample)
@@ -744,6 +814,9 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
 
         if (session->sample_type & PERF_SAMPLE_CALLCHAIN)
                 callchain__printf(sample);
+
+        if (session->sample_type & PERF_SAMPLE_BRANCH_STACK)
+                branch_stack__printf(sample);
 }
 
 static struct machine *
@@ -796,6 +869,10 @@ static int perf_session_deliver_event(struct perf_session *session,
                         ++session->hists.stats.nr_unknown_id;
                         return -1;
                 }
+                if (machine == NULL) {
+                        ++session->hists.stats.nr_unprocessable_samples;
+                        return -1;
+                }
                 return tool->sample(tool, event, sample, evsel, machine);
         case PERF_RECORD_MMAP:
                 return tool->mmap(tool, event, sample, machine);
@@ -964,6 +1041,12 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
                             session->hists.stats.nr_invalid_chains,
                             session->hists.stats.nr_events[PERF_RECORD_SAMPLE]);
         }
+
+        if (session->hists.stats.nr_unprocessable_samples != 0) {
+                ui__warning("%u unprocessable samples recorded.\n"
+                            "Do you have a KVM guest running and not using 'perf kvm'?\n",
+                            session->hists.stats.nr_unprocessable_samples);
+        }
 }
 
 #define session_done()  (*(volatile int *)(&session_done))
@@ -1293,10 +1376,9 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 
 void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
                           struct machine *machine, struct perf_evsel *evsel,
-                          int print_sym, int print_dso)
+                          int print_sym, int print_dso, int print_symoffset)
 {
         struct addr_location al;
-        const char *symname, *dsoname;
         struct callchain_cursor *cursor = &evsel->hists.callchain_cursor;
         struct callchain_cursor_node *node;
 
@@ -1324,20 +1406,13 @@ void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
 
                         printf("\t%16" PRIx64, node->ip);
                         if (print_sym) {
-                                if (node->sym && node->sym->name)
-                                        symname = node->sym->name;
-                                else
-                                        symname = "";
-
-                                printf(" %s", symname);
+                                printf(" ");
+                                symbol__fprintf_symname(node->sym, stdout);
                         }
                         if (print_dso) {
-                                if (node->map && node->map->dso && node->map->dso->name)
-                                        dsoname = node->map->dso->name;
-                                else
-                                        dsoname = "";
-
-                                printf(" (%s)", dsoname);
+                                printf(" (");
+                                map__fprintf_dsoname(al.map, stdout);
+                                printf(")");
                         }
                         printf("\n");
 
@@ -1347,21 +1422,18 @@ void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
         } else {
                 printf("%16" PRIx64, sample->ip);
                 if (print_sym) {
-                        if (al.sym && al.sym->name)
-                                symname = al.sym->name;
+                        printf(" ");
+                        if (print_symoffset)
+                                symbol__fprintf_symname_offs(al.sym, &al,
+                                                             stdout);
                         else
-                                symname = "";
-
-                        printf(" %s", symname);
+                                symbol__fprintf_symname(al.sym, stdout);
                 }
 
                 if (print_dso) {
-                        if (al.map && al.map->dso && al.map->dso->name)
-                                dsoname = al.map->dso->name;
-                        else
-                                dsoname = "";
-
-                        printf(" (%s)", dsoname);
+                        printf(" (");
+                        map__fprintf_dsoname(al.map, stdout);
+                        printf(")");
                 }
         }
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 37bc38381fb6..7a5434c00565 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -73,6 +73,10 @@ int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel
                                     struct ip_callchain *chain,
                                     struct symbol **parent);
 
+struct branch_info *machine__resolve_bstack(struct machine *self,
+                                            struct thread *thread,
+                                            struct branch_stack *bs);
+
 bool perf_session__has_traces(struct perf_session *self, const char *msg);
 
 void mem_bswap_64(void *src, int byte_size);
@@ -147,7 +151,7 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
 
 void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
                           struct machine *machine, struct perf_evsel *evsel,
-                          int print_sym, int print_dso);
+                          int print_sym, int print_dso, int print_symoffset);
 
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 36d4c5619575..d0f9f29cf181 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -24,11 +24,11 @@ cflags += getenv('CFLAGS', '').split()
 build_lib = getenv('PYTHON_EXTBUILD_LIB')
 build_tmp = getenv('PYTHON_EXTBUILD_TMP')
 
+ext_sources = [f.strip() for f in file('util/python-ext-sources')
+                                if len(f.strip()) > 0 and f[0] != '#']
+
 perf = Extension('perf',
-                  sources = ['util/python.c', 'util/ctype.c', 'util/evlist.c',
-                             'util/evsel.c', 'util/cpumap.c', 'util/thread_map.c',
-                             'util/util.c', 'util/xyarray.c', 'util/cgroup.c',
-                             'util/debugfs.c'],
+                  sources = ext_sources,
                   include_dirs = ['util/include'],
                   extra_compile_args = cflags,
                  )
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 16da30d8d765..a27237430c5f 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -8,6 +8,7 @@ const char	default_sort_order[] = "comm,dso,symbol";
 const char      *sort_order = default_sort_order;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
+int             sort__branch_mode = -1; /* -1 = means not set */
 
 enum sort_type  sort__first_dimension;
 
@@ -33,6 +34,9 @@ static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
                 }
         }
         va_end(ap);
+
+        if (n >= (int)size)
+                return size - 1;
         return n;
 }
 
@@ -94,6 +98,26 @@ static int hist_entry__comm_snprintf(struct hist_entry *self, char *bf,
         return repsep_snprintf(bf, size, "%*s", width, self->thread->comm);
 }
 
+static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
+{
+        struct dso *dso_l = map_l ? map_l->dso : NULL;
+        struct dso *dso_r = map_r ? map_r->dso : NULL;
+        const char *dso_name_l, *dso_name_r;
+
+        if (!dso_l || !dso_r)
+                return cmp_null(dso_l, dso_r);
+
+        if (verbose) {
+                dso_name_l = dso_l->long_name;
+                dso_name_r = dso_r->long_name;
+        } else {
+                dso_name_l = dso_l->short_name;
+                dso_name_r = dso_r->short_name;
+        }
+
+        return strcmp(dso_name_l, dso_name_r);
+}
+
 struct sort_entry sort_comm = {
         .se_header      = "Command",
         .se_cmp         = sort__comm_cmp,
@@ -107,36 +131,74 @@ struct sort_entry sort_comm = {
 static int64_t
 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 {
-        struct dso *dso_l = left->ms.map ? left->ms.map->dso : NULL;
-        struct dso *dso_r = right->ms.map ? right->ms.map->dso : NULL;
-        const char *dso_name_l, *dso_name_r;
+        return _sort__dso_cmp(left->ms.map, right->ms.map);
+}
 
-        if (!dso_l || !dso_r)
-                return cmp_null(dso_l, dso_r);
 
-        if (verbose) {
-                dso_name_l = dso_l->long_name;
-                dso_name_r = dso_r->long_name;
-        } else {
-                dso_name_l = dso_l->short_name;
-                dso_name_r = dso_r->short_name;
+static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r,
+                              u64 ip_l, u64 ip_r)
+{
+        if (!sym_l || !sym_r)
+                return cmp_null(sym_l, sym_r);
+
+        if (sym_l == sym_r)
+                return 0;
+
+        if (sym_l)
+                ip_l = sym_l->start;
+        if (sym_r)
+                ip_r = sym_r->start;
+
+        return (int64_t)(ip_r - ip_l);
+}
+
+static int _hist_entry__dso_snprintf(struct map *map, char *bf,
+                                     size_t size, unsigned int width)
+{
+        if (map && map->dso) {
+                const char *dso_name = !verbose ? map->dso->short_name :
+                        map->dso->long_name;
+                return repsep_snprintf(bf, size, "%-*s", width, dso_name);
         }
 
-        return strcmp(dso_name_l, dso_name_r);
+        return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
 }
 
 static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
                                     size_t size, unsigned int width)
 {
-        if (self->ms.map && self->ms.map->dso) {
-                const char *dso_name = !verbose ? self->ms.map->dso->short_name :
-                                                  self->ms.map->dso->long_name;
-                return repsep_snprintf(bf, size, "%-*s", width, dso_name);
+        return _hist_entry__dso_snprintf(self->ms.map, bf, size, width);
+}
+
+static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
+                                     u64 ip, char level, char *bf, size_t size,
+                                     unsigned int width __used)
+{
+        size_t ret = 0;
+
+        if (verbose) {
+                char o = map ? dso__symtab_origin(map->dso) : '!';
+                ret += repsep_snprintf(bf, size, "%-#*llx %c ",
+                                       BITS_PER_LONG / 4, ip, o);
         }
 
-        return repsep_snprintf(bf, size, "%-*s", width, "[unknown]");
+        ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
+        if (sym)
+                ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                       width - ret,
+                                       sym->name);
+        else {
+                size_t len = BITS_PER_LONG / 4;
+                ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
+                                       len, ip);
+                ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
+                                       width - ret, "");
+        }
+
+        return ret;
 }
 
+
 struct sort_entry sort_dso = {
         .se_header      = "Shared Object",
         .se_cmp         = sort__dso_cmp,
@@ -144,8 +206,14 @@ struct sort_entry sort_dso = {
         .se_width_idx   = HISTC_DSO,
 };
 
-/* --sort symbol */
+static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width __used)
+{
+        return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
+                                         self->level, bf, size, width);
+}
 
+/* --sort symbol */
 static int64_t
 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 {
@@ -163,31 +231,7 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
         ip_l = left->ms.sym->start;
         ip_r = right->ms.sym->start;
 
-        return (int64_t)(ip_r - ip_l);
-}
-
-static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
-                                    size_t size, unsigned int width __used)
-{
-        size_t ret = 0;
-
-        if (verbose) {
-                char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
-                ret += repsep_snprintf(bf, size, "%-#*llx %c ",
-                                       BITS_PER_LONG / 4, self->ip, o);
-        }
-
-        if (!sort_dso.elide)
-                ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
-
-        if (self->ms.sym)
-                ret += repsep_snprintf(bf + ret, size - ret, "%s",
-                                       self->ms.sym->name);
-        else
-                ret += repsep_snprintf(bf + ret, size - ret, "%-#*llx",
-                                       BITS_PER_LONG / 4, self->ip);
-
-        return ret;
+        return _sort__sym_cmp(left->ms.sym, right->ms.sym, ip_l, ip_r);
 }
 
 struct sort_entry sort_sym = {
@@ -246,19 +290,155 @@ struct sort_entry sort_cpu = {
         .se_width_idx   = HISTC_CPU,
 };
 
+static int64_t
+sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return _sort__dso_cmp(left->branch_info->from.map,
+                              right->branch_info->from.map);
+}
+
+static int hist_entry__dso_from_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width)
+{
+        return _hist_entry__dso_snprintf(self->branch_info->from.map,
+                                         bf, size, width);
+}
+
+struct sort_entry sort_dso_from = {
+        .se_header      = "Source Shared Object",
+        .se_cmp         = sort__dso_from_cmp,
+        .se_snprintf    = hist_entry__dso_from_snprintf,
+        .se_width_idx   = HISTC_DSO_FROM,
+};
+
+static int64_t
+sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return _sort__dso_cmp(left->branch_info->to.map,
+                              right->branch_info->to.map);
+}
+
+static int hist_entry__dso_to_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
+{
+        return _hist_entry__dso_snprintf(self->branch_info->to.map,
+                                         bf, size, width);
+}
+
+static int64_t
+sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct addr_map_symbol *from_l = &left->branch_info->from;
+        struct addr_map_symbol *from_r = &right->branch_info->from;
+
+        if (!from_l->sym && !from_r->sym)
+                return right->level - left->level;
+
+        return _sort__sym_cmp(from_l->sym, from_r->sym, from_l->addr,
+                             from_r->addr);
+}
+
+static int64_t
+sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        struct addr_map_symbol *to_l = &left->branch_info->to;
+        struct addr_map_symbol *to_r = &right->branch_info->to;
+
+        if (!to_l->sym && !to_r->sym)
+                return right->level - left->level;
+
+        return _sort__sym_cmp(to_l->sym, to_r->sym, to_l->addr, to_r->addr);
+}
+
+static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width __used)
+{
+        struct addr_map_symbol *from = &self->branch_info->from;
+        return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
+                                         self->level, bf, size, width);
+
+}
+
+static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width __used)
+{
+        struct addr_map_symbol *to = &self->branch_info->to;
+        return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
+                                         self->level, bf, size, width);
+
+}
+
+struct sort_entry sort_dso_to = {
+        .se_header      = "Target Shared Object",
+        .se_cmp         = sort__dso_to_cmp,
+        .se_snprintf    = hist_entry__dso_to_snprintf,
+        .se_width_idx   = HISTC_DSO_TO,
+};
+
+struct sort_entry sort_sym_from = {
+        .se_header      = "Source Symbol",
+        .se_cmp         = sort__sym_from_cmp,
+        .se_snprintf    = hist_entry__sym_from_snprintf,
+        .se_width_idx   = HISTC_SYMBOL_FROM,
+};
+
+struct sort_entry sort_sym_to = {
+        .se_header      = "Target Symbol",
+        .se_cmp         = sort__sym_to_cmp,
+        .se_snprintf    = hist_entry__sym_to_snprintf,
+        .se_width_idx   = HISTC_SYMBOL_TO,
+};
+
+static int64_t
+sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        const unsigned char mp = left->branch_info->flags.mispred !=
+                                        right->branch_info->flags.mispred;
+        const unsigned char p = left->branch_info->flags.predicted !=
+                                        right->branch_info->flags.predicted;
+
+        return mp || p;
+}
+
+static int hist_entry__mispredict_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width){
+        static const char *out = "N/A";
+
+        if (self->branch_info->flags.predicted)
+                out = "N";
+        else if (self->branch_info->flags.mispred)
+                out = "Y";
+
+        return repsep_snprintf(bf, size, "%-*s", width, out);
+}
+
+struct sort_entry sort_mispredict = {
+        .se_header      = "Branch Mispredicted",
+        .se_cmp         = sort__mispredict_cmp,
+        .se_snprintf    = hist_entry__mispredict_snprintf,
+        .se_width_idx   = HISTC_MISPREDICT,
+};
+
 struct sort_dimension {
         const char              *name;
         struct sort_entry       *entry;
         int                     taken;
 };
 
+#define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
+
 static struct sort_dimension sort_dimensions[] = {
-        { .name = "pid",        .entry = &sort_thread,  },
-        { .name = "comm",       .entry = &sort_comm,    },
-        { .name = "dso",        .entry = &sort_dso,     },
-        { .name = "symbol",     .entry = &sort_sym,     },
-        { .name = "parent",     .entry = &sort_parent,  },
-        { .name = "cpu",        .entry = &sort_cpu,     },
+        DIM(SORT_PID, "pid", sort_thread),
+        DIM(SORT_COMM, "comm", sort_comm),
+        DIM(SORT_DSO, "dso", sort_dso),
+        DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
+        DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
+        DIM(SORT_SYM, "symbol", sort_sym),
+        DIM(SORT_SYM_TO, "symbol_from", sort_sym_from),
+        DIM(SORT_SYM_FROM, "symbol_to", sort_sym_to),
+        DIM(SORT_PARENT, "parent", sort_parent),
+        DIM(SORT_CPU, "cpu", sort_cpu),
+        DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
 };
 
 int sort_dimension__add(const char *tok)
@@ -270,7 +450,6 @@ int sort_dimension__add(const char *tok)
 
                 if (strncasecmp(tok, sd->name, strlen(tok)))
                         continue;
-
                 if (sd->entry == &sort_parent) {
                         int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
                         if (ret) {
@@ -302,6 +481,16 @@ int sort_dimension__add(const char *tok)
                                 sort__first_dimension = SORT_PARENT;
                         else if (!strcmp(sd->name, "cpu"))
                                 sort__first_dimension = SORT_CPU;
+                        else if (!strcmp(sd->name, "symbol_from"))
+                                sort__first_dimension = SORT_SYM_FROM;
+                        else if (!strcmp(sd->name, "symbol_to"))
+                                sort__first_dimension = SORT_SYM_TO;
+                        else if (!strcmp(sd->name, "dso_from"))
+                                sort__first_dimension = SORT_DSO_FROM;
+                        else if (!strcmp(sd->name, "dso_to"))
+                                sort__first_dimension = SORT_DSO_TO;
+                        else if (!strcmp(sd->name, "mispredict"))
+                                sort__first_dimension = SORT_MISPREDICT;
                 }
 
                 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
@@ -309,7 +498,6 @@ int sort_dimension__add(const char *tok)
 
                 return 0;
         }
-
         return -ESRCH;
 }
 
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 3f67ae395752..472aa5a63a58 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -31,11 +31,16 @@ extern const char *parent_pattern;
 extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
+extern int sort__branch_mode;
 extern char *field_sep;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
 extern struct sort_entry sort_parent;
+extern struct sort_entry sort_dso_from;
+extern struct sort_entry sort_dso_to;
+extern struct sort_entry sort_sym_from;
+extern struct sort_entry sort_sym_to;
 extern enum sort_type sort__first_dimension;
 
 /**
@@ -72,6 +77,7 @@ struct hist_entry {
                 struct hist_entry *pair;
                 struct rb_root    sorted_chain;
         };
+        struct branch_info      *branch_info;
         struct callchain_root   callchain[0];
 };
 
@@ -82,6 +88,11 @@ enum sort_type {
         SORT_SYM,
         SORT_PARENT,
         SORT_CPU,
+        SORT_DSO_FROM,
+        SORT_DSO_TO,
+        SORT_SYM_FROM,
+        SORT_SYM_TO,
+        SORT_MISPREDICT,
 };
 
 /*
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 92e068517c1a..2eeb51baf077 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -1,4 +1,5 @@
 #include "cache.h"
+#include <linux/kernel.h>
 
 int prefixcmp(const char *str, const char *prefix)
 {
@@ -89,14 +90,14 @@ void strbuf_addf(struct strbuf *sb, const char *fmt, ...)
         if (!strbuf_avail(sb))
                 strbuf_grow(sb, 64);
         va_start(ap, fmt);
-        len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
+        len = vscnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
         va_end(ap);
         if (len < 0)
-                die("your vsnprintf is broken");
+                die("your vscnprintf is broken");
         if (len > strbuf_avail(sb)) {
                 strbuf_grow(sb, len);
                 va_start(ap, fmt);
-                len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
+                len = vscnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
                 va_end(ap);
                 if (len > strbuf_avail(sb)) {
                         die("this should not happen, your snprintf is broken");
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 0975438c3e72..5dd83c3e2c0c 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1,4 +1,3 @@
-#include <ctype.h>
 #include <dirent.h>
 #include <errno.h>
 #include <libgen.h>
@@ -12,6 +11,7 @@
 #include <unistd.h>
 #include <inttypes.h>
 #include "build-id.h"
+#include "util.h"
 #include "debug.h"
 #include "symbol.h"
 #include "strlist.h"
@@ -263,6 +263,28 @@ static size_t symbol__fprintf(struct symbol *sym, FILE *fp)
                        sym->name);
 }
 
+size_t symbol__fprintf_symname_offs(const struct symbol *sym,
+                                    const struct addr_location *al, FILE *fp)
+{
+        unsigned long offset;
+        size_t length;
+
+        if (sym && sym->name) {
+                length = fprintf(fp, "%s", sym->name);
+                if (al) {
+                        offset = al->addr - sym->start;
+                        length += fprintf(fp, "+0x%lx", offset);
+                }
+                return length;
+        } else
+                return fprintf(fp, "[unknown]");
+}
+
+size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp)
+{
+        return symbol__fprintf_symname_offs(sym, NULL, fp);
+}
+
 void dso__set_long_name(struct dso *dso, char *name)
 {
         if (name == NULL)
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 123c2e14353e..ac49ef208a5f 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -5,6 +5,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "map.h"
+#include "../perf.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
 #include <stdio.h>
@@ -70,6 +71,7 @@ struct symbol_conf {
         unsigned short  priv_size;
         unsigned short  nr_events;
         bool            try_vmlinux_path,
+                        show_kernel_path,
                         use_modules,
                         sort_by_name,
                         show_nr_samples,
@@ -95,7 +97,11 @@ struct symbol_conf {
                         *col_width_list_str;
        struct strlist   *dso_list,
                         *comm_list,
-                        *sym_list;
+                        *sym_list,
+                        *dso_from_list,
+                        *dso_to_list,
+                        *sym_from_list,
+                        *sym_to_list;
         const char      *symfs;
 };
 
@@ -119,6 +125,19 @@ struct map_symbol {
         bool          has_children;
 };
 
+struct addr_map_symbol {
+        struct map    *map;
+        struct symbol *sym;
+        u64           addr;
+        u64           al_addr;
+};
+
+struct branch_info {
+        struct addr_map_symbol from;
+        struct addr_map_symbol to;
+        struct branch_flags flags;
+};
+
 struct addr_location {
         struct thread *thread;
         struct map    *map;
@@ -241,6 +260,9 @@ void machines__destroy_guest_kernel_maps(struct rb_root *machines);
 
 int symbol__init(void);
 void symbol__exit(void);
+size_t symbol__fprintf_symname_offs(const struct symbol *sym,
+                                    const struct addr_location *al, FILE *fp);
+size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 
 size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp);
diff --git a/tools/perf/util/sysfs.c b/tools/perf/util/sysfs.c
new file mode 100644
index 000000000000..48c6902e749f
--- /dev/null
+++ b/tools/perf/util/sysfs.c
@@ -0,0 +1,60 @@
+
+#include "util.h"
+#include "sysfs.h"
+
+static const char * const sysfs_known_mountpoints[] = {
+        "/sys",
+        0,
+};
+
+static int sysfs_found;
+char sysfs_mountpoint[PATH_MAX];
+
+static int sysfs_valid_mountpoint(const char *sysfs)
+{
+        struct statfs st_fs;
+
+        if (statfs(sysfs, &st_fs) < 0)
+                return -ENOENT;
+        else if (st_fs.f_type != (long) SYSFS_MAGIC)
+                return -ENOENT;
+
+        return 0;
+}
+
+const char *sysfs_find_mountpoint(void)
+{
+        const char * const *ptr;
+        char type[100];
+        FILE *fp;
+
+        if (sysfs_found)
+                return (const char *) sysfs_mountpoint;
+
+        ptr = sysfs_known_mountpoints;
+        while (*ptr) {
+                if (sysfs_valid_mountpoint(*ptr) == 0) {
+                        sysfs_found = 1;
+                        strcpy(sysfs_mountpoint, *ptr);
+                        return sysfs_mountpoint;
+                }
+                ptr++;
+        }
+
+        /* give up and parse /proc/mounts */
+        fp = fopen("/proc/mounts", "r");
+        if (fp == NULL)
+                return NULL;
+
+        while (!sysfs_found &&
+               fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
+                      sysfs_mountpoint, type) == 2) {
+
+                if (strcmp(type, "sysfs") == 0)
+                        sysfs_found = 1;
+        }
+
+        fclose(fp);
+
+        return sysfs_found ? sysfs_mountpoint : NULL;
+}
diff --git a/tools/perf/util/sysfs.h b/tools/perf/util/sysfs.h
new file mode 100644
index 000000000000..a813b7203938
--- /dev/null
+++ b/tools/perf/util/sysfs.h
@@ -0,0 +1,6 @@
+#ifndef __SYSFS_H__
+#define __SYSFS_H__
+
+const char *sysfs_find_mountpoint(void);
+
+#endif /* __DEBUGFS_H__ */
diff --git a/tools/perf/util/thread_map.c b/tools/perf/util/thread_map.c
index a5df131b77c3..84d9bd782004 100644
--- a/tools/perf/util/thread_map.c
+++ b/tools/perf/util/thread_map.c
@@ -1,6 +1,13 @@
 #include <dirent.h>
+#include <limits.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "strlist.h"
+#include <string.h>
 #include "thread_map.h"
 
 /* Skip "." and ".." directories */
@@ -23,7 +30,7 @@ struct thread_map *thread_map__new_by_pid(pid_t pid)
         sprintf(name, "/proc/%d/task", pid);
         items = scandir(name, &namelist, filter, NULL);
         if (items <= 0)
-                return NULL;
+                return NULL;
 
         threads = malloc(sizeof(*threads) + sizeof(pid_t) * items);
         if (threads != NULL) {
@@ -51,14 +58,240 @@ struct thread_map *thread_map__new_by_tid(pid_t tid)
         return threads;
 }
 
-struct thread_map *thread_map__new(pid_t pid, pid_t tid)
+struct thread_map *thread_map__new_by_uid(uid_t uid)
+{
+        DIR *proc;
+        int max_threads = 32, items, i;
+        char path[256];
+        struct dirent dirent, *next, **namelist = NULL;
+        struct thread_map *threads = malloc(sizeof(*threads) +
+                                            max_threads * sizeof(pid_t));
+        if (threads == NULL)
+                goto out;
+
+        proc = opendir("/proc");
+        if (proc == NULL)
+                goto out_free_threads;
+
+        threads->nr = 0;
+
+        while (!readdir_r(proc, &dirent, &next) && next) {
+                char *end;
+                bool grow = false;
+                struct stat st;
+                pid_t pid = strtol(dirent.d_name, &end, 10);
+
+                if (*end) /* only interested in proper numerical dirents */
+                        continue;
+
+                snprintf(path, sizeof(path), "/proc/%s", dirent.d_name);
+
+                if (stat(path, &st) != 0)
+                        continue;
+
+                if (st.st_uid != uid)
+                        continue;
+
+                snprintf(path, sizeof(path), "/proc/%d/task", pid);
+                items = scandir(path, &namelist, filter, NULL);
+                if (items <= 0)
+                        goto out_free_closedir;
+
+                while (threads->nr + items >= max_threads) {
+                        max_threads *= 2;
+                        grow = true;
+                }
+
+                if (grow) {
+                        struct thread_map *tmp;
+
+                        tmp = realloc(threads, (sizeof(*threads) +
+                                                max_threads * sizeof(pid_t)));
+                        if (tmp == NULL)
+                                goto out_free_namelist;
+
+                        threads = tmp;
+                }
+
+                for (i = 0; i < items; i++)
+                        threads->map[threads->nr + i] = atoi(namelist[i]->d_name);
+
+                for (i = 0; i < items; i++)
+                        free(namelist[i]);
+                free(namelist);
+
+                threads->nr += items;
+        }
+
+out_closedir:
+        closedir(proc);
+out:
+        return threads;
+
+out_free_threads:
+        free(threads);
+        return NULL;
+
+out_free_namelist:
+        for (i = 0; i < items; i++)
+                free(namelist[i]);
+        free(namelist);
+
+out_free_closedir:
+        free(threads);
+        threads = NULL;
+        goto out_closedir;
+}
+
+struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid)
 {
         if (pid != -1)
                 return thread_map__new_by_pid(pid);
+
+        if (tid == -1 && uid != UINT_MAX)
+                return thread_map__new_by_uid(uid);
+
         return thread_map__new_by_tid(tid);
 }
 
+static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
+{
+        struct thread_map *threads = NULL, *nt;
+        char name[256];
+        int items, total_tasks = 0;
+        struct dirent **namelist = NULL;
+        int i, j = 0;
+        pid_t pid, prev_pid = INT_MAX;
+        char *end_ptr;
+        struct str_node *pos;
+        struct strlist *slist = strlist__new(false, pid_str);
+
+        if (!slist)
+                return NULL;
+
+        strlist__for_each(pos, slist) {
+                pid = strtol(pos->s, &end_ptr, 10);
+
+                if (pid == INT_MIN || pid == INT_MAX ||
+                    (*end_ptr != '\0' && *end_ptr != ','))
+                        goto out_free_threads;
+
+                if (pid == prev_pid)
+                        continue;
+
+                sprintf(name, "/proc/%d/task", pid);
+                items = scandir(name, &namelist, filter, NULL);
+                if (items <= 0)
+                        goto out_free_threads;
+
+                total_tasks += items;
+                nt = realloc(threads, (sizeof(*threads) +
+                                       sizeof(pid_t) * total_tasks));
+                if (nt == NULL)
+                        goto out_free_threads;
+
+                threads = nt;
+
+                if (threads) {
+                        for (i = 0; i < items; i++)
+                                threads->map[j++] = atoi(namelist[i]->d_name);
+                        threads->nr = total_tasks;
+                }
+
+                for (i = 0; i < items; i++)
+                        free(namelist[i]);
+                free(namelist);
+
+                if (!threads)
+                        break;
+        }
+
+out:
+        strlist__delete(slist);
+        return threads;
+
+out_free_threads:
+        free(threads);
+        threads = NULL;
+        goto out;
+}
+
+static struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
+{
+        struct thread_map *threads = NULL, *nt;
+        int ntasks = 0;
+        pid_t tid, prev_tid = INT_MAX;
+        char *end_ptr;
+        struct str_node *pos;
+        struct strlist *slist;
+
+        /* perf-stat expects threads to be generated even if tid not given */
+        if (!tid_str) {
+                threads = malloc(sizeof(*threads) + sizeof(pid_t));
+                if (threads != NULL) {
+                        threads->map[0] = -1;
+                        threads->nr     = 1;
+                }
+                return threads;
+        }
+
+        slist = strlist__new(false, tid_str);
+        if (!slist)
+                return NULL;
+
+        strlist__for_each(pos, slist) {
+                tid = strtol(pos->s, &end_ptr, 10);
+
+                if (tid == INT_MIN || tid == INT_MAX ||
+                    (*end_ptr != '\0' && *end_ptr != ','))
+                        goto out_free_threads;
+
+                if (tid == prev_tid)
+                        continue;
+
+                ntasks++;
+                nt = realloc(threads, sizeof(*threads) + sizeof(pid_t) * ntasks);
+
+                if (nt == NULL)
+                        goto out_free_threads;
+
+                threads = nt;
+                threads->map[ntasks - 1] = tid;
+                threads->nr              = ntasks;
+        }
+out:
+        return threads;
+
+out_free_threads:
+        free(threads);
+        threads = NULL;
+        goto out;
+}
+
+struct thread_map *thread_map__new_str(const char *pid, const char *tid,
+                                       uid_t uid)
+{
+        if (pid)
+                return thread_map__new_by_pid_str(pid);
+
+        if (!tid && uid != UINT_MAX)
+                return thread_map__new_by_uid(uid);
+
+        return thread_map__new_by_tid_str(tid);
+}
+
 void thread_map__delete(struct thread_map *threads)
 {
         free(threads);
 }
+
+size_t thread_map__fprintf(struct thread_map *threads, FILE *fp)
+{
+        int i;
+        size_t printed = fprintf(fp, "%d thread%s: ",
+                                 threads->nr, threads->nr > 1 ? "s" : "");
+        for (i = 0; i < threads->nr; ++i)
+                printed += fprintf(fp, "%s%d", i ? ", " : "", threads->map[i]);
+
+        return printed + fprintf(fp, "\n");
+}
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index 3cb907311409..7da80f14418b 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -2,6 +2,7 @@
 #define __PERF_THREAD_MAP_H
 
 #include <sys/types.h>
+#include <stdio.h>
 
 struct thread_map {
         int nr;
@@ -10,6 +11,14 @@ struct thread_map {
 
 struct thread_map *thread_map__new_by_pid(pid_t pid);
 struct thread_map *thread_map__new_by_tid(pid_t tid);
-struct thread_map *thread_map__new(pid_t pid, pid_t tid);
+struct thread_map *thread_map__new_by_uid(uid_t uid);
+struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid);
+
+struct thread_map *thread_map__new_str(const char *pid,
+                const char *tid, uid_t uid);
+
 void thread_map__delete(struct thread_map *threads);
+
+size_t thread_map__fprintf(struct thread_map *threads, FILE *fp);
+
 #endif  /* __PERF_THREAD_MAP_H */
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 500471dffa4f..09fe579ccafb 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -69,12 +69,15 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
 
         ret += SNPRINTF(bf + ret, size - ret, "], ");
 
-        if (top->target_pid != -1)
-                ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %d",
+        if (top->target_pid)
+                ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %s",
                                 top->target_pid);
-        else if (top->target_tid != -1)
-                ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %d",
+        else if (top->target_tid)
+                ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %s",
                                 top->target_tid);
+        else if (top->uid_str != NULL)
+                ret += SNPRINTF(bf + ret, size - ret, " (uid: %s",
+                                top->uid_str);
         else
                 ret += SNPRINTF(bf + ret, size - ret, " (all");
 
@@ -82,7 +85,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
                 ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)",
                                 top->evlist->cpus->nr > 1 ? "s" : "", top->cpu_list);
         else {
-                if (top->target_tid != -1)
+                if (top->target_tid)
                         ret += SNPRINTF(bf + ret, size - ret, ")");
                 else
                         ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)",
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index f2eab81435ae..ce61cb2d1acf 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -23,7 +23,8 @@ struct perf_top {
         u64                guest_us_samples, guest_kernel_samples;
         int                print_entries, count_filter, delay_secs;
         int                freq;
-        pid_t              target_pid, target_tid;
+        const char         *target_pid, *target_tid;
+        uid_t              uid;
         bool               hide_kernel_symbols, hide_user_symbols, zero;
         bool               system_wide;
         bool               use_tui, use_stdio;
@@ -33,7 +34,7 @@ struct perf_top {
         bool               vmlinux_warned;
         bool               inherit;
         bool               group;
-        bool               sample_id_all_avail;
+        bool               sample_id_all_missing;
         bool               exclude_guest_missing;
         bool               dump_symtab;
         const char         *cpu_list;
@@ -46,6 +47,7 @@ struct perf_top {
         int                realtime_prio;
         int                sym_pcnt_filter;
         const char         *sym_filter;
+        const char         *uid_str;
 };
 
 size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size);
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 1a8d4dc4f386..a4088ced1e64 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -25,7 +25,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <errno.h>
 
 #include "../perf.h"
@@ -1424,6 +1423,11 @@ static long long arg_num_eval(struct print_arg *arg)
                                 die("unknown op '%s'", arg->op.op);
                         }
                         break;
+                case '+':
+                        left = arg_num_eval(arg->op.left);
+                        right = arg_num_eval(arg->op.right);
+                        val = left + right;
+                        break;
                 default:
                         die("unknown op '%s'", arg->op.op);
                 }
@@ -1484,6 +1488,13 @@ process_fields(struct event *event, struct print_flag_sym **list, char **tok)
 
                 free_token(token);
                 type = process_arg(event, arg, &token);
+
+                if (type == EVENT_OP)
+                        type = process_op(event, arg, &token);
+
+                if (type == EVENT_ERROR)
+                        goto out_free;
+
                 if (test_type_token(type, token, EVENT_DELIM, ","))
                         goto out_free;
 
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index f55cc3a765a1..b9592e0de8d7 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -33,7 +33,6 @@
 #include <pthread.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <ctype.h>
 #include <errno.h>
 
 #include "../perf.h"
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index a3fdf55f317b..18ae6c1831d3 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -22,7 +22,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
 #include <errno.h>
 
 #include "../perf.h"
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
index 295a9c93f945..57a4c6ef3fd2 100644
--- a/tools/perf/util/ui/browsers/annotate.c
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -69,14 +69,17 @@ static void annotate_browser__write(struct ui_browser *self, void *entry, int ro
         if (!self->navkeypressed)
                 width += 1;
 
+        if (!ab->hide_src_code && ol->offset != -1)
+                if (!current_entry || (self->use_navkeypressed &&
+                                       !self->navkeypressed))
+                        ui_browser__set_color(self, HE_COLORSET_CODE);
+
         if (!*ol->line)
                 slsmg_write_nstring(" ", width - 18);
         else
                 slsmg_write_nstring(ol->line, width - 18);
 
-        if (!current_entry)
-                ui_browser__set_color(self, HE_COLORSET_CODE);
-        else
+        if (current_entry)
                 ab->selection = ol;
 }
 
@@ -230,9 +233,9 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
         struct rb_node *nd = NULL;
         struct map_symbol *ms = self->b.priv;
         struct symbol *sym = ms->sym;
-        const char *help = "<-, ESC: exit, TAB/shift+TAB: cycle hottest lines, "
-                           "H: Hottest, -> Line action, S -> Toggle source "
-                           "code view";
+        const char *help = "<-/ESC: Exit, TAB/shift+TAB: Cycle hot lines, "
+                           "H: Go to hottest line, ->/ENTER: Line action, "
+                           "S: Toggle source code view";
         int key;
 
         if (ui_browser__show(&self->b, sym->name, help) < 0)
@@ -284,9 +287,11 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                                 nd = self->curr_hot;
                         break;
                 case 'H':
+                case 'h':
                         nd = self->curr_hot;
                         break;
                 case 'S':
+                case 's':
                         if (annotate_browser__toggle_source(self))
                                 ui_helpline__puts(help);
                         continue;
@@ -338,6 +343,7 @@ static int annotate_browser__run(struct annotate_browser *self, int evidx,
                                 pthread_mutex_unlock(&notes->lock);
                                 symbol__tui_annotate(target, ms->map, evidx,
                                                      timer, arg, delay_secs);
+                                ui_browser__show_title(&self->b, sym->name);
                         }
                         continue;
                 case K_LEFT:
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
index e81aef1f2569..fa530fcc764a 100644
--- a/tools/perf/util/ui/browsers/hists.c
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -805,8 +805,11 @@ static struct hist_browser *hist_browser__new(struct hists *hists)
                 self->hists = hists;
                 self->b.refresh = hist_browser__refresh;
                 self->b.seek = ui_browser__hists_seek;
-                self->b.use_navkeypressed = true,
-                self->has_symbols = sort_sym.list.next != NULL;
+                self->b.use_navkeypressed = true;
+                if (sort__branch_mode == 1)
+                        self->has_symbols = sort_sym_from.list.next != NULL;
+                else
+                        self->has_symbols = sort_sym.list.next != NULL;
         }
 
         return self;
@@ -837,19 +840,32 @@ static int hists__browser_title(struct hists *self, char *bf, size_t size,
         unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 
         nr_events = convert_unit(nr_events, &unit);
-        printed = snprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
+        printed = scnprintf(bf, size, "Events: %lu%c %s", nr_events, unit, ev_name);
 
-        if (thread)
+        if (self->uid_filter_str)
                 printed += snprintf(bf + printed, size - printed,
+                                    ", UID: %s", self->uid_filter_str);
+        if (thread)
+                printed += scnprintf(bf + printed, size - printed,
                                     ", Thread: %s(%d)",
                                     (thread->comm_set ? thread->comm : ""),
                                     thread->pid);
         if (dso)
-                printed += snprintf(bf + printed, size - printed,
+                printed += scnprintf(bf + printed, size - printed,
                                     ", DSO: %s", dso->short_name);
         return printed;
 }
 
+static inline void free_popup_options(char **options, int n)
+{
+        int i;
+
+        for (i = 0; i < n; ++i) {
+                free(options[i]);
+                options[i] = NULL;
+        }
+}
+
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                     const char *helpline, const char *ev_name,
                                     bool left_exits,
@@ -858,7 +874,10 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 {
         struct hists *self = &evsel->hists;
         struct hist_browser *browser = hist_browser__new(self);
+        struct branch_info *bi;
         struct pstack *fstack;
+        char *options[16];
+        int nr_options = 0;
         int key = -1;
 
         if (browser == NULL)
@@ -870,13 +889,16 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
 
         ui_helpline__push(helpline);
 
+        memset(options, 0, sizeof(options));
+
         while (1) {
                 const struct thread *thread = NULL;
                 const struct dso *dso = NULL;
-                char *options[16];
-                int nr_options = 0, choice = 0, i,
+                int choice = 0,
                     annotate = -2, zoom_dso = -2, zoom_thread = -2,
-                    browse_map = -2;
+                    annotate_f = -2, annotate_t = -2, browse_map = -2;
+
+                nr_options = 0;
 
                 key = hist_browser__run(browser, ev_name, timer, arg, delay_secs);
 
@@ -884,7 +906,6 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         thread = hist_browser__selected_thread(browser);
                         dso = browser->selection->map ? browser->selection->map->dso : NULL;
                 }
-
                 switch (key) {
                 case K_TAB:
                 case K_UNTAB:
@@ -899,7 +920,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         if (!browser->has_symbols) {
                                 ui_browser__warning(&browser->b, delay_secs * 2,
                         "Annotation is only available for symbolic views, "
-                        "include \"sym\" in --sort to use it.");
+                        "include \"sym*\" in --sort to use it.");
                                 continue;
                         }
 
@@ -969,12 +990,34 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                 if (!browser->has_symbols)
                         goto add_exit_option;
 
-                if (browser->selection != NULL &&
-                    browser->selection->sym != NULL &&
-                    !browser->selection->map->dso->annotate_warned &&
-                    asprintf(&options[nr_options], "Annotate %s",
-                             browser->selection->sym->name) > 0)
-                        annotate = nr_options++;
+                if (sort__branch_mode == 1) {
+                        bi = browser->he_selection->branch_info;
+                        if (browser->selection != NULL &&
+                            bi &&
+                            bi->from.sym != NULL &&
+                            !bi->from.map->dso->annotate_warned &&
+                                asprintf(&options[nr_options], "Annotate %s",
+                                         bi->from.sym->name) > 0)
+                                annotate_f = nr_options++;
+
+                        if (browser->selection != NULL &&
+                            bi &&
+                            bi->to.sym != NULL &&
+                            !bi->to.map->dso->annotate_warned &&
+                            (bi->to.sym != bi->from.sym ||
+                             bi->to.map->dso != bi->from.map->dso) &&
+                                asprintf(&options[nr_options], "Annotate %s",
+                                         bi->to.sym->name) > 0)
+                                annotate_t = nr_options++;
+                } else {
+
+                        if (browser->selection != NULL &&
+                            browser->selection->sym != NULL &&
+                            !browser->selection->map->dso->annotate_warned &&
+                                asprintf(&options[nr_options], "Annotate %s",
+                                         browser->selection->sym->name) > 0)
+                                annotate = nr_options++;
+                }
 
                 if (thread != NULL &&
                     asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
@@ -995,25 +1038,39 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         browse_map = nr_options++;
 add_exit_option:
                 options[nr_options++] = (char *)"Exit";
-
+retry_popup_menu:
                 choice = ui__popup_menu(nr_options, options);
 
-                for (i = 0; i < nr_options - 1; ++i)
-                        free(options[i]);
-
                 if (choice == nr_options - 1)
                         break;
 
-                if (choice == -1)
+                if (choice == -1) {
+                        free_popup_options(options, nr_options - 1);
                         continue;
+                }
 
-                if (choice == annotate) {
+                if (choice == annotate || choice == annotate_t || choice == annotate_f) {
                         struct hist_entry *he;
                         int err;
 do_annotate:
                         he = hist_browser__selected_entry(browser);
                         if (he == NULL)
                                 continue;
+
+                        /*
+                         * we stash the branch_info symbol + map into the
+                         * the ms so we don't have to rewrite all the annotation
+                         * code to use branch_info.
+                         * in branch mode, the ms struct is not used
+                         */
+                        if (choice == annotate_f) {
+                                he->ms.sym = he->branch_info->from.sym;
+                                he->ms.map = he->branch_info->from.map;
+                        }  else if (choice == annotate_t) {
+                                he->ms.sym = he->branch_info->to.sym;
+                                he->ms.map = he->branch_info->to.map;
+                        }
+
                         /*
                          * Don't let this be freed, say, by hists__decay_entry.
                          */
@@ -1021,9 +1078,18 @@ do_annotate:
                         err = hist_entry__tui_annotate(he, evsel->idx,
                                                        timer, arg, delay_secs);
                         he->used = false;
+                        /*
+                         * offer option to annotate the other branch source or target
+                         * (if they exists) when returning from annotate
+                         */
+                        if ((err == 'q' || err == CTRL('c'))
+                            && annotate_t != -2 && annotate_f != -2)
+                                goto retry_popup_menu;
+
                         ui_browser__update_nr_entries(&browser->b, browser->hists->nr_entries);
                         if (err)
                                 ui_browser__handle_resize(&browser->b);
+
                 } else if (choice == browse_map)
                         map__browse(browser->selection->map);
                 else if (choice == zoom_dso) {
@@ -1069,6 +1135,7 @@ out_free_stack:
         pstack__delete(fstack);
 out:
         hist_browser__delete(browser);
+        free_popup_options(options, nr_options - 1);
         return key;
 }
 
@@ -1095,7 +1162,7 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
                                                        HE_COLORSET_NORMAL);
 
         nr_events = convert_unit(nr_events, &unit);
-        printed = snprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
+        printed = scnprintf(bf, sizeof(bf), "%lu%c%s%s", nr_events,
                            unit, unit == ' ' ? "" : " ", ev_name);
         slsmg_printf("%s", bf);
 
@@ -1105,8 +1172,8 @@ static void perf_evsel_menu__write(struct ui_browser *browser,
                 if (!current_entry)
                         ui_browser__set_color(browser, HE_COLORSET_TOP);
                 nr_events = convert_unit(nr_events, &unit);
-                snprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!", nr_events,
-                         unit, unit == ' ' ? "" : " ");
+                printed += scnprintf(bf, sizeof(bf), ": %ld%c%schunks LOST!",
+                                     nr_events, unit, unit == ' ' ? "" : " ");
                 warn = bf;
         }
 
diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/util/ui/browsers/map.c
index 6905bcc8be2d..eca6575abfd0 100644
--- a/tools/perf/util/ui/browsers/map.c
+++ b/tools/perf/util/ui/browsers/map.c
@@ -3,9 +3,9 @@
 #include <newt.h>
 #include <inttypes.h>
 #include <sys/ttydefaults.h>
-#include <ctype.h>
 #include <string.h>
 #include <linux/bitops.h>
+#include "../../util.h"
 #include "../../debug.h"
 #include "../../symbol.h"
 #include "../browser.h"
diff --git a/tools/perf/util/ui/helpline.c b/tools/perf/util/ui/helpline.c
index 4f48f5901b30..2f950c2641c8 100644
--- a/tools/perf/util/ui/helpline.c
+++ b/tools/perf/util/ui/helpline.c
@@ -64,7 +64,7 @@ int ui_helpline__show_help(const char *format, va_list ap)
         static int backlog;
 
         pthread_mutex_lock(&ui__lock);
-        ret = vsnprintf(ui_helpline__last_msg + backlog,
+        ret = vscnprintf(ui_helpline__last_msg + backlog,
                         sizeof(ui_helpline__last_msg) - backlog, format, ap);
         backlog += ret;
 
diff --git a/tools/perf/util/usage.c b/tools/perf/util/usage.c
index d76d1c0ff98f..52bb07c6442a 100644
--- a/tools/perf/util/usage.c
+++ b/tools/perf/util/usage.c
@@ -7,6 +7,7 @@
  * Copyright (C) Linus Torvalds, 2005
  */
 #include "util.h"
+#include "debug.h"
 
 static void report(const char *prefix, const char *err, va_list params)
 {
@@ -81,3 +82,41 @@ void warning(const char *warn, ...)
         warn_routine(warn, params);
         va_end(params);
 }
+
+uid_t parse_target_uid(const char *str, const char *tid, const char *pid)
+{
+        struct passwd pwd, *result;
+        char buf[1024];
+
+        if (str == NULL)
+                return UINT_MAX;
+
+        /* UID and PID are mutually exclusive */
+        if (tid || pid) {
+                ui__warning("PID/TID switch overriding UID\n");
+                sleep(1);
+                return UINT_MAX;
+        }
+
+        getpwnam_r(str, &pwd, buf, sizeof(buf), &result);
+
+        if (result == NULL) {
+                char *endptr;
+                int uid = strtol(str, &endptr, 10);
+
+                if (*endptr != '\0') {
+                        ui__error("Invalid user %s\n", str);
+                        return UINT_MAX - 1;
+                }
+
+                getpwuid_r(uid, &pwd, buf, sizeof(buf), &result);
+
+                if (result == NULL) {
+                        ui__error("Problems obtaining information for user %s\n",
+                                  str);
+                        return UINT_MAX - 1;
+                }
+        }
+
+        return result->pw_uid;
+}
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index fb25d1329218..8109a907841e 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -14,6 +14,8 @@ void event_attr_init(struct perf_event_attr *attr)
                 attr->exclude_host  = 1;
         if (!perf_guest)
                 attr->exclude_guest = 1;
+        /* to capture ABI version */
+        attr->size = sizeof(*attr);
 }
 
 int mkdir_p(char *path, mode_t mode)
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index ecf9898169c8..0f99f394d8e0 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -199,6 +199,8 @@ static inline int has_extension(const char *filename, const char *ext)
 #undef isalpha
 #undef isprint
 #undef isalnum
+#undef islower
+#undef isupper
 #undef tolower
 #undef toupper
 
@@ -219,6 +221,8 @@ extern unsigned char sane_ctype[256];
 #define isalpha(x) sane_istest(x,GIT_ALPHA)
 #define isalnum(x) sane_istest(x,GIT_ALPHA | GIT_DIGIT)
 #define isprint(x) sane_istest(x,GIT_PRINT)
+#define islower(x) (sane_istest(x,GIT_ALPHA) && sane_istest(x,0x20))
+#define isupper(x) (sane_istest(x,GIT_ALPHA) && !sane_istest(x,0x20))
 #define tolower(x) sane_case((unsigned char)(x), 0x20)
 #define toupper(x) sane_case((unsigned char)(x), 0)
 
@@ -245,6 +249,8 @@ struct perf_event_attr;
 
 void event_attr_init(struct perf_event_attr *attr);
 
+uid_t parse_target_uid(const char *str, const char *tid, const char *pid);
+
 #define _STR(x) #x
 #define STR(x) _STR(x)
 
diff --git a/tools/testing/ktest/ktest.pl b/tools/testing/ktest/ktest.pl
index 9507c4b251a8..758ec2a08c40 100755
--- a/tools/testing/ktest/ktest.pl
+++ b/tools/testing/ktest/ktest.pl
@@ -2601,7 +2601,7 @@ sub config_bisect {
     # read directly what we want to check
     my %config_check;
     open (IN, $output_config)
-        or dodie "faied to open $output_config";
+        or dodie "failed to open $output_config";
 
     while (<IN>) {
         if (/^((CONFIG\S*)=.*)/) {
diff --git a/tools/usb/ffs-test.c b/tools/usb/ffs-test.c
index b9c798631699..53452c35d5e1 100644
--- a/tools/usb/ffs-test.c
+++ b/tools/usb/ffs-test.c
@@ -2,7 +2,7 @@
  * ffs-test.c.c -- user mode filesystem api for usb composite function
  *
  * Copyright (C) 2010 Samsung Electronics
- *                    Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ *                    Author: Michal Nazarewicz <mina86@mina86.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
diff --git a/tools/usb/testusb.c b/tools/usb/testusb.c
index f08e89463842..6e0f56701e44 100644
--- a/tools/usb/testusb.c
+++ b/tools/usb/testusb.c
@@ -3,7 +3,7 @@
 /*
  * Copyright (c) 2002 by David Brownell
  * Copyright (c) 2010 by Samsung Electronics
- * Author: Michal Nazarewicz <m.nazarewicz@samsung.com>
+ * Author: Michal Nazarewicz <mina86@mina86.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 the