.comm   = perf_event__process_comm,
                        .exit   = perf_event__process_exit,
                        .fork   = perf_event__process_fork,
-                       .ordered_samples = true,
+                       .ordered_events = true,
                        .ordering_requires_timestamps = true,
                },
        };
 
        .exit   = perf_event__process_exit,
        .fork   = perf_event__process_fork,
        .lost   = perf_event__process_lost,
-       .ordered_samples = true,
+       .ordered_events = true,
        .ordering_requires_timestamps = true,
 };
 
 
        } else if (inject->sched_stat) {
                struct perf_evsel *evsel;
 
-               inject->tool.ordered_samples = true;
+               inject->tool.ordered_events = true;
 
                evlist__for_each(session->evlist, evsel) {
                        const char *name = perf_evsel__name(evsel);
 
 static struct perf_tool perf_kmem = {
        .sample          = process_sample_event,
        .comm            = perf_event__process_comm,
-       .ordered_samples = true,
+       .ordered_events  = true,
 };
 
 static double fragmentation(unsigned long n_req, unsigned long n_alloc)
 
        struct perf_tool eops = {
                .sample                 = process_sample_event,
                .comm                   = perf_event__process_comm,
-               .ordered_samples        = true,
+               .ordered_events         = true,
        };
        struct perf_data_file file = {
                .path = kvm->file_name,
        kvm->tool.exit   = perf_event__process_exit;
        kvm->tool.fork   = perf_event__process_fork;
        kvm->tool.lost   = process_lost_event;
-       kvm->tool.ordered_samples = true;
+       kvm->tool.ordered_events = true;
        perf_tool__fill_defaults(&kvm->tool);
 
        /* set defaults */
 
        struct perf_tool eops = {
                .sample          = process_sample_event,
                .comm            = perf_event__process_comm,
-               .ordered_samples = true,
+               .ordered_events  = true,
        };
        struct perf_data_file file = {
                .path = input_name,
 
                        .lost           = perf_event__process_lost,
                        .fork           = perf_event__process_fork,
                        .build_id       = perf_event__process_build_id,
-                       .ordered_samples = true,
+                       .ordered_events = true,
                },
                .input_name              = "perf.data",
        };
 
                        .attr            = perf_event__process_attr,
                        .tracing_data    = perf_event__process_tracing_data,
                        .build_id        = perf_event__process_build_id,
-                       .ordered_samples = true,
+                       .ordered_events  = true,
                        .ordering_requires_timestamps = true,
                },
                .max_stack               = PERF_MAX_STACK_DEPTH,
 
                        .comm            = perf_event__process_comm,
                        .lost            = perf_event__process_lost,
                        .fork            = perf_sched__process_fork_event,
-                       .ordered_samples = true,
+                       .ordered_events = true,
                },
                .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
                .sort_list            = LIST_HEAD_INIT(sched.sort_list),
 
                        .attr            = process_attr,
                        .tracing_data    = perf_event__process_tracing_data,
                        .build_id        = perf_event__process_build_id,
-                       .ordered_samples = true,
+                       .ordered_events  = true,
                        .ordering_requires_timestamps = true,
                },
        };
 
                        .fork            = process_fork_event,
                        .exit            = process_exit_event,
                        .sample          = process_sample_event,
-                       .ordered_samples = true,
+                       .ordered_events  = true,
                },
                .proc_num = 15,
                .min_time = 1000000,
 
        trace->tool.tracing_data = perf_event__process_tracing_data;
        trace->tool.build_id      = perf_event__process_build_id;
 
-       trace->tool.ordered_samples = true;
+       trace->tool.ordered_events = true;
        trace->tool.ordering_requires_timestamps = true;
 
        /* add tid to output */
 
        }
 
        if (tool && tool->ordering_requires_timestamps &&
-           tool->ordered_samples && !perf_evlist__sample_id_all(session->evlist)) {
+           tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
                dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
-               tool->ordered_samples = false;
+               tool->ordered_events = false;
        }
 
        return session;
        if (tool->build_id == NULL)
                tool->build_id = process_finished_round_stub;
        if (tool->finished_round == NULL) {
-               if (tool->ordered_samples)
+               if (tool->ordered_events)
                        tool->finished_round = process_finished_round;
                else
                        tool->finished_round = process_finished_round_stub;
        struct ui_progress prog;
        int ret;
 
-       if (!tool->ordered_samples || !limit)
+       if (!tool->ordered_events || !limit)
                return 0;
 
        if (show_progress)
        if (ret)
                return ret;
 
-       if (tool->ordered_samples) {
+       if (tool->ordered_events) {
                ret = perf_session_queue_event(session, event, &sample,
                                               file_offset);
                if (ret != -ETIME)
 
        event_op2       tracing_data;
        event_op2       finished_round,
                        build_id;
-       bool            ordered_samples;
+       bool            ordered_events;
        bool            ordering_requires_timestamps;
 };