1 files changed, 115 insertions, 1 deletions

diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index ec1dec86d0e1..2310a1752983 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -29,6 +29,61 @@
 #include "stat.h"
 #include "arch/common.h"
 
+#ifdef HAVE_ZSTD_SUPPORT
+static int perf_session__process_compressed_event(struct perf_session *session,
+                                                  union perf_event *event, u64 file_offset)
+{
+        void *src;
+        size_t decomp_size, src_size;
+        u64 decomp_last_rem = 0;
+        size_t decomp_len = session->header.env.comp_mmap_len;
+        struct decomp *decomp, *decomp_last = session->decomp_last;
+
+        decomp = mmap(NULL, sizeof(struct decomp) + decomp_len, PROT_READ|PROT_WRITE,
+                      MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+        if (decomp == MAP_FAILED) {
+                pr_err("Couldn't allocate memory for decompression\n");
+                return -1;
+        }
+
+        decomp->file_pos = file_offset;
+        decomp->head = 0;
+
+        if (decomp_last) {
+                decomp_last_rem = decomp_last->size - decomp_last->head;
+                memcpy(decomp->data, &(decomp_last->data[decomp_last->head]), decomp_last_rem);
+                decomp->size = decomp_last_rem;
+        }
+
+        src = (void *)event + sizeof(struct compressed_event);
+        src_size = event->pack.header.size - sizeof(struct compressed_event);
+
+        decomp_size = zstd_decompress_stream(&(session->zstd_data), src, src_size,
+                                &(decomp->data[decomp_last_rem]), decomp_len - decomp_last_rem);
+        if (!decomp_size) {
+                munmap(decomp, sizeof(struct decomp) + decomp_len);
+                pr_err("Couldn't decompress data\n");
+                return -1;
+        }
+
+        decomp->size += decomp_size;
+
+        if (session->decomp == NULL) {
+                session->decomp = decomp;
+                session->decomp_last = decomp;
+        } else {
+                session->decomp_last->next = decomp;
+                session->decomp_last = decomp;
+        }
+
+        pr_debug("decomp (B): %ld to %ld\n", src_size, decomp_size);
+
+        return 0;
+}
+#else /* !HAVE_ZSTD_SUPPORT */
+#define perf_session__process_compressed_event perf_session__process_compressed_event_stub
+#endif
+
 static int perf_session__deliver_event(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_tool *tool,
@@ -197,6 +252,21 @@ static void perf_session__delete_threads(struct perf_session *session)
         machine__delete_threads(&session->machines.host);
 }
 
+static void perf_session__release_decomp_events(struct perf_session *session)
+{
+        struct decomp *next, *decomp;
+        size_t decomp_len;
+        next = session->decomp;
+        decomp_len = session->header.env.comp_mmap_len;
+        do {
+                decomp = next;
+                if (decomp == NULL)
+                        break;
+                next = decomp->next;
+                munmap(decomp, decomp_len + sizeof(struct decomp));
+        } while (1);
+}
+
 void perf_session__delete(struct perf_session *session)
 {
         if (session == NULL)
@@ -205,6 +275,7 @@ void perf_session__delete(struct perf_session *session)
         auxtrace_index__free(&session->auxtrace_index);
         perf_session__destroy_kernel_maps(session);
         perf_session__delete_threads(session);
+        perf_session__release_decomp_events(session);
         perf_env__exit(&session->header.env);
         machines__exit(&session->machines);
         if (session->data)
@@ -439,7 +510,7 @@ void perf_tool__fill_defaults(struct perf_tool *tool)
         if (tool->feature == NULL)
                 tool->feature = process_event_op2_stub;
         if (tool->compressed == NULL)
-                tool->compressed = perf_session__process_compressed_event_stub;
+                tool->compressed = perf_session__process_compressed_event;
 }
 
 static void swap_sample_id_all(union perf_event *event, void *data)
@@ -1725,6 +1796,8 @@ static int perf_session__flush_thread_stacks(struct perf_session *session)
 
 volatile int session_done;
 
+static int __perf_session__process_decomp_events(struct perf_session *session);
+
 static int __perf_session__process_pipe_events(struct perf_session *session)
 {
         struct ordered_events *oe = &session->ordered_events;
@@ -1805,6 +1878,10 @@ more:
         if (skip > 0)
                 head += skip;
 
+        err = __perf_session__process_decomp_events(session);
+        if (err)
+                goto out_err;
+
         if (!session_done())
                 goto more;
 done:
@@ -1853,6 +1930,39 @@ fetch_mmaped_event(struct perf_session *session,
         return event;
 }
 
+static int __perf_session__process_decomp_events(struct perf_session *session)
+{
+        s64 skip;
+        u64 size, file_pos = 0;
+        struct decomp *decomp = session->decomp_last;
+
+        if (!decomp)
+                return 0;
+
+        while (decomp->head < decomp->size && !session_done()) {
+                union perf_event *event = fetch_mmaped_event(session, decomp->head, decomp->size, decomp->data);
+
+                if (!event)
+                        break;
+
+                size = event->header.size;
+
+                if (size < sizeof(struct perf_event_header) ||
+                    (skip = perf_session__process_event(session, event, file_pos)) < 0) {
+                        pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
+                                decomp->file_pos + decomp->head, event->header.size, event->header.type);
+                        return -EINVAL;
+                }
+
+                if (skip)
+                        size += skip;
+
+                decomp->head += size;
+        }
+
+        return 0;
+}
+
 /*
  * On 64bit we can mmap the data file in one go. No need for tiny mmap
  * slices. On 32bit we use 32MB.
@@ -1962,6 +2072,10 @@ more:
         head += size;
         file_pos += size;
 
+        err = __perf_session__process_decomp_events(session);
+        if (err)
+                goto out;
+
         ui_progress__update(prog, size);
 
         if (session_done())