From patchwork Fri May 20 16:38:33 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wang Nan X-Patchwork-Id: 68299 Delivered-To: patch@linaro.org Received: by 10.140.92.199 with SMTP id b65csp3886452qge; Fri, 20 May 2016 09:47:27 -0700 (PDT) X-Received: by 10.66.49.230 with SMTP id x6mr6331751pan.100.1463762409628; Fri, 20 May 2016 09:40:09 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z188si28949456pfz.56.2016.05.20.09.40.09; Fri, 20 May 2016 09:40:09 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756132AbcETQjx (ORCPT + 30 others); Fri, 20 May 2016 12:39:53 -0400 Received: from szxga03-in.huawei.com ([119.145.14.66]:32241 "EHLO szxga03-in.huawei.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756075AbcETQjt (ORCPT ); Fri, 20 May 2016 12:39:49 -0400 Received: from 172.24.1.60 (EHLO szxeml425-hub.china.huawei.com) ([172.24.1.60]) by szxrg03-dlp.huawei.com (MOS 4.4.3-GA FastPath queued) with ESMTP id CBY95739; Sat, 21 May 2016 00:38:55 +0800 (CST) Received: from linux-4hy3.site (10.107.193.248) by szxeml425-hub.china.huawei.com (10.82.67.180) with Microsoft SMTP Server id 14.3.235.1; Sat, 21 May 2016 00:38:47 +0800 From: Wang Nan To: CC: , , Wang Nan , He Kuang , "Arnaldo Carvalho de Melo" , Jiri Olsa , Masami Hiramatsu , Namhyung Kim , "Zefan Li" Subject: [PATCH v2 11/13] perf record: Toggle overwrite ring buffer for reading Date: Fri, 20 May 2016 16:38:33 +0000 Message-ID: <1463762315-155689-12-git-send-email-wangnan0@huawei.com> X-Mailer: git-send-email 1.8.3.4 In-Reply-To: <1463762315-155689-1-git-send-email-wangnan0@huawei.com> References: <1463762315-155689-1-git-send-email-wangnan0@huawei.com> MIME-Version: 1.0 X-Originating-IP: [10.107.193.248] X-CFilter-Loop: Reflected X-Mirapoint-Virus-RAPID-Raw: score=unknown(0), refid=str=0001.0A020203.573F3DA0.0061, ss=1, re=0.000, recu=0.000, reip=0.000, cl=1, cld=1, fgs=0, ip=0.0.0.0, so=2013-05-26 15:14:31, dmn=2013-03-21 17:37:32 X-Mirapoint-Loop-Id: 653d034b316b3cd19beb7a2d4e3e0090 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org overwrite_evt_state is introduced to reflect the state of overwritable ring buffers. It is a state machine with 3 states: RUNNING --(1)--> DATA_PENDING --(2)--> EMPTY ^ ^ | | |___(disallow)___/| | | \_________________(3)______________/ RUNNING : Overwritable ring buffers are recording DATA_PENDING : We are required to collect overwritable ring buffers EMPTY : We have collected data from those ring buffers. (1): Pause ring buffers for reading (2): N/A (3): Resume ring buffers for recording We can't avoid this complexity. Because we deliberately drop records from overwritable ring buffer, we can't detect remaining data by checking head and old pointers. Therefore, DATA_PENDING state is mandatory. Signed-off-by: Wang Nan Signed-off-by: He Kuang Cc: Arnaldo Carvalho de Melo Cc: Jiri Olsa Cc: Masami Hiramatsu Cc: Namhyung Kim Cc: Zefan Li Cc: pi3orama@163.com --- tools/perf/builtin-record.c | 136 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 126 insertions(+), 10 deletions(-) -- 1.8.3.4 diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c index b940c0d..77cfb87 100644 --- a/tools/perf/builtin-record.c +++ b/tools/perf/builtin-record.c @@ -42,6 +42,28 @@ #include #include +/* + * State machine of overwrite_evt_state: + * + * RUNNING --(1)--> DATA_PENDING --(2)--> EMPTY + * ^ ^ | + * | |___(disallow)___/| + * | | + * \_________________(3)______________/ + * + * RUNNING : Overwritable ring buffers are recording + * DATA_PENDING : We are required to collect overwritable ring buffers + * EMPTY : We have collected data from those ring buffers. + * + * (1): Pause ring buffers for reading + * (2): N/A + * (3): Resume ring buffers for recording + */ +enum overwrite_evt_state { + OVERWRITE_EVT_RUNNING, + OVERWRITE_EVT_DATA_PENDING, + OVERWRITE_EVT_EMPTY, +}; struct record { struct perf_tool tool; @@ -61,6 +83,7 @@ struct record { bool buildid_all; bool timestamp_filename; bool switch_output; + enum overwrite_evt_state overwrite_evt_state; unsigned long long samples; }; @@ -132,9 +155,9 @@ rb_find_range(struct perf_evlist *evlist, return backward_rb_find_range(data, mask, head, start, end); } -static int record__mmap_read(struct record *rec, int idx) +static int record__mmap_read(struct record *rec, struct perf_evlist *evlist, int idx) { - struct perf_mmap *md = &rec->evlist->mmap[idx]; + struct perf_mmap *md = &evlist->mmap[idx]; u64 head = perf_mmap__read_head(md); u64 old = md->prev; u64 end = head, start = old; @@ -143,7 +166,7 @@ static int record__mmap_read(struct record *rec, int idx) void *buf; int rc = 0; - if (rb_find_range(rec->evlist, data, md->mask, head, + if (rb_find_range(evlist, data, md->mask, head, old, &start, &end)) return -1; @@ -157,7 +180,7 @@ static int record__mmap_read(struct record *rec, int idx) WARN_ONCE(1, "failed to keep up with mmap data. (warn only once)\n"); md->prev = head; - perf_evlist__mmap_consume(rec->evlist, idx); + perf_evlist__mmap_consume(evlist, idx); return 0; } @@ -182,7 +205,7 @@ static int record__mmap_read(struct record *rec, int idx) } md->prev = head; - perf_evlist__mmap_consume(rec->evlist, idx); + perf_evlist__mmap_consume(evlist, idx); out: return rc; } @@ -462,6 +485,7 @@ try_again: goto out; session->evlist = evlist; perf_session__set_id_hdr_size(session); + rec->overwrite_evt_state = OVERWRITE_EVT_RUNNING; out: return rc; } @@ -542,17 +566,62 @@ static struct perf_event_header finished_round_event = { .type = PERF_RECORD_FINISHED_ROUND, }; -static int record__mmap_read_all(struct record *rec) +static void +record__toggle_overwrite_evsels(struct record *rec, + enum overwrite_evt_state state) +{ + struct perf_evlist *evlist = rec->overwrite_evlist; + enum overwrite_evt_state old_state = rec->overwrite_evt_state; + enum action { + NONE, + PAUSE, + RESUME, + } action = NONE; + + switch (old_state) { + case OVERWRITE_EVT_RUNNING: + if (state != OVERWRITE_EVT_RUNNING) + action = PAUSE; + break; + case OVERWRITE_EVT_DATA_PENDING: + if (state == OVERWRITE_EVT_RUNNING) + action = RESUME; + break; + case OVERWRITE_EVT_EMPTY: + if (state == OVERWRITE_EVT_RUNNING) + action = RESUME; + if (state == OVERWRITE_EVT_DATA_PENDING) + state = OVERWRITE_EVT_EMPTY; + break; + default: + WARN_ONCE(1, "Shouldn't get there\n"); + } + + rec->overwrite_evt_state = state; + + if (action == NONE) + return; + + if (!evlist) + return; + + perf_evlist__toggle_paused(evlist, action == PAUSE); +} + +static int __record__mmap_read_evlist(struct record *rec, struct perf_evlist *evlist) { u64 bytes_written = rec->bytes_written; int i; int rc = 0; - for (i = 0; i < rec->evlist->nr_mmaps; i++) { - struct auxtrace_mmap *mm = &rec->evlist->mmap[i].auxtrace_mmap; + if (!evlist) + return 0; - if (rec->evlist->mmap[i].base) { - if (record__mmap_read(rec, i) != 0) { + for (i = 0; i < evlist->nr_mmaps; i++) { + struct auxtrace_mmap *mm = &evlist->mmap[i].auxtrace_mmap; + + if (evlist->mmap[i].base) { + if (record__mmap_read(rec, evlist, i) != 0) { rc = -1; goto out; } @@ -576,6 +645,23 @@ out: return rc; } +static int record__mmap_read_all(struct record *rec) +{ + int err; + + err = __record__mmap_read_evlist(rec, rec->evlist); + if (err) + return err; + + if (rec->overwrite_evt_state == OVERWRITE_EVT_DATA_PENDING) { + err = __record__mmap_read_evlist(rec, rec->overwrite_evlist); + if (err) + return err; + record__toggle_overwrite_evsels(rec, OVERWRITE_EVT_EMPTY); + } + return 0; +} + static void record__init_features(struct record *rec) { struct perf_session *session = rec->session; @@ -972,6 +1058,17 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) for (;;) { unsigned long long hits = rec->samples; + /* + * rec->overwrite_evt_state is possible to be + * OVERWRITE_EVT_EMPTY here: when done == true and + * hits != rec->samples after previous reading. + * + * record__toggle_overwrite_evsels ensure we never + * convert OVERWRITE_EVT_EMPTY to OVERWRITE_EVT_DATA_PENDING. + */ + if (trigger_is_hit(&switch_output_trigger) || done || draining) + record__toggle_overwrite_evsels(rec, OVERWRITE_EVT_DATA_PENDING); + if (record__mmap_read_all(rec) < 0) { trigger_error(&auxtrace_snapshot_trigger); trigger_error(&switch_output_trigger); @@ -991,8 +1088,27 @@ static int __cmd_record(struct record *rec, int argc, const char **argv) } if (trigger_is_hit(&switch_output_trigger)) { + /* + * If switch_output_trigger is hit, the data in + * overwritable ring buffer should have been collected, + * so overwrite_evt_state should be set to + * OVERWRITE_EVT_EMPTY. + * + * If SIGUSR2 raise after or during record__mmap_read_all(), + * record__mmap_read_all() didn't collect data from + * overwritable ring buffer. Read again. + */ + if (rec->overwrite_evt_state == OVERWRITE_EVT_RUNNING) + continue; trigger_ready(&switch_output_trigger); + /* + * Reenable events in overwrite ring buffer after + * record__mmap_read_all(): we should have collected + * data from it. + */ + record__toggle_overwrite_evsels(rec, OVERWRITE_EVT_RUNNING); + if (!quiet) fprintf(stderr, "[ perf record: dump data: Woken up %ld times ]\n", waking);