From nobody Sat Apr 11 05:10:38 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id C7E58C25B0E for ; Mon, 15 Aug 2022 20:32:49 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1346682AbiHOUax (ORCPT ); Mon, 15 Aug 2022 16:30:53 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53142 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347341AbiHOUWS (ORCPT ); Mon, 15 Aug 2022 16:22:18 -0400 Received: from mail-pj1-x102e.google.com (mail-pj1-x102e.google.com [IPv6:2607:f8b0:4864:20::102e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0713533E36; Mon, 15 Aug 2022 12:02:42 -0700 (PDT) Received: by mail-pj1-x102e.google.com with SMTP id gj1so7722403pjb.0; Mon, 15 Aug 2022 12:02:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:from:to:cc; bh=84gL6qYXoIL91eAhUH7dgvAezoFgyrY4+iuV6650YZc=; b=jSMG8Jug+aL1qEMcn+JaVOdPAILDwRdcaGp9YeL+6lMX1w36/c7YMc0rFNPgcA1/zD rDdxOPAn3QOKYG/kGuRLcgrwczvCaR0zDN/xaIvc5Pt1+wFyF/pM9kyl0919pOfYv78W E9F66io5oP9v1Q0HZNrsgn7Oc0T1o3JLifsDt5RwUeREgp7VpAHXa8CP00fJS2wDfvuJ BWyVIa83Tq4QD6W9+vPKRT/SOqb+QE4FYoc34vE0HAHQCx4pBUSm1QhZ7nVI4v1e0XuF n/rER/u07yf+s7b7I6HEe6EqaZ8pwm7yJULdpw3BL1xSVH2XqMnGqzEuvdNhXvJPfpQX Fvzw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:x-gm-message-state:from :to:cc; bh=84gL6qYXoIL91eAhUH7dgvAezoFgyrY4+iuV6650YZc=; b=graC1WKtNq03DQuArUaVH818WxqXGUya1Qcf74uif0xTBHij7EOh4PD6Z4uueIVhhF wDxU1rCGv/FrvCkvgsiNOmstIUEoemJ2+tRIFTNEdORjqKYWcmMFiQ5IoQiHkrs1B6nJ gLXFOoZK5LRxrMzFbgGeUWODcWYISwdj2XJtxV+NTXfRxfJfRyb1+dcTh0fbCq3csozR fDR0Vv4wcof3DQpj40UF5uolJ5w7O5ysZu7p61IJenRIe0zdTMYKY1jWoJLbuQI7sktS VHM1ouG8Jnt6dSEHjuyeiVYHUR19rDZtMLxwVWdLfWLukAAP9yb+Yq1PRvPIO+aZq85m iVyg== X-Gm-Message-State: ACgBeo34KGFnfUaFme4B6GwkW4guUsbZh+9/mcz8OWtfHMhhONIzeWXz TN+/C7iijQRZvc8ra31Aou4H/6I6vSe1yw== X-Google-Smtp-Source: AA6agR5v8h/l8L4a2l4uFMG3eittr5svYMMW7mudoTU1ePgOr5JOXPq8o1Q3H7A+CdIIIJFaS/f0TQ== X-Received: by 2002:a17:902:8f8a:b0:16f:975e:7c6e with SMTP id z10-20020a1709028f8a00b0016f975e7c6emr18748120plo.136.1660590161502; Mon, 15 Aug 2022 12:02:41 -0700 (PDT) Received: from youngsil.svl.corp.google.com ([2620:15c:2d4:203:df3e:22e0:b905:822b]) by smtp.gmail.com with ESMTPSA id q13-20020a170902a3cd00b0016a4db13429sm7266926plb.192.2022.08.15.12.02.39 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Aug 2022 12:02:40 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: LKML , Ian Rogers , linux-perf-users@vger.kernel.org Subject: [PATCH 1/4] tools headers UAPI: Sync linux/perf_event.h with the kernel sources Date: Mon, 15 Aug 2022 12:01:03 -0700 Message-Id: <20220815190106.1293082-2-namhyung@kernel.org> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog In-Reply-To: <20220815190106.1293082-1-namhyung@kernel.org> References: <20220815190106.1293082-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" To pick the trivial change in: 119a784c8127 ("perf/core: Add a new read format to get a number of lost s= amples") Signed-off-by: Namhyung Kim --- tools/include/uapi/linux/perf_event.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tools/include/uapi/linux/perf_event.h b/tools/include/uapi/lin= ux/perf_event.h index e2b77fbca91e..581ed4bdc062 100644 --- a/tools/include/uapi/linux/perf_event.h +++ b/tools/include/uapi/linux/perf_event.h @@ -301,6 +301,7 @@ enum { * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING * { u64 id; } && PERF_FORMAT_ID + * { u64 lost; } && PERF_FORMAT_LOST * } && !PERF_FORMAT_GROUP * * { u64 nr; @@ -308,6 +309,7 @@ enum { * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING * { u64 value; * { u64 id; } && PERF_FORMAT_ID + * { u64 lost; } && PERF_FORMAT_LOST * } cntr[nr]; * } && PERF_FORMAT_GROUP * }; @@ -317,8 +319,9 @@ enum perf_event_read_format { PERF_FORMAT_TOTAL_TIME_RUNNING =3D 1U << 1, PERF_FORMAT_ID =3D 1U << 2, PERF_FORMAT_GROUP =3D 1U << 3, + PERF_FORMAT_LOST =3D 1U << 4, =20 - PERF_FORMAT_MAX =3D 1U << 4, /* non-ABI */ + PERF_FORMAT_MAX =3D 1U << 5, /* non-ABI */ }; =20 #define PERF_ATTR_SIZE_VER0 64 /* sizeof first published struct */ --=20 2.37.1.595.g718a3a8f04-goog From nobody Sat Apr 11 05:10:38 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B8602C25B0E for ; Mon, 15 Aug 2022 20:32:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1346944AbiHOUa4 (ORCPT ); Mon, 15 Aug 2022 16:30:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53150 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S245187AbiHOUWT (ORCPT ); Mon, 15 Aug 2022 16:22:19 -0400 Received: from mail-pg1-x529.google.com (mail-pg1-x529.google.com [IPv6:2607:f8b0:4864:20::529]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E0FC3357C7; Mon, 15 Aug 2022 12:02:43 -0700 (PDT) Received: by mail-pg1-x529.google.com with SMTP id 202so7241484pgc.8; Mon, 15 Aug 2022 12:02:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:from:to:cc; bh=T1urwYp+ngUfbtL/zRS1WH8Fw+1Y+MfmKi5JR02MB5Y=; b=aZUuvkegx2ruNP8I4pY27Gd7ajx8X7gfwOxSAZ3xO1ObIxlYQCyO+KsPGzDJdleVTv hGYNLNcK1bd4lx7e5tOpFAVQQat1kKKrbOnhbZVf/vzXlCVLycrJBvSo6GZqBb6xhon5 w64+6nGYOe1CU8KjLKooaF5XJnYY8fFQJIANLHPyxTrE+i+T6NqwBCvLV8/DRuCUYsVA cbR9a22h60S3UnNmRA4/ngshmTMqszxt1Y/9kGjBtpqXsMHLcCKLBOs0rr1NgThW2cy9 LhoEHznxETNRdAg9+KRCxsNXk5Ty5LZSCMAlrb7JiEuMhWSsGVgcw33aSwNl8id53TRG zFgg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:x-gm-message-state:from :to:cc; bh=T1urwYp+ngUfbtL/zRS1WH8Fw+1Y+MfmKi5JR02MB5Y=; b=ugGFFmcTUOaFdGFh2TRcZ/ZM6P5MTbzHZfBD886PY0uaoDJl/R1B8+8mSMtQFu4f5q uiDvSp80rxDrtqFRVJxOl5b6HZoJOg6pyKbxdfvfB7un76+Xlwm1/a4e1pX6eye1v7kr CpHMdrWIrp8ZJIDcWXK5YWfCQuOkjdCkXYpNcH7yPWIkswLCAvfFZL/NVPKetHAnHKn7 wPMUKFvQrAI9JkXQsz+Hg7dcvU/cCFP5nQNWhv+nF3l57Mt/7G6oanAq2MxXJk5YmOZW 884JzrUkXgjKWHAABLIQpSQMV9FT3cpi61P6aBNQBgRaGY1nOrYEM8+UuTIn5UQQAyRk ajCg== X-Gm-Message-State: ACgBeo2tjXUSsEOHe3oUC6b/Gyz+wN4qxJ/ELJw/li2Y34lg9vKFDddi HSXmkd5NPxg7IRsQDp77CaA= X-Google-Smtp-Source: AA6agR4b/ybl6R8xhfXlQvXXGF/WKD/S1mp5KP2qIF0fDxTUUsj1b0ep3zp3dknndIRIq/PtXohsXA== X-Received: by 2002:a63:db06:0:b0:41d:f6f6:49d0 with SMTP id e6-20020a63db06000000b0041df6f649d0mr14624683pgg.83.1660590163000; Mon, 15 Aug 2022 12:02:43 -0700 (PDT) Received: from youngsil.svl.corp.google.com ([2620:15c:2d4:203:df3e:22e0:b905:822b]) by smtp.gmail.com with ESMTPSA id q13-20020a170902a3cd00b0016a4db13429sm7266926plb.192.2022.08.15.12.02.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Aug 2022 12:02:42 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: LKML , Ian Rogers , linux-perf-users@vger.kernel.org Subject: [PATCH 2/4] tools lib perf: Handle read format in perf_evsel__read() Date: Mon, 15 Aug 2022 12:01:04 -0700 Message-Id: <20220815190106.1293082-3-namhyung@kernel.org> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog In-Reply-To: <20220815190106.1293082-1-namhyung@kernel.org> References: <20220815190106.1293082-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The perf_counts_values should be increased to read the new lost data. Also adjust values after read according the read format. This supports PERF_FORMAT_GROUP which has a different data format but it's only available for leader events. Currently it doesn't have an API to read sibling (member) events in the group. But users may read the sibling event directly. Also reading from mmap would be disabled when the read format has ID or LOST bit as it's not exposed via mmap. Signed-off-by: Namhyung Kim --- tools/lib/perf/evsel.c | 72 +++++++++++++++++++++++++++++ tools/lib/perf/include/perf/event.h | 3 +- tools/lib/perf/include/perf/evsel.h | 4 +- 3 files changed, 77 insertions(+), 2 deletions(-) diff --git a/tools/lib/perf/evsel.c b/tools/lib/perf/evsel.c index 952f3520d5c2..fc23670231cb 100644 --- a/tools/lib/perf/evsel.c +++ b/tools/lib/perf/evsel.c @@ -305,6 +305,9 @@ int perf_evsel__read_size(struct perf_evsel *evsel) if (read_format & PERF_FORMAT_ID) entry +=3D sizeof(u64); =20 + if (read_format & PERF_FORMAT_LOST) + entry +=3D sizeof(u64); + if (read_format & PERF_FORMAT_GROUP) { nr =3D evsel->nr_members; size +=3D sizeof(u64); @@ -314,24 +317,93 @@ int perf_evsel__read_size(struct perf_evsel *evsel) return size; } =20 +/* This only reads values for the leader */ +static int perf_evsel__read_group(struct perf_evsel *evsel, int cpu_map_id= x, + int thread, struct perf_counts_values *count) +{ + size_t size =3D perf_evsel__read_size(evsel); + int *fd =3D FD(evsel, cpu_map_idx, thread); + u64 read_format =3D evsel->attr.read_format; + u64 *data; + int idx =3D 1; + + if (fd =3D=3D NULL || *fd < 0) + return -EINVAL; + + data =3D calloc(1, size); + if (data =3D=3D NULL) + return -ENOMEM; + + if (readn(*fd, data, size) <=3D 0) { + free(data); + return -errno; + } + + if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) + count->ena =3D data[idx++]; + if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) + count->run =3D data[idx++]; + + /* value is always available */ + count->val =3D data[idx++]; + if (read_format & PERF_FORMAT_ID) + count->id =3D data[idx++]; + if (read_format & PERF_FORMAT_LOST) + count->lost =3D data[idx++]; + + free(data); + return 0; +} + +/* + * The perf read format is very flexible. It needs to set the proper + * values according to the read format. + */ +static void perf_evsel__adjust_values(struct perf_evsel *evsel, + struct perf_counts_values *count) +{ + u64 read_format =3D evsel->attr.read_format; + + if (!(read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)) { + memmove(&count->values[2], &count->values[1], 24); + count->ena =3D 0; + } + + if (!(read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)) { + memmove(&count->values[3], &count->values[2], 16); + count->run =3D 0; + } + + if (!(read_format & PERF_FORMAT_ID)) { + memmove(&count->values[4], &count->values[3], 8); + count->id =3D 0; + } +} + int perf_evsel__read(struct perf_evsel *evsel, int cpu_map_idx, int thread, struct perf_counts_values *count) { size_t size =3D perf_evsel__read_size(evsel); int *fd =3D FD(evsel, cpu_map_idx, thread); + u64 read_format =3D evsel->attr.read_format; =20 memset(count, 0, sizeof(*count)); =20 if (fd =3D=3D NULL || *fd < 0) return -EINVAL; =20 + if (read_format & PERF_FORMAT_GROUP) + return perf_evsel__read_group(evsel, cpu_map_idx, thread, count); + if (MMAP(evsel, cpu_map_idx, thread) && + !(read_format & (PERF_FORMAT_ID | PERF_FORMAT_LOST)) && !perf_mmap__read_self(MMAP(evsel, cpu_map_idx, thread), count)) return 0; =20 if (readn(*fd, count->values, size) <=3D 0) return -errno; =20 + perf_evsel__adjust_values(evsel, count); return 0; } =20 diff --git a/tools/lib/perf/include/perf/event.h b/tools/lib/perf/include/p= erf/event.h index 556bb06798f2..38dd35cbca71 100644 --- a/tools/lib/perf/include/perf/event.h +++ b/tools/lib/perf/include/perf/event.h @@ -76,7 +76,7 @@ struct perf_record_lost_samples { }; =20 /* - * PERF_FORMAT_ENABLED | PERF_FORMAT_RUNNING | PERF_FORMAT_ID + * PERF_FORMAT_ENABLED | PERF_FORMAT_RUNNING | PERF_FORMAT_ID | PERF_FORMA= T_LOST */ struct perf_record_read { struct perf_event_header header; @@ -85,6 +85,7 @@ struct perf_record_read { __u64 time_enabled; __u64 time_running; __u64 id; + __u64 lost; }; =20 struct perf_record_throttle { diff --git a/tools/lib/perf/include/perf/evsel.h b/tools/lib/perf/include/p= erf/evsel.h index 699c0ed97d34..6f92204075c2 100644 --- a/tools/lib/perf/include/perf/evsel.h +++ b/tools/lib/perf/include/perf/evsel.h @@ -18,8 +18,10 @@ struct perf_counts_values { uint64_t val; uint64_t ena; uint64_t run; + uint64_t id; + uint64_t lost; }; - uint64_t values[3]; + uint64_t values[5]; }; }; =20 --=20 2.37.1.595.g718a3a8f04-goog From nobody Sat Apr 11 05:10:38 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id D85EDC25B08 for ; Mon, 15 Aug 2022 20:32:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347395AbiHOUbI (ORCPT ); Mon, 15 Aug 2022 16:31:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46908 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S243000AbiHOUW3 (ORCPT ); Mon, 15 Aug 2022 16:22:29 -0400 Received: from mail-pg1-x533.google.com (mail-pg1-x533.google.com [IPv6:2607:f8b0:4864:20::533]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6B9A04B4AA; Mon, 15 Aug 2022 12:02:46 -0700 (PDT) Received: by mail-pg1-x533.google.com with SMTP id d71so7228630pgc.13; Mon, 15 Aug 2022 12:02:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:from:to:cc; bh=aFH5O6viJ6NTA25wi2Aiw0FQRIeUfCBP+ZrmMXU/R8U=; b=fAg5GvhC9b+uSX4XfLoHrTm5t4cfjluFZpstnDR2BqZ5sCf56CjAqed44UFm7y7wiX qJrtG+PIYnh1PeATPzDnrbmqumlB+SK7UM9LN7CNz3XSd9HNKUgPpgHY2tWKLD9J96cV AF+2lzINY4HTQW9LpP2TPSwinit/dLpR0/GRokt0QupZghmB3V77w5ozAC8pDbSsPL86 2BA17TbR6AcQrQKowa7GYIVVp1bOvxC5kG1d7nnxCAFvCipvPn/rF6EV/VIZPGlvxtSi g9T3easUzlitoITO3fGfz3uBG2Aem/LyvyMnS4MvQKD3KyDUB+ZYOKNuy03nzRdzWtqb cW7g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:x-gm-message-state:from :to:cc; bh=aFH5O6viJ6NTA25wi2Aiw0FQRIeUfCBP+ZrmMXU/R8U=; b=pzkMLpm6f9elhZElyLpzDdc+Urq4dL/MYCvBpSjYcay39xzNuIrIa2rGoIfYi5OCV8 huAeuiZFg2lQzylveXUIVwCanqQ4e7PJ+i8UAPNUio1GWd24gv7fZJ9Sf1Y1VpsJpd9X P5lV9DQQ25Ik+V0kh2coMtgNGHF86txOQWX8K5oi9FRul9tNwsG2D+2oB7pID7JaBffH JXmuJIA3uRxKQ0vMvb1txNDO19hXU93Shq2+CtNjl956KotJ+KgOnjR9yVsS3gWZ12XK ldLkB/hwlk43WiTOy5/xet4Qece9iBbOHdBU6uU40EX7zV8Az1l8N6yNJJVkWbVOYZBz p9Mg== X-Gm-Message-State: ACgBeo38YUHYJ+OqtwWR2wR2XwnLNrtvbR6NHndGxTrJrkgvWo3hVJMY wMA9BqabeXToqQYRbGEw2egcCqJ3K1+Hyw== X-Google-Smtp-Source: AA6agR68bfyFcPtOh9vOrp8v/SUJJPQ60t8CE7KEgOseSTZNnkHGZ4D3OXVcrP2kTTf1bI1kHq7aAg== X-Received: by 2002:a63:8bc8:0:b0:41c:6800:d4e9 with SMTP id j191-20020a638bc8000000b0041c6800d4e9mr14484480pge.45.1660590165321; Mon, 15 Aug 2022 12:02:45 -0700 (PDT) Received: from youngsil.svl.corp.google.com ([2620:15c:2d4:203:df3e:22e0:b905:822b]) by smtp.gmail.com with ESMTPSA id q13-20020a170902a3cd00b0016a4db13429sm7266926plb.192.2022.08.15.12.02.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Aug 2022 12:02:43 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: LKML , Ian Rogers , linux-perf-users@vger.kernel.org Subject: [PATCH 3/4] tools lib perf: Add a test case for read formats Date: Mon, 15 Aug 2022 12:01:05 -0700 Message-Id: <20220815190106.1293082-4-namhyung@kernel.org> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog In-Reply-To: <20220815190106.1293082-1-namhyung@kernel.org> References: <20220815190106.1293082-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" It checks a various combination of the read format settings and verify it return the value in a proper position. The test uses task-clock software events to guarantee it's always active and sets enabled/running time. Signed-off-by: Namhyung Kim --- tools/lib/perf/tests/test-evsel.c | 161 ++++++++++++++++++++++++++++++ 1 file changed, 161 insertions(+) diff --git a/tools/lib/perf/tests/test-evsel.c b/tools/lib/perf/tests/test-= evsel.c index 89be89afb24d..a11fc51bfb68 100644 --- a/tools/lib/perf/tests/test-evsel.c +++ b/tools/lib/perf/tests/test-evsel.c @@ -1,10 +1,13 @@ // SPDX-License-Identifier: GPL-2.0 #include #include +#include #include +#include #include #include #include +#include #include #include "tests.h" =20 @@ -189,6 +192,163 @@ static int test_stat_user_read(int event) return 0; } =20 +static int test_stat_read_format_single(struct perf_event_attr *attr, stru= ct perf_thread_map *threads) +{ + struct perf_evsel *evsel; + struct perf_counts_values counts; + volatile int count =3D 0x100000; + int err; + + evsel =3D perf_evsel__new(attr); + __T("failed to create evsel", evsel); + + /* skip old kernels that don't support the format */ + err =3D perf_evsel__open(evsel, NULL, threads); + if (err < 0) + return 0; + + while (count--) ; + + memset(&counts, -1, sizeof(counts)); + perf_evsel__read(evsel, 0, 0, &counts); + + __T("failed to read value", counts.val); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) + __T("failed to read TOTAL_TIME_ENABLED", counts.ena); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) + __T("failed to read TOTAL_TIME_RUNNING", counts.run); + if (attr->read_format & PERF_FORMAT_ID) + __T("failed to read ID", counts.id); + if (attr->read_format & PERF_FORMAT_LOST) + __T("failed to read LOST", counts.lost =3D=3D 0); + + perf_evsel__close(evsel); + perf_evsel__delete(evsel); + return 0; +} + +static int test_stat_read_format_group(struct perf_event_attr *attr, struc= t perf_thread_map *threads) +{ + struct perf_evsel *leader, *member; + struct perf_counts_values counts; + volatile int count =3D 0x100000; + int err; + + attr->read_format |=3D PERF_FORMAT_GROUP; + leader =3D perf_evsel__new(attr); + __T("failed to create leader", leader); + + attr->read_format &=3D ~PERF_FORMAT_GROUP; + member =3D perf_evsel__new(attr); + __T("failed to create member", member); + + member->leader =3D leader; + leader->nr_members =3D 2; + + /* skip old kernels that don't support the format */ + err =3D perf_evsel__open(leader, NULL, threads); + if (err < 0) + return 0; + err =3D perf_evsel__open(member, NULL, threads); + if (err < 0) + return 0; + + while (count--) ; + + memset(&counts, -1, sizeof(counts)); + perf_evsel__read(leader, 0, 0, &counts); + + __T("failed to read leader value", counts.val); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) + __T("failed to read leader TOTAL_TIME_ENABLED", counts.ena); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) + __T("failed to read leader TOTAL_TIME_RUNNING", counts.run); + if (attr->read_format & PERF_FORMAT_ID) + __T("failed to read leader ID", counts.id); + if (attr->read_format & PERF_FORMAT_LOST) + __T("failed to read leader LOST", counts.lost =3D=3D 0); + + memset(&counts, -1, sizeof(counts)); + perf_evsel__read(member, 0, 0, &counts); + + __T("failed to read member value", counts.val); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) + __T("failed to read member TOTAL_TIME_ENABLED", counts.ena); + if (attr->read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) + __T("failed to read member TOTAL_TIME_RUNNING", counts.run); + if (attr->read_format & PERF_FORMAT_ID) + __T("failed to read member ID", counts.id); + if (attr->read_format & PERF_FORMAT_LOST) + __T("failed to read member LOST", counts.lost =3D=3D 0); + + perf_evsel__close(member); + perf_evsel__close(leader); + perf_evsel__delete(member); + perf_evsel__delete(leader); + return 0; +} + +static int test_stat_read_format(void) +{ + struct perf_thread_map *threads; + struct perf_event_attr attr =3D { + .type =3D PERF_TYPE_SOFTWARE, + .config =3D PERF_COUNT_SW_TASK_CLOCK, + }; + int err, i; + +#define FMT(_fmt) PERF_FORMAT_ ## _fmt +#define FMT_TIME (FMT(TOTAL_TIME_ENABLED) | FMT(TOTAL_TIME_RUNNING)) + + uint64_t test_formats [] =3D { + 0, + FMT_TIME, + FMT(ID), + FMT(LOST), + FMT_TIME | FMT(ID), + FMT_TIME | FMT(LOST), + FMT_TIME | FMT(ID) | FMT(LOST), + FMT(ID) | FMT(LOST), + }; + +#undef FMT +#undef FMT_TIME + + threads =3D perf_thread_map__new_dummy(); + __T("failed to create threads", threads); + + perf_thread_map__set_pid(threads, 0, 0); + + for (i =3D 0; i < (int)ARRAY_SIZE(test_formats); i++) { + attr.read_format =3D test_formats[i]; + __T_VERBOSE("testing single read with read_format: %lx\n", + (unsigned long)test_formats[i]); + + err =3D test_stat_read_format_single(&attr, threads); + __T("failed to read single format", err =3D=3D 0); + } + + perf_thread_map__put(threads); + + threads =3D perf_thread_map__new_array(2, NULL); + __T("failed to create threads", threads); + + perf_thread_map__set_pid(threads, 0, 0); + perf_thread_map__set_pid(threads, 1, 0); + + for (i =3D 0; i < (int)ARRAY_SIZE(test_formats); i++) { + attr.read_format =3D test_formats[i]; + __T_VERBOSE("testing group read with read_format: %lx\n", + (unsigned long)test_formats[i]); + + err =3D test_stat_read_format_group(&attr, threads); + __T("failed to read group format", err =3D=3D 0); + } + + perf_thread_map__put(threads); + return 0; +} + int test_evsel(int argc, char **argv) { __T_START; @@ -200,6 +360,7 @@ int test_evsel(int argc, char **argv) test_stat_thread_enable(); test_stat_user_read(PERF_COUNT_HW_INSTRUCTIONS); test_stat_user_read(PERF_COUNT_HW_CPU_CYCLES); + test_stat_read_format(); =20 __T_END; return tests_failed =3D=3D 0 ? 0 : -1; --=20 2.37.1.595.g718a3a8f04-goog From nobody Sat Apr 11 05:10:38 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 06100C282E7 for ; Mon, 15 Aug 2022 20:32:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347533AbiHOUbT (ORCPT ); Mon, 15 Aug 2022 16:31:19 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49434 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347109AbiHOUX3 (ORCPT ); Mon, 15 Aug 2022 16:23:29 -0400 Received: from mail-pl1-x631.google.com (mail-pl1-x631.google.com [IPv6:2607:f8b0:4864:20::631]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 0CBE14BD01; Mon, 15 Aug 2022 12:02:48 -0700 (PDT) Received: by mail-pl1-x631.google.com with SMTP id z19so7153916plb.1; Mon, 15 Aug 2022 12:02:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:from:to:cc; bh=eGwWLAV+VmdnzL2DzlRl4cqZkvkUk0pyXNIXElL51oM=; b=J/lvfr3edKFmTE604ZrQ7c46BPEPDrQKT6POvbxYhQTGKf2baJhUBrNqQfEkBLsqdc TgJ7BiBQTb3owvJ6CiWD6ROAXyvRIurtJIQwkM2cuZWotTw2iDFP0FAiVLw7Tzr8NIG8 pvnuQfBhV1H9PEy+8he0i7Zh/WPiwPTPdwrO69CT6ANnLKxY7SGWhXkk8wpv4jrI1xC/ 35Lr9JrCPzOYxOJtg6t5AILyWhQZYM4YN3F6QcTRKceC3R1saINrFc6xsvk0k3y5+klO scUx+HQquIZAhb91/vt6XvoU7WNvZ/xStfKf7SNPZe4Bn9yCBSDZAKoTTEEAcKSff9OU H9qA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:sender:x-gm-message-state:from :to:cc; bh=eGwWLAV+VmdnzL2DzlRl4cqZkvkUk0pyXNIXElL51oM=; b=fOYCsm5W42ChTZGkB9MYqMFI1FuYSFOpnfg64FOexc4Mbba37arQrT2aIozsGRnqdz 7Vqr3vi1VOsr+9fAUUcAp887nDminOkOsj/4VbFWl385qBya4m9JKKAJrZ3rMcBWjVNT WSH0w6EiahhMyS3BRH0ppbQXnlSRyJIDibOfwUhrsopGQBUT/GF1ZQtid/6rBCOHN20x QQ8581086/VcexbrVzVL7vgbmGR7RI+RKG117ZuPTcVPDkk8nAdLZy9z7MyvspEA+45T Hfm91mA2wPjSzAvzUSqteZDAxSGd4sp0TW0ty0r5oubtbkvbkAka7RF5bvnp8WYcDvgR Fvtg== X-Gm-Message-State: ACgBeo1iVMQt7QsbPSCWUvNXBiJYyywwNmZiNc/kUYuj8/HfYVBY29QQ 4IIxDNhiPyCidGZ6QtFKCeo= X-Google-Smtp-Source: AA6agR6FsoK6jpHF+J6IYoYqVk42xSZCvYEAqxFRv568MP0hdMRmGFRKiEerc48b+ygoz4rlYkImEw== X-Received: by 2002:a17:902:b903:b0:170:9964:b47b with SMTP id bf3-20020a170902b90300b001709964b47bmr18023909plb.83.1660590167848; Mon, 15 Aug 2022 12:02:47 -0700 (PDT) Received: from youngsil.svl.corp.google.com ([2620:15c:2d4:203:df3e:22e0:b905:822b]) by smtp.gmail.com with ESMTPSA id q13-20020a170902a3cd00b0016a4db13429sm7266926plb.192.2022.08.15.12.02.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Aug 2022 12:02:46 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: LKML , Ian Rogers , linux-perf-users@vger.kernel.org Subject: [PATCH 4/4] perf tools: Support reading PERF_FORMAT_LOST Date: Mon, 15 Aug 2022 12:01:06 -0700 Message-Id: <20220815190106.1293082-5-namhyung@kernel.org> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog In-Reply-To: <20220815190106.1293082-1-namhyung@kernel.org> References: <20220815190106.1293082-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The recent kernel added lost count can be read from either read(2) or ring buffer data with PERF_SAMPLE_READ. As it's a variable length data we need to access it according to the format info. But for perf tools use cases, PERF_FORMAT_ID is always set. So we can only check PERF_FORMAT_LOST bit to determine the data format. Add sample_read_value_size() and next_sample_read_value() helpers to make it a bit easier to access. Use them in all places where it reads the struct sample_read_value. Signed-off-by: Namhyung Kim --- tools/perf/tests/sample-parsing.c | 14 +++++--- tools/perf/util/event.h | 18 +++++++++- tools/perf/util/evsel.c | 33 +++++++++++++----- .../scripting-engines/trace-event-python.c | 16 ++++++--- tools/perf/util/session.c | 32 +++++++++++------ tools/perf/util/synthetic-events.c | 34 +++++++++++++++---- 6 files changed, 112 insertions(+), 35 deletions(-) diff --git a/tools/perf/tests/sample-parsing.c b/tools/perf/tests/sample-pa= rsing.c index 07f2411b0ad4..20930dd48ee0 100644 --- a/tools/perf/tests/sample-parsing.c +++ b/tools/perf/tests/sample-parsing.c @@ -86,10 +86,15 @@ static bool samples_same(const struct perf_sample *s1, COMP(read.time_running); /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */ if (read_format & PERF_FORMAT_GROUP) { - for (i =3D 0; i < s1->read.group.nr; i++) - MCOMP(read.group.values[i]); + for (i =3D 0; i < s1->read.group.nr; i++) { + /* FIXME: check values without LOST */ + if (read_format & PERF_FORMAT_LOST) + MCOMP(read.group.values[i]); + } } else { COMP(read.one.id); + if (read_format & PERF_FORMAT_LOST) + COMP(read.one.lost); } } =20 @@ -263,7 +268,7 @@ static int do_test(u64 sample_type, u64 sample_regs, u6= 4 read_format) .data =3D (void *)aux_data, }, }; - struct sample_read_value values[] =3D {{1, 5}, {9, 3}, {2, 7}, {6, 4},}; + struct sample_read_value values[] =3D {{1, 5, 0}, {9, 3, 0}, {2, 7, 0}, {= 6, 4, 1},}; struct perf_sample sample_out, sample_out_endian; size_t i, sz, bufsz; int err, ret =3D -1; @@ -286,6 +291,7 @@ static int do_test(u64 sample_type, u64 sample_regs, u6= 4 read_format) } else { sample.read.one.value =3D 0x08789faeb786aa87ULL; sample.read.one.id =3D 99; + sample.read.one.lost =3D 1; } =20 sz =3D perf_event__sample_event_size(&sample, sample_type, read_format); @@ -370,7 +376,7 @@ static int do_test(u64 sample_type, u64 sample_regs, u6= 4 read_format) */ static int test__sample_parsing(struct test_suite *test __maybe_unused, in= t subtest __maybe_unused) { - const u64 rf[] =3D {4, 5, 6, 7, 12, 13, 14, 15}; + const u64 rf[] =3D {4, 5, 6, 7, 12, 13, 14, 15, 20, 21, 22, 28, 29, 30, 3= 1}; u64 sample_type; u64 sample_regs; size_t i; diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h index a7b0931d5137..7753368d70d6 100644 --- a/tools/perf/util/event.h +++ b/tools/perf/util/event.h @@ -65,7 +65,8 @@ struct stack_dump { =20 struct sample_read_value { u64 value; - u64 id; + u64 id; /* only if PERF_FORMAT_ID */ + u64 lost; /* only if PERF_FORMAT_LOST */ }; =20 struct sample_read { @@ -80,6 +81,21 @@ struct sample_read { }; }; =20 +static inline size_t sample_read_value_size(u64 read_format) +{ + /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */ + if (read_format & PERF_FORMAT_LOST) + return sizeof(struct sample_read_value); + else + return offsetof(struct sample_read_value, lost); +} + +static inline struct sample_read_value * +next_sample_read_value(struct sample_read_value *v, u64 read_format) +{ + return (void *)v + sample_read_value_size(read_format); +} + struct ip_callchain { u64 nr; u64 ips[]; diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c index 4852089e1d79..781367ccdb84 100644 --- a/tools/perf/util/evsel.c +++ b/tools/perf/util/evsel.c @@ -1541,7 +1541,7 @@ static int evsel__read_one(struct evsel *evsel, int c= pu_map_idx, int thread) } =20 static void evsel__set_count(struct evsel *counter, int cpu_map_idx, int t= hread, - u64 val, u64 ena, u64 run) + u64 val, u64 ena, u64 run, u64 lost) { struct perf_counts_values *count; =20 @@ -1550,6 +1550,7 @@ static void evsel__set_count(struct evsel *counter, i= nt cpu_map_idx, int thread, count->val =3D val; count->ena =3D ena; count->run =3D run; + count->lost =3D lost; =20 perf_counts__set_loaded(counter->counts, cpu_map_idx, thread, true); } @@ -1558,7 +1559,7 @@ static int evsel__process_group_data(struct evsel *le= ader, int cpu_map_idx, int { u64 read_format =3D leader->core.attr.read_format; struct sample_read_value *v; - u64 nr, ena =3D 0, run =3D 0, i; + u64 nr, ena =3D 0, run =3D 0, lost =3D 0, i; =20 nr =3D *data++; =20 @@ -1573,16 +1574,25 @@ static int evsel__process_group_data(struct evsel *= leader, int cpu_map_idx, int =20 v =3D (struct sample_read_value *) data; =20 - evsel__set_count(leader, cpu_map_idx, thread, v[0].value, ena, run); + if (read_format & PERF_FORMAT_LOST) + lost =3D v->lost; + + evsel__set_count(leader, cpu_map_idx, thread, v[0].value, ena, run, lost); + + v =3D next_sample_read_value(v, read_format); =20 for (i =3D 1; i < nr; i++) { struct evsel *counter; =20 - counter =3D evlist__id2evsel(leader->evlist, v[i].id); + counter =3D evlist__id2evsel(leader->evlist, v->id); if (!counter) return -EINVAL; =20 - evsel__set_count(counter, cpu_map_idx, thread, v[i].value, ena, run); + if (read_format & PERF_FORMAT_LOST) + lost =3D v->lost; + + evsel__set_count(counter, cpu_map_idx, thread, v->value, ena, run, lost); + v =3D next_sample_read_value(v, read_format); } =20 return 0; @@ -2475,16 +2485,21 @@ int evsel__parse_sample(struct evsel *evsel, union = perf_event *event, =20 if (data->read.group.nr > max_group_nr) return -EFAULT; - sz =3D data->read.group.nr * - sizeof(struct sample_read_value); + + sz =3D data->read.group.nr * sample_read_value_size(read_format); OVERFLOW_CHECK(array, sz, max_size); - data->read.group.values =3D - (struct sample_read_value *)array; + data->read.group.values =3D (void *)array; array =3D (void *)array + sz; } else { OVERFLOW_CHECK_u64(array); data->read.one.id =3D *array; array++; + + if (read_format & PERF_FORMAT_LOST) { + OVERFLOW_CHECK_u64(array); + data->read.one.lost =3D *array; + array++; + } } } =20 diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools= /perf/util/scripting-engines/trace-event-python.c index 9ef2406e0ede..7e15e64f311b 100644 --- a/tools/perf/util/scripting-engines/trace-event-python.c +++ b/tools/perf/util/scripting-engines/trace-event-python.c @@ -642,15 +642,19 @@ static PyObject *python_process_brstacksym(struct per= f_sample *sample, return pylist; } =20 -static PyObject *get_sample_value_as_tuple(struct sample_read_value *value) +static PyObject *get_sample_value_as_tuple(struct sample_read_value *value, + u64 read_format) { PyObject *t; =20 - t =3D PyTuple_New(2); + t =3D PyTuple_New(3); if (!t) Py_FatalError("couldn't create Python tuple"); PyTuple_SetItem(t, 0, PyLong_FromUnsignedLongLong(value->id)); PyTuple_SetItem(t, 1, PyLong_FromUnsignedLongLong(value->value)); + if (read_format & PERF_FORMAT_LOST) + PyTuple_SetItem(t, 2, PyLong_FromUnsignedLongLong(value->lost)); + return t; } =20 @@ -681,12 +685,16 @@ static void set_sample_read_in_dict(PyObject *dict_sa= mple, Py_FatalError("couldn't create Python list"); =20 if (read_format & PERF_FORMAT_GROUP) { + struct sample_read_value *v =3D sample->read.group.values; + for (i =3D 0; i < sample->read.group.nr; i++) { - PyObject *t =3D get_sample_value_as_tuple(&sample->read.group.values[i]= ); + PyObject *t =3D get_sample_value_as_tuple(v, read_format); PyList_SET_ITEM(values, i, t); + v =3D next_sample_read_value(v, read_format); } } else { - PyObject *t =3D get_sample_value_as_tuple(&sample->read.one); + PyObject *t =3D get_sample_value_as_tuple(&sample->read.one, + read_format); PyList_SET_ITEM(values, 0, t); } pydict_set_item_string_decref(dict_sample, "values", values); diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index 98e16659a149..dd818764bd4d 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -1284,20 +1284,26 @@ static void sample_read__printf(struct perf_sample = *sample, u64 read_format) =20 if (read_format & PERF_FORMAT_GROUP) { u64 i; + struct sample_read_value *value =3D sample->read.group.values; =20 printf(".... group nr %" PRIu64 "\n", sample->read.group.nr); =20 for (i =3D 0; i < sample->read.group.nr; i++) { - struct sample_read_value *value; - - value =3D &sample->read.group.values[i]; printf("..... id %016" PRIx64 - ", value %016" PRIx64 "\n", + ", value %016" PRIx64, value->id, value->value); + if (read_format & PERF_FORMAT_LOST) + printf(", lost %" PRIu64, value->lost); + printf("\n"); + value =3D next_sample_read_value(value, read_format); } - } else - printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n", + } else { + printf("..... id %016" PRIx64 ", value %016" PRIx64, sample->read.one.id, sample->read.one.value); + if (read_format & PERF_FORMAT_LOST) + printf(", lost %" PRIu64, sample->read.one.lost); + printf("\n"); + } } =20 static void dump_event(struct evlist *evlist, union perf_event *event, @@ -1411,6 +1417,9 @@ static void dump_read(struct evsel *evsel, union perf= _event *event) =20 if (read_format & PERF_FORMAT_ID) printf("... id : %" PRI_lu64 "\n", read_event->id); + + if (read_format & PERF_FORMAT_LOST) + printf("... lost : %" PRI_lu64 "\n", read_event->lost); } =20 static struct machine *machines__find_for_cpumode(struct machines *machine= s, @@ -1479,17 +1488,20 @@ static int deliver_sample_group(struct evlist *evli= st, struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, - struct machine *machine) + struct machine *machine, + u64 read_format) { int ret =3D -EINVAL; u64 i; + struct sample_read_value *v =3D sample->read.group.values; =20 for (i =3D 0; i < sample->read.group.nr; i++) { - ret =3D deliver_sample_value(evlist, tool, event, sample, - &sample->read.group.values[i], + ret =3D deliver_sample_value(evlist, tool, event, sample, v, machine); if (ret) break; + + v =3D next_sample_read_value(v, read_format); } =20 return ret; @@ -1510,7 +1522,7 @@ static int evlist__deliver_sample(struct evlist *evli= st, struct perf_tool *tool, /* For PERF_SAMPLE_READ we have either single or group mode. */ if (read_format & PERF_FORMAT_GROUP) return deliver_sample_group(evlist, tool, event, sample, - machine); + machine, read_format); else return deliver_sample_value(evlist, tool, event, sample, &sample->read.one, machine); diff --git a/tools/perf/util/synthetic-events.c b/tools/perf/util/synthetic= -events.c index 2ae59c03ae77..9b8dc7633a02 100644 --- a/tools/perf/util/synthetic-events.c +++ b/tools/perf/util/synthetic-events.c @@ -1432,11 +1432,12 @@ size_t perf_event__sample_event_size(const struct p= erf_sample *sample, u64 type, result +=3D sizeof(u64); /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */ if (read_format & PERF_FORMAT_GROUP) { - sz =3D sample->read.group.nr * - sizeof(struct sample_read_value); - result +=3D sz; + sz =3D sample_read_value_size(read_format); + result +=3D sz * sample->read.group.nr; } else { result +=3D sizeof(u64); + if (read_format & PERF_FORMAT_LOST) + result +=3D sizeof(u64); } } =20 @@ -1521,6 +1522,22 @@ void __weak arch_perf_synthesize_sample_weight(const= struct perf_sample *data, *array =3D data->weight; } =20 +static __u64 *copy_read_group_values(__u64 *array, __u64 read_format, + const struct perf_sample *sample) +{ + size_t i, sz; + void *data =3D sample->read.group.values; + + sz =3D sample_read_value_size(read_format); + for (i =3D 0; i < sample->read.group.nr; i++) { + memcpy(array, data, sz); + + data +=3D sz; + array =3D (void *)array + sz; + } + return array; +} + int perf_event__synthesize_sample(union perf_event *event, u64 type, u64 r= ead_format, const struct perf_sample *sample) { @@ -1602,13 +1619,16 @@ int perf_event__synthesize_sample(union perf_event = *event, u64 type, u64 read_fo =20 /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */ if (read_format & PERF_FORMAT_GROUP) { - sz =3D sample->read.group.nr * - sizeof(struct sample_read_value); - memcpy(array, sample->read.group.values, sz); - array =3D (void *)array + sz; + array =3D copy_read_group_values(array, read_format, + sample); } else { *array =3D sample->read.one.id; array++; + + if (read_format & PERF_FORMAT_LOST) { + *array =3D sample->read.one.lost; + array++; + } } } =20 --=20 2.37.1.595.g718a3a8f04-goog